blob: 5fd65f53f44be3e296a37b12b6e7e653003eb9ad [file] [log] [blame]
Chris Lattner5b183d82006-11-10 05:03:26 +00001//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner5b183d82006-11-10 05:03:26 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for expressions.
11//
12//===----------------------------------------------------------------------===//
13
John McCall83024632010-08-25 22:03:47 +000014#include "clang/Sema/SemaInternal.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000015#include "TreeTransform.h"
Argyrios Kyrtzidise5dc5b32012-02-10 20:10:44 +000016#include "clang/AST/ASTConsumer.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/AST/ASTContext.h"
Faisal Valia17d19f2013-11-07 05:17:06 +000018#include "clang/AST/ASTLambda.h"
Sebastian Redl2ac2c722011-04-29 08:19:30 +000019#include "clang/AST/ASTMutationListener.h"
Douglas Gregord1702062010-04-29 00:18:15 +000020#include "clang/AST/CXXInheritance.h"
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000021#include "clang/AST/DeclObjC.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000022#include "clang/AST/DeclTemplate.h"
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000023#include "clang/AST/EvaluatedExprVisitor.h"
Douglas Gregor882211c2010-04-28 22:16:22 +000024#include "clang/AST/Expr.h"
Chris Lattneraa9c7ae2008-04-08 04:40:51 +000025#include "clang/AST/ExprCXX.h"
Steve Naroff021ca182008-05-29 21:12:08 +000026#include "clang/AST/ExprObjC.h"
Douglas Gregor5597ab42010-05-07 23:12:07 +000027#include "clang/AST/RecursiveASTVisitor.h"
Douglas Gregor882211c2010-04-28 22:16:22 +000028#include "clang/AST/TypeLoc.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000029#include "clang/Basic/PartialDiagnostic.h"
Steve Narofff2fb89e2007-03-13 20:29:44 +000030#include "clang/Basic/SourceManager.h"
Chris Lattner5b183d82006-11-10 05:03:26 +000031#include "clang/Basic/TargetInfo.h"
Anders Carlsson029fc692009-08-26 22:59:12 +000032#include "clang/Lex/LiteralSupport.h"
33#include "clang/Lex/Preprocessor.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000034#include "clang/Sema/AnalysisBasedWarnings.h"
John McCall8b0666c2010-08-20 18:27:03 +000035#include "clang/Sema/DeclSpec.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000036#include "clang/Sema/DelayedDiagnostic.h"
John McCall8b0666c2010-08-20 18:27:03 +000037#include "clang/Sema/Designator.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000038#include "clang/Sema/Initialization.h"
39#include "clang/Sema/Lookup.h"
40#include "clang/Sema/ParsedTemplate.h"
John McCall8b0666c2010-08-20 18:27:03 +000041#include "clang/Sema/Scope.h"
John McCallaab3e412010-08-25 08:40:02 +000042#include "clang/Sema/ScopeInfo.h"
Anna Zaks3b402712011-07-28 19:51:27 +000043#include "clang/Sema/SemaFixItUtils.h"
John McCallde6836a2010-08-24 07:21:54 +000044#include "clang/Sema/Template.h"
Chris Lattner5b183d82006-11-10 05:03:26 +000045using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000046using namespace sema;
Chris Lattner5b183d82006-11-10 05:03:26 +000047
Sebastian Redlb49c46c2011-09-24 17:48:00 +000048/// \brief Determine whether the use of this declaration is valid, without
49/// emitting diagnostics.
50bool Sema::CanUseDecl(NamedDecl *D) {
51 // See if this is an auto-typed variable whose initializer we are parsing.
52 if (ParsingInitForAutoVars.count(D))
53 return false;
54
55 // See if this is a deleted function.
56 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
57 if (FD->isDeleted())
58 return false;
Richard Smith2a7d4812013-05-04 07:00:32 +000059
60 // If the function has a deduced return type, and we can't deduce it,
61 // then we can't use it either.
62 if (getLangOpts().CPlusPlus1y && FD->getResultType()->isUndeducedType() &&
63 DeduceReturnType(FD, SourceLocation(), /*Diagnose*/false))
64 return false;
Sebastian Redlb49c46c2011-09-24 17:48:00 +000065 }
Sebastian Redl5999aec2011-10-16 18:19:16 +000066
67 // See if this function is unavailable.
68 if (D->getAvailability() == AR_Unavailable &&
69 cast<Decl>(CurContext)->getAvailability() != AR_Unavailable)
70 return false;
71
Sebastian Redlb49c46c2011-09-24 17:48:00 +000072 return true;
73}
David Chisnall9f57c292009-08-17 16:35:33 +000074
Fariborz Jahanian66c93f42012-09-06 16:43:18 +000075static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc) {
76 // Warn if this is used but marked unused.
77 if (D->hasAttr<UnusedAttr>()) {
Fariborz Jahanian979780f2012-09-06 18:38:58 +000078 const Decl *DC = cast<Decl>(S.getCurObjCLexicalContext());
Fariborz Jahanian66c93f42012-09-06 16:43:18 +000079 if (!DC->hasAttr<UnusedAttr>())
80 S.Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName();
81 }
82}
83
Ted Kremenek6eb25622012-02-10 02:45:47 +000084static AvailabilityResult DiagnoseAvailabilityOfDecl(Sema &S,
Fariborz Jahanian6b854c52011-09-29 22:45:21 +000085 NamedDecl *D, SourceLocation Loc,
86 const ObjCInterfaceDecl *UnknownObjCClass) {
87 // See if this declaration is unavailable or deprecated.
88 std::string Message;
89 AvailabilityResult Result = D->getAvailability(&Message);
Fariborz Jahanian25d09c22011-11-28 19:45:58 +000090 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D))
91 if (Result == AR_Available) {
92 const DeclContext *DC = ECD->getDeclContext();
93 if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC))
94 Result = TheEnumDecl->getAvailability(&Message);
95 }
Jordan Rose2bd991a2012-10-10 16:42:54 +000096
Fariborz Jahanian974c9482012-09-21 20:46:37 +000097 const ObjCPropertyDecl *ObjCPDecl = 0;
Jordan Rose2bd991a2012-10-10 16:42:54 +000098 if (Result == AR_Deprecated || Result == AR_Unavailable) {
99 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
100 if (const ObjCPropertyDecl *PD = MD->findPropertyDecl()) {
101 AvailabilityResult PDeclResult = PD->getAvailability(0);
102 if (PDeclResult == Result)
103 ObjCPDecl = PD;
104 }
Fariborz Jahanian974c9482012-09-21 20:46:37 +0000105 }
Jordan Rose2bd991a2012-10-10 16:42:54 +0000106 }
Fariborz Jahanian25d09c22011-11-28 19:45:58 +0000107
Fariborz Jahanian6b854c52011-09-29 22:45:21 +0000108 switch (Result) {
109 case AR_Available:
110 case AR_NotYetIntroduced:
111 break;
112
113 case AR_Deprecated:
Ted Kremenekcb42dbe2013-11-20 17:24:03 +0000114 if (S.getCurContextAvailability() != AR_Deprecated)
Ted Kremenekb79ee572013-12-18 23:30:06 +0000115 S.EmitAvailabilityWarning(Sema::AD_Deprecation,
116 D, Message, Loc, UnknownObjCClass, ObjCPDecl);
Fariborz Jahanian6b854c52011-09-29 22:45:21 +0000117 break;
Ted Kremenekb79ee572013-12-18 23:30:06 +0000118
Fariborz Jahanian6b854c52011-09-29 22:45:21 +0000119 case AR_Unavailable:
Ted Kremenekb79ee572013-12-18 23:30:06 +0000120 if (S.getCurContextAvailability() != AR_Unavailable)
121 S.EmitAvailabilityWarning(Sema::AD_Unavailable,
122 D, Message, Loc, UnknownObjCClass, ObjCPDecl);
Fariborz Jahanian6b854c52011-09-29 22:45:21 +0000123 break;
Ted Kremenekb79ee572013-12-18 23:30:06 +0000124
Fariborz Jahanian6b854c52011-09-29 22:45:21 +0000125 }
126 return Result;
127}
128
Eli Friedmanebea0f22013-07-18 23:29:14 +0000129/// \brief Emit a note explaining that this function is deleted.
Richard Smith852265f2012-03-30 20:53:28 +0000130void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
Eli Friedmanebea0f22013-07-18 23:29:14 +0000131 assert(Decl->isDeleted());
132
Richard Smith852265f2012-03-30 20:53:28 +0000133 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl);
134
Eli Friedmanebea0f22013-07-18 23:29:14 +0000135 if (Method && Method->isDeleted() && Method->isDefaulted()) {
Richard Smith6f1e2c62012-04-02 20:59:25 +0000136 // If the method was explicitly defaulted, point at that declaration.
137 if (!Method->isImplicit())
138 Diag(Decl->getLocation(), diag::note_implicitly_deleted);
139
140 // Try to diagnose why this special member function was implicitly
141 // deleted. This might fail, if that reason no longer applies.
Richard Smith852265f2012-03-30 20:53:28 +0000142 CXXSpecialMember CSM = getSpecialMember(Method);
Richard Smith6f1e2c62012-04-02 20:59:25 +0000143 if (CSM != CXXInvalid)
144 ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true);
145
146 return;
Richard Smith852265f2012-03-30 20:53:28 +0000147 }
148
Eli Friedmanebea0f22013-07-18 23:29:14 +0000149 if (CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Decl)) {
150 if (CXXConstructorDecl *BaseCD =
151 const_cast<CXXConstructorDecl*>(CD->getInheritedConstructor())) {
152 Diag(Decl->getLocation(), diag::note_inherited_deleted_here);
153 if (BaseCD->isDeleted()) {
154 NoteDeletedFunction(BaseCD);
155 } else {
156 // FIXME: An explanation of why exactly it can't be inherited
157 // would be nice.
158 Diag(BaseCD->getLocation(), diag::note_cannot_inherit);
159 }
160 return;
161 }
162 }
163
Ted Kremenekb79ee572013-12-18 23:30:06 +0000164 Diag(Decl->getLocation(), diag::note_availability_specified_here)
165 << Decl << true;
Richard Smith852265f2012-03-30 20:53:28 +0000166}
167
Jordan Rose28cd12f2012-06-18 22:09:19 +0000168/// \brief Determine whether a FunctionDecl was ever declared with an
169/// explicit storage class.
170static bool hasAnyExplicitStorageClass(const FunctionDecl *D) {
171 for (FunctionDecl::redecl_iterator I = D->redecls_begin(),
172 E = D->redecls_end();
173 I != E; ++I) {
Rafael Espindola6ae7e502013-04-03 19:27:57 +0000174 if (I->getStorageClass() != SC_None)
Jordan Rose28cd12f2012-06-18 22:09:19 +0000175 return true;
176 }
177 return false;
178}
179
180/// \brief Check whether we're in an extern inline function and referring to a
Jordan Rosede9e9762012-06-20 18:50:06 +0000181/// variable or function with internal linkage (C11 6.7.4p3).
Jordan Rose28cd12f2012-06-18 22:09:19 +0000182///
Jordan Rose28cd12f2012-06-18 22:09:19 +0000183/// This is only a warning because we used to silently accept this code, but
Jordan Rosede9e9762012-06-20 18:50:06 +0000184/// in many cases it will not behave correctly. This is not enabled in C++ mode
185/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)
186/// and so while there may still be user mistakes, most of the time we can't
187/// prove that there are errors.
Jordan Rose28cd12f2012-06-18 22:09:19 +0000188static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S,
189 const NamedDecl *D,
190 SourceLocation Loc) {
Jordan Rosede9e9762012-06-20 18:50:06 +0000191 // This is disabled under C++; there are too many ways for this to fire in
192 // contexts where the warning is a false positive, or where it is technically
193 // correct but benign.
194 if (S.getLangOpts().CPlusPlus)
195 return;
Jordan Rose28cd12f2012-06-18 22:09:19 +0000196
197 // Check if this is an inlined function or method.
198 FunctionDecl *Current = S.getCurFunctionDecl();
199 if (!Current)
200 return;
201 if (!Current->isInlined())
202 return;
Rafael Espindola3ae00052013-05-13 00:12:11 +0000203 if (!Current->isExternallyVisible())
Jordan Rose28cd12f2012-06-18 22:09:19 +0000204 return;
Rafael Espindola3ae00052013-05-13 00:12:11 +0000205
Jordan Rose28cd12f2012-06-18 22:09:19 +0000206 // Check if the decl has internal linkage.
Rafael Espindola3ae00052013-05-13 00:12:11 +0000207 if (D->getFormalLinkage() != InternalLinkage)
Jordan Rose28cd12f2012-06-18 22:09:19 +0000208 return;
Jordan Rose28cd12f2012-06-18 22:09:19 +0000209
Jordan Rose815fe262012-06-21 05:54:50 +0000210 // Downgrade from ExtWarn to Extension if
211 // (1) the supposedly external inline function is in the main file,
212 // and probably won't be included anywhere else.
213 // (2) the thing we're referencing is a pure function.
214 // (3) the thing we're referencing is another inline function.
215 // This last can give us false negatives, but it's better than warning on
216 // wrappers for simple C library functions.
217 const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D);
Eli Friedman5ba37d52013-08-22 00:27:10 +0000218 bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc);
Jordan Rose815fe262012-06-21 05:54:50 +0000219 if (!DowngradeWarning && UsedFn)
220 DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>();
221
222 S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline
223 : diag::warn_internal_in_extern_inline)
224 << /*IsVar=*/!UsedFn << D;
Jordan Rose28cd12f2012-06-18 22:09:19 +0000225
John McCallc87d9722013-04-02 02:48:58 +0000226 S.MaybeSuggestAddingStaticToDecl(Current);
Jordan Rose28cd12f2012-06-18 22:09:19 +0000227
228 S.Diag(D->getCanonicalDecl()->getLocation(),
229 diag::note_internal_decl_declared_here)
230 << D;
231}
232
John McCallc87d9722013-04-02 02:48:58 +0000233void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) {
Rafael Espindola8db352d2013-10-17 15:37:26 +0000234 const FunctionDecl *First = Cur->getFirstDecl();
John McCallc87d9722013-04-02 02:48:58 +0000235
236 // Suggest "static" on the function, if possible.
237 if (!hasAnyExplicitStorageClass(First)) {
238 SourceLocation DeclBegin = First->getSourceRange().getBegin();
239 Diag(DeclBegin, diag::note_convert_inline_to_static)
240 << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
241 }
242}
243
Douglas Gregor171c45a2009-02-18 21:56:37 +0000244/// \brief Determine whether the use of this declaration is valid, and
245/// emit any corresponding diagnostics.
246///
247/// This routine diagnoses various problems with referencing
248/// declarations that can occur when using a declaration. For example,
249/// it might warn if a deprecated or unavailable declaration is being
250/// used, or produce an error (and return true) if a C++0x deleted
251/// function is being used.
252///
253/// \returns true if there was an error (this declaration cannot be
254/// referenced), false otherwise.
Chris Lattnerb7df3c62009-10-25 22:31:57 +0000255///
Fariborz Jahanian7d6e11a2010-12-21 00:44:01 +0000256bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc,
Fariborz Jahanian6b854c52011-09-29 22:45:21 +0000257 const ObjCInterfaceDecl *UnknownObjCClass) {
David Blaikiebbafb8a2012-03-11 07:00:24 +0000258 if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000259 // If there were any diagnostics suppressed by template argument deduction,
260 // emit them now.
Craig Topper79be4cd2013-07-05 04:33:53 +0000261 SuppressedDiagnosticsMap::iterator
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000262 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
263 if (Pos != SuppressedDiagnostics.end()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000264 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second;
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000265 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I)
266 Diag(Suppressed[I].first, Suppressed[I].second);
267
268 // Clear out the list of suppressed diagnostics, so that we don't emit
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000269 // them again for this specialization. However, we don't obsolete this
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +0000270 // entry from the table, because we want to avoid ever emitting these
271 // diagnostics again.
272 Suppressed.clear();
273 }
274 }
275
Richard Smith30482bc2011-02-20 03:19:35 +0000276 // See if this is an auto-typed variable whose initializer we are parsing.
Richard Smithb2bc2e62011-02-21 20:05:19 +0000277 if (ParsingInitForAutoVars.count(D)) {
278 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
279 << D->getDeclName();
280 return true;
Richard Smith30482bc2011-02-20 03:19:35 +0000281 }
282
Douglas Gregor171c45a2009-02-18 21:56:37 +0000283 // See if this is a deleted function.
Douglas Gregorde681d42009-02-24 04:26:15 +0000284 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Douglas Gregor171c45a2009-02-18 21:56:37 +0000285 if (FD->isDeleted()) {
286 Diag(Loc, diag::err_deleted_function_use);
Richard Smith852265f2012-03-30 20:53:28 +0000287 NoteDeletedFunction(FD);
Douglas Gregor171c45a2009-02-18 21:56:37 +0000288 return true;
289 }
Richard Smith2a7d4812013-05-04 07:00:32 +0000290
291 // If the function has a deduced return type, and we can't deduce it,
292 // then we can't use it either.
293 if (getLangOpts().CPlusPlus1y && FD->getResultType()->isUndeducedType() &&
294 DeduceReturnType(FD, Loc))
295 return true;
Douglas Gregorde681d42009-02-24 04:26:15 +0000296 }
Ted Kremenek6eb25622012-02-10 02:45:47 +0000297 DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass);
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000298
Fariborz Jahanian66c93f42012-09-06 16:43:18 +0000299 DiagnoseUnusedOfDecl(*this, D, Loc);
Jordan Rose2684c682012-06-15 18:19:48 +0000300
Jordan Rose28cd12f2012-06-18 22:09:19 +0000301 diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);
Jordan Rose2684c682012-06-15 18:19:48 +0000302
Douglas Gregor171c45a2009-02-18 21:56:37 +0000303 return false;
Chris Lattner4bf74fd2009-02-15 22:43:40 +0000304}
305
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000306/// \brief Retrieve the message suffix that should be added to a
307/// diagnostic complaining about the given function being deleted or
308/// unavailable.
309std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000310 std::string Message;
311 if (FD->getAvailability(&Message))
312 return ": " + Message;
313
314 return std::string();
315}
316
John McCallb46f2872011-09-09 07:56:05 +0000317/// DiagnoseSentinelCalls - This routine checks whether a call or
318/// message-send is to a declaration with the sentinel attribute, and
319/// if so, it checks that the requirements of the sentinel are
320/// satisfied.
Fariborz Jahanian027b8862009-05-13 18:09:35 +0000321void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +0000322 ArrayRef<Expr *> Args) {
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000323 const SentinelAttr *attr = D->getAttr<SentinelAttr>();
Mike Stump11289f42009-09-09 15:08:12 +0000324 if (!attr)
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000325 return;
Douglas Gregorc298ffc2010-04-22 16:44:27 +0000326
John McCallb46f2872011-09-09 07:56:05 +0000327 // The number of formal parameters of the declaration.
328 unsigned numFormalParams;
Mike Stump11289f42009-09-09 15:08:12 +0000329
John McCallb46f2872011-09-09 07:56:05 +0000330 // The kind of declaration. This is also an index into a %select in
331 // the diagnostic.
332 enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType;
333
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000334 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
John McCallb46f2872011-09-09 07:56:05 +0000335 numFormalParams = MD->param_size();
336 calleeType = CT_Method;
Mike Stump12b8ce12009-08-04 21:02:39 +0000337 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
John McCallb46f2872011-09-09 07:56:05 +0000338 numFormalParams = FD->param_size();
339 calleeType = CT_Function;
340 } else if (isa<VarDecl>(D)) {
341 QualType type = cast<ValueDecl>(D)->getType();
342 const FunctionType *fn = 0;
343 if (const PointerType *ptr = type->getAs<PointerType>()) {
344 fn = ptr->getPointeeType()->getAs<FunctionType>();
345 if (!fn) return;
346 calleeType = CT_Function;
347 } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) {
348 fn = ptr->getPointeeType()->castAs<FunctionType>();
349 calleeType = CT_Block;
350 } else {
Fariborz Jahanian0aa5c452009-05-15 20:33:25 +0000351 return;
John McCallb46f2872011-09-09 07:56:05 +0000352 }
Fariborz Jahanian4a528032009-05-14 18:00:00 +0000353
John McCallb46f2872011-09-09 07:56:05 +0000354 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) {
355 numFormalParams = proto->getNumArgs();
356 } else {
357 numFormalParams = 0;
358 }
359 } else {
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000360 return;
361 }
John McCallb46f2872011-09-09 07:56:05 +0000362
363 // "nullPos" is the number of formal parameters at the end which
364 // effectively count as part of the variadic arguments. This is
365 // useful if you would prefer to not have *any* formal parameters,
366 // but the language forces you to have at least one.
367 unsigned nullPos = attr->getNullPos();
368 assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel");
369 numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos);
370
371 // The number of arguments which should follow the sentinel.
372 unsigned numArgsAfterSentinel = attr->getSentinel();
373
374 // If there aren't enough arguments for all the formal parameters,
375 // the sentinel, and the args after the sentinel, complain.
Dmitri Gribenko9c785c22013-05-09 21:02:07 +0000376 if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) {
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000377 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName();
Joerg Sonnenbergerffc6d492013-06-26 21:31:47 +0000378 Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
Fariborz Jahanian9e877212009-05-13 23:20:50 +0000379 return;
380 }
John McCallb46f2872011-09-09 07:56:05 +0000381
382 // Otherwise, find the sentinel expression.
Dmitri Gribenko9c785c22013-05-09 21:02:07 +0000383 Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1];
John McCall7ddbcf42010-05-06 23:53:00 +0000384 if (!sentinelExpr) return;
John McCall7ddbcf42010-05-06 23:53:00 +0000385 if (sentinelExpr->isValueDependent()) return;
Argyrios Kyrtzidis2e809ce2012-02-03 05:58:16 +0000386 if (Context.isSentinelNullExpr(sentinelExpr)) return;
John McCall7ddbcf42010-05-06 23:53:00 +0000387
John McCallb46f2872011-09-09 07:56:05 +0000388 // Pick a reasonable string to insert. Optimistically use 'nil' or
389 // 'NULL' if those are actually defined in the context. Only use
390 // 'nil' for ObjC methods, where it's much more likely that the
391 // variadic arguments form a list of object pointers.
392 SourceLocation MissingNilLoc
Douglas Gregor5ff4e982011-07-30 08:57:03 +0000393 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd());
394 std::string NullValue;
John McCallb46f2872011-09-09 07:56:05 +0000395 if (calleeType == CT_Method &&
396 PP.getIdentifierInfo("nil")->hasMacroDefinition())
Douglas Gregor5ff4e982011-07-30 08:57:03 +0000397 NullValue = "nil";
398 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition())
399 NullValue = "NULL";
Douglas Gregor5ff4e982011-07-30 08:57:03 +0000400 else
John McCallb46f2872011-09-09 07:56:05 +0000401 NullValue = "(void*) 0";
Eli Friedman9ab36372011-09-27 23:46:37 +0000402
403 if (MissingNilLoc.isInvalid())
Joerg Sonnenbergerffc6d492013-06-26 21:31:47 +0000404 Diag(Loc, diag::warn_missing_sentinel) << int(calleeType);
Eli Friedman9ab36372011-09-27 23:46:37 +0000405 else
406 Diag(MissingNilLoc, diag::warn_missing_sentinel)
Joerg Sonnenbergerffc6d492013-06-26 21:31:47 +0000407 << int(calleeType)
Eli Friedman9ab36372011-09-27 23:46:37 +0000408 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue);
Joerg Sonnenbergerffc6d492013-06-26 21:31:47 +0000409 Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType);
Fariborz Jahanian027b8862009-05-13 18:09:35 +0000410}
411
Richard Trieuba63ce62011-09-09 01:45:06 +0000412SourceRange Sema::getExprRange(Expr *E) const {
413 return E ? E->getSourceRange() : SourceRange();
Douglas Gregor87f95b02009-02-26 21:00:50 +0000414}
415
Chris Lattner513165e2008-07-25 21:10:04 +0000416//===----------------------------------------------------------------------===//
417// Standard Promotions and Conversions
418//===----------------------------------------------------------------------===//
419
Chris Lattner513165e2008-07-25 21:10:04 +0000420/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
John Wiegley01296292011-04-08 18:41:53 +0000421ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) {
John McCall50a2c2c2011-10-11 23:14:30 +0000422 // Handle any placeholder expressions which made it here.
423 if (E->getType()->isPlaceholderType()) {
424 ExprResult result = CheckPlaceholderExpr(E);
425 if (result.isInvalid()) return ExprError();
426 E = result.take();
427 }
428
Chris Lattner513165e2008-07-25 21:10:04 +0000429 QualType Ty = E->getType();
430 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
431
Chris Lattner513165e2008-07-25 21:10:04 +0000432 if (Ty->isFunctionType())
John Wiegley01296292011-04-08 18:41:53 +0000433 E = ImpCastExprToType(E, Context.getPointerType(Ty),
434 CK_FunctionToPointerDecay).take();
Chris Lattner61f60a02008-07-25 21:33:13 +0000435 else if (Ty->isArrayType()) {
436 // In C90 mode, arrays only promote to pointers if the array expression is
437 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
438 // type 'array of type' is converted to an expression that has type 'pointer
439 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression
440 // that has type 'array of type' ...". The relevant change is "an lvalue"
441 // (C90) to "an expression" (C99).
Argyrios Kyrtzidis9321c742008-09-11 04:25:59 +0000442 //
443 // C++ 4.2p1:
444 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
445 // T" can be converted to an rvalue of type "pointer to T".
446 //
David Blaikiebbafb8a2012-03-11 07:00:24 +0000447 if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue())
John Wiegley01296292011-04-08 18:41:53 +0000448 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
449 CK_ArrayToPointerDecay).take();
Chris Lattner61f60a02008-07-25 21:33:13 +0000450 }
John Wiegley01296292011-04-08 18:41:53 +0000451 return Owned(E);
Chris Lattner513165e2008-07-25 21:10:04 +0000452}
453
Argyrios Kyrtzidisa9b630e2011-04-26 17:41:22 +0000454static void CheckForNullPointerDereference(Sema &S, Expr *E) {
455 // Check to see if we are dereferencing a null pointer. If so,
456 // and if not volatile-qualified, this is undefined behavior that the
457 // optimizer will delete, so warn about it. People sometimes try to use this
458 // to get a deterministic trap and are surprised by clang's behavior. This
459 // only handles the pattern "*null", which is a very syntactic check.
460 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))
461 if (UO->getOpcode() == UO_Deref &&
462 UO->getSubExpr()->IgnoreParenCasts()->
463 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) &&
464 !UO->getType().isVolatileQualified()) {
465 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
466 S.PDiag(diag::warn_indirection_through_null)
467 << UO->getSubExpr()->getSourceRange());
468 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO,
469 S.PDiag(diag::note_indirection_through_null));
470 }
471}
472
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +0000473static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
Fariborz Jahanianf12ff4df2013-04-02 18:57:54 +0000474 SourceLocation AssignLoc,
475 const Expr* RHS) {
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +0000476 const ObjCIvarDecl *IV = OIRE->getDecl();
477 if (!IV)
478 return;
479
480 DeclarationName MemberName = IV->getDeclName();
481 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
482 if (!Member || !Member->isStr("isa"))
483 return;
484
485 const Expr *Base = OIRE->getBase();
486 QualType BaseType = Base->getType();
487 if (OIRE->isArrow())
488 BaseType = BaseType->getPointeeType();
489 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>())
490 if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {
491 ObjCInterfaceDecl *ClassDeclared = 0;
492 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
493 if (!ClassDeclared->getSuperClass()
494 && (*ClassDeclared->ivar_begin()) == IV) {
Fariborz Jahanianf12ff4df2013-04-02 18:57:54 +0000495 if (RHS) {
496 NamedDecl *ObjectSetClass =
497 S.LookupSingleName(S.TUScope,
498 &S.Context.Idents.get("object_setClass"),
499 SourceLocation(), S.LookupOrdinaryName);
500 if (ObjectSetClass) {
501 SourceLocation RHSLocEnd = S.PP.getLocForEndOfToken(RHS->getLocEnd());
502 S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign) <<
503 FixItHint::CreateInsertion(OIRE->getLocStart(), "object_setClass(") <<
504 FixItHint::CreateReplacement(SourceRange(OIRE->getOpLoc(),
505 AssignLoc), ",") <<
506 FixItHint::CreateInsertion(RHSLocEnd, ")");
507 }
508 else
509 S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);
510 } else {
511 NamedDecl *ObjectGetClass =
512 S.LookupSingleName(S.TUScope,
513 &S.Context.Idents.get("object_getClass"),
514 SourceLocation(), S.LookupOrdinaryName);
515 if (ObjectGetClass)
516 S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use) <<
517 FixItHint::CreateInsertion(OIRE->getLocStart(), "object_getClass(") <<
518 FixItHint::CreateReplacement(
519 SourceRange(OIRE->getOpLoc(),
520 OIRE->getLocEnd()), ")");
521 else
522 S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use);
523 }
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +0000524 S.Diag(IV->getLocation(), diag::note_ivar_decl);
525 }
526 }
527}
528
John Wiegley01296292011-04-08 18:41:53 +0000529ExprResult Sema::DefaultLvalueConversion(Expr *E) {
John McCall50a2c2c2011-10-11 23:14:30 +0000530 // Handle any placeholder expressions which made it here.
531 if (E->getType()->isPlaceholderType()) {
532 ExprResult result = CheckPlaceholderExpr(E);
533 if (result.isInvalid()) return ExprError();
534 E = result.take();
535 }
536
John McCallf3735e02010-12-01 04:43:34 +0000537 // C++ [conv.lval]p1:
538 // A glvalue of a non-function, non-array type T can be
539 // converted to a prvalue.
John Wiegley01296292011-04-08 18:41:53 +0000540 if (!E->isGLValue()) return Owned(E);
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +0000541
John McCall27584242010-12-06 20:48:59 +0000542 QualType T = E->getType();
543 assert(!T.isNull() && "r-value conversion on typeless expression?");
John McCall34376a62010-12-04 03:47:34 +0000544
John McCall27584242010-12-06 20:48:59 +0000545 // We don't want to throw lvalue-to-rvalue casts on top of
546 // expressions of certain types in C++.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000547 if (getLangOpts().CPlusPlus &&
John McCall27584242010-12-06 20:48:59 +0000548 (E->getType() == Context.OverloadTy ||
549 T->isDependentType() ||
550 T->isRecordType()))
John Wiegley01296292011-04-08 18:41:53 +0000551 return Owned(E);
John McCall27584242010-12-06 20:48:59 +0000552
553 // The C standard is actually really unclear on this point, and
554 // DR106 tells us what the result should be but not why. It's
555 // generally best to say that void types just doesn't undergo
556 // lvalue-to-rvalue at all. Note that expressions of unqualified
557 // 'void' type are never l-values, but qualified void can be.
558 if (T->isVoidType())
John Wiegley01296292011-04-08 18:41:53 +0000559 return Owned(E);
John McCall27584242010-12-06 20:48:59 +0000560
John McCall6ced97a2013-02-12 01:29:43 +0000561 // OpenCL usually rejects direct accesses to values of 'half' type.
562 if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16 &&
563 T->isHalfType()) {
564 Diag(E->getExprLoc(), diag::err_opencl_half_load_store)
565 << 0 << T;
566 return ExprError();
567 }
568
Argyrios Kyrtzidisa9b630e2011-04-26 17:41:22 +0000569 CheckForNullPointerDereference(*this, E);
Fariborz Jahanian06bb7f72013-03-28 19:50:55 +0000570 if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {
571 NamedDecl *ObjectGetClass = LookupSingleName(TUScope,
572 &Context.Idents.get("object_getClass"),
573 SourceLocation(), LookupOrdinaryName);
574 if (ObjectGetClass)
575 Diag(E->getExprLoc(), diag::warn_objc_isa_use) <<
576 FixItHint::CreateInsertion(OISA->getLocStart(), "object_getClass(") <<
577 FixItHint::CreateReplacement(
578 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");
579 else
580 Diag(E->getExprLoc(), diag::warn_objc_isa_use);
581 }
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +0000582 else if (const ObjCIvarRefExpr *OIRE =
583 dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
Fariborz Jahanianf12ff4df2013-04-02 18:57:54 +0000584 DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/0);
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +0000585
John McCall27584242010-12-06 20:48:59 +0000586 // C++ [conv.lval]p1:
587 // [...] If T is a non-class type, the type of the prvalue is the
588 // cv-unqualified version of T. Otherwise, the type of the
589 // rvalue is T.
590 //
591 // C99 6.3.2.1p2:
592 // If the lvalue has qualified type, the value has the unqualified
593 // version of the type of the lvalue; otherwise, the value has the
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000594 // type of the lvalue.
John McCall27584242010-12-06 20:48:59 +0000595 if (T.hasQualifiers())
596 T = T.getUnqualifiedType();
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000597
Eli Friedman3bda6b12012-02-02 23:15:15 +0000598 UpdateMarkingForLValueToRValue(E);
Fariborz Jahanianfbd19742012-11-27 23:02:53 +0000599
600 // Loading a __weak object implicitly retains the value, so we need a cleanup to
601 // balance that.
602 if (getLangOpts().ObjCAutoRefCount &&
603 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
604 ExprNeedsCleanups = true;
Eli Friedman3bda6b12012-02-02 23:15:15 +0000605
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000606 ExprResult Res = Owned(ImplicitCastExpr::Create(Context, T, CK_LValueToRValue,
607 E, 0, VK_RValue));
608
Douglas Gregorc79862f2012-04-12 17:51:55 +0000609 // C11 6.3.2.1p2:
610 // ... if the lvalue has atomic type, the value has the non-atomic version
611 // of the type of the lvalue ...
612 if (const AtomicType *Atomic = T->getAs<AtomicType>()) {
613 T = Atomic->getValueType().getUnqualifiedType();
614 Res = Owned(ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic,
615 Res.get(), 0, VK_RValue));
616 }
617
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000618 return Res;
John McCall27584242010-12-06 20:48:59 +0000619}
620
John Wiegley01296292011-04-08 18:41:53 +0000621ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) {
622 ExprResult Res = DefaultFunctionArrayConversion(E);
623 if (Res.isInvalid())
624 return ExprError();
625 Res = DefaultLvalueConversion(Res.take());
626 if (Res.isInvalid())
627 return ExprError();
Benjamin Kramer62b95d82012-08-23 21:35:17 +0000628 return Res;
Douglas Gregorb92a1562010-02-03 00:27:59 +0000629}
630
631
Chris Lattner513165e2008-07-25 21:10:04 +0000632/// UsualUnaryConversions - Performs various conversions that are common to most
Mike Stump11289f42009-09-09 15:08:12 +0000633/// operators (C99 6.3). The conversions of array and function types are
Chris Lattner57540c52011-04-15 05:22:18 +0000634/// sometimes suppressed. For example, the array->pointer conversion doesn't
Chris Lattner513165e2008-07-25 21:10:04 +0000635/// apply if the array is an argument to the sizeof or address (&) operators.
636/// In these instances, this routine should *not* be called.
John Wiegley01296292011-04-08 18:41:53 +0000637ExprResult Sema::UsualUnaryConversions(Expr *E) {
John McCallf3735e02010-12-01 04:43:34 +0000638 // First, convert to an r-value.
John Wiegley01296292011-04-08 18:41:53 +0000639 ExprResult Res = DefaultFunctionArrayLvalueConversion(E);
640 if (Res.isInvalid())
Fariborz Jahanian47ef4662013-03-06 00:37:40 +0000641 return ExprError();
John Wiegley01296292011-04-08 18:41:53 +0000642 E = Res.take();
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000643
John McCallf3735e02010-12-01 04:43:34 +0000644 QualType Ty = E->getType();
Chris Lattner513165e2008-07-25 21:10:04 +0000645 assert(!Ty.isNull() && "UsualUnaryConversions - missing type");
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000646
Joey Goulydd7f4562013-01-23 11:56:20 +0000647 // Half FP have to be promoted to float unless it is natively supported
648 if (Ty->isHalfType() && !getLangOpts().NativeHalfType)
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000649 return ImpCastExprToType(Res.take(), Context.FloatTy, CK_FloatingCast);
650
John McCallf3735e02010-12-01 04:43:34 +0000651 // Try to perform integral promotions if the object has a theoretically
652 // promotable type.
653 if (Ty->isIntegralOrUnscopedEnumerationType()) {
654 // C99 6.3.1.1p2:
655 //
656 // The following may be used in an expression wherever an int or
657 // unsigned int may be used:
658 // - an object or expression with an integer type whose integer
659 // conversion rank is less than or equal to the rank of int
660 // and unsigned int.
661 // - A bit-field of type _Bool, int, signed int, or unsigned int.
662 //
663 // If an int can represent all values of the original type, the
664 // value is converted to an int; otherwise, it is converted to an
665 // unsigned int. These are called the integer promotions. All
666 // other types are unchanged by the integer promotions.
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000667
John McCallf3735e02010-12-01 04:43:34 +0000668 QualType PTy = Context.isPromotableBitField(E);
669 if (!PTy.isNull()) {
John Wiegley01296292011-04-08 18:41:53 +0000670 E = ImpCastExprToType(E, PTy, CK_IntegralCast).take();
671 return Owned(E);
John McCallf3735e02010-12-01 04:43:34 +0000672 }
673 if (Ty->isPromotableIntegerType()) {
674 QualType PT = Context.getPromotedIntegerType(Ty);
John Wiegley01296292011-04-08 18:41:53 +0000675 E = ImpCastExprToType(E, PT, CK_IntegralCast).take();
676 return Owned(E);
John McCallf3735e02010-12-01 04:43:34 +0000677 }
Eli Friedman629ffb92009-08-20 04:21:42 +0000678 }
John Wiegley01296292011-04-08 18:41:53 +0000679 return Owned(E);
Chris Lattner513165e2008-07-25 21:10:04 +0000680}
681
Chris Lattner2ce500f2008-07-25 22:25:12 +0000682/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
Tim Northoverda165072013-01-30 09:46:55 +0000683/// do not have a prototype. Arguments that have type float or __fp16
684/// are promoted to double. All other argument types are converted by
685/// UsualUnaryConversions().
John Wiegley01296292011-04-08 18:41:53 +0000686ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
687 QualType Ty = E->getType();
Chris Lattner2ce500f2008-07-25 22:25:12 +0000688 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
Mike Stump11289f42009-09-09 15:08:12 +0000689
John Wiegley01296292011-04-08 18:41:53 +0000690 ExprResult Res = UsualUnaryConversions(E);
691 if (Res.isInvalid())
Fariborz Jahanian47ef4662013-03-06 00:37:40 +0000692 return ExprError();
John Wiegley01296292011-04-08 18:41:53 +0000693 E = Res.take();
John McCall9bc26772010-12-06 18:36:11 +0000694
Tim Northoverda165072013-01-30 09:46:55 +0000695 // If this is a 'float' or '__fp16' (CVR qualified or typedef) promote to
696 // double.
697 const BuiltinType *BTy = Ty->getAs<BuiltinType>();
698 if (BTy && (BTy->getKind() == BuiltinType::Half ||
699 BTy->getKind() == BuiltinType::Float))
John Wiegley01296292011-04-08 18:41:53 +0000700 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take();
701
John McCall4bb057d2011-08-27 22:06:17 +0000702 // C++ performs lvalue-to-rvalue conversion as a default argument
John McCall0562caa2011-08-29 23:55:37 +0000703 // promotion, even on class types, but note:
704 // C++11 [conv.lval]p2:
705 // When an lvalue-to-rvalue conversion occurs in an unevaluated
706 // operand or a subexpression thereof the value contained in the
707 // referenced object is not accessed. Otherwise, if the glvalue
708 // has a class type, the conversion copy-initializes a temporary
709 // of type T from the glvalue and the result of the conversion
710 // is a prvalue for the temporary.
Eli Friedman05e28012012-01-17 02:13:45 +0000711 // FIXME: add some way to gate this entire thing for correctness in
712 // potentially potentially evaluated contexts.
David Blaikie131fcb42012-08-06 22:47:24 +0000713 if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) {
Eli Friedman05e28012012-01-17 02:13:45 +0000714 ExprResult Temp = PerformCopyInitialization(
715 InitializedEntity::InitializeTemporary(E->getType()),
716 E->getExprLoc(),
717 Owned(E));
718 if (Temp.isInvalid())
719 return ExprError();
720 E = Temp.get();
John McCall29ad95b2011-08-27 01:09:30 +0000721 }
722
John Wiegley01296292011-04-08 18:41:53 +0000723 return Owned(E);
Chris Lattner2ce500f2008-07-25 22:25:12 +0000724}
725
Richard Smith55ce3522012-06-25 20:30:08 +0000726/// Determine the degree of POD-ness for an expression.
727/// Incomplete types are considered POD, since this check can be performed
728/// when we're in an unevaluated context.
729Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) {
Jordan Rose3e0ec582012-07-19 18:10:23 +0000730 if (Ty->isIncompleteType()) {
Richard Smithd7293d72013-08-05 18:49:43 +0000731 // C++11 [expr.call]p7:
732 // After these conversions, if the argument does not have arithmetic,
733 // enumeration, pointer, pointer to member, or class type, the program
734 // is ill-formed.
735 //
736 // Since we've already performed array-to-pointer and function-to-pointer
737 // decay, the only such type in C++ is cv void. This also handles
738 // initializer lists as variadic arguments.
739 if (Ty->isVoidType())
740 return VAK_Invalid;
741
Jordan Rose3e0ec582012-07-19 18:10:23 +0000742 if (Ty->isObjCObjectType())
743 return VAK_Invalid;
Richard Smith55ce3522012-06-25 20:30:08 +0000744 return VAK_Valid;
Jordan Rose3e0ec582012-07-19 18:10:23 +0000745 }
746
747 if (Ty.isCXX98PODType(Context))
748 return VAK_Valid;
749
Richard Smith16488472012-11-16 00:53:38 +0000750 // C++11 [expr.call]p7:
751 // Passing a potentially-evaluated argument of class type (Clause 9)
Richard Smith55ce3522012-06-25 20:30:08 +0000752 // having a non-trivial copy constructor, a non-trivial move constructor,
Richard Smith16488472012-11-16 00:53:38 +0000753 // or a non-trivial destructor, with no corresponding parameter,
Richard Smith55ce3522012-06-25 20:30:08 +0000754 // is conditionally-supported with implementation-defined semantics.
Richard Smith2bf7fdb2013-01-02 11:42:31 +0000755 if (getLangOpts().CPlusPlus11 && !Ty->isDependentType())
Richard Smith55ce3522012-06-25 20:30:08 +0000756 if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl())
Richard Smith16488472012-11-16 00:53:38 +0000757 if (!Record->hasNonTrivialCopyConstructor() &&
758 !Record->hasNonTrivialMoveConstructor() &&
759 !Record->hasNonTrivialDestructor())
Richard Smith55ce3522012-06-25 20:30:08 +0000760 return VAK_ValidInCXX11;
761
762 if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType())
763 return VAK_Valid;
Richard Smithd7293d72013-08-05 18:49:43 +0000764
765 if (Ty->isObjCObjectType())
766 return VAK_Invalid;
767
768 // FIXME: In C++11, these cases are conditionally-supported, meaning we're
769 // permitted to reject them. We should consider doing so.
770 return VAK_Undefined;
Richard Smith55ce3522012-06-25 20:30:08 +0000771}
772
Richard Smithd7293d72013-08-05 18:49:43 +0000773void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
Richard Smith55ce3522012-06-25 20:30:08 +0000774 // Don't allow one to pass an Objective-C interface to a vararg.
Richard Smithd7293d72013-08-05 18:49:43 +0000775 const QualType &Ty = E->getType();
776 VarArgKind VAK = isValidVarArgType(Ty);
Richard Smith55ce3522012-06-25 20:30:08 +0000777
778 // Complain about passing non-POD types through varargs.
Richard Smithd7293d72013-08-05 18:49:43 +0000779 switch (VAK) {
Richard Smith55ce3522012-06-25 20:30:08 +0000780 case VAK_Valid:
781 break;
Jordan Rose3e0ec582012-07-19 18:10:23 +0000782
Richard Smithd7293d72013-08-05 18:49:43 +0000783 case VAK_ValidInCXX11:
784 DiagRuntimeBehavior(
785 E->getLocStart(), 0,
786 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg)
787 << E->getType() << CT);
788 break;
789
790 case VAK_Undefined:
791 DiagRuntimeBehavior(
792 E->getLocStart(), 0,
793 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
794 << getLangOpts().CPlusPlus11 << Ty << CT);
795 break;
796
797 case VAK_Invalid:
798 if (Ty->isObjCObjectType())
799 DiagRuntimeBehavior(
800 E->getLocStart(), 0,
801 PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
802 << Ty << CT);
803 else
804 Diag(E->getLocStart(), diag::err_cannot_pass_to_vararg)
805 << isa<InitListExpr>(E) << Ty << CT;
806 break;
Richard Smith55ce3522012-06-25 20:30:08 +0000807 }
Richard Smith55ce3522012-06-25 20:30:08 +0000808}
809
Chris Lattnera8a7d0f2009-04-12 08:11:20 +0000810/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
Jordan Rose3e0ec582012-07-19 18:10:23 +0000811/// will create a trap if the resulting type is not a POD type.
John Wiegley01296292011-04-08 18:41:53 +0000812ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
John McCall31168b02011-06-15 23:02:42 +0000813 FunctionDecl *FDecl) {
Richard Smith7659b122012-06-27 20:29:39 +0000814 if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) {
John McCall4124c492011-10-17 18:40:02 +0000815 // Strip the unbridged-cast placeholder expression off, if applicable.
816 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
817 (CT == VariadicMethod ||
818 (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) {
819 E = stripARCUnbridgedCast(E);
820
821 // Otherwise, do normal placeholder checking.
822 } else {
823 ExprResult ExprRes = CheckPlaceholderExpr(E);
824 if (ExprRes.isInvalid())
825 return ExprError();
826 E = ExprRes.take();
827 }
828 }
Douglas Gregorcbd446d2011-06-17 00:15:10 +0000829
John McCall4124c492011-10-17 18:40:02 +0000830 ExprResult ExprRes = DefaultArgumentPromotion(E);
John Wiegley01296292011-04-08 18:41:53 +0000831 if (ExprRes.isInvalid())
832 return ExprError();
833 E = ExprRes.take();
Mike Stump11289f42009-09-09 15:08:12 +0000834
Richard Smith55ce3522012-06-25 20:30:08 +0000835 // Diagnostics regarding non-POD argument types are
836 // emitted along with format string checking in Sema::CheckFunctionCall().
Richard Smithd7293d72013-08-05 18:49:43 +0000837 if (isValidVarArgType(E->getType()) == VAK_Undefined) {
Richard Smith55ce3522012-06-25 20:30:08 +0000838 // Turn this into a trap.
839 CXXScopeSpec SS;
840 SourceLocation TemplateKWLoc;
841 UnqualifiedId Name;
842 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"),
843 E->getLocStart());
844 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc,
845 Name, true, false);
846 if (TrapFn.isInvalid())
847 return ExprError();
John McCall31168b02011-06-15 23:02:42 +0000848
Richard Smith55ce3522012-06-25 20:30:08 +0000849 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(),
Dmitri Gribenko78852e92013-05-05 20:40:26 +0000850 E->getLocStart(), None,
Richard Smith55ce3522012-06-25 20:30:08 +0000851 E->getLocEnd());
852 if (Call.isInvalid())
853 return ExprError();
Douglas Gregor347e0f22011-05-21 19:26:31 +0000854
Richard Smith55ce3522012-06-25 20:30:08 +0000855 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma,
856 Call.get(), E);
857 if (Comma.isInvalid())
858 return ExprError();
859 return Comma.get();
Douglas Gregor253cadf2011-05-21 16:27:21 +0000860 }
Richard Smith55ce3522012-06-25 20:30:08 +0000861
David Blaikiebbafb8a2012-03-11 07:00:24 +0000862 if (!getLangOpts().CPlusPlus &&
Fariborz Jahanian3854a552012-03-01 23:42:00 +0000863 RequireCompleteType(E->getExprLoc(), E->getType(),
Fariborz Jahanianbf482812012-03-02 17:05:03 +0000864 diag::err_call_incomplete_argument))
Fariborz Jahanian3854a552012-03-01 23:42:00 +0000865 return ExprError();
Richard Smith55ce3522012-06-25 20:30:08 +0000866
John Wiegley01296292011-04-08 18:41:53 +0000867 return Owned(E);
Anders Carlssona7d069d2009-01-16 16:48:51 +0000868}
869
Richard Trieu7aa58f12011-09-02 20:58:51 +0000870/// \brief Converts an integer to complex float type. Helper function of
871/// UsualArithmeticConversions()
872///
873/// \return false if the integer expression is an integer type and is
874/// successfully converted to the complex type.
Richard Trieuba63ce62011-09-09 01:45:06 +0000875static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr,
876 ExprResult &ComplexExpr,
877 QualType IntTy,
878 QualType ComplexTy,
879 bool SkipCast) {
880 if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
881 if (SkipCast) return false;
882 if (IntTy->isIntegerType()) {
883 QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType();
884 IntExpr = S.ImpCastExprToType(IntExpr.take(), fpTy, CK_IntegralToFloating);
885 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000886 CK_FloatingRealToComplex);
887 } else {
Richard Trieuba63ce62011-09-09 01:45:06 +0000888 assert(IntTy->isComplexIntegerType());
889 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000890 CK_IntegralComplexToFloatingComplex);
891 }
892 return false;
893}
894
895/// \brief Takes two complex float types and converts them to the same type.
896/// Helper function of UsualArithmeticConversions()
897static QualType
Richard Trieu5065cdd2011-09-06 18:25:09 +0000898handleComplexFloatToComplexFloatConverstion(Sema &S, ExprResult &LHS,
899 ExprResult &RHS, QualType LHSType,
900 QualType RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +0000901 bool IsCompAssign) {
Richard Trieu5065cdd2011-09-06 18:25:09 +0000902 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
Richard Trieu7aa58f12011-09-02 20:58:51 +0000903
904 if (order < 0) {
905 // _Complex float -> _Complex double
Richard Trieuba63ce62011-09-09 01:45:06 +0000906 if (!IsCompAssign)
Richard Trieu5065cdd2011-09-06 18:25:09 +0000907 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast);
908 return RHSType;
Richard Trieu7aa58f12011-09-02 20:58:51 +0000909 }
910 if (order > 0)
911 // _Complex float -> _Complex double
Richard Trieu5065cdd2011-09-06 18:25:09 +0000912 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingComplexCast);
913 return LHSType;
Richard Trieu7aa58f12011-09-02 20:58:51 +0000914}
915
916/// \brief Converts otherExpr to complex float and promotes complexExpr if
917/// necessary. Helper function of UsualArithmeticConversions()
918static QualType handleOtherComplexFloatConversion(Sema &S,
Richard Trieuba63ce62011-09-09 01:45:06 +0000919 ExprResult &ComplexExpr,
920 ExprResult &OtherExpr,
921 QualType ComplexTy,
922 QualType OtherTy,
923 bool ConvertComplexExpr,
924 bool ConvertOtherExpr) {
925 int order = S.Context.getFloatingTypeOrder(ComplexTy, OtherTy);
Richard Trieu7aa58f12011-09-02 20:58:51 +0000926
927 // If just the complexExpr is complex, the otherExpr needs to be converted,
928 // and the complexExpr might need to be promoted.
929 if (order > 0) { // complexExpr is wider
930 // float -> _Complex double
Richard Trieuba63ce62011-09-09 01:45:06 +0000931 if (ConvertOtherExpr) {
932 QualType fp = cast<ComplexType>(ComplexTy)->getElementType();
933 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), fp, CK_FloatingCast);
934 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), ComplexTy,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000935 CK_FloatingRealToComplex);
936 }
Richard Trieuba63ce62011-09-09 01:45:06 +0000937 return ComplexTy;
Richard Trieu7aa58f12011-09-02 20:58:51 +0000938 }
939
940 // otherTy is at least as wide. Find its corresponding complex type.
Richard Trieuba63ce62011-09-09 01:45:06 +0000941 QualType result = (order == 0 ? ComplexTy :
942 S.Context.getComplexType(OtherTy));
Richard Trieu7aa58f12011-09-02 20:58:51 +0000943
944 // double -> _Complex double
Richard Trieuba63ce62011-09-09 01:45:06 +0000945 if (ConvertOtherExpr)
946 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), result,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000947 CK_FloatingRealToComplex);
948
949 // _Complex float -> _Complex double
Richard Trieuba63ce62011-09-09 01:45:06 +0000950 if (ConvertComplexExpr && order < 0)
951 ComplexExpr = S.ImpCastExprToType(ComplexExpr.take(), result,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000952 CK_FloatingComplexCast);
953
954 return result;
955}
956
957/// \brief Handle arithmetic conversion with complex types. Helper function of
958/// UsualArithmeticConversions()
Richard Trieu5065cdd2011-09-06 18:25:09 +0000959static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS,
960 ExprResult &RHS, QualType LHSType,
961 QualType RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +0000962 bool IsCompAssign) {
Richard Trieu7aa58f12011-09-02 20:58:51 +0000963 // if we have an integer operand, the result is the complex type.
Richard Trieu5065cdd2011-09-06 18:25:09 +0000964 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000965 /*skipCast*/false))
Richard Trieu5065cdd2011-09-06 18:25:09 +0000966 return LHSType;
967 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +0000968 /*skipCast*/IsCompAssign))
Richard Trieu5065cdd2011-09-06 18:25:09 +0000969 return RHSType;
Richard Trieu7aa58f12011-09-02 20:58:51 +0000970
971 // This handles complex/complex, complex/float, or float/complex.
972 // When both operands are complex, the shorter operand is converted to the
973 // type of the longer, and that is the type of the result. This corresponds
974 // to what is done when combining two real floating-point operands.
975 // The fun begins when size promotion occur across type domains.
976 // From H&S 6.3.4: When one operand is complex and the other is a real
977 // floating-point type, the less precise type is converted, within it's
978 // real or complex domain, to the precision of the other type. For example,
979 // when combining a "long double" with a "double _Complex", the
980 // "double _Complex" is promoted to "long double _Complex".
981
Richard Trieu5065cdd2011-09-06 18:25:09 +0000982 bool LHSComplexFloat = LHSType->isComplexType();
983 bool RHSComplexFloat = RHSType->isComplexType();
Richard Trieu7aa58f12011-09-02 20:58:51 +0000984
985 // If both are complex, just cast to the more precise type.
986 if (LHSComplexFloat && RHSComplexFloat)
Richard Trieu5065cdd2011-09-06 18:25:09 +0000987 return handleComplexFloatToComplexFloatConverstion(S, LHS, RHS,
988 LHSType, RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +0000989 IsCompAssign);
Richard Trieu7aa58f12011-09-02 20:58:51 +0000990
991 // If only one operand is complex, promote it if necessary and convert the
992 // other operand to complex.
993 if (LHSComplexFloat)
994 return handleOtherComplexFloatConversion(
Richard Trieuba63ce62011-09-09 01:45:06 +0000995 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!IsCompAssign,
Richard Trieu7aa58f12011-09-02 20:58:51 +0000996 /*convertOtherExpr*/ true);
997
998 assert(RHSComplexFloat);
999 return handleOtherComplexFloatConversion(
Richard Trieu5065cdd2011-09-06 18:25:09 +00001000 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true,
Richard Trieuba63ce62011-09-09 01:45:06 +00001001 /*convertOtherExpr*/ !IsCompAssign);
Richard Trieu7aa58f12011-09-02 20:58:51 +00001002}
1003
1004/// \brief Hande arithmetic conversion from integer to float. Helper function
1005/// of UsualArithmeticConversions()
Richard Trieuba63ce62011-09-09 01:45:06 +00001006static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
1007 ExprResult &IntExpr,
1008 QualType FloatTy, QualType IntTy,
1009 bool ConvertFloat, bool ConvertInt) {
1010 if (IntTy->isIntegerType()) {
1011 if (ConvertInt)
Richard Trieu7aa58f12011-09-02 20:58:51 +00001012 // Convert intExpr to the lhs floating point type.
Richard Trieuba63ce62011-09-09 01:45:06 +00001013 IntExpr = S.ImpCastExprToType(IntExpr.take(), FloatTy,
Richard Trieu7aa58f12011-09-02 20:58:51 +00001014 CK_IntegralToFloating);
Richard Trieuba63ce62011-09-09 01:45:06 +00001015 return FloatTy;
Richard Trieu7aa58f12011-09-02 20:58:51 +00001016 }
1017
1018 // Convert both sides to the appropriate complex float.
Richard Trieuba63ce62011-09-09 01:45:06 +00001019 assert(IntTy->isComplexIntegerType());
1020 QualType result = S.Context.getComplexType(FloatTy);
Richard Trieu7aa58f12011-09-02 20:58:51 +00001021
1022 // _Complex int -> _Complex float
Richard Trieuba63ce62011-09-09 01:45:06 +00001023 if (ConvertInt)
1024 IntExpr = S.ImpCastExprToType(IntExpr.take(), result,
Richard Trieu7aa58f12011-09-02 20:58:51 +00001025 CK_IntegralComplexToFloatingComplex);
1026
1027 // float -> _Complex float
Richard Trieuba63ce62011-09-09 01:45:06 +00001028 if (ConvertFloat)
1029 FloatExpr = S.ImpCastExprToType(FloatExpr.take(), result,
Richard Trieu7aa58f12011-09-02 20:58:51 +00001030 CK_FloatingRealToComplex);
1031
1032 return result;
1033}
1034
1035/// \brief Handle arithmethic conversion with floating point types. Helper
1036/// function of UsualArithmeticConversions()
Richard Trieucfe3f212011-09-06 18:38:41 +00001037static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
1038 ExprResult &RHS, QualType LHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +00001039 QualType RHSType, bool IsCompAssign) {
Richard Trieucfe3f212011-09-06 18:38:41 +00001040 bool LHSFloat = LHSType->isRealFloatingType();
1041 bool RHSFloat = RHSType->isRealFloatingType();
Richard Trieu7aa58f12011-09-02 20:58:51 +00001042
1043 // If we have two real floating types, convert the smaller operand
1044 // to the bigger result.
1045 if (LHSFloat && RHSFloat) {
Richard Trieucfe3f212011-09-06 18:38:41 +00001046 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
Richard Trieu7aa58f12011-09-02 20:58:51 +00001047 if (order > 0) {
Richard Trieucfe3f212011-09-06 18:38:41 +00001048 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingCast);
1049 return LHSType;
Richard Trieu7aa58f12011-09-02 20:58:51 +00001050 }
1051
1052 assert(order < 0 && "illegal float comparison");
Richard Trieuba63ce62011-09-09 01:45:06 +00001053 if (!IsCompAssign)
Richard Trieucfe3f212011-09-06 18:38:41 +00001054 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast);
1055 return RHSType;
Richard Trieu7aa58f12011-09-02 20:58:51 +00001056 }
1057
1058 if (LHSFloat)
Richard Trieucfe3f212011-09-06 18:38:41 +00001059 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +00001060 /*convertFloat=*/!IsCompAssign,
Richard Trieu7aa58f12011-09-02 20:58:51 +00001061 /*convertInt=*/ true);
1062 assert(RHSFloat);
Richard Trieucfe3f212011-09-06 18:38:41 +00001063 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
Richard Trieu7aa58f12011-09-02 20:58:51 +00001064 /*convertInt=*/ true,
Richard Trieuba63ce62011-09-09 01:45:06 +00001065 /*convertFloat=*/!IsCompAssign);
Richard Trieu7aa58f12011-09-02 20:58:51 +00001066}
1067
Bill Schmidteb03ae22013-02-01 15:34:29 +00001068typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);
Richard Trieu7aa58f12011-09-02 20:58:51 +00001069
Bill Schmidteb03ae22013-02-01 15:34:29 +00001070namespace {
1071/// These helper callbacks are placed in an anonymous namespace to
1072/// permit their use as function template parameters.
1073ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
1074 return S.ImpCastExprToType(op, toType, CK_IntegralCast);
1075}
Richard Trieu7aa58f12011-09-02 20:58:51 +00001076
Bill Schmidteb03ae22013-02-01 15:34:29 +00001077ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
1078 return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
1079 CK_IntegralComplexCast);
1080}
Richard Trieu7aa58f12011-09-02 20:58:51 +00001081}
1082
1083/// \brief Handle integer arithmetic conversions. Helper function of
1084/// UsualArithmeticConversions()
Bill Schmidteb03ae22013-02-01 15:34:29 +00001085template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001086static QualType handleIntegerConversion(Sema &S, ExprResult &LHS,
1087 ExprResult &RHS, QualType LHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +00001088 QualType RHSType, bool IsCompAssign) {
Richard Trieu7aa58f12011-09-02 20:58:51 +00001089 // The rules for this case are in C99 6.3.1.8
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001090 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
1091 bool LHSSigned = LHSType->hasSignedIntegerRepresentation();
1092 bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
1093 if (LHSSigned == RHSSigned) {
Richard Trieu7aa58f12011-09-02 20:58:51 +00001094 // Same signedness; use the higher-ranked type
1095 if (order >= 0) {
Bill Schmidteb03ae22013-02-01 15:34:29 +00001096 RHS = (*doRHSCast)(S, RHS.take(), LHSType);
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001097 return LHSType;
Richard Trieuba63ce62011-09-09 01:45:06 +00001098 } else if (!IsCompAssign)
Bill Schmidteb03ae22013-02-01 15:34:29 +00001099 LHS = (*doLHSCast)(S, LHS.take(), RHSType);
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001100 return RHSType;
1101 } else if (order != (LHSSigned ? 1 : -1)) {
Richard Trieu7aa58f12011-09-02 20:58:51 +00001102 // The unsigned type has greater than or equal rank to the
1103 // signed type, so use the unsigned type
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001104 if (RHSSigned) {
Bill Schmidteb03ae22013-02-01 15:34:29 +00001105 RHS = (*doRHSCast)(S, RHS.take(), LHSType);
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001106 return LHSType;
Richard Trieuba63ce62011-09-09 01:45:06 +00001107 } else if (!IsCompAssign)
Bill Schmidteb03ae22013-02-01 15:34:29 +00001108 LHS = (*doLHSCast)(S, LHS.take(), RHSType);
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001109 return RHSType;
1110 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) {
Richard Trieu7aa58f12011-09-02 20:58:51 +00001111 // The two types are different widths; if we are here, that
1112 // means the signed type is larger than the unsigned type, so
1113 // use the signed type.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001114 if (LHSSigned) {
Bill Schmidteb03ae22013-02-01 15:34:29 +00001115 RHS = (*doRHSCast)(S, RHS.take(), LHSType);
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001116 return LHSType;
Richard Trieuba63ce62011-09-09 01:45:06 +00001117 } else if (!IsCompAssign)
Bill Schmidteb03ae22013-02-01 15:34:29 +00001118 LHS = (*doLHSCast)(S, LHS.take(), RHSType);
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001119 return RHSType;
Richard Trieu7aa58f12011-09-02 20:58:51 +00001120 } else {
1121 // The signed type is higher-ranked than the unsigned type,
1122 // but isn't actually any bigger (like unsigned int and long
1123 // on most 32-bit systems). Use the unsigned type corresponding
1124 // to the signed type.
1125 QualType result =
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001126 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
Bill Schmidteb03ae22013-02-01 15:34:29 +00001127 RHS = (*doRHSCast)(S, RHS.take(), result);
Richard Trieuba63ce62011-09-09 01:45:06 +00001128 if (!IsCompAssign)
Bill Schmidteb03ae22013-02-01 15:34:29 +00001129 LHS = (*doLHSCast)(S, LHS.take(), result);
Richard Trieu7aa58f12011-09-02 20:58:51 +00001130 return result;
1131 }
1132}
1133
Bill Schmidteb03ae22013-02-01 15:34:29 +00001134/// \brief Handle conversions with GCC complex int extension. Helper function
1135/// of UsualArithmeticConversions()
1136static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
1137 ExprResult &RHS, QualType LHSType,
1138 QualType RHSType,
1139 bool IsCompAssign) {
1140 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType();
1141 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType();
1142
1143 if (LHSComplexInt && RHSComplexInt) {
1144 QualType LHSEltType = LHSComplexInt->getElementType();
1145 QualType RHSEltType = RHSComplexInt->getElementType();
1146 QualType ScalarType =
1147 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
1148 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
1149
1150 return S.Context.getComplexType(ScalarType);
1151 }
1152
1153 if (LHSComplexInt) {
1154 QualType LHSEltType = LHSComplexInt->getElementType();
1155 QualType ScalarType =
1156 handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
1157 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
1158 QualType ComplexType = S.Context.getComplexType(ScalarType);
1159 RHS = S.ImpCastExprToType(RHS.take(), ComplexType,
1160 CK_IntegralRealToComplex);
1161
1162 return ComplexType;
1163 }
1164
1165 assert(RHSComplexInt);
1166
1167 QualType RHSEltType = RHSComplexInt->getElementType();
1168 QualType ScalarType =
1169 handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
1170 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
1171 QualType ComplexType = S.Context.getComplexType(ScalarType);
1172
1173 if (!IsCompAssign)
1174 LHS = S.ImpCastExprToType(LHS.take(), ComplexType,
1175 CK_IntegralRealToComplex);
1176 return ComplexType;
1177}
1178
Chris Lattner513165e2008-07-25 21:10:04 +00001179/// UsualArithmeticConversions - Performs various conversions that are common to
1180/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
Mike Stump11289f42009-09-09 15:08:12 +00001181/// routine returns the first non-arithmetic type found. The client is
Chris Lattner513165e2008-07-25 21:10:04 +00001182/// responsible for emitting appropriate error diagnostics.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001183QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
Richard Trieuba63ce62011-09-09 01:45:06 +00001184 bool IsCompAssign) {
1185 if (!IsCompAssign) {
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001186 LHS = UsualUnaryConversions(LHS.take());
1187 if (LHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00001188 return QualType();
1189 }
Eli Friedman8b7b1b12009-03-28 01:22:36 +00001190
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001191 RHS = UsualUnaryConversions(RHS.take());
1192 if (RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00001193 return QualType();
Douglas Gregora11693b2008-11-12 17:17:38 +00001194
Mike Stump11289f42009-09-09 15:08:12 +00001195 // For conversion purposes, we ignore any qualifiers.
Chris Lattner513165e2008-07-25 21:10:04 +00001196 // For example, "const float" and "float" are equivalent.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001197 QualType LHSType =
1198 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
1199 QualType RHSType =
1200 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
Douglas Gregora11693b2008-11-12 17:17:38 +00001201
Eli Friedman93ee5ca2012-06-16 02:19:17 +00001202 // For conversion purposes, we ignore any atomic qualifier on the LHS.
1203 if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>())
1204 LHSType = AtomicLHS->getValueType();
1205
Douglas Gregora11693b2008-11-12 17:17:38 +00001206 // If both types are identical, no conversion is needed.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001207 if (LHSType == RHSType)
1208 return LHSType;
Douglas Gregora11693b2008-11-12 17:17:38 +00001209
1210 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
1211 // The caller can deal with this (e.g. pointer + int).
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001212 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
Eli Friedman93ee5ca2012-06-16 02:19:17 +00001213 return QualType();
Douglas Gregora11693b2008-11-12 17:17:38 +00001214
John McCalld005ac92010-11-13 08:17:45 +00001215 // Apply unary and bitfield promotions to the LHS's type.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001216 QualType LHSUnpromotedType = LHSType;
1217 if (LHSType->isPromotableIntegerType())
1218 LHSType = Context.getPromotedIntegerType(LHSType);
1219 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get());
Douglas Gregord2c2d172009-05-02 00:36:19 +00001220 if (!LHSBitfieldPromoteTy.isNull())
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001221 LHSType = LHSBitfieldPromoteTy;
Richard Trieuba63ce62011-09-09 01:45:06 +00001222 if (LHSType != LHSUnpromotedType && !IsCompAssign)
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001223 LHS = ImpCastExprToType(LHS.take(), LHSType, CK_IntegralCast);
Douglas Gregord2c2d172009-05-02 00:36:19 +00001224
John McCalld005ac92010-11-13 08:17:45 +00001225 // If both types are identical, no conversion is needed.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001226 if (LHSType == RHSType)
1227 return LHSType;
John McCalld005ac92010-11-13 08:17:45 +00001228
1229 // At this point, we have two different arithmetic types.
1230
1231 // Handle complex types first (C99 6.3.1.8p1).
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001232 if (LHSType->isComplexType() || RHSType->isComplexType())
1233 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +00001234 IsCompAssign);
John McCalld005ac92010-11-13 08:17:45 +00001235
1236 // Now handle "real" floating types (i.e. float, double, long double).
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001237 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
1238 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +00001239 IsCompAssign);
John McCalld005ac92010-11-13 08:17:45 +00001240
1241 // Handle GCC complex int extension.
Richard Trieu9a52fbb2011-09-06 19:52:52 +00001242 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType())
Benjamin Kramer499c68b2011-09-06 19:57:14 +00001243 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType,
Richard Trieuba63ce62011-09-09 01:45:06 +00001244 IsCompAssign);
John McCalld005ac92010-11-13 08:17:45 +00001245
1246 // Finally, we have two differing integer types.
Bill Schmidteb03ae22013-02-01 15:34:29 +00001247 return handleIntegerConversion<doIntegralCast, doIntegralCast>
1248 (*this, LHS, RHS, LHSType, RHSType, IsCompAssign);
Douglas Gregora11693b2008-11-12 17:17:38 +00001249}
1250
Bill Schmidteb03ae22013-02-01 15:34:29 +00001251
Chris Lattner513165e2008-07-25 21:10:04 +00001252//===----------------------------------------------------------------------===//
1253// Semantic Analysis for various Expression Types
1254//===----------------------------------------------------------------------===//
1255
1256
Peter Collingbourne91147592011-04-15 00:35:48 +00001257ExprResult
1258Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
1259 SourceLocation DefaultLoc,
1260 SourceLocation RParenLoc,
1261 Expr *ControllingExpr,
Dmitri Gribenko82360372013-05-10 13:06:58 +00001262 ArrayRef<ParsedType> ArgTypes,
1263 ArrayRef<Expr *> ArgExprs) {
Richard Trieuba63ce62011-09-09 01:45:06 +00001264 unsigned NumAssocs = ArgTypes.size();
1265 assert(NumAssocs == ArgExprs.size());
Peter Collingbourne91147592011-04-15 00:35:48 +00001266
Peter Collingbourne91147592011-04-15 00:35:48 +00001267 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
1268 for (unsigned i = 0; i < NumAssocs; ++i) {
Dmitri Gribenko82360372013-05-10 13:06:58 +00001269 if (ArgTypes[i])
1270 (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
Peter Collingbourne91147592011-04-15 00:35:48 +00001271 else
1272 Types[i] = 0;
1273 }
1274
1275 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc,
Dmitri Gribenko82360372013-05-10 13:06:58 +00001276 ControllingExpr,
1277 llvm::makeArrayRef(Types, NumAssocs),
1278 ArgExprs);
Benjamin Kramer34623762011-04-15 11:21:57 +00001279 delete [] Types;
Peter Collingbourne91147592011-04-15 00:35:48 +00001280 return ER;
1281}
1282
1283ExprResult
1284Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc,
1285 SourceLocation DefaultLoc,
1286 SourceLocation RParenLoc,
1287 Expr *ControllingExpr,
Dmitri Gribenko82360372013-05-10 13:06:58 +00001288 ArrayRef<TypeSourceInfo *> Types,
1289 ArrayRef<Expr *> Exprs) {
1290 unsigned NumAssocs = Types.size();
1291 assert(NumAssocs == Exprs.size());
John McCall587b3482013-02-12 02:08:12 +00001292 if (ControllingExpr->getType()->isPlaceholderType()) {
1293 ExprResult result = CheckPlaceholderExpr(ControllingExpr);
1294 if (result.isInvalid()) return ExprError();
1295 ControllingExpr = result.take();
1296 }
1297
Peter Collingbourne91147592011-04-15 00:35:48 +00001298 bool TypeErrorFound = false,
1299 IsResultDependent = ControllingExpr->isTypeDependent(),
1300 ContainsUnexpandedParameterPack
1301 = ControllingExpr->containsUnexpandedParameterPack();
1302
1303 for (unsigned i = 0; i < NumAssocs; ++i) {
1304 if (Exprs[i]->containsUnexpandedParameterPack())
1305 ContainsUnexpandedParameterPack = true;
1306
1307 if (Types[i]) {
1308 if (Types[i]->getType()->containsUnexpandedParameterPack())
1309 ContainsUnexpandedParameterPack = true;
1310
1311 if (Types[i]->getType()->isDependentType()) {
1312 IsResultDependent = true;
1313 } else {
Benjamin Kramere56f3932011-12-23 17:00:35 +00001314 // C11 6.5.1.1p2 "The type name in a generic association shall specify a
Peter Collingbourne91147592011-04-15 00:35:48 +00001315 // complete object type other than a variably modified type."
1316 unsigned D = 0;
1317 if (Types[i]->getType()->isIncompleteType())
1318 D = diag::err_assoc_type_incomplete;
1319 else if (!Types[i]->getType()->isObjectType())
1320 D = diag::err_assoc_type_nonobject;
1321 else if (Types[i]->getType()->isVariablyModifiedType())
1322 D = diag::err_assoc_type_variably_modified;
1323
1324 if (D != 0) {
1325 Diag(Types[i]->getTypeLoc().getBeginLoc(), D)
1326 << Types[i]->getTypeLoc().getSourceRange()
1327 << Types[i]->getType();
1328 TypeErrorFound = true;
1329 }
1330
Benjamin Kramere56f3932011-12-23 17:00:35 +00001331 // C11 6.5.1.1p2 "No two generic associations in the same generic
Peter Collingbourne91147592011-04-15 00:35:48 +00001332 // selection shall specify compatible types."
1333 for (unsigned j = i+1; j < NumAssocs; ++j)
1334 if (Types[j] && !Types[j]->getType()->isDependentType() &&
1335 Context.typesAreCompatible(Types[i]->getType(),
1336 Types[j]->getType())) {
1337 Diag(Types[j]->getTypeLoc().getBeginLoc(),
1338 diag::err_assoc_compatible_types)
1339 << Types[j]->getTypeLoc().getSourceRange()
1340 << Types[j]->getType()
1341 << Types[i]->getType();
1342 Diag(Types[i]->getTypeLoc().getBeginLoc(),
1343 diag::note_compat_assoc)
1344 << Types[i]->getTypeLoc().getSourceRange()
1345 << Types[i]->getType();
1346 TypeErrorFound = true;
1347 }
1348 }
1349 }
1350 }
1351 if (TypeErrorFound)
1352 return ExprError();
1353
1354 // If we determined that the generic selection is result-dependent, don't
1355 // try to compute the result expression.
1356 if (IsResultDependent)
1357 return Owned(new (Context) GenericSelectionExpr(
1358 Context, KeyLoc, ControllingExpr,
Dmitri Gribenko82360372013-05-10 13:06:58 +00001359 Types, Exprs,
Benjamin Kramerc215e762012-08-24 11:54:20 +00001360 DefaultLoc, RParenLoc, ContainsUnexpandedParameterPack));
Peter Collingbourne91147592011-04-15 00:35:48 +00001361
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001362 SmallVector<unsigned, 1> CompatIndices;
Peter Collingbourne91147592011-04-15 00:35:48 +00001363 unsigned DefaultIndex = -1U;
1364 for (unsigned i = 0; i < NumAssocs; ++i) {
1365 if (!Types[i])
1366 DefaultIndex = i;
1367 else if (Context.typesAreCompatible(ControllingExpr->getType(),
1368 Types[i]->getType()))
1369 CompatIndices.push_back(i);
1370 }
1371
Benjamin Kramere56f3932011-12-23 17:00:35 +00001372 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have
Peter Collingbourne91147592011-04-15 00:35:48 +00001373 // type compatible with at most one of the types named in its generic
1374 // association list."
1375 if (CompatIndices.size() > 1) {
1376 // We strip parens here because the controlling expression is typically
1377 // parenthesized in macro definitions.
1378 ControllingExpr = ControllingExpr->IgnoreParens();
1379 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match)
1380 << ControllingExpr->getSourceRange() << ControllingExpr->getType()
1381 << (unsigned) CompatIndices.size();
Craig Topper2341c0d2013-07-04 03:08:24 +00001382 for (SmallVectorImpl<unsigned>::iterator I = CompatIndices.begin(),
Peter Collingbourne91147592011-04-15 00:35:48 +00001383 E = CompatIndices.end(); I != E; ++I) {
1384 Diag(Types[*I]->getTypeLoc().getBeginLoc(),
1385 diag::note_compat_assoc)
1386 << Types[*I]->getTypeLoc().getSourceRange()
1387 << Types[*I]->getType();
1388 }
1389 return ExprError();
1390 }
1391
Benjamin Kramere56f3932011-12-23 17:00:35 +00001392 // C11 6.5.1.1p2 "If a generic selection has no default generic association,
Peter Collingbourne91147592011-04-15 00:35:48 +00001393 // its controlling expression shall have type compatible with exactly one of
1394 // the types named in its generic association list."
1395 if (DefaultIndex == -1U && CompatIndices.size() == 0) {
1396 // We strip parens here because the controlling expression is typically
1397 // parenthesized in macro definitions.
1398 ControllingExpr = ControllingExpr->IgnoreParens();
1399 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match)
1400 << ControllingExpr->getSourceRange() << ControllingExpr->getType();
1401 return ExprError();
1402 }
1403
Benjamin Kramere56f3932011-12-23 17:00:35 +00001404 // C11 6.5.1.1p3 "If a generic selection has a generic association with a
Peter Collingbourne91147592011-04-15 00:35:48 +00001405 // type name that is compatible with the type of the controlling expression,
1406 // then the result expression of the generic selection is the expression
1407 // in that generic association. Otherwise, the result expression of the
1408 // generic selection is the expression in the default generic association."
1409 unsigned ResultIndex =
1410 CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
1411
1412 return Owned(new (Context) GenericSelectionExpr(
1413 Context, KeyLoc, ControllingExpr,
Dmitri Gribenko82360372013-05-10 13:06:58 +00001414 Types, Exprs,
Benjamin Kramerc215e762012-08-24 11:54:20 +00001415 DefaultLoc, RParenLoc, ContainsUnexpandedParameterPack,
Peter Collingbourne91147592011-04-15 00:35:48 +00001416 ResultIndex));
1417}
1418
Richard Smith75b67d62012-03-08 01:34:56 +00001419/// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the
1420/// location of the token and the offset of the ud-suffix within it.
1421static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc,
1422 unsigned Offset) {
1423 return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00001424 S.getLangOpts());
Richard Smith75b67d62012-03-08 01:34:56 +00001425}
1426
Richard Smithbcc22fc2012-03-09 08:00:36 +00001427/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up
1428/// the corresponding cooked (non-raw) literal operator, and build a call to it.
1429static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
1430 IdentifierInfo *UDSuffix,
1431 SourceLocation UDSuffixLoc,
1432 ArrayRef<Expr*> Args,
1433 SourceLocation LitEndLoc) {
1434 assert(Args.size() <= 2 && "too many arguments for literal operator");
1435
1436 QualType ArgTy[2];
1437 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) {
1438 ArgTy[ArgIdx] = Args[ArgIdx]->getType();
1439 if (ArgTy[ArgIdx]->isArrayType())
1440 ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]);
1441 }
1442
1443 DeclarationName OpName =
1444 S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
1445 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
1446 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
1447
1448 LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName);
1449 if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()),
Richard Smithb8b41d32013-10-07 19:57:58 +00001450 /*AllowRaw*/false, /*AllowTemplate*/false,
1451 /*AllowStringTemplate*/false) == Sema::LOLR_Error)
Richard Smithbcc22fc2012-03-09 08:00:36 +00001452 return ExprError();
1453
1454 return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc);
1455}
1456
Steve Naroff83895f72007-09-16 03:34:24 +00001457/// ActOnStringLiteral - The specified tokens were lexed as pasted string
Chris Lattner5b183d82006-11-10 05:03:26 +00001458/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
1459/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1460/// multiple tokens. However, the common case is that StringToks points to one
1461/// string.
Sebastian Redlffbcf962009-01-18 18:53:16 +00001462///
John McCalldadc5752010-08-24 06:29:42 +00001463ExprResult
Richard Smithbcc22fc2012-03-09 08:00:36 +00001464Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks,
1465 Scope *UDLScope) {
Chris Lattner5b183d82006-11-10 05:03:26 +00001466 assert(NumStringToks && "Must have at least one string!");
1467
Chris Lattner8a24e582009-01-16 18:51:42 +00001468 StringLiteralParser Literal(StringToks, NumStringToks, PP);
Steve Naroff4f88b312007-03-13 22:37:02 +00001469 if (Literal.hadError)
Sebastian Redlffbcf962009-01-18 18:53:16 +00001470 return ExprError();
Chris Lattner5b183d82006-11-10 05:03:26 +00001471
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001472 SmallVector<SourceLocation, 4> StringTokLocs;
Chris Lattner5b183d82006-11-10 05:03:26 +00001473 for (unsigned i = 0; i != NumStringToks; ++i)
1474 StringTokLocs.push_back(StringToks[i].getLocation());
Chris Lattner36fc8792008-02-11 00:02:17 +00001475
Richard Smithb8b41d32013-10-07 19:57:58 +00001476 QualType CharTy = Context.CharTy;
Douglas Gregorfb65e592011-07-27 05:40:30 +00001477 StringLiteral::StringKind Kind = StringLiteral::Ascii;
Richard Smithb8b41d32013-10-07 19:57:58 +00001478 if (Literal.isWide()) {
1479 CharTy = Context.getWideCharType();
Douglas Gregorfb65e592011-07-27 05:40:30 +00001480 Kind = StringLiteral::Wide;
Richard Smithb8b41d32013-10-07 19:57:58 +00001481 } else if (Literal.isUTF8()) {
Douglas Gregorfb65e592011-07-27 05:40:30 +00001482 Kind = StringLiteral::UTF8;
Richard Smithb8b41d32013-10-07 19:57:58 +00001483 } else if (Literal.isUTF16()) {
1484 CharTy = Context.Char16Ty;
Douglas Gregorfb65e592011-07-27 05:40:30 +00001485 Kind = StringLiteral::UTF16;
Richard Smithb8b41d32013-10-07 19:57:58 +00001486 } else if (Literal.isUTF32()) {
1487 CharTy = Context.Char32Ty;
Douglas Gregorfb65e592011-07-27 05:40:30 +00001488 Kind = StringLiteral::UTF32;
Richard Smithb8b41d32013-10-07 19:57:58 +00001489 } else if (Literal.isPascal()) {
1490 CharTy = Context.UnsignedCharTy;
1491 }
Douglas Gregorfb65e592011-07-27 05:40:30 +00001492
Richard Smithb8b41d32013-10-07 19:57:58 +00001493 QualType CharTyConst = CharTy;
Douglas Gregoraa1e21d2008-09-12 00:47:35 +00001494 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1).
David Blaikiebbafb8a2012-03-11 07:00:24 +00001495 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings)
Richard Smithb8b41d32013-10-07 19:57:58 +00001496 CharTyConst.addConst();
Sebastian Redlffbcf962009-01-18 18:53:16 +00001497
Chris Lattner36fc8792008-02-11 00:02:17 +00001498 // Get an array type for the string, according to C99 6.4.5. This includes
1499 // the nul terminator character as well as the string length for pascal
1500 // strings.
Richard Smithb8b41d32013-10-07 19:57:58 +00001501 QualType StrTy = Context.getConstantArrayType(CharTyConst,
Chris Lattnerd42c29f2009-02-26 23:01:51 +00001502 llvm::APInt(32, Literal.GetNumStringChars()+1),
Richard Smithb8b41d32013-10-07 19:57:58 +00001503 ArrayType::Normal, 0);
Mike Stump11289f42009-09-09 15:08:12 +00001504
Joey Gouly561bba22013-11-14 18:26:10 +00001505 // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
1506 if (getLangOpts().OpenCL) {
1507 StrTy = Context.getAddrSpaceQualType(StrTy, LangAS::opencl_constant);
1508 }
1509
Chris Lattner5b183d82006-11-10 05:03:26 +00001510 // Pass &StringTokLocs[0], StringTokLocs.size() to factory!
Richard Smithc67fdd42012-03-07 08:35:16 +00001511 StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(),
1512 Kind, Literal.Pascal, StrTy,
1513 &StringTokLocs[0],
1514 StringTokLocs.size());
1515 if (Literal.getUDSuffix().empty())
1516 return Owned(Lit);
1517
1518 // We're building a user-defined literal.
1519 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
Richard Smith75b67d62012-03-08 01:34:56 +00001520 SourceLocation UDSuffixLoc =
1521 getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
1522 Literal.getUDSuffixOffset());
Richard Smithc67fdd42012-03-07 08:35:16 +00001523
Richard Smithbcc22fc2012-03-09 08:00:36 +00001524 // Make sure we're allowed user-defined literals here.
1525 if (!UDLScope)
1526 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl));
1527
Richard Smithc67fdd42012-03-07 08:35:16 +00001528 // C++11 [lex.ext]p5: The literal L is treated as a call of the form
1529 // operator "" X (str, len)
1530 QualType SizeType = Context.getSizeType();
Richard Smithb8b41d32013-10-07 19:57:58 +00001531
1532 DeclarationName OpName =
1533 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
1534 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
1535 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
1536
1537 QualType ArgTy[] = {
1538 Context.getArrayDecayedType(StrTy), SizeType
1539 };
1540
1541 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
1542 switch (LookupLiteralOperator(UDLScope, R, ArgTy,
1543 /*AllowRaw*/false, /*AllowTemplate*/false,
1544 /*AllowStringTemplate*/true)) {
1545
1546 case LOLR_Cooked: {
1547 llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars());
1548 IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType,
1549 StringTokLocs[0]);
1550 Expr *Args[] = { Lit, LenArg };
1551
1552 return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back());
1553 }
1554
1555 case LOLR_StringTemplate: {
1556 TemplateArgumentListInfo ExplicitArgs;
1557
1558 unsigned CharBits = Context.getIntWidth(CharTy);
1559 bool CharIsUnsigned = CharTy->isUnsignedIntegerType();
1560 llvm::APSInt Value(CharBits, CharIsUnsigned);
1561
1562 TemplateArgument TypeArg(CharTy);
1563 TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy));
1564 ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo));
1565
1566 for (unsigned I = 0, N = Lit->getLength(); I != N; ++I) {
1567 Value = Lit->getCodeUnit(I);
1568 TemplateArgument Arg(Context, Value, CharTy);
1569 TemplateArgumentLocInfo ArgInfo;
1570 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
1571 }
1572 return BuildLiteralOperatorCall(R, OpNameInfo, None, StringTokLocs.back(),
1573 &ExplicitArgs);
1574 }
1575 case LOLR_Raw:
1576 case LOLR_Template:
1577 llvm_unreachable("unexpected literal operator lookup result");
1578 case LOLR_Error:
1579 return ExprError();
1580 }
1581 llvm_unreachable("unexpected literal operator lookup result");
Chris Lattner5b183d82006-11-10 05:03:26 +00001582}
1583
John McCalldadc5752010-08-24 06:29:42 +00001584ExprResult
John McCall7decc9e2010-11-18 06:31:45 +00001585Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
John McCallf4cd4f92011-02-09 01:13:10 +00001586 SourceLocation Loc,
1587 const CXXScopeSpec *SS) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001588 DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
John McCall7decc9e2010-11-18 06:31:45 +00001589 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001590}
1591
John McCallf4cd4f92011-02-09 01:13:10 +00001592/// BuildDeclRefExpr - Build an expression that references a
1593/// declaration that does not require a closure capture.
John McCalldadc5752010-08-24 06:29:42 +00001594ExprResult
John McCallf4cd4f92011-02-09 01:13:10 +00001595Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001596 const DeclarationNameInfo &NameInfo,
Larisse Voufo39a1e502013-08-06 01:03:05 +00001597 const CXXScopeSpec *SS, NamedDecl *FoundD,
1598 const TemplateArgumentListInfo *TemplateArgs) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001599 if (getLangOpts().CUDA)
Peter Collingbourne7277fe82011-10-02 23:49:40 +00001600 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
1601 if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) {
1602 CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller),
1603 CalleeTarget = IdentifyCUDATarget(Callee);
1604 if (CheckCUDATarget(CallerTarget, CalleeTarget)) {
1605 Diag(NameInfo.getLoc(), diag::err_ref_bad_target)
1606 << CalleeTarget << D->getIdentifier() << CallerTarget;
1607 Diag(D->getLocation(), diag::note_previous_decl)
1608 << D->getIdentifier();
1609 return ExprError();
1610 }
1611 }
1612
John McCall113bee02012-03-10 09:33:50 +00001613 bool refersToEnclosingScope =
1614 (CurContext != D->getDeclContext() &&
Richard Smith75e3f692013-09-28 04:31:26 +00001615 D->getDeclContext()->isFunctionOrMethod()) ||
1616 (isa<VarDecl>(D) &&
1617 cast<VarDecl>(D)->isInitCapture());
John McCall113bee02012-03-10 09:33:50 +00001618
Larisse Voufo39a1e502013-08-06 01:03:05 +00001619 DeclRefExpr *E;
1620 if (isa<VarTemplateSpecializationDecl>(D)) {
1621 VarTemplateSpecializationDecl *VarSpec =
1622 cast<VarTemplateSpecializationDecl>(D);
1623
1624 E = DeclRefExpr::Create(
1625 Context,
1626 SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc(),
1627 VarSpec->getTemplateKeywordLoc(), D, refersToEnclosingScope,
1628 NameInfo.getLoc(), Ty, VK, FoundD, TemplateArgs);
1629 } else {
1630 assert(!TemplateArgs && "No template arguments for non-variable"
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001631 " template specialization references");
Larisse Voufo39a1e502013-08-06 01:03:05 +00001632 E = DeclRefExpr::Create(
1633 Context,
1634 SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc(),
1635 SourceLocation(), D, refersToEnclosingScope, NameInfo, Ty, VK, FoundD);
1636 }
Mike Stump11289f42009-09-09 15:08:12 +00001637
Eli Friedmanfa0df832012-02-02 03:46:19 +00001638 MarkDeclRefReferenced(E);
John McCall086a4642010-11-24 05:12:34 +00001639
Jordan Rose657b5f42012-09-28 22:21:35 +00001640 if (getLangOpts().ObjCARCWeak && isa<VarDecl>(D) &&
1641 Ty.getObjCLifetime() == Qualifiers::OCL_Weak) {
1642 DiagnosticsEngine::Level Level =
1643 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak,
1644 E->getLocStart());
1645 if (Level != DiagnosticsEngine::Ignored)
Fariborz Jahanian6f829e32013-05-21 21:20:26 +00001646 recordUseOfEvaluatedWeak(E);
Jordan Rose657b5f42012-09-28 22:21:35 +00001647 }
1648
John McCall086a4642010-11-24 05:12:34 +00001649 // Just in case we're building an illegal pointer-to-member.
Richard Smithcaf33902011-10-10 18:28:20 +00001650 FieldDecl *FD = dyn_cast<FieldDecl>(D);
1651 if (FD && FD->isBitField())
John McCall086a4642010-11-24 05:12:34 +00001652 E->setObjectKind(OK_BitField);
1653
1654 return Owned(E);
Douglas Gregorc7acfdf2009-01-06 05:10:23 +00001655}
1656
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001657/// Decomposes the given name into a DeclarationNameInfo, its location, and
John McCall10eae182009-11-30 22:42:35 +00001658/// possibly a list of template arguments.
1659///
1660/// If this produces template arguments, it is permitted to call
1661/// DecomposeTemplateName.
1662///
1663/// This actually loses a lot of source location information for
1664/// non-standard name kinds; we should consider preserving that in
1665/// some way.
Richard Trieucfc491d2011-08-02 04:35:43 +00001666void
1667Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id,
1668 TemplateArgumentListInfo &Buffer,
1669 DeclarationNameInfo &NameInfo,
1670 const TemplateArgumentListInfo *&TemplateArgs) {
John McCall10eae182009-11-30 22:42:35 +00001671 if (Id.getKind() == UnqualifiedId::IK_TemplateId) {
1672 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
1673 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
1674
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00001675 ASTTemplateArgsPtr TemplateArgsPtr(Id.TemplateId->getTemplateArgs(),
John McCall10eae182009-11-30 22:42:35 +00001676 Id.TemplateId->NumArgs);
Douglas Gregor5476205b2011-06-23 00:49:38 +00001677 translateTemplateArguments(TemplateArgsPtr, Buffer);
John McCall10eae182009-11-30 22:42:35 +00001678
John McCall3e56fd42010-08-23 07:28:44 +00001679 TemplateName TName = Id.TemplateId->Template.get();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001680 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc;
Douglas Gregor5476205b2011-06-23 00:49:38 +00001681 NameInfo = Context.getNameForTemplate(TName, TNameLoc);
John McCall10eae182009-11-30 22:42:35 +00001682 TemplateArgs = &Buffer;
1683 } else {
Douglas Gregor5476205b2011-06-23 00:49:38 +00001684 NameInfo = GetNameFromUnqualifiedId(Id);
John McCall10eae182009-11-30 22:42:35 +00001685 TemplateArgs = 0;
1686 }
1687}
1688
John McCalld681c392009-12-16 08:11:27 +00001689/// Diagnose an empty lookup.
1690///
1691/// \return false if new lookup candidates were found
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001692bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
Kaelyn Uhrain79d01c12012-01-18 05:58:54 +00001693 CorrectionCandidateCallback &CCC,
Kaelyn Uhrain42830922011-08-05 00:09:52 +00001694 TemplateArgumentListInfo *ExplicitTemplateArgs,
Robert Wilhelm16e94b92013-08-09 18:02:13 +00001695 ArrayRef<Expr *> Args) {
John McCalld681c392009-12-16 08:11:27 +00001696 DeclarationName Name = R.getLookupName();
1697
John McCalld681c392009-12-16 08:11:27 +00001698 unsigned diagnostic = diag::err_undeclared_var_use;
Douglas Gregor598b08f2009-12-31 05:20:13 +00001699 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;
John McCalld681c392009-12-16 08:11:27 +00001700 if (Name.getNameKind() == DeclarationName::CXXOperatorName ||
1701 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName ||
Douglas Gregor598b08f2009-12-31 05:20:13 +00001702 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
John McCalld681c392009-12-16 08:11:27 +00001703 diagnostic = diag::err_undeclared_use;
Douglas Gregor598b08f2009-12-31 05:20:13 +00001704 diagnostic_suggest = diag::err_undeclared_use_suggest;
1705 }
John McCalld681c392009-12-16 08:11:27 +00001706
Douglas Gregor598b08f2009-12-31 05:20:13 +00001707 // If the original lookup was an unqualified lookup, fake an
1708 // unqualified lookup. This is useful when (for example) the
1709 // original lookup would not have found something because it was a
1710 // dependent name.
David Blaikiec4c0e8a2012-05-28 01:26:45 +00001711 DeclContext *DC = (SS.isEmpty() && !CallsUndergoingInstantiation.empty())
1712 ? CurContext : 0;
Francois Pichetde232cb2011-11-25 01:10:54 +00001713 while (DC) {
John McCalld681c392009-12-16 08:11:27 +00001714 if (isa<CXXRecordDecl>(DC)) {
1715 LookupQualifiedName(R, DC);
1716
1717 if (!R.empty()) {
1718 // Don't give errors about ambiguities in this lookup.
1719 R.suppressDiagnostics();
1720
Francois Pichet857f9d62011-11-17 03:44:24 +00001721 // During a default argument instantiation the CurContext points
1722 // to a CXXMethodDecl; but we can't apply a this-> fixit inside a
1723 // function parameter list, hence add an explicit check.
1724 bool isDefaultArgument = !ActiveTemplateInstantiations.empty() &&
1725 ActiveTemplateInstantiations.back().Kind ==
1726 ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation;
John McCalld681c392009-12-16 08:11:27 +00001727 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1728 bool isInstance = CurMethod &&
1729 CurMethod->isInstance() &&
Francois Pichet857f9d62011-11-17 03:44:24 +00001730 DC == CurMethod->getParent() && !isDefaultArgument;
1731
John McCalld681c392009-12-16 08:11:27 +00001732
1733 // Give a code modification hint to insert 'this->'.
1734 // TODO: fixit for inserting 'Base<T>::' in the other cases.
1735 // Actually quite difficult!
Nico Weberdf7dffb2012-06-20 20:21:42 +00001736 if (getLangOpts().MicrosoftMode)
1737 diagnostic = diag::warn_found_via_dependent_bases_lookup;
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001738 if (isInstance) {
Nico Weber3c10fb12012-06-22 16:39:39 +00001739 Diag(R.getNameLoc(), diagnostic) << Name
1740 << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001741 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(
1742 CallsUndergoingInstantiation.back()->getCallee());
Nico Weber3c10fb12012-06-22 16:39:39 +00001743
Nico Weber3c10fb12012-06-22 16:39:39 +00001744 CXXMethodDecl *DepMethod;
Douglas Gregor89c0a912013-03-26 22:43:55 +00001745 if (CurMethod->isDependentContext())
1746 DepMethod = CurMethod;
1747 else if (CurMethod->getTemplatedKind() ==
Nico Weber3c10fb12012-06-22 16:39:39 +00001748 FunctionDecl::TK_FunctionTemplateSpecialization)
1749 DepMethod = cast<CXXMethodDecl>(CurMethod->getPrimaryTemplate()->
1750 getInstantiatedFromMemberTemplate()->getTemplatedDecl());
1751 else
1752 DepMethod = cast<CXXMethodDecl>(
1753 CurMethod->getInstantiatedFromMemberFunction());
1754 assert(DepMethod && "No template pattern found");
1755
1756 QualType DepThisType = DepMethod->getThisType(Context);
1757 CheckCXXThisCapture(R.getNameLoc());
1758 CXXThisExpr *DepThis = new (Context) CXXThisExpr(
1759 R.getNameLoc(), DepThisType, false);
1760 TemplateArgumentListInfo TList;
1761 if (ULE->hasExplicitTemplateArgs())
1762 ULE->copyTemplateArgumentsInto(TList);
1763
1764 CXXScopeSpec SS;
1765 SS.Adopt(ULE->getQualifierLoc());
1766 CXXDependentScopeMemberExpr *DepExpr =
1767 CXXDependentScopeMemberExpr::Create(
1768 Context, DepThis, DepThisType, true, SourceLocation(),
1769 SS.getWithLocInContext(Context),
1770 ULE->getTemplateKeywordLoc(), 0,
1771 R.getLookupNameInfo(),
1772 ULE->hasExplicitTemplateArgs() ? &TList : 0);
1773 CallsUndergoingInstantiation.back()->setCallee(DepExpr);
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001774 } else {
John McCalld681c392009-12-16 08:11:27 +00001775 Diag(R.getNameLoc(), diagnostic) << Name;
Nick Lewyckyc96c37f2010-07-06 19:51:49 +00001776 }
John McCalld681c392009-12-16 08:11:27 +00001777
1778 // Do we really want to note all of these?
1779 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
1780 Diag((*I)->getLocation(), diag::note_dependent_var_use);
1781
Francois Pichet857f9d62011-11-17 03:44:24 +00001782 // Return true if we are inside a default argument instantiation
1783 // and the found name refers to an instance member function, otherwise
1784 // the function calling DiagnoseEmptyLookup will try to create an
1785 // implicit member call and this is wrong for default argument.
1786 if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) {
1787 Diag(R.getNameLoc(), diag::err_member_call_without_object);
1788 return true;
1789 }
1790
John McCalld681c392009-12-16 08:11:27 +00001791 // Tell the callee to try to recover.
1792 return false;
1793 }
Douglas Gregor86b8d9f2010-08-09 22:38:14 +00001794
1795 R.clear();
John McCalld681c392009-12-16 08:11:27 +00001796 }
Francois Pichetde232cb2011-11-25 01:10:54 +00001797
1798 // In Microsoft mode, if we are performing lookup from within a friend
1799 // function definition declared at class scope then we must set
1800 // DC to the lexical parent to be able to search into the parent
1801 // class.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001802 if (getLangOpts().MicrosoftMode && isa<FunctionDecl>(DC) &&
Francois Pichetde232cb2011-11-25 01:10:54 +00001803 cast<FunctionDecl>(DC)->getFriendObjectKind() &&
1804 DC->getLexicalParent()->isRecord())
1805 DC = DC->getLexicalParent();
1806 else
1807 DC = DC->getParent();
John McCalld681c392009-12-16 08:11:27 +00001808 }
1809
Douglas Gregor598b08f2009-12-31 05:20:13 +00001810 // We didn't find anything, so try to correct for a typo.
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001811 TypoCorrection Corrected;
1812 if (S && (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(),
Kaelyn Uhrain4e8942c2012-01-31 23:49:25 +00001813 S, &SS, CCC))) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001814 std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
Richard Smithf9b15102013-08-17 00:46:16 +00001815 bool DroppedSpecifier =
Kaelyn Uhrain10413a42013-07-02 23:47:44 +00001816 Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr;
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001817 R.setLookupName(Corrected.getCorrection());
1818
Richard Smithf9b15102013-08-17 00:46:16 +00001819 bool AcceptableWithRecovery = false;
1820 bool AcceptableWithoutRecovery = false;
1821 NamedDecl *ND = Corrected.getCorrectionDecl();
1822 if (ND) {
Kaelyn Uhrainacbdc572011-08-03 20:36:05 +00001823 if (Corrected.isOverloaded()) {
1824 OverloadCandidateSet OCS(R.getNameLoc());
1825 OverloadCandidateSet::iterator Best;
1826 for (TypoCorrection::decl_iterator CD = Corrected.begin(),
1827 CDEnd = Corrected.end();
1828 CD != CDEnd; ++CD) {
Kaelyn Uhrain62422202011-08-08 17:35:31 +00001829 if (FunctionTemplateDecl *FTD =
Kaelyn Uhrain42830922011-08-05 00:09:52 +00001830 dyn_cast<FunctionTemplateDecl>(*CD))
1831 AddTemplateOverloadCandidate(
1832 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs,
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00001833 Args, OCS);
Kaelyn Uhrain62422202011-08-08 17:35:31 +00001834 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD))
1835 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0)
1836 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none),
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00001837 Args, OCS);
Kaelyn Uhrainacbdc572011-08-03 20:36:05 +00001838 }
1839 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) {
Richard Smithf9b15102013-08-17 00:46:16 +00001840 case OR_Success:
1841 ND = Best->Function;
1842 Corrected.setCorrectionDecl(ND);
1843 break;
1844 default:
1845 // FIXME: Arbitrarily pick the first declaration for the note.
1846 Corrected.setCorrectionDecl(ND);
1847 break;
Kaelyn Uhrainacbdc572011-08-03 20:36:05 +00001848 }
1849 }
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001850 R.addDecl(ND);
Ted Kremenekc6ebda12013-02-21 21:40:44 +00001851
Richard Smithf9b15102013-08-17 00:46:16 +00001852 AcceptableWithRecovery =
1853 isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND);
1854 // FIXME: If we ended up with a typo for a type name or
1855 // Objective-C class name, we're in trouble because the parser
1856 // is in the wrong place to recover. Suggest the typo
1857 // correction, but don't make it a fix-it since we're not going
1858 // to recover well anyway.
1859 AcceptableWithoutRecovery =
1860 isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001861 } else {
Alexis Huntc46382e2010-04-28 23:02:27 +00001862 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
Douglas Gregor280e1ee2010-04-14 20:04:41 +00001863 // because we aren't able to recover.
Richard Smithf9b15102013-08-17 00:46:16 +00001864 AcceptableWithoutRecovery = true;
1865 }
1866
1867 if (AcceptableWithRecovery || AcceptableWithoutRecovery) {
1868 unsigned NoteID = (Corrected.getCorrectionDecl() &&
1869 isa<ImplicitParamDecl>(Corrected.getCorrectionDecl()))
1870 ? diag::note_implicit_param_decl
1871 : diag::note_previous_decl;
Douglas Gregor25363982010-01-01 00:15:04 +00001872 if (SS.isEmpty())
Richard Smithf9b15102013-08-17 00:46:16 +00001873 diagnoseTypo(Corrected, PDiag(diagnostic_suggest) << Name,
1874 PDiag(NoteID), AcceptableWithRecovery);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00001875 else
Richard Smithf9b15102013-08-17 00:46:16 +00001876 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
1877 << Name << computeDeclContext(SS, false)
1878 << DroppedSpecifier << SS.getRange(),
1879 PDiag(NoteID), AcceptableWithRecovery);
1880
1881 // Tell the callee whether to try to recover.
1882 return !AcceptableWithRecovery;
Douglas Gregor25363982010-01-01 00:15:04 +00001883 }
Douglas Gregor598b08f2009-12-31 05:20:13 +00001884 }
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001885 R.clear();
Douglas Gregor598b08f2009-12-31 05:20:13 +00001886
1887 // Emit a special diagnostic for failed member lookups.
1888 // FIXME: computing the declaration context might fail here (?)
1889 if (!SS.isEmpty()) {
1890 Diag(R.getNameLoc(), diag::err_no_member)
1891 << Name << computeDeclContext(SS, false)
1892 << SS.getRange();
1893 return true;
1894 }
1895
John McCalld681c392009-12-16 08:11:27 +00001896 // Give up, we can't recover.
1897 Diag(R.getNameLoc(), diagnostic) << Name;
1898 return true;
1899}
1900
John McCalldadc5752010-08-24 06:29:42 +00001901ExprResult Sema::ActOnIdExpression(Scope *S,
John McCall24d18942010-08-24 22:52:39 +00001902 CXXScopeSpec &SS,
Abramo Bagnara7945c982012-01-27 09:46:47 +00001903 SourceLocation TemplateKWLoc,
John McCall24d18942010-08-24 22:52:39 +00001904 UnqualifiedId &Id,
1905 bool HasTrailingLParen,
Kaelyn Uhrain77e21fc2012-01-25 20:49:08 +00001906 bool IsAddressOfOperand,
Chad Rosierb9aff1e2013-05-24 18:32:55 +00001907 CorrectionCandidateCallback *CCC,
1908 bool IsInlineAsmIdentifier) {
Richard Trieuba63ce62011-09-09 01:45:06 +00001909 assert(!(IsAddressOfOperand && HasTrailingLParen) &&
John McCalle66edc12009-11-24 19:00:30 +00001910 "cannot be direct & operand and have a trailing lparen");
John McCalle66edc12009-11-24 19:00:30 +00001911 if (SS.isInvalid())
Douglas Gregored8f2882009-01-30 01:04:22 +00001912 return ExprError();
Douglas Gregor90a1a652009-03-19 17:26:29 +00001913
John McCall10eae182009-11-30 22:42:35 +00001914 TemplateArgumentListInfo TemplateArgsBuffer;
John McCalle66edc12009-11-24 19:00:30 +00001915
1916 // Decompose the UnqualifiedId into the following data.
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001917 DeclarationNameInfo NameInfo;
John McCalle66edc12009-11-24 19:00:30 +00001918 const TemplateArgumentListInfo *TemplateArgs;
Douglas Gregor5476205b2011-06-23 00:49:38 +00001919 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs);
Douglas Gregor90a1a652009-03-19 17:26:29 +00001920
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001921 DeclarationName Name = NameInfo.getName();
Douglas Gregor4ea80432008-11-18 15:03:34 +00001922 IdentifierInfo *II = Name.getAsIdentifierInfo();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00001923 SourceLocation NameLoc = NameInfo.getLoc();
John McCalld14a8642009-11-21 08:51:07 +00001924
John McCalle66edc12009-11-24 19:00:30 +00001925 // C++ [temp.dep.expr]p3:
1926 // An id-expression is type-dependent if it contains:
Douglas Gregorea0a0a92010-01-11 18:40:55 +00001927 // -- an identifier that was declared with a dependent type,
1928 // (note: handled after lookup)
1929 // -- a template-id that is dependent,
1930 // (note: handled in BuildTemplateIdExpr)
1931 // -- a conversion-function-id that specifies a dependent type,
John McCalle66edc12009-11-24 19:00:30 +00001932 // -- a nested-name-specifier that contains a class-name that
1933 // names a dependent type.
1934 // Determine whether this is a member of an unknown specialization;
1935 // we need to handle these differently.
Eli Friedman964dbda2010-08-06 23:41:47 +00001936 bool DependentID = false;
1937 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName &&
1938 Name.getCXXNameType()->isDependentType()) {
1939 DependentID = true;
1940 } else if (SS.isSet()) {
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001941 if (DeclContext *DC = computeDeclContext(SS, false)) {
Eli Friedman964dbda2010-08-06 23:41:47 +00001942 if (RequireCompleteDeclContext(SS, DC))
1943 return ExprError();
Eli Friedman964dbda2010-08-06 23:41:47 +00001944 } else {
1945 DependentID = true;
1946 }
1947 }
1948
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001949 if (DependentID)
Abramo Bagnara7945c982012-01-27 09:46:47 +00001950 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
1951 IsAddressOfOperand, TemplateArgs);
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001952
John McCalle66edc12009-11-24 19:00:30 +00001953 // Perform the required lookup.
Fariborz Jahanian7f4427f2011-07-12 17:16:56 +00001954 LookupResult R(*this, NameInfo,
1955 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam)
1956 ? LookupObjCImplicitSelfParam : LookupOrdinaryName);
John McCalle66edc12009-11-24 19:00:30 +00001957 if (TemplateArgs) {
Douglas Gregor3e51e172010-05-20 20:58:56 +00001958 // Lookup the template name again to correctly establish the context in
1959 // which it was found. This is really unfortunate as we already did the
1960 // lookup to determine that it was a template name in the first place. If
1961 // this becomes a performance hit, we can work harder to preserve those
1962 // results until we get here but it's likely not worth it.
Douglas Gregor786123d2010-05-21 23:18:07 +00001963 bool MemberOfUnknownSpecialization;
1964 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false,
1965 MemberOfUnknownSpecialization);
Douglas Gregora5226932011-02-04 13:35:07 +00001966
1967 if (MemberOfUnknownSpecialization ||
1968 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation))
Abramo Bagnara7945c982012-01-27 09:46:47 +00001969 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
1970 IsAddressOfOperand, TemplateArgs);
John McCalle66edc12009-11-24 19:00:30 +00001971 } else {
Benjamin Kramer46921442012-01-20 14:57:34 +00001972 bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl();
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00001973 LookupParsedName(R, S, &SS, !IvarLookupFollowUp);
Mike Stump11289f42009-09-09 15:08:12 +00001974
Douglas Gregora5226932011-02-04 13:35:07 +00001975 // If the result might be in a dependent base class, this is a dependent
1976 // id-expression.
1977 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)
Abramo Bagnara7945c982012-01-27 09:46:47 +00001978 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
1979 IsAddressOfOperand, TemplateArgs);
1980
John McCalle66edc12009-11-24 19:00:30 +00001981 // If this reference is in an Objective-C method, then we need to do
1982 // some special Objective-C lookup, too.
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00001983 if (IvarLookupFollowUp) {
John McCalldadc5752010-08-24 06:29:42 +00001984 ExprResult E(LookupInObjCMethod(R, S, II, true));
John McCalle66edc12009-11-24 19:00:30 +00001985 if (E.isInvalid())
1986 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00001987
Chris Lattnerebb5c6c2011-02-18 01:27:55 +00001988 if (Expr *Ex = E.takeAs<Expr>())
1989 return Owned(Ex);
Steve Naroffebf4cb42008-06-02 23:03:37 +00001990 }
Chris Lattner59a25942008-03-31 00:36:02 +00001991 }
Douglas Gregorf15f5d32009-02-16 19:28:42 +00001992
John McCalle66edc12009-11-24 19:00:30 +00001993 if (R.isAmbiguous())
1994 return ExprError();
1995
Douglas Gregor171c45a2009-02-18 21:56:37 +00001996 // Determine whether this name might be a candidate for
1997 // argument-dependent lookup.
John McCalle66edc12009-11-24 19:00:30 +00001998 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
Douglas Gregor171c45a2009-02-18 21:56:37 +00001999
John McCalle66edc12009-11-24 19:00:30 +00002000 if (R.empty() && !ADL) {
Larisse Voufo39a1e502013-08-06 01:03:05 +00002001
Bill Wendling4073ed52007-02-13 01:51:42 +00002002 // Otherwise, this could be an implicitly declared function reference (legal
John McCalle66edc12009-11-24 19:00:30 +00002003 // in C90, extension in C99, forbidden in C++).
David Blaikiebbafb8a2012-03-11 07:00:24 +00002004 if (HasTrailingLParen && II && !getLangOpts().CPlusPlus) {
John McCalle66edc12009-11-24 19:00:30 +00002005 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
2006 if (D) R.addDecl(D);
2007 }
2008
2009 // If this name wasn't predeclared and if this is not a function
2010 // call, diagnose the problem.
2011 if (R.empty()) {
Francois Pichetd8e4e412011-09-24 10:38:05 +00002012 // In Microsoft mode, if we are inside a template class member function
Richard Smitha3519fa2013-04-29 08:45:27 +00002013 // whose parent class has dependent base classes, and we can't resolve
Reid Kleckner916ac4d2013-10-15 18:38:02 +00002014 // an identifier, then assume the identifier is a member of a dependent
2015 // base class. The goal is to postpone name lookup to instantiation time
2016 // to be able to search into the type dependent base classes.
2017 // FIXME: If we want 100% compatibility with MSVC, we will have delay all
2018 // unqualified name lookup. Any name lookup during template parsing means
2019 // clang might find something that MSVC doesn't. For now, we only handle
2020 // the common case of members of a dependent base class.
Richard Smitha3519fa2013-04-29 08:45:27 +00002021 if (getLangOpts().MicrosoftMode) {
2022 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext);
Reid Kleckner916ac4d2013-10-15 18:38:02 +00002023 if (MD && MD->isInstance() && MD->getParent()->hasAnyDependentBases()) {
2024 assert(SS.isEmpty() && "qualifiers should be already handled");
2025 QualType ThisType = MD->getThisType(Context);
2026 // Since the 'this' expression is synthesized, we don't need to
2027 // perform the double-lookup check.
2028 NamedDecl *FirstQualifierInScope = 0;
2029 return Owned(CXXDependentScopeMemberExpr::Create(
2030 Context, /*This=*/0, ThisType, /*IsArrow=*/true,
2031 /*Op=*/SourceLocation(), SS.getWithLocInContext(Context),
2032 TemplateKWLoc, FirstQualifierInScope, NameInfo, TemplateArgs));
2033 }
Richard Smitha3519fa2013-04-29 08:45:27 +00002034 }
Francois Pichetd8e4e412011-09-24 10:38:05 +00002035
Chad Rosierb9aff1e2013-05-24 18:32:55 +00002036 // Don't diagnose an empty lookup for inline assmebly.
2037 if (IsInlineAsmIdentifier)
2038 return ExprError();
2039
Kaelyn Uhrain79d01c12012-01-18 05:58:54 +00002040 CorrectionCandidateCallback DefaultValidator;
Kaelyn Uhrain77e21fc2012-01-25 20:49:08 +00002041 if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator))
John McCalld681c392009-12-16 08:11:27 +00002042 return ExprError();
2043
2044 assert(!R.empty() &&
2045 "DiagnoseEmptyLookup returned false but added no results");
Douglas Gregor35b0bac2010-01-03 18:01:57 +00002046
2047 // If we found an Objective-C instance variable, let
2048 // LookupInObjCMethod build the appropriate expression to
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002049 // reference the ivar.
Douglas Gregor35b0bac2010-01-03 18:01:57 +00002050 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) {
2051 R.clear();
John McCalldadc5752010-08-24 06:29:42 +00002052 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier()));
Fariborz Jahanian44653702011-09-23 23:11:38 +00002053 // In a hopelessly buggy code, Objective-C instance variable
2054 // lookup fails and no expression will be built to reference it.
2055 if (!E.isInvalid() && !E.get())
2056 return ExprError();
Benjamin Kramer62b95d82012-08-23 21:35:17 +00002057 return E;
Douglas Gregor35b0bac2010-01-03 18:01:57 +00002058 }
Steve Naroff92e30f82007-04-02 22:35:25 +00002059 }
Chris Lattner17ed4872006-11-20 04:58:19 +00002060 }
Mike Stump11289f42009-09-09 15:08:12 +00002061
John McCalle66edc12009-11-24 19:00:30 +00002062 // This is guaranteed from this point on.
2063 assert(!R.empty() || ADL);
2064
John McCall2d74de92009-12-01 22:10:20 +00002065 // Check whether this might be a C++ implicit instance member access.
John McCall24d18942010-08-24 22:52:39 +00002066 // C++ [class.mfct.non-static]p3:
2067 // When an id-expression that is not part of a class member access
2068 // syntax and not used to form a pointer to member is used in the
2069 // body of a non-static member function of class X, if name lookup
2070 // resolves the name in the id-expression to a non-static non-type
2071 // member of some class C, the id-expression is transformed into a
2072 // class member access expression using (*this) as the
2073 // postfix-expression to the left of the . operator.
John McCall8d08b9b2010-08-27 09:08:28 +00002074 //
2075 // But we don't actually need to do this for '&' operands if R
2076 // resolved to a function or overloaded function set, because the
2077 // expression is ill-formed if it actually works out to be a
2078 // non-static member function:
2079 //
2080 // C++ [expr.ref]p4:
2081 // Otherwise, if E1.E2 refers to a non-static member function. . .
2082 // [t]he expression can be used only as the left-hand operand of a
2083 // member function call.
2084 //
2085 // There are other safeguards against such uses, but it's important
2086 // to get this right here so that we don't end up making a
2087 // spuriously dependent expression if we're inside a dependent
2088 // instance method.
John McCall57500772009-12-16 12:17:52 +00002089 if (!R.empty() && (*R.begin())->isCXXClassMember()) {
John McCall8d08b9b2010-08-27 09:08:28 +00002090 bool MightBeImplicitMember;
Richard Trieuba63ce62011-09-09 01:45:06 +00002091 if (!IsAddressOfOperand)
John McCall8d08b9b2010-08-27 09:08:28 +00002092 MightBeImplicitMember = true;
2093 else if (!SS.isEmpty())
2094 MightBeImplicitMember = false;
2095 else if (R.isOverloadedResult())
2096 MightBeImplicitMember = false;
Douglas Gregor1262b062010-08-30 16:00:47 +00002097 else if (R.isUnresolvableResult())
2098 MightBeImplicitMember = true;
John McCall8d08b9b2010-08-27 09:08:28 +00002099 else
Francois Pichet783dd6e2010-11-21 06:08:52 +00002100 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) ||
Reid Kleckner0a0c8892013-06-19 16:37:23 +00002101 isa<IndirectFieldDecl>(R.getFoundDecl()) ||
2102 isa<MSPropertyDecl>(R.getFoundDecl());
John McCall8d08b9b2010-08-27 09:08:28 +00002103
2104 if (MightBeImplicitMember)
Abramo Bagnara7945c982012-01-27 09:46:47 +00002105 return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc,
2106 R, TemplateArgs);
John McCallb53bbd42009-11-22 01:44:31 +00002107 }
2108
Larisse Voufo39a1e502013-08-06 01:03:05 +00002109 if (TemplateArgs || TemplateKWLoc.isValid()) {
2110
2111 // In C++1y, if this is a variable template id, then check it
2112 // in BuildTemplateIdExpr().
2113 // The single lookup result must be a variable template declaration.
2114 if (Id.getKind() == UnqualifiedId::IK_TemplateId && Id.TemplateId &&
2115 Id.TemplateId->Kind == TNK_Var_template) {
2116 assert(R.getAsSingle<VarTemplateDecl>() &&
2117 "There should only be one declaration found.");
2118 }
2119
Abramo Bagnara65f7c3d2012-02-06 14:31:00 +00002120 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs);
Larisse Voufo39a1e502013-08-06 01:03:05 +00002121 }
John McCallb53bbd42009-11-22 01:44:31 +00002122
John McCalle66edc12009-11-24 19:00:30 +00002123 return BuildDeclarationNameExpr(SS, R, ADL);
2124}
2125
John McCall10eae182009-11-30 22:42:35 +00002126/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
2127/// declaration name, generally during template instantiation.
2128/// There's a large number of things which don't need to be done along
2129/// this path.
John McCalldadc5752010-08-24 06:29:42 +00002130ExprResult
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00002131Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
Richard Smithdb2630f2012-10-21 03:28:35 +00002132 const DeclarationNameInfo &NameInfo,
2133 bool IsAddressOfOperand) {
Richard Smith40c180d2012-10-23 19:56:01 +00002134 DeclContext *DC = computeDeclContext(SS, false);
2135 if (!DC)
Abramo Bagnara65f7c3d2012-02-06 14:31:00 +00002136 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
2137 NameInfo, /*TemplateArgs=*/0);
John McCalle66edc12009-11-24 19:00:30 +00002138
John McCall0b66eb32010-05-01 00:40:08 +00002139 if (RequireCompleteDeclContext(SS, DC))
Douglas Gregora02bb342010-04-28 07:04:26 +00002140 return ExprError();
2141
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002142 LookupResult R(*this, NameInfo, LookupOrdinaryName);
John McCalle66edc12009-11-24 19:00:30 +00002143 LookupQualifiedName(R, DC);
2144
2145 if (R.isAmbiguous())
2146 return ExprError();
2147
Richard Smith40c180d2012-10-23 19:56:01 +00002148 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)
2149 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(),
2150 NameInfo, /*TemplateArgs=*/0);
2151
John McCalle66edc12009-11-24 19:00:30 +00002152 if (R.empty()) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002153 Diag(NameInfo.getLoc(), diag::err_no_member)
2154 << NameInfo.getName() << DC << SS.getRange();
John McCalle66edc12009-11-24 19:00:30 +00002155 return ExprError();
2156 }
2157
Richard Smithdb2630f2012-10-21 03:28:35 +00002158 // Defend against this resolving to an implicit member access. We usually
2159 // won't get here if this might be a legitimate a class member (we end up in
2160 // BuildMemberReferenceExpr instead), but this can be valid if we're forming
2161 // a pointer-to-member or in an unevaluated context in C++11.
2162 if (!R.empty() && (*R.begin())->isCXXClassMember() && !IsAddressOfOperand)
2163 return BuildPossibleImplicitMemberExpr(SS,
2164 /*TemplateKWLoc=*/SourceLocation(),
2165 R, /*TemplateArgs=*/0);
2166
2167 return BuildDeclarationNameExpr(SS, R, /* ADL */ false);
John McCalle66edc12009-11-24 19:00:30 +00002168}
2169
2170/// LookupInObjCMethod - The parser has read a name in, and Sema has
2171/// detected that we're currently inside an ObjC method. Perform some
2172/// additional lookup.
2173///
2174/// Ideally, most of this would be done by lookup, but there's
2175/// actually quite a lot of extra work involved.
2176///
2177/// Returns a null sentinel to indicate trivial success.
John McCalldadc5752010-08-24 06:29:42 +00002178ExprResult
John McCalle66edc12009-11-24 19:00:30 +00002179Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S,
Chris Lattnera36ec422010-04-11 08:28:14 +00002180 IdentifierInfo *II, bool AllowBuiltinCreation) {
John McCalle66edc12009-11-24 19:00:30 +00002181 SourceLocation Loc = Lookup.getNameLoc();
Chris Lattner87313662010-04-12 05:10:17 +00002182 ObjCMethodDecl *CurMethod = getCurMethodDecl();
Fariborz Jahanian223ca5c2013-02-18 17:22:23 +00002183
2184 // Check for error condition which is already reported.
2185 if (!CurMethod)
2186 return ExprError();
Alexis Huntc46382e2010-04-28 23:02:27 +00002187
John McCalle66edc12009-11-24 19:00:30 +00002188 // There are two cases to handle here. 1) scoped lookup could have failed,
2189 // in which case we should look for an ivar. 2) scoped lookup could have
2190 // found a decl, but that decl is outside the current instance method (i.e.
2191 // a global variable). In these two cases, we do a lookup for an ivar with
2192 // this name, if the lookup sucedes, we replace it our current decl.
2193
2194 // If we're in a class method, we don't normally want to look for
2195 // ivars. But if we don't find anything else, and there's an
2196 // ivar, that's an error.
Chris Lattner87313662010-04-12 05:10:17 +00002197 bool IsClassMethod = CurMethod->isClassMethod();
John McCalle66edc12009-11-24 19:00:30 +00002198
2199 bool LookForIvars;
2200 if (Lookup.empty())
2201 LookForIvars = true;
2202 else if (IsClassMethod)
2203 LookForIvars = false;
2204 else
2205 LookForIvars = (Lookup.isSingleResult() &&
2206 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod());
Fariborz Jahanian45878032010-02-09 19:31:38 +00002207 ObjCInterfaceDecl *IFace = 0;
John McCalle66edc12009-11-24 19:00:30 +00002208 if (LookForIvars) {
Chris Lattner87313662010-04-12 05:10:17 +00002209 IFace = CurMethod->getClassInterface();
John McCalle66edc12009-11-24 19:00:30 +00002210 ObjCInterfaceDecl *ClassDeclared;
Argyrios Kyrtzidis4e8b1362011-10-19 02:25:16 +00002211 ObjCIvarDecl *IV = 0;
2212 if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) {
John McCalle66edc12009-11-24 19:00:30 +00002213 // Diagnose using an ivar in a class method.
2214 if (IsClassMethod)
2215 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
2216 << IV->getDeclName());
2217
2218 // If we're referencing an invalid decl, just return this as a silent
2219 // error node. The error diagnostic was already emitted on the decl.
2220 if (IV->isInvalidDecl())
2221 return ExprError();
2222
2223 // Check if referencing a field with __attribute__((deprecated)).
2224 if (DiagnoseUseOfDecl(IV, Loc))
2225 return ExprError();
2226
2227 // Diagnose the use of an ivar outside of the declaring class.
2228 if (IV->getAccessControl() == ObjCIvarDecl::Private &&
Fariborz Jahaniand6cb4a82012-03-07 00:58:41 +00002229 !declaresSameEntity(ClassDeclared, IFace) &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00002230 !getLangOpts().DebuggerSupport)
John McCalle66edc12009-11-24 19:00:30 +00002231 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName();
2232
2233 // FIXME: This should use a new expr for a direct reference, don't
2234 // turn this into Self->ivar, just return a BareIVarExpr or something.
2235 IdentifierInfo &II = Context.Idents.get("self");
2236 UnqualifiedId SelfName;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002237 SelfName.setIdentifier(&II, SourceLocation());
Fariborz Jahanian7f4427f2011-07-12 17:16:56 +00002238 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam);
John McCalle66edc12009-11-24 19:00:30 +00002239 CXXScopeSpec SelfScopeSpec;
Abramo Bagnara7945c982012-01-27 09:46:47 +00002240 SourceLocation TemplateKWLoc;
2241 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc,
Douglas Gregora1ed39b2010-09-22 16:33:13 +00002242 SelfName, false, false);
2243 if (SelfExpr.isInvalid())
2244 return ExprError();
2245
John Wiegley01296292011-04-08 18:41:53 +00002246 SelfExpr = DefaultLvalueConversion(SelfExpr.take());
2247 if (SelfExpr.isInvalid())
2248 return ExprError();
John McCall27584242010-12-06 20:48:59 +00002249
Nick Lewycky45b50522013-02-02 00:25:55 +00002250 MarkAnyDeclReferenced(Loc, IV, true);
Fariborz Jahanian39d90422013-10-25 22:04:47 +00002251 if (!IV->getBackingIvarReferencedInAccessor()) {
2252 // Mark this ivar 'referenced' in this method, if it is a backing ivar
2253 // of a property and current method is one of its property accessor.
2254 const ObjCPropertyDecl *PDecl;
2255 const ObjCIvarDecl *BIV = GetIvarBackingPropertyAccessor(CurMethod, PDecl);
2256 if (BIV && BIV == IV)
2257 IV->setBackingIvarReferencedInAccessor(true);
2258 }
Fariborz Jahaniana5063a62012-08-08 16:41:04 +00002259
2260 ObjCMethodFamily MF = CurMethod->getMethodFamily();
Fariborz Jahaniana934a022013-02-14 19:07:19 +00002261 if (MF != OMF_init && MF != OMF_dealloc && MF != OMF_finalize &&
2262 !IvarBacksCurrentMethodAccessor(IFace, CurMethod, IV))
Fariborz Jahaniana5063a62012-08-08 16:41:04 +00002263 Diag(Loc, diag::warn_direct_ivar_access) << IV->getDeclName();
Jordan Rose657b5f42012-09-28 22:21:35 +00002264
2265 ObjCIvarRefExpr *Result = new (Context) ObjCIvarRefExpr(IV, IV->getType(),
Fariborz Jahanianf12ff4df2013-04-02 18:57:54 +00002266 Loc, IV->getLocation(),
Jordan Rose657b5f42012-09-28 22:21:35 +00002267 SelfExpr.take(),
2268 true, true);
2269
2270 if (getLangOpts().ObjCAutoRefCount) {
2271 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
2272 DiagnosticsEngine::Level Level =
2273 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak, Loc);
2274 if (Level != DiagnosticsEngine::Ignored)
Fariborz Jahanian6f829e32013-05-21 21:20:26 +00002275 recordUseOfEvaluatedWeak(Result);
Jordan Rose657b5f42012-09-28 22:21:35 +00002276 }
Fariborz Jahanian4a675082012-10-03 17:55:29 +00002277 if (CurContext->isClosure())
2278 Diag(Loc, diag::warn_implicitly_retains_self)
2279 << FixItHint::CreateInsertion(Loc, "self->");
Jordan Rose657b5f42012-09-28 22:21:35 +00002280 }
2281
2282 return Owned(Result);
John McCalle66edc12009-11-24 19:00:30 +00002283 }
Chris Lattner87313662010-04-12 05:10:17 +00002284 } else if (CurMethod->isInstanceMethod()) {
John McCalle66edc12009-11-24 19:00:30 +00002285 // We should warn if a local variable hides an ivar.
Fariborz Jahanian557fc9a2011-11-08 22:51:27 +00002286 if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) {
2287 ObjCInterfaceDecl *ClassDeclared;
2288 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) {
2289 if (IV->getAccessControl() != ObjCIvarDecl::Private ||
Douglas Gregor0b144e12011-12-15 00:29:59 +00002290 declaresSameEntity(IFace, ClassDeclared))
Fariborz Jahanian557fc9a2011-11-08 22:51:27 +00002291 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName();
2292 }
John McCalle66edc12009-11-24 19:00:30 +00002293 }
Fariborz Jahanian028b9e12011-12-20 22:21:08 +00002294 } else if (Lookup.isSingleResult() &&
2295 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) {
2296 // If accessing a stand-alone ivar in a class method, this is an error.
2297 if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl()))
2298 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method)
2299 << IV->getDeclName());
John McCalle66edc12009-11-24 19:00:30 +00002300 }
2301
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00002302 if (Lookup.empty() && II && AllowBuiltinCreation) {
2303 // FIXME. Consolidate this with similar code in LookupName.
2304 if (unsigned BuiltinID = II->getBuiltinID()) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00002305 if (!(getLangOpts().CPlusPlus &&
Fariborz Jahanian6fada5b2010-01-12 23:58:59 +00002306 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) {
2307 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID,
2308 S, Lookup.isForRedeclaration(),
2309 Lookup.getNameLoc());
2310 if (D) Lookup.addDecl(D);
2311 }
2312 }
2313 }
John McCalle66edc12009-11-24 19:00:30 +00002314 // Sentinel value saying that we didn't do anything special.
2315 return Owned((Expr*) 0);
Douglas Gregor3256d042009-06-30 15:47:41 +00002316}
John McCalld14a8642009-11-21 08:51:07 +00002317
John McCall16df1e52010-03-30 21:47:33 +00002318/// \brief Cast a base object to a member's actual type.
2319///
2320/// Logically this happens in three phases:
2321///
2322/// * First we cast from the base type to the naming class.
2323/// The naming class is the class into which we were looking
2324/// when we found the member; it's the qualifier type if a
2325/// qualifier was provided, and otherwise it's the base type.
2326///
2327/// * Next we cast from the naming class to the declaring class.
2328/// If the member we found was brought into a class's scope by
2329/// a using declaration, this is that class; otherwise it's
2330/// the class declaring the member.
2331///
2332/// * Finally we cast from the declaring class to the "true"
2333/// declaring class of the member. This conversion does not
2334/// obey access control.
John Wiegley01296292011-04-08 18:41:53 +00002335ExprResult
2336Sema::PerformObjectMemberConversion(Expr *From,
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002337 NestedNameSpecifier *Qualifier,
John McCall16df1e52010-03-30 21:47:33 +00002338 NamedDecl *FoundDecl,
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002339 NamedDecl *Member) {
2340 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext());
2341 if (!RD)
John Wiegley01296292011-04-08 18:41:53 +00002342 return Owned(From);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002343
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002344 QualType DestRecordType;
2345 QualType DestType;
2346 QualType FromRecordType;
2347 QualType FromType = From->getType();
2348 bool PointerConversions = false;
2349 if (isa<FieldDecl>(Member)) {
2350 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD));
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002351
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002352 if (FromType->getAs<PointerType>()) {
2353 DestType = Context.getPointerType(DestRecordType);
2354 FromRecordType = FromType->getPointeeType();
2355 PointerConversions = true;
2356 } else {
2357 DestType = DestRecordType;
2358 FromRecordType = FromType;
Fariborz Jahanianbb67b822009-07-29 18:40:24 +00002359 }
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002360 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) {
2361 if (Method->isStatic())
John Wiegley01296292011-04-08 18:41:53 +00002362 return Owned(From);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002363
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002364 DestType = Method->getThisType(Context);
2365 DestRecordType = DestType->getPointeeType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002366
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002367 if (FromType->getAs<PointerType>()) {
2368 FromRecordType = FromType->getPointeeType();
2369 PointerConversions = true;
2370 } else {
2371 FromRecordType = FromType;
2372 DestType = DestRecordType;
2373 }
2374 } else {
2375 // No conversion necessary.
John Wiegley01296292011-04-08 18:41:53 +00002376 return Owned(From);
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002377 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002378
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002379 if (DestType->isDependentType() || FromType->isDependentType())
John Wiegley01296292011-04-08 18:41:53 +00002380 return Owned(From);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002381
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002382 // If the unqualified types are the same, no conversion is necessary.
2383 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
John Wiegley01296292011-04-08 18:41:53 +00002384 return Owned(From);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002385
John McCall16df1e52010-03-30 21:47:33 +00002386 SourceRange FromRange = From->getSourceRange();
2387 SourceLocation FromLoc = FromRange.getBegin();
2388
Eli Friedmanbe4b3632011-09-27 21:58:52 +00002389 ExprValueKind VK = From->getValueKind();
Sebastian Redlc57d34b2010-07-20 04:20:21 +00002390
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002391 // C++ [class.member.lookup]p8:
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002392 // [...] Ambiguities can often be resolved by qualifying a name with its
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002393 // class name.
2394 //
2395 // If the member was a qualified name and the qualified referred to a
2396 // specific base subobject type, we'll cast to that intermediate type
2397 // first and then to the object in which the member is declared. That allows
2398 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as:
2399 //
2400 // class Base { public: int x; };
2401 // class Derived1 : public Base { };
2402 // class Derived2 : public Base { };
2403 // class VeryDerived : public Derived1, public Derived2 { void f(); };
2404 //
2405 // void VeryDerived::f() {
2406 // x = 17; // error: ambiguous base subobjects
2407 // Derived1::x = 17; // okay, pick the Base subobject of Derived1
2408 // }
David Majnemer13657812013-08-05 04:53:41 +00002409 if (Qualifier && Qualifier->getAsType()) {
John McCall16df1e52010-03-30 21:47:33 +00002410 QualType QType = QualType(Qualifier->getAsType(), 0);
John McCall16df1e52010-03-30 21:47:33 +00002411 assert(QType->isRecordType() && "lookup done with non-record type");
2412
2413 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0);
2414
2415 // In C++98, the qualifier type doesn't actually have to be a base
2416 // type of the object type, in which case we just ignore it.
2417 // Otherwise build the appropriate casts.
2418 if (IsDerivedFrom(FromRecordType, QRecordType)) {
John McCallcf142162010-08-07 06:22:56 +00002419 CXXCastPath BasePath;
John McCall16df1e52010-03-30 21:47:33 +00002420 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
Anders Carlssonb78feca2010-04-24 19:22:20 +00002421 FromLoc, FromRange, &BasePath))
John Wiegley01296292011-04-08 18:41:53 +00002422 return ExprError();
John McCall16df1e52010-03-30 21:47:33 +00002423
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002424 if (PointerConversions)
John McCall16df1e52010-03-30 21:47:33 +00002425 QType = Context.getPointerType(QType);
John Wiegley01296292011-04-08 18:41:53 +00002426 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
2427 VK, &BasePath).take();
John McCall16df1e52010-03-30 21:47:33 +00002428
2429 FromType = QType;
2430 FromRecordType = QRecordType;
2431
2432 // If the qualifier type was the same as the destination type,
2433 // we're done.
2434 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType))
John Wiegley01296292011-04-08 18:41:53 +00002435 return Owned(From);
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002436 }
2437 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002438
John McCall16df1e52010-03-30 21:47:33 +00002439 bool IgnoreAccess = false;
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002440
John McCall16df1e52010-03-30 21:47:33 +00002441 // If we actually found the member through a using declaration, cast
2442 // down to the using declaration's type.
2443 //
2444 // Pointer equality is fine here because only one declaration of a
2445 // class ever has member declarations.
2446 if (FoundDecl->getDeclContext() != Member->getDeclContext()) {
2447 assert(isa<UsingShadowDecl>(FoundDecl));
2448 QualType URecordType = Context.getTypeDeclType(
2449 cast<CXXRecordDecl>(FoundDecl->getDeclContext()));
2450
2451 // We only need to do this if the naming-class to declaring-class
2452 // conversion is non-trivial.
2453 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) {
2454 assert(IsDerivedFrom(FromRecordType, URecordType));
John McCallcf142162010-08-07 06:22:56 +00002455 CXXCastPath BasePath;
John McCall16df1e52010-03-30 21:47:33 +00002456 if (CheckDerivedToBaseConversion(FromRecordType, URecordType,
Anders Carlssonb78feca2010-04-24 19:22:20 +00002457 FromLoc, FromRange, &BasePath))
John Wiegley01296292011-04-08 18:41:53 +00002458 return ExprError();
Alexis Huntc46382e2010-04-28 23:02:27 +00002459
John McCall16df1e52010-03-30 21:47:33 +00002460 QualType UType = URecordType;
2461 if (PointerConversions)
2462 UType = Context.getPointerType(UType);
John Wiegley01296292011-04-08 18:41:53 +00002463 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase,
2464 VK, &BasePath).take();
John McCall16df1e52010-03-30 21:47:33 +00002465 FromType = UType;
2466 FromRecordType = URecordType;
2467 }
2468
2469 // We don't do access control for the conversion from the
2470 // declaring class to the true declaring class.
2471 IgnoreAccess = true;
Douglas Gregorcc3f3252010-03-03 23:55:11 +00002472 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002473
John McCallcf142162010-08-07 06:22:56 +00002474 CXXCastPath BasePath;
Anders Carlssonb78feca2010-04-24 19:22:20 +00002475 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
2476 FromLoc, FromRange, &BasePath,
John McCall16df1e52010-03-30 21:47:33 +00002477 IgnoreAccess))
John Wiegley01296292011-04-08 18:41:53 +00002478 return ExprError();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002479
John Wiegley01296292011-04-08 18:41:53 +00002480 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase,
2481 VK, &BasePath);
Fariborz Jahanianbb67b822009-07-29 18:40:24 +00002482}
Douglas Gregor3256d042009-06-30 15:47:41 +00002483
John McCalle66edc12009-11-24 19:00:30 +00002484bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
John McCallb53bbd42009-11-22 01:44:31 +00002485 const LookupResult &R,
2486 bool HasTrailingLParen) {
John McCalld14a8642009-11-21 08:51:07 +00002487 // Only when used directly as the postfix-expression of a call.
2488 if (!HasTrailingLParen)
2489 return false;
2490
2491 // Never if a scope specifier was provided.
John McCalle66edc12009-11-24 19:00:30 +00002492 if (SS.isSet())
John McCalld14a8642009-11-21 08:51:07 +00002493 return false;
2494
2495 // Only in C++ or ObjC++.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002496 if (!getLangOpts().CPlusPlus)
John McCalld14a8642009-11-21 08:51:07 +00002497 return false;
2498
2499 // Turn off ADL when we find certain kinds of declarations during
2500 // normal lookup:
2501 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
2502 NamedDecl *D = *I;
2503
2504 // C++0x [basic.lookup.argdep]p3:
2505 // -- a declaration of a class member
2506 // Since using decls preserve this property, we check this on the
2507 // original decl.
John McCall57500772009-12-16 12:17:52 +00002508 if (D->isCXXClassMember())
John McCalld14a8642009-11-21 08:51:07 +00002509 return false;
2510
2511 // C++0x [basic.lookup.argdep]p3:
2512 // -- a block-scope function declaration that is not a
2513 // using-declaration
2514 // NOTE: we also trigger this for function templates (in fact, we
2515 // don't check the decl type at all, since all other decl types
2516 // turn off ADL anyway).
2517 if (isa<UsingShadowDecl>(D))
2518 D = cast<UsingShadowDecl>(D)->getTargetDecl();
Richard Smith541b38b2013-09-20 01:15:31 +00002519 else if (D->getLexicalDeclContext()->isFunctionOrMethod())
John McCalld14a8642009-11-21 08:51:07 +00002520 return false;
2521
2522 // C++0x [basic.lookup.argdep]p3:
2523 // -- a declaration that is neither a function or a function
2524 // template
2525 // And also for builtin functions.
2526 if (isa<FunctionDecl>(D)) {
2527 FunctionDecl *FDecl = cast<FunctionDecl>(D);
2528
2529 // But also builtin functions.
2530 if (FDecl->getBuiltinID() && FDecl->isImplicit())
2531 return false;
2532 } else if (!isa<FunctionTemplateDecl>(D))
2533 return false;
2534 }
2535
2536 return true;
2537}
2538
2539
John McCalld14a8642009-11-21 08:51:07 +00002540/// Diagnoses obvious problems with the use of the given declaration
2541/// as an expression. This is only actually called for lookups that
2542/// were not overloaded, and it doesn't promise that the declaration
2543/// will in fact be used.
2544static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) {
Richard Smithdda56e42011-04-15 14:24:37 +00002545 if (isa<TypedefNameDecl>(D)) {
John McCalld14a8642009-11-21 08:51:07 +00002546 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName();
2547 return true;
2548 }
2549
2550 if (isa<ObjCInterfaceDecl>(D)) {
2551 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName();
2552 return true;
2553 }
2554
2555 if (isa<NamespaceDecl>(D)) {
2556 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName();
2557 return true;
2558 }
2559
2560 return false;
2561}
2562
John McCalldadc5752010-08-24 06:29:42 +00002563ExprResult
John McCalle66edc12009-11-24 19:00:30 +00002564Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
John McCallb53bbd42009-11-22 01:44:31 +00002565 LookupResult &R,
2566 bool NeedsADL) {
John McCall3a60c872009-12-08 22:45:53 +00002567 // If this is a single, fully-resolved result and we don't need ADL,
2568 // just build an ordinary singleton decl ref.
Douglas Gregor4b4844f2010-01-29 17:15:43 +00002569 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>())
Daniel Jasper689ae012013-03-22 10:01:35 +00002570 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(),
2571 R.getRepresentativeDecl());
John McCalld14a8642009-11-21 08:51:07 +00002572
2573 // We only need to check the declaration if there's exactly one
2574 // result, because in the overloaded case the results can only be
2575 // functions and function templates.
John McCallb53bbd42009-11-22 01:44:31 +00002576 if (R.isSingleResult() &&
2577 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl()))
John McCalld14a8642009-11-21 08:51:07 +00002578 return ExprError();
2579
John McCall58cc69d2010-01-27 01:50:18 +00002580 // Otherwise, just build an unresolved lookup expression. Suppress
2581 // any lookup-related diagnostics; we'll hash these out later, when
2582 // we've picked a target.
2583 R.suppressDiagnostics();
2584
John McCalld14a8642009-11-21 08:51:07 +00002585 UnresolvedLookupExpr *ULE
Douglas Gregora6e053e2010-12-15 01:34:56 +00002586 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(),
Douglas Gregor0da1d432011-02-28 20:01:57 +00002587 SS.getWithLocInContext(Context),
2588 R.getLookupNameInfo(),
Douglas Gregor30a4f4c2010-05-23 18:57:34 +00002589 NeedsADL, R.isOverloadedResult(),
2590 R.begin(), R.end());
John McCalld14a8642009-11-21 08:51:07 +00002591
2592 return Owned(ULE);
2593}
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002594
John McCalld14a8642009-11-21 08:51:07 +00002595/// \brief Complete semantic analysis for a reference to the given declaration.
Larisse Voufo39a1e502013-08-06 01:03:05 +00002596ExprResult Sema::BuildDeclarationNameExpr(
2597 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
2598 NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs) {
John McCalld14a8642009-11-21 08:51:07 +00002599 assert(D && "Cannot refer to a NULL declaration");
John McCall283b9012009-11-22 00:44:51 +00002600 assert(!isa<FunctionTemplateDecl>(D) &&
2601 "Cannot refer unambiguously to a function template");
John McCalld14a8642009-11-21 08:51:07 +00002602
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00002603 SourceLocation Loc = NameInfo.getLoc();
John McCalld14a8642009-11-21 08:51:07 +00002604 if (CheckDeclInExpr(*this, Loc, D))
2605 return ExprError();
Steve Narofff1e53692007-03-23 22:27:02 +00002606
Douglas Gregore7488b92009-12-01 16:58:18 +00002607 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
2608 // Specifically diagnose references to class templates that are missing
2609 // a template argument list.
Larisse Voufo39a1e502013-08-06 01:03:05 +00002610 Diag(Loc, diag::err_template_decl_ref) << (isa<VarTemplateDecl>(D) ? 1 : 0)
2611 << Template << SS.getRange();
Douglas Gregore7488b92009-12-01 16:58:18 +00002612 Diag(Template->getLocation(), diag::note_template_decl_here);
2613 return ExprError();
2614 }
2615
2616 // Make sure that we're referring to a value.
2617 ValueDecl *VD = dyn_cast<ValueDecl>(D);
2618 if (!VD) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00002619 Diag(Loc, diag::err_ref_non_value)
Douglas Gregore7488b92009-12-01 16:58:18 +00002620 << D << SS.getRange();
John McCallb48971d2009-12-18 18:35:10 +00002621 Diag(D->getLocation(), diag::note_declared_at);
Douglas Gregore7488b92009-12-01 16:58:18 +00002622 return ExprError();
2623 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002624
Douglas Gregor171c45a2009-02-18 21:56:37 +00002625 // Check whether this declaration can be used. Note that we suppress
2626 // this check when we're going to perform argument-dependent lookup
2627 // on this function name, because this might not be the function
2628 // that overload resolution actually selects.
John McCalld14a8642009-11-21 08:51:07 +00002629 if (DiagnoseUseOfDecl(VD, Loc))
Douglas Gregor171c45a2009-02-18 21:56:37 +00002630 return ExprError();
2631
Steve Naroff8de9c3a2008-09-05 22:11:13 +00002632 // Only create DeclRefExpr's for valid Decl's.
2633 if (VD->isInvalidDecl())
Sebastian Redlffbcf962009-01-18 18:53:16 +00002634 return ExprError();
2635
John McCallf3a88602011-02-03 08:15:49 +00002636 // Handle members of anonymous structs and unions. If we got here,
2637 // and the reference is to a class member indirect field, then this
2638 // must be the subject of a pointer-to-member expression.
2639 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))
2640 if (!indirectField->isCXXClassMember())
2641 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(),
2642 indirectField);
Francois Pichet783dd6e2010-11-21 06:08:52 +00002643
Eli Friedman9bb33f52012-02-03 02:04:35 +00002644 {
John McCallf4cd4f92011-02-09 01:13:10 +00002645 QualType type = VD->getType();
Daniel Dunbar7c2dc362011-02-10 18:29:28 +00002646 ExprValueKind valueKind = VK_RValue;
John McCallf4cd4f92011-02-09 01:13:10 +00002647
2648 switch (D->getKind()) {
2649 // Ignore all the non-ValueDecl kinds.
2650#define ABSTRACT_DECL(kind)
2651#define VALUE(type, base)
2652#define DECL(type, base) \
2653 case Decl::type:
2654#include "clang/AST/DeclNodes.inc"
2655 llvm_unreachable("invalid value decl kind");
John McCallf4cd4f92011-02-09 01:13:10 +00002656
2657 // These shouldn't make it here.
2658 case Decl::ObjCAtDefsField:
2659 case Decl::ObjCIvar:
2660 llvm_unreachable("forming non-member reference to ivar?");
John McCallf4cd4f92011-02-09 01:13:10 +00002661
2662 // Enum constants are always r-values and never references.
2663 // Unresolved using declarations are dependent.
2664 case Decl::EnumConstant:
2665 case Decl::UnresolvedUsingValue:
2666 valueKind = VK_RValue;
2667 break;
2668
2669 // Fields and indirect fields that got here must be for
2670 // pointer-to-member expressions; we just call them l-values for
2671 // internal consistency, because this subexpression doesn't really
2672 // exist in the high-level semantics.
2673 case Decl::Field:
2674 case Decl::IndirectField:
David Blaikiebbafb8a2012-03-11 07:00:24 +00002675 assert(getLangOpts().CPlusPlus &&
John McCallf4cd4f92011-02-09 01:13:10 +00002676 "building reference to field in C?");
2677
2678 // These can't have reference type in well-formed programs, but
2679 // for internal consistency we do this anyway.
2680 type = type.getNonReferenceType();
2681 valueKind = VK_LValue;
2682 break;
2683
2684 // Non-type template parameters are either l-values or r-values
2685 // depending on the type.
2686 case Decl::NonTypeTemplateParm: {
2687 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) {
2688 type = reftype->getPointeeType();
2689 valueKind = VK_LValue; // even if the parameter is an r-value reference
2690 break;
2691 }
2692
2693 // For non-references, we need to strip qualifiers just in case
2694 // the template parameter was declared as 'const int' or whatever.
2695 valueKind = VK_RValue;
2696 type = type.getUnqualifiedType();
2697 break;
2698 }
2699
2700 case Decl::Var:
Larisse Voufo39a1e502013-08-06 01:03:05 +00002701 case Decl::VarTemplateSpecialization:
2702 case Decl::VarTemplatePartialSpecialization:
John McCallf4cd4f92011-02-09 01:13:10 +00002703 // In C, "extern void blah;" is valid and is an r-value.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002704 if (!getLangOpts().CPlusPlus &&
John McCallf4cd4f92011-02-09 01:13:10 +00002705 !type.hasQualifiers() &&
2706 type->isVoidType()) {
2707 valueKind = VK_RValue;
2708 break;
2709 }
2710 // fallthrough
2711
2712 case Decl::ImplicitParam:
Douglas Gregor812d8f62012-02-18 05:51:20 +00002713 case Decl::ParmVar: {
John McCallf4cd4f92011-02-09 01:13:10 +00002714 // These are always l-values.
2715 valueKind = VK_LValue;
2716 type = type.getNonReferenceType();
Eli Friedman9bb33f52012-02-03 02:04:35 +00002717
Douglas Gregor812d8f62012-02-18 05:51:20 +00002718 // FIXME: Does the addition of const really only apply in
2719 // potentially-evaluated contexts? Since the variable isn't actually
2720 // captured in an unevaluated context, it seems that the answer is no.
David Blaikie131fcb42012-08-06 22:47:24 +00002721 if (!isUnevaluatedContext()) {
Douglas Gregor812d8f62012-02-18 05:51:20 +00002722 QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc);
2723 if (!CapturedType.isNull())
2724 type = CapturedType;
2725 }
2726
John McCallf4cd4f92011-02-09 01:13:10 +00002727 break;
Douglas Gregor812d8f62012-02-18 05:51:20 +00002728 }
2729
John McCallf4cd4f92011-02-09 01:13:10 +00002730 case Decl::Function: {
Eli Friedman34866c72012-08-31 00:14:07 +00002731 if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
2732 if (!Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
2733 type = Context.BuiltinFnTy;
2734 valueKind = VK_RValue;
2735 break;
2736 }
2737 }
2738
John McCall2979fe02011-04-12 00:42:48 +00002739 const FunctionType *fty = type->castAs<FunctionType>();
2740
2741 // If we're referring to a function with an __unknown_anytype
2742 // result type, make the entire expression __unknown_anytype.
2743 if (fty->getResultType() == Context.UnknownAnyTy) {
2744 type = Context.UnknownAnyTy;
2745 valueKind = VK_RValue;
2746 break;
2747 }
2748
John McCallf4cd4f92011-02-09 01:13:10 +00002749 // Functions are l-values in C++.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002750 if (getLangOpts().CPlusPlus) {
John McCallf4cd4f92011-02-09 01:13:10 +00002751 valueKind = VK_LValue;
2752 break;
2753 }
2754
2755 // C99 DR 316 says that, if a function type comes from a
2756 // function definition (without a prototype), that type is only
2757 // used for checking compatibility. Therefore, when referencing
2758 // the function, we pretend that we don't have the full function
2759 // type.
John McCall2979fe02011-04-12 00:42:48 +00002760 if (!cast<FunctionDecl>(VD)->hasPrototype() &&
2761 isa<FunctionProtoType>(fty))
2762 type = Context.getFunctionNoProtoType(fty->getResultType(),
2763 fty->getExtInfo());
John McCallf4cd4f92011-02-09 01:13:10 +00002764
2765 // Functions are r-values in C.
2766 valueKind = VK_RValue;
2767 break;
2768 }
2769
John McCall5e77d762013-04-16 07:28:30 +00002770 case Decl::MSProperty:
2771 valueKind = VK_LValue;
2772 break;
2773
John McCallf4cd4f92011-02-09 01:13:10 +00002774 case Decl::CXXMethod:
John McCall2979fe02011-04-12 00:42:48 +00002775 // If we're referring to a method with an __unknown_anytype
2776 // result type, make the entire expression __unknown_anytype.
2777 // This should only be possible with a type written directly.
Richard Trieucfc491d2011-08-02 04:35:43 +00002778 if (const FunctionProtoType *proto
2779 = dyn_cast<FunctionProtoType>(VD->getType()))
John McCall2979fe02011-04-12 00:42:48 +00002780 if (proto->getResultType() == Context.UnknownAnyTy) {
2781 type = Context.UnknownAnyTy;
2782 valueKind = VK_RValue;
2783 break;
2784 }
2785
John McCallf4cd4f92011-02-09 01:13:10 +00002786 // C++ methods are l-values if static, r-values if non-static.
2787 if (cast<CXXMethodDecl>(VD)->isStatic()) {
2788 valueKind = VK_LValue;
2789 break;
2790 }
2791 // fallthrough
2792
2793 case Decl::CXXConversion:
2794 case Decl::CXXDestructor:
2795 case Decl::CXXConstructor:
2796 valueKind = VK_RValue;
2797 break;
2798 }
2799
Larisse Voufo39a1e502013-08-06 01:03:05 +00002800 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
2801 TemplateArgs);
John McCallf4cd4f92011-02-09 01:13:10 +00002802 }
Chris Lattner17ed4872006-11-20 04:58:19 +00002803}
Chris Lattnere168f762006-11-10 05:29:30 +00002804
Wei Panc354d212013-09-16 13:57:27 +00002805ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc,
2806 PredefinedExpr::IdentType IT) {
2807 // Pick the current block, lambda, captured statement or function.
2808 Decl *currentDecl = 0;
Benjamin Kramer90f54222013-08-21 11:45:27 +00002809 if (const BlockScopeInfo *BSI = getCurBlock())
2810 currentDecl = BSI->TheDecl;
2811 else if (const LambdaScopeInfo *LSI = getCurLambda())
2812 currentDecl = LSI->CallOperator;
Wei Pan8d6b19a2013-08-26 14:27:34 +00002813 else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion())
2814 currentDecl = CSI->TheCapturedDecl;
Benjamin Kramer90f54222013-08-21 11:45:27 +00002815 else
2816 currentDecl = getCurFunctionOrMethodDecl();
Benjamin Kramer6928cf72012-12-06 15:42:21 +00002817
Anders Carlsson2fb08242009-09-08 18:24:21 +00002818 if (!currentDecl) {
Chris Lattnerf45c5ec2008-12-12 05:05:20 +00002819 Diag(Loc, diag::ext_predef_outside_function);
Anders Carlsson2fb08242009-09-08 18:24:21 +00002820 currentDecl = Context.getTranslationUnitDecl();
Chris Lattnerf45c5ec2008-12-12 05:05:20 +00002821 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00002822
Anders Carlsson0b209a82009-09-11 01:22:35 +00002823 QualType ResTy;
Wei Panc354d212013-09-16 13:57:27 +00002824 if (cast<DeclContext>(currentDecl)->isDependentContext())
Anders Carlsson0b209a82009-09-11 01:22:35 +00002825 ResTy = Context.DependentTy;
Wei Panc354d212013-09-16 13:57:27 +00002826 else {
2827 // Pre-defined identifiers are of type char[x], where x is the length of
2828 // the string.
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002829 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002830
Anders Carlsson0b209a82009-09-11 01:22:35 +00002831 llvm::APInt LengthI(32, Length + 1);
Nico Weber3052abd2012-06-29 16:39:58 +00002832 if (IT == PredefinedExpr::LFunction)
Hans Wennborg0d81e012013-05-10 10:08:40 +00002833 ResTy = Context.WideCharTy.withConst();
Nico Weber3a691a32012-06-23 02:07:59 +00002834 else
2835 ResTy = Context.CharTy.withConst();
Anders Carlsson0b209a82009-09-11 01:22:35 +00002836 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0);
2837 }
Wei Panc354d212013-09-16 13:57:27 +00002838
Steve Narofff6009ed2009-01-21 00:14:39 +00002839 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
Chris Lattnere168f762006-11-10 05:29:30 +00002840}
2841
Wei Panc354d212013-09-16 13:57:27 +00002842ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) {
2843 PredefinedExpr::IdentType IT;
2844
2845 switch (Kind) {
2846 default: llvm_unreachable("Unknown simple primary expr!");
2847 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
2848 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
David Majnemerbed356a2013-11-06 23:31:56 +00002849 case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS]
Wei Panc354d212013-09-16 13:57:27 +00002850 case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break;
2851 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
2852 }
2853
2854 return BuildPredefinedExpr(Loc, IT);
2855}
2856
Richard Smithbcc22fc2012-03-09 08:00:36 +00002857ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00002858 SmallString<16> CharBuffer;
Douglas Gregordc970f02010-03-16 22:30:13 +00002859 bool Invalid = false;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002860 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid);
Douglas Gregordc970f02010-03-16 22:30:13 +00002861 if (Invalid)
2862 return ExprError();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002863
Benjamin Kramer0a1abd42010-02-27 13:44:12 +00002864 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(),
Douglas Gregorfb65e592011-07-27 05:40:30 +00002865 PP, Tok.getKind());
Steve Naroffae4143e2007-04-26 20:39:23 +00002866 if (Literal.hadError())
Sebastian Redlffbcf962009-01-18 18:53:16 +00002867 return ExprError();
Chris Lattneref24b382008-03-01 08:32:21 +00002868
Chris Lattnerc3847ba2009-12-30 21:19:39 +00002869 QualType Ty;
Seth Cantrell02f86052012-01-18 12:27:06 +00002870 if (Literal.isWide())
Hans Wennborg0d81e012013-05-10 10:08:40 +00002871 Ty = Context.WideCharTy; // L'x' -> wchar_t in C and C++.
Douglas Gregorfb65e592011-07-27 05:40:30 +00002872 else if (Literal.isUTF16())
Seth Cantrell02f86052012-01-18 12:27:06 +00002873 Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11.
Douglas Gregorfb65e592011-07-27 05:40:30 +00002874 else if (Literal.isUTF32())
Seth Cantrell02f86052012-01-18 12:27:06 +00002875 Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002876 else if (!getLangOpts().CPlusPlus || Literal.isMultiChar())
Seth Cantrell02f86052012-01-18 12:27:06 +00002877 Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
Chris Lattnerc3847ba2009-12-30 21:19:39 +00002878 else
2879 Ty = Context.CharTy; // 'x' -> char in C++
Chris Lattneref24b382008-03-01 08:32:21 +00002880
Douglas Gregorfb65e592011-07-27 05:40:30 +00002881 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii;
2882 if (Literal.isWide())
2883 Kind = CharacterLiteral::Wide;
2884 else if (Literal.isUTF16())
2885 Kind = CharacterLiteral::UTF16;
2886 else if (Literal.isUTF32())
2887 Kind = CharacterLiteral::UTF32;
2888
Richard Smith75b67d62012-03-08 01:34:56 +00002889 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
2890 Tok.getLocation());
2891
2892 if (Literal.getUDSuffix().empty())
2893 return Owned(Lit);
2894
2895 // We're building a user-defined literal.
2896 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
2897 SourceLocation UDSuffixLoc =
2898 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
2899
Richard Smithbcc22fc2012-03-09 08:00:36 +00002900 // Make sure we're allowed user-defined literals here.
2901 if (!UDLScope)
2902 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl));
2903
Richard Smith75b67d62012-03-08 01:34:56 +00002904 // C++11 [lex.ext]p6: The literal L is treated as a call of the form
2905 // operator "" X (ch)
Richard Smithbcc22fc2012-03-09 08:00:36 +00002906 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc,
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00002907 Lit, Tok.getLocation());
Steve Naroffae4143e2007-04-26 20:39:23 +00002908}
2909
Ted Kremeneke65b0862012-03-06 20:05:56 +00002910ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) {
2911 unsigned IntSize = Context.getTargetInfo().getIntWidth();
2912 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val),
2913 Context.IntTy, Loc));
2914}
2915
Richard Smith39570d002012-03-08 08:45:32 +00002916static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal,
2917 QualType Ty, SourceLocation Loc) {
2918 const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty);
2919
2920 using llvm::APFloat;
2921 APFloat Val(Format);
2922
2923 APFloat::opStatus result = Literal.GetFloatValue(Val);
2924
2925 // Overflow is always an error, but underflow is only an error if
2926 // we underflowed to zero (APFloat reports denormals as underflow).
2927 if ((result & APFloat::opOverflow) ||
2928 ((result & APFloat::opUnderflow) && Val.isZero())) {
2929 unsigned diagnostic;
2930 SmallString<20> buffer;
2931 if (result & APFloat::opOverflow) {
2932 diagnostic = diag::warn_float_overflow;
2933 APFloat::getLargest(Format).toString(buffer);
2934 } else {
2935 diagnostic = diag::warn_float_underflow;
2936 APFloat::getSmallest(Format).toString(buffer);
2937 }
2938
2939 S.Diag(Loc, diagnostic)
2940 << Ty
2941 << StringRef(buffer.data(), buffer.size());
2942 }
2943
2944 bool isExact = (result == APFloat::opOK);
2945 return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc);
2946}
2947
Richard Smithbcc22fc2012-03-09 08:00:36 +00002948ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
Sebastian Redlffbcf962009-01-18 18:53:16 +00002949 // Fast path for a single digit (which is quite common). A single digit
Richard Smithbcc22fc2012-03-09 08:00:36 +00002950 // cannot have a trigraph, escaped newline, radix prefix, or suffix.
Steve Narofff2fb89e2007-03-13 20:29:44 +00002951 if (Tok.getLength() == 1) {
Chris Lattner9240b3e2009-01-26 22:36:52 +00002952 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok);
Ted Kremeneke65b0862012-03-06 20:05:56 +00002953 return ActOnIntegerConstant(Tok.getLocation(), Val-'0');
Steve Narofff2fb89e2007-03-13 20:29:44 +00002954 }
Ted Kremeneke9814182009-01-13 23:19:12 +00002955
Dmitri Gribenko7ba91722012-09-24 09:53:54 +00002956 SmallString<128> SpellingBuffer;
2957 // NumericLiteralParser wants to overread by one character. Add padding to
2958 // the buffer in case the token is copied to the buffer. If getSpelling()
2959 // returns a StringRef to the memory buffer, it should have a null char at
2960 // the EOF, so it is also safe.
2961 SpellingBuffer.resize(Tok.getLength() + 1);
Sebastian Redlffbcf962009-01-18 18:53:16 +00002962
Chris Lattner67ca9252007-05-21 01:08:44 +00002963 // Get the spelling of the token, which eliminates trigraphs, etc.
Douglas Gregordc970f02010-03-16 22:30:13 +00002964 bool Invalid = false;
Dmitri Gribenko7ba91722012-09-24 09:53:54 +00002965 StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid);
Douglas Gregordc970f02010-03-16 22:30:13 +00002966 if (Invalid)
2967 return ExprError();
Sebastian Redlffbcf962009-01-18 18:53:16 +00002968
Dmitri Gribenko7ba91722012-09-24 09:53:54 +00002969 NumericLiteralParser Literal(TokSpelling, Tok.getLocation(), PP);
Steve Narofff2fb89e2007-03-13 20:29:44 +00002970 if (Literal.hadError)
Sebastian Redlffbcf962009-01-18 18:53:16 +00002971 return ExprError();
2972
Richard Smith39570d002012-03-08 08:45:32 +00002973 if (Literal.hasUDSuffix()) {
2974 // We're building a user-defined literal.
2975 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
2976 SourceLocation UDSuffixLoc =
2977 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
2978
Richard Smithbcc22fc2012-03-09 08:00:36 +00002979 // Make sure we're allowed user-defined literals here.
2980 if (!UDLScope)
2981 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl));
Richard Smith39570d002012-03-08 08:45:32 +00002982
Richard Smithbcc22fc2012-03-09 08:00:36 +00002983 QualType CookedTy;
Richard Smith39570d002012-03-08 08:45:32 +00002984 if (Literal.isFloatingLiteral()) {
2985 // C++11 [lex.ext]p4: If S contains a literal operator with parameter type
2986 // long double, the literal is treated as a call of the form
2987 // operator "" X (f L)
Richard Smithbcc22fc2012-03-09 08:00:36 +00002988 CookedTy = Context.LongDoubleTy;
Richard Smith39570d002012-03-08 08:45:32 +00002989 } else {
2990 // C++11 [lex.ext]p3: If S contains a literal operator with parameter type
2991 // unsigned long long, the literal is treated as a call of the form
2992 // operator "" X (n ULL)
Richard Smithbcc22fc2012-03-09 08:00:36 +00002993 CookedTy = Context.UnsignedLongLongTy;
Richard Smith39570d002012-03-08 08:45:32 +00002994 }
2995
Richard Smithbcc22fc2012-03-09 08:00:36 +00002996 DeclarationName OpName =
2997 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
2998 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
2999 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
3000
Richard Smithb8b41d32013-10-07 19:57:58 +00003001 SourceLocation TokLoc = Tok.getLocation();
3002
Richard Smithbcc22fc2012-03-09 08:00:36 +00003003 // Perform literal operator lookup to determine if we're building a raw
3004 // literal or a cooked one.
3005 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003006 switch (LookupLiteralOperator(UDLScope, R, CookedTy,
Richard Smithb8b41d32013-10-07 19:57:58 +00003007 /*AllowRaw*/true, /*AllowTemplate*/true,
3008 /*AllowStringTemplate*/false)) {
Richard Smithbcc22fc2012-03-09 08:00:36 +00003009 case LOLR_Error:
3010 return ExprError();
3011
3012 case LOLR_Cooked: {
3013 Expr *Lit;
3014 if (Literal.isFloatingLiteral()) {
3015 Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation());
3016 } else {
3017 llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0);
3018 if (Literal.GetIntegerValue(ResultVal))
Eli Friedman088d39a2013-07-23 00:25:18 +00003019 Diag(Tok.getLocation(), diag::err_integer_too_large);
Richard Smithbcc22fc2012-03-09 08:00:36 +00003020 Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy,
3021 Tok.getLocation());
3022 }
Richard Smithb8b41d32013-10-07 19:57:58 +00003023 return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
Richard Smithbcc22fc2012-03-09 08:00:36 +00003024 }
3025
3026 case LOLR_Raw: {
3027 // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the
3028 // literal is treated as a call of the form
3029 // operator "" X ("n")
Richard Smithbcc22fc2012-03-09 08:00:36 +00003030 unsigned Length = Literal.getUDSuffixOffset();
3031 QualType StrTy = Context.getConstantArrayType(
Richard Smithbe8229c2013-01-23 23:38:20 +00003032 Context.CharTy.withConst(), llvm::APInt(32, Length + 1),
Richard Smithbcc22fc2012-03-09 08:00:36 +00003033 ArrayType::Normal, 0);
3034 Expr *Lit = StringLiteral::Create(
Dmitri Gribenko7ba91722012-09-24 09:53:54 +00003035 Context, StringRef(TokSpelling.data(), Length), StringLiteral::Ascii,
Richard Smithbcc22fc2012-03-09 08:00:36 +00003036 /*Pascal*/false, StrTy, &TokLoc, 1);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003037 return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc);
Richard Smithbcc22fc2012-03-09 08:00:36 +00003038 }
3039
Richard Smithb8b41d32013-10-07 19:57:58 +00003040 case LOLR_Template: {
Richard Smithbcc22fc2012-03-09 08:00:36 +00003041 // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator
3042 // template), L is treated as a call fo the form
3043 // operator "" X <'c1', 'c2', ... 'ck'>()
3044 // where n is the source character sequence c1 c2 ... ck.
3045 TemplateArgumentListInfo ExplicitArgs;
3046 unsigned CharBits = Context.getIntWidth(Context.CharTy);
3047 bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType();
3048 llvm::APSInt Value(CharBits, CharIsUnsigned);
3049 for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) {
Dmitri Gribenko7ba91722012-09-24 09:53:54 +00003050 Value = TokSpelling[I];
Benjamin Kramer6003ad52012-06-07 15:09:51 +00003051 TemplateArgument Arg(Context, Value, Context.CharTy);
Richard Smithbcc22fc2012-03-09 08:00:36 +00003052 TemplateArgumentLocInfo ArgInfo;
3053 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo));
3054 }
Richard Smithb8b41d32013-10-07 19:57:58 +00003055 return BuildLiteralOperatorCall(R, OpNameInfo, None, TokLoc,
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00003056 &ExplicitArgs);
Richard Smithbcc22fc2012-03-09 08:00:36 +00003057 }
Richard Smithb8b41d32013-10-07 19:57:58 +00003058 case LOLR_StringTemplate:
3059 llvm_unreachable("unexpected literal operator lookup result");
3060 }
Richard Smith39570d002012-03-08 08:45:32 +00003061 }
3062
Chris Lattner1c20a172007-08-26 03:42:43 +00003063 Expr *Res;
Sebastian Redlffbcf962009-01-18 18:53:16 +00003064
Chris Lattner1c20a172007-08-26 03:42:43 +00003065 if (Literal.isFloatingLiteral()) {
Chris Lattnerec0a6d92007-09-22 18:29:59 +00003066 QualType Ty;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00003067 if (Literal.isFloat)
Chris Lattnerec0a6d92007-09-22 18:29:59 +00003068 Ty = Context.FloatTy;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00003069 else if (!Literal.isLong)
Chris Lattnerec0a6d92007-09-22 18:29:59 +00003070 Ty = Context.DoubleTy;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00003071 else
Chris Lattner7570e9c2008-03-08 08:52:55 +00003072 Ty = Context.LongDoubleTy;
Chris Lattner9a8d1d92008-06-30 18:32:54 +00003073
Richard Smith39570d002012-03-08 08:45:32 +00003074 Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
Sebastian Redlffbcf962009-01-18 18:53:16 +00003075
Peter Collingbournec77f85b2011-03-11 19:24:59 +00003076 if (Ty == Context.DoubleTy) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00003077 if (getLangOpts().SinglePrecisionConstants) {
John Wiegley01296292011-04-08 18:41:53 +00003078 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take();
David Blaikiebbafb8a2012-03-11 07:00:24 +00003079 } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) {
Peter Collingbournec77f85b2011-03-11 19:24:59 +00003080 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64);
John Wiegley01296292011-04-08 18:41:53 +00003081 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take();
Peter Collingbournec77f85b2011-03-11 19:24:59 +00003082 }
3083 }
Chris Lattner1c20a172007-08-26 03:42:43 +00003084 } else if (!Literal.isIntegerLiteral()) {
Sebastian Redlffbcf962009-01-18 18:53:16 +00003085 return ExprError();
Chris Lattner1c20a172007-08-26 03:42:43 +00003086 } else {
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003087 QualType Ty;
Chris Lattner67ca9252007-05-21 01:08:44 +00003088
Dmitri Gribenko1cd23052012-09-24 18:19:21 +00003089 // 'long long' is a C99 or C++11 feature.
3090 if (!getLangOpts().C99 && Literal.isLongLong) {
3091 if (getLangOpts().CPlusPlus)
3092 Diag(Tok.getLocation(),
Richard Smith2bf7fdb2013-01-02 11:42:31 +00003093 getLangOpts().CPlusPlus11 ?
Dmitri Gribenko1cd23052012-09-24 18:19:21 +00003094 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
3095 else
3096 Diag(Tok.getLocation(), diag::ext_c99_longlong);
3097 }
Neil Boothac582c52007-08-29 22:00:19 +00003098
Chris Lattner67ca9252007-05-21 01:08:44 +00003099 // Get the value in the widest-possible width.
Stephen Canonfdc6c1a2012-05-03 22:49:43 +00003100 unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth();
3101 // The microsoft literal suffix extensions support 128-bit literals, which
3102 // may be wider than [u]intmax_t.
Richard Smithe6a56db2012-11-29 05:41:51 +00003103 // FIXME: Actually, they don't. We seem to have accidentally invented the
3104 // i128 suffix.
3105 if (Literal.isMicrosoftInteger && MaxWidth < 128 &&
3106 PP.getTargetInfo().hasInt128Type())
Stephen Canonfdc6c1a2012-05-03 22:49:43 +00003107 MaxWidth = 128;
3108 llvm::APInt ResultVal(MaxWidth, 0);
Sebastian Redlffbcf962009-01-18 18:53:16 +00003109
Chris Lattner67ca9252007-05-21 01:08:44 +00003110 if (Literal.GetIntegerValue(ResultVal)) {
Eli Friedman088d39a2013-07-23 00:25:18 +00003111 // If this value didn't fit into uintmax_t, error and force to ull.
3112 Diag(Tok.getLocation(), diag::err_integer_too_large);
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003113 Ty = Context.UnsignedLongLongTy;
3114 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
Chris Lattner37e05872008-03-05 18:54:05 +00003115 "long long is not intmax_t?");
Steve Naroff09ef4742007-03-09 23:16:33 +00003116 } else {
Chris Lattner67ca9252007-05-21 01:08:44 +00003117 // If this value fits into a ULL, try to figure out what else it fits into
3118 // according to the rules of C99 6.4.4.1p5.
Sebastian Redlffbcf962009-01-18 18:53:16 +00003119
Chris Lattner67ca9252007-05-21 01:08:44 +00003120 // Octal, Hexadecimal, and integers with a U suffix are allowed to
3121 // be an unsigned int.
3122 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10;
3123
3124 // Check from smallest to largest, picking the smallest type we can.
Chris Lattner55258cf2008-05-09 05:59:00 +00003125 unsigned Width = 0;
Chris Lattner7b939cf2007-08-23 21:58:08 +00003126 if (!Literal.isLong && !Literal.isLongLong) {
3127 // Are int/unsigned possibilities?
Douglas Gregore8bbc122011-09-02 00:18:52 +00003128 unsigned IntSize = Context.getTargetInfo().getIntWidth();
Sebastian Redlffbcf962009-01-18 18:53:16 +00003129
Chris Lattner67ca9252007-05-21 01:08:44 +00003130 // Does it fit in a unsigned int?
3131 if (ResultVal.isIntN(IntSize)) {
3132 // Does it fit in a signed int?
3133 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003134 Ty = Context.IntTy;
Chris Lattner67ca9252007-05-21 01:08:44 +00003135 else if (AllowUnsigned)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003136 Ty = Context.UnsignedIntTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00003137 Width = IntSize;
Chris Lattner67ca9252007-05-21 01:08:44 +00003138 }
Chris Lattner67ca9252007-05-21 01:08:44 +00003139 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00003140
Chris Lattner67ca9252007-05-21 01:08:44 +00003141 // Are long/unsigned long possibilities?
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003142 if (Ty.isNull() && !Literal.isLongLong) {
Douglas Gregore8bbc122011-09-02 00:18:52 +00003143 unsigned LongSize = Context.getTargetInfo().getLongWidth();
Sebastian Redlffbcf962009-01-18 18:53:16 +00003144
Chris Lattner67ca9252007-05-21 01:08:44 +00003145 // Does it fit in a unsigned long?
3146 if (ResultVal.isIntN(LongSize)) {
3147 // Does it fit in a signed long?
3148 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003149 Ty = Context.LongTy;
Chris Lattner67ca9252007-05-21 01:08:44 +00003150 else if (AllowUnsigned)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003151 Ty = Context.UnsignedLongTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00003152 Width = LongSize;
Chris Lattner67ca9252007-05-21 01:08:44 +00003153 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00003154 }
3155
Stephen Canonfdc6c1a2012-05-03 22:49:43 +00003156 // Check long long if needed.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003157 if (Ty.isNull()) {
Douglas Gregore8bbc122011-09-02 00:18:52 +00003158 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth();
Sebastian Redlffbcf962009-01-18 18:53:16 +00003159
Chris Lattner67ca9252007-05-21 01:08:44 +00003160 // Does it fit in a unsigned long long?
3161 if (ResultVal.isIntN(LongLongSize)) {
3162 // Does it fit in a signed long long?
Francois Pichetc3e73b32011-01-11 23:38:13 +00003163 // To be compatible with MSVC, hex integer literals ending with the
3164 // LL or i64 suffix are always signed in Microsoft mode.
Francois Pichetbf711d92011-01-11 12:23:00 +00003165 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
David Blaikiebbafb8a2012-03-11 07:00:24 +00003166 (getLangOpts().MicrosoftExt && Literal.isLongLong)))
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003167 Ty = Context.LongLongTy;
Chris Lattner67ca9252007-05-21 01:08:44 +00003168 else if (AllowUnsigned)
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003169 Ty = Context.UnsignedLongLongTy;
Chris Lattner55258cf2008-05-09 05:59:00 +00003170 Width = LongLongSize;
Chris Lattner67ca9252007-05-21 01:08:44 +00003171 }
3172 }
Stephen Canonfdc6c1a2012-05-03 22:49:43 +00003173
3174 // If it doesn't fit in unsigned long long, and we're using Microsoft
3175 // extensions, then its a 128-bit integer literal.
Richard Smithe6a56db2012-11-29 05:41:51 +00003176 if (Ty.isNull() && Literal.isMicrosoftInteger &&
3177 PP.getTargetInfo().hasInt128Type()) {
Stephen Canonfdc6c1a2012-05-03 22:49:43 +00003178 if (Literal.isUnsigned)
3179 Ty = Context.UnsignedInt128Ty;
3180 else
3181 Ty = Context.Int128Ty;
3182 Width = 128;
3183 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00003184
Chris Lattner67ca9252007-05-21 01:08:44 +00003185 // If we still couldn't decide a type, we probably have something that
3186 // does not fit in a signed long long, but has no U suffix.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003187 if (Ty.isNull()) {
Eli Friedmanab091872013-07-26 00:06:45 +00003188 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed);
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003189 Ty = Context.UnsignedLongLongTy;
Douglas Gregore8bbc122011-09-02 00:18:52 +00003190 Width = Context.getTargetInfo().getLongLongWidth();
Chris Lattner67ca9252007-05-21 01:08:44 +00003191 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00003192
Chris Lattner55258cf2008-05-09 05:59:00 +00003193 if (ResultVal.getBitWidth() != Width)
Jay Foad6d4db0c2010-12-07 08:25:34 +00003194 ResultVal = ResultVal.trunc(Width);
Steve Naroff09ef4742007-03-09 23:16:33 +00003195 }
Argyrios Kyrtzidis43b20572010-08-28 09:06:06 +00003196 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation());
Steve Naroff09ef4742007-03-09 23:16:33 +00003197 }
Sebastian Redlffbcf962009-01-18 18:53:16 +00003198
Chris Lattner1c20a172007-08-26 03:42:43 +00003199 // If this is an imaginary literal, create the ImaginaryLiteral wrapper.
3200 if (Literal.isImaginary)
Mike Stump11289f42009-09-09 15:08:12 +00003201 Res = new (Context) ImaginaryLiteral(Res,
Steve Narofff6009ed2009-01-21 00:14:39 +00003202 Context.getComplexType(Res->getType()));
Sebastian Redlffbcf962009-01-18 18:53:16 +00003203
3204 return Owned(Res);
Chris Lattnere168f762006-11-10 05:29:30 +00003205}
3206
Richard Trieuba63ce62011-09-09 01:45:06 +00003207ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) {
Chris Lattner24d5bfe2008-04-02 04:24:33 +00003208 assert((E != 0) && "ActOnParenExpr() missing expr");
Steve Narofff6009ed2009-01-21 00:14:39 +00003209 return Owned(new (Context) ParenExpr(L, R, E));
Chris Lattnere168f762006-11-10 05:29:30 +00003210}
3211
Chandler Carruth62da79c2011-05-26 08:53:12 +00003212static bool CheckVecStepTraitOperandType(Sema &S, QualType T,
3213 SourceLocation Loc,
3214 SourceRange ArgRange) {
3215 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in
3216 // scalar or vector data type argument..."
3217 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
3218 // type (C99 6.2.5p18) or void.
3219 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
3220 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
3221 << T << ArgRange;
3222 return true;
3223 }
3224
3225 assert((T->isVoidType() || !T->isIncompleteType()) &&
3226 "Scalar types should always be complete");
3227 return false;
3228}
3229
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003230static bool CheckExtensionTraitOperandType(Sema &S, QualType T,
3231 SourceLocation Loc,
3232 SourceRange ArgRange,
3233 UnaryExprOrTypeTrait TraitKind) {
Eli Friedman4e28b262013-08-13 22:26:42 +00003234 // Invalid types must be hard errors for SFINAE in C++.
3235 if (S.LangOpts.CPlusPlus)
3236 return true;
3237
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003238 // C99 6.5.3.4p1:
Richard Smith9cf21ae2013-03-18 23:37:25 +00003239 if (T->isFunctionType() &&
3240 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf)) {
3241 // sizeof(function)/alignof(function) is allowed as an extension.
3242 S.Diag(Loc, diag::ext_sizeof_alignof_function_type)
3243 << TraitKind << ArgRange;
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003244 return false;
3245 }
3246
Joey Gouly4ba0f1e2013-12-31 15:47:49 +00003247 // Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where
3248 // this is an error (OpenCL v1.1 s6.3.k)
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003249 if (T->isVoidType()) {
Joey Gouly4ba0f1e2013-12-31 15:47:49 +00003250 unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type
3251 : diag::ext_sizeof_alignof_void_type;
3252 S.Diag(Loc, DiagID) << TraitKind << ArgRange;
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003253 return false;
3254 }
3255
3256 return true;
3257}
3258
3259static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T,
3260 SourceLocation Loc,
3261 SourceRange ArgRange,
3262 UnaryExprOrTypeTrait TraitKind) {
John McCallf2538342012-07-31 05:14:30 +00003263 // Reject sizeof(interface) and sizeof(interface<proto>) if the
3264 // runtime doesn't allow it.
3265 if (!S.LangOpts.ObjCRuntime.allowsSizeofAlignof() && T->isObjCObjectType()) {
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003266 S.Diag(Loc, diag::err_sizeof_nonfragile_interface)
3267 << T << (TraitKind == UETT_SizeOf)
3268 << ArgRange;
3269 return true;
3270 }
3271
3272 return false;
3273}
3274
Benjamin Kramer054faa52013-03-29 21:43:21 +00003275/// \brief Check whether E is a pointer from a decayed array type (the decayed
3276/// pointer type is equal to T) and emit a warning if it is.
3277static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T,
3278 Expr *E) {
3279 // Don't warn if the operation changed the type.
3280 if (T != E->getType())
3281 return;
3282
3283 // Now look for array decays.
3284 ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E);
3285 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
3286 return;
3287
3288 S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
3289 << ICE->getType()
3290 << ICE->getSubExpr()->getType();
3291}
3292
Chandler Carruth14502c22011-05-26 08:53:10 +00003293/// \brief Check the constrains on expression operands to unary type expression
3294/// and type traits.
3295///
Chandler Carruth7c430c02011-05-27 01:33:31 +00003296/// Completes any types necessary and validates the constraints on the operand
3297/// expression. The logic mostly mirrors the type-based overload, but may modify
3298/// the expression as it completes the type for that expression through template
3299/// instantiation, etc.
Richard Trieuba63ce62011-09-09 01:45:06 +00003300bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
Chandler Carruth14502c22011-05-26 08:53:10 +00003301 UnaryExprOrTypeTrait ExprKind) {
Richard Trieuba63ce62011-09-09 01:45:06 +00003302 QualType ExprTy = E->getType();
John McCall768439e2013-05-06 07:40:34 +00003303 assert(!ExprTy->isReferenceType());
Chandler Carruth7c430c02011-05-27 01:33:31 +00003304
3305 if (ExprKind == UETT_VecStep)
Richard Trieuba63ce62011-09-09 01:45:06 +00003306 return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(),
3307 E->getSourceRange());
Chandler Carruth7c430c02011-05-27 01:33:31 +00003308
3309 // Whitelist some types as extensions
Richard Trieuba63ce62011-09-09 01:45:06 +00003310 if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(),
3311 E->getSourceRange(), ExprKind))
Chandler Carruth7c430c02011-05-27 01:33:31 +00003312 return false;
3313
Richard Trieuba63ce62011-09-09 01:45:06 +00003314 if (RequireCompleteExprType(E,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00003315 diag::err_sizeof_alignof_incomplete_type,
3316 ExprKind, E->getSourceRange()))
Chandler Carruth7c430c02011-05-27 01:33:31 +00003317 return true;
3318
John McCall768439e2013-05-06 07:40:34 +00003319 // Completing the expression's type may have changed it.
Richard Trieuba63ce62011-09-09 01:45:06 +00003320 ExprTy = E->getType();
John McCall768439e2013-05-06 07:40:34 +00003321 assert(!ExprTy->isReferenceType());
Chandler Carruth7c430c02011-05-27 01:33:31 +00003322
Eli Friedman4e28b262013-08-13 22:26:42 +00003323 if (ExprTy->isFunctionType()) {
3324 Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type)
3325 << ExprKind << E->getSourceRange();
3326 return true;
3327 }
3328
Richard Trieuba63ce62011-09-09 01:45:06 +00003329 if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(),
3330 E->getSourceRange(), ExprKind))
Chandler Carruth7c430c02011-05-27 01:33:31 +00003331 return true;
3332
Nico Weber0870deb2011-06-15 02:47:03 +00003333 if (ExprKind == UETT_SizeOf) {
Richard Trieuba63ce62011-09-09 01:45:06 +00003334 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
Nico Weber0870deb2011-06-15 02:47:03 +00003335 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) {
3336 QualType OType = PVD->getOriginalType();
3337 QualType Type = PVD->getType();
3338 if (Type->isPointerType() && OType->isArrayType()) {
Richard Trieuba63ce62011-09-09 01:45:06 +00003339 Diag(E->getExprLoc(), diag::warn_sizeof_array_param)
Nico Weber0870deb2011-06-15 02:47:03 +00003340 << Type << OType;
3341 Diag(PVD->getLocation(), diag::note_declared_at);
3342 }
3343 }
3344 }
Benjamin Kramer054faa52013-03-29 21:43:21 +00003345
3346 // Warn on "sizeof(array op x)" and "sizeof(x op array)", where the array
3347 // decays into a pointer and returns an unintended result. This is most
3348 // likely a typo for "sizeof(array) op x".
3349 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) {
3350 warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
3351 BO->getLHS());
3352 warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
3353 BO->getRHS());
3354 }
Nico Weber0870deb2011-06-15 02:47:03 +00003355 }
3356
Chandler Carruth7c430c02011-05-27 01:33:31 +00003357 return false;
Chandler Carruth14502c22011-05-26 08:53:10 +00003358}
3359
3360/// \brief Check the constraints on operands to unary expression and type
3361/// traits.
3362///
3363/// This will complete any types necessary, and validate the various constraints
3364/// on those operands.
3365///
Steve Naroff71b59a92007-06-04 22:22:31 +00003366/// The UsualUnaryConversions() function is *not* called by this routine.
Chandler Carruth14502c22011-05-26 08:53:10 +00003367/// C99 6.3.2.1p[2-4] all state:
3368/// Except when it is the operand of the sizeof operator ...
3369///
3370/// C++ [expr.sizeof]p4
3371/// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
3372/// standard conversions are not applied to the operand of sizeof.
3373///
3374/// This policy is followed for all of the unary trait expressions.
Richard Trieuba63ce62011-09-09 01:45:06 +00003375bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
Peter Collingbournee190dee2011-03-11 19:24:49 +00003376 SourceLocation OpLoc,
3377 SourceRange ExprRange,
3378 UnaryExprOrTypeTrait ExprKind) {
Richard Trieuba63ce62011-09-09 01:45:06 +00003379 if (ExprType->isDependentType())
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00003380 return false;
3381
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00003382 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
3383 // the result is the size of the referenced type."
3384 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the
3385 // result shall be the alignment of the referenced type."
Richard Trieuba63ce62011-09-09 01:45:06 +00003386 if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
3387 ExprType = Ref->getPointeeType();
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00003388
Chandler Carruth62da79c2011-05-26 08:53:12 +00003389 if (ExprKind == UETT_VecStep)
Richard Trieuba63ce62011-09-09 01:45:06 +00003390 return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
Peter Collingbournee190dee2011-03-11 19:24:49 +00003391
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003392 // Whitelist some types as extensions
Richard Trieuba63ce62011-09-09 01:45:06 +00003393 if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003394 ExprKind))
Chris Lattnerb1355b12009-01-24 19:46:37 +00003395 return false;
Mike Stump11289f42009-09-09 15:08:12 +00003396
Richard Trieuba63ce62011-09-09 01:45:06 +00003397 if (RequireCompleteType(OpLoc, ExprType,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00003398 diag::err_sizeof_alignof_incomplete_type,
3399 ExprKind, ExprRange))
Chris Lattner62975a72009-04-24 00:30:45 +00003400 return true;
Mike Stump11289f42009-09-09 15:08:12 +00003401
Eli Friedman4e28b262013-08-13 22:26:42 +00003402 if (ExprType->isFunctionType()) {
3403 Diag(OpLoc, diag::err_sizeof_alignof_function_type)
3404 << ExprKind << ExprRange;
3405 return true;
3406 }
3407
Richard Trieuba63ce62011-09-09 01:45:06 +00003408 if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
Chandler Carruthcea1aac2011-05-26 08:53:16 +00003409 ExprKind))
Chris Lattnercd2a8c52009-04-24 22:30:50 +00003410 return true;
Mike Stump11289f42009-09-09 15:08:12 +00003411
Chris Lattner62975a72009-04-24 00:30:45 +00003412 return false;
Steve Naroff043d45d2007-05-15 02:32:35 +00003413}
3414
Chandler Carruth14502c22011-05-26 08:53:10 +00003415static bool CheckAlignOfExpr(Sema &S, Expr *E) {
Chris Lattner8dff0172009-01-24 20:17:12 +00003416 E = E->IgnoreParens();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00003417
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00003418 // Cannot know anything else if the expression is dependent.
3419 if (E->isTypeDependent())
3420 return false;
3421
John McCall768439e2013-05-06 07:40:34 +00003422 if (E->getObjectKind() == OK_BitField) {
Chandler Carruth14502c22011-05-26 08:53:10 +00003423 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield)
3424 << 1 << E->getSourceRange();
Douglas Gregor71235ec2009-05-02 02:18:30 +00003425 return true;
Chris Lattner8dff0172009-01-24 20:17:12 +00003426 }
Douglas Gregor71235ec2009-05-02 02:18:30 +00003427
John McCall768439e2013-05-06 07:40:34 +00003428 ValueDecl *D = 0;
3429 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
3430 D = DRE->getDecl();
3431 } else if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
3432 D = ME->getMemberDecl();
3433 }
3434
3435 // If it's a field, require the containing struct to have a
3436 // complete definition so that we can compute the layout.
3437 //
3438 // This requires a very particular set of circumstances. For a
3439 // field to be contained within an incomplete type, we must in the
3440 // process of parsing that type. To have an expression refer to a
3441 // field, it must be an id-expression or a member-expression, but
3442 // the latter are always ill-formed when the base type is
3443 // incomplete, including only being partially complete. An
3444 // id-expression can never refer to a field in C because fields
3445 // are not in the ordinary namespace. In C++, an id-expression
3446 // can implicitly be a member access, but only if there's an
3447 // implicit 'this' value, and all such contexts are subject to
3448 // delayed parsing --- except for trailing return types in C++11.
3449 // And if an id-expression referring to a field occurs in a
3450 // context that lacks a 'this' value, it's ill-formed --- except,
Alp Tokerf6a24ce2013-12-05 16:25:25 +00003451 // again, in C++11, where such references are allowed in an
John McCall768439e2013-05-06 07:40:34 +00003452 // unevaluated context. So C++11 introduces some new complexity.
3453 //
3454 // For the record, since __alignof__ on expressions is a GCC
3455 // extension, GCC seems to permit this but always gives the
3456 // nonsensical answer 0.
3457 //
3458 // We don't really need the layout here --- we could instead just
3459 // directly check for all the appropriate alignment-lowing
3460 // attributes --- but that would require duplicating a lot of
3461 // logic that just isn't worth duplicating for such a marginal
3462 // use-case.
3463 if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {
3464 // Fast path this check, since we at least know the record has a
3465 // definition if we can find a member of it.
3466 if (!FD->getParent()->isCompleteDefinition()) {
3467 S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type)
3468 << E->getSourceRange();
3469 return true;
3470 }
3471
3472 // Otherwise, if it's a field, and the field doesn't have
3473 // reference type, then it must have a complete type (or be a
3474 // flexible array member, which we explicitly want to
3475 // white-list anyway), which makes the following checks trivial.
3476 if (!FD->getType()->isReferenceType())
Douglas Gregor71235ec2009-05-02 02:18:30 +00003477 return false;
John McCall768439e2013-05-06 07:40:34 +00003478 }
Douglas Gregor71235ec2009-05-02 02:18:30 +00003479
Chandler Carruth14502c22011-05-26 08:53:10 +00003480 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf);
Peter Collingbournee190dee2011-03-11 19:24:49 +00003481}
3482
Chandler Carruth14502c22011-05-26 08:53:10 +00003483bool Sema::CheckVecStepExpr(Expr *E) {
Peter Collingbournee190dee2011-03-11 19:24:49 +00003484 E = E->IgnoreParens();
3485
3486 // Cannot know anything else if the expression is dependent.
3487 if (E->isTypeDependent())
3488 return false;
3489
Chandler Carruth14502c22011-05-26 08:53:10 +00003490 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep);
Chris Lattner8dff0172009-01-24 20:17:12 +00003491}
3492
Douglas Gregor0950e412009-03-13 21:01:28 +00003493/// \brief Build a sizeof or alignof expression given a type operand.
John McCalldadc5752010-08-24 06:29:42 +00003494ExprResult
Peter Collingbournee190dee2011-03-11 19:24:49 +00003495Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
3496 SourceLocation OpLoc,
3497 UnaryExprOrTypeTrait ExprKind,
3498 SourceRange R) {
John McCallbcd03502009-12-07 02:54:59 +00003499 if (!TInfo)
Douglas Gregor0950e412009-03-13 21:01:28 +00003500 return ExprError();
3501
John McCallbcd03502009-12-07 02:54:59 +00003502 QualType T = TInfo->getType();
John McCall4c98fd82009-11-04 07:28:41 +00003503
Douglas Gregor0950e412009-03-13 21:01:28 +00003504 if (!T->isDependentType() &&
Peter Collingbournee190dee2011-03-11 19:24:49 +00003505 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind))
Douglas Gregor0950e412009-03-13 21:01:28 +00003506 return ExprError();
3507
3508 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
Peter Collingbournee190dee2011-03-11 19:24:49 +00003509 return Owned(new (Context) UnaryExprOrTypeTraitExpr(ExprKind, TInfo,
3510 Context.getSizeType(),
3511 OpLoc, R.getEnd()));
Douglas Gregor0950e412009-03-13 21:01:28 +00003512}
3513
3514/// \brief Build a sizeof or alignof expression given an expression
3515/// operand.
John McCalldadc5752010-08-24 06:29:42 +00003516ExprResult
Chandler Carrutha923fb22011-05-29 07:32:14 +00003517Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
3518 UnaryExprOrTypeTrait ExprKind) {
Douglas Gregor835af982011-06-22 23:21:00 +00003519 ExprResult PE = CheckPlaceholderExpr(E);
3520 if (PE.isInvalid())
3521 return ExprError();
3522
3523 E = PE.get();
3524
Douglas Gregor0950e412009-03-13 21:01:28 +00003525 // Verify that the operand is valid.
3526 bool isInvalid = false;
3527 if (E->isTypeDependent()) {
3528 // Delay type-checking for type-dependent expressions.
Peter Collingbournee190dee2011-03-11 19:24:49 +00003529 } else if (ExprKind == UETT_AlignOf) {
Chandler Carruth14502c22011-05-26 08:53:10 +00003530 isInvalid = CheckAlignOfExpr(*this, E);
Peter Collingbournee190dee2011-03-11 19:24:49 +00003531 } else if (ExprKind == UETT_VecStep) {
Chandler Carruth14502c22011-05-26 08:53:10 +00003532 isInvalid = CheckVecStepExpr(E);
John McCalld25db7e2013-05-06 21:39:12 +00003533 } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
Chandler Carruth14502c22011-05-26 08:53:10 +00003534 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0;
Douglas Gregor0950e412009-03-13 21:01:28 +00003535 isInvalid = true;
3536 } else {
Chandler Carruth14502c22011-05-26 08:53:10 +00003537 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf);
Douglas Gregor0950e412009-03-13 21:01:28 +00003538 }
3539
3540 if (isInvalid)
3541 return ExprError();
3542
Eli Friedmane0afc982012-01-21 01:01:51 +00003543 if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) {
Benjamin Kramerd81108f2012-11-14 15:08:31 +00003544 PE = TransformToPotentiallyEvaluated(E);
Eli Friedmane0afc982012-01-21 01:01:51 +00003545 if (PE.isInvalid()) return ExprError();
3546 E = PE.take();
3547 }
3548
Douglas Gregor0950e412009-03-13 21:01:28 +00003549 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
Chandler Carruth14502c22011-05-26 08:53:10 +00003550 return Owned(new (Context) UnaryExprOrTypeTraitExpr(
Chandler Carrutha923fb22011-05-29 07:32:14 +00003551 ExprKind, E, Context.getSizeType(), OpLoc,
Chandler Carruth14502c22011-05-26 08:53:10 +00003552 E->getSourceRange().getEnd()));
Douglas Gregor0950e412009-03-13 21:01:28 +00003553}
3554
Peter Collingbournee190dee2011-03-11 19:24:49 +00003555/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
3556/// expr and the same for @c alignof and @c __alignof
Sebastian Redl6f282892008-11-11 17:56:53 +00003557/// Note that the ArgRange is invalid if isType is false.
John McCalldadc5752010-08-24 06:29:42 +00003558ExprResult
Peter Collingbournee190dee2011-03-11 19:24:49 +00003559Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00003560 UnaryExprOrTypeTrait ExprKind, bool IsType,
Peter Collingbournee190dee2011-03-11 19:24:49 +00003561 void *TyOrEx, const SourceRange &ArgRange) {
Chris Lattner0d8b1a12006-11-20 04:34:45 +00003562 // If error parsing type, ignore.
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003563 if (TyOrEx == 0) return ExprError();
Steve Naroff043d45d2007-05-15 02:32:35 +00003564
Richard Trieuba63ce62011-09-09 01:45:06 +00003565 if (IsType) {
John McCallbcd03502009-12-07 02:54:59 +00003566 TypeSourceInfo *TInfo;
John McCallba7bf592010-08-24 05:47:05 +00003567 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
Peter Collingbournee190dee2011-03-11 19:24:49 +00003568 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
Mike Stump11289f42009-09-09 15:08:12 +00003569 }
Sebastian Redl6f282892008-11-11 17:56:53 +00003570
Douglas Gregor0950e412009-03-13 21:01:28 +00003571 Expr *ArgEx = (Expr *)TyOrEx;
Chandler Carrutha923fb22011-05-29 07:32:14 +00003572 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind);
Benjamin Kramer62b95d82012-08-23 21:35:17 +00003573 return Result;
Chris Lattnere168f762006-11-10 05:29:30 +00003574}
3575
John Wiegley01296292011-04-08 18:41:53 +00003576static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc,
Richard Trieuba63ce62011-09-09 01:45:06 +00003577 bool IsReal) {
John Wiegley01296292011-04-08 18:41:53 +00003578 if (V.get()->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00003579 return S.Context.DependentTy;
Mike Stump11289f42009-09-09 15:08:12 +00003580
John McCall34376a62010-12-04 03:47:34 +00003581 // _Real and _Imag are only l-values for normal l-values.
John Wiegley01296292011-04-08 18:41:53 +00003582 if (V.get()->getObjectKind() != OK_Ordinary) {
3583 V = S.DefaultLvalueConversion(V.take());
3584 if (V.isInvalid())
3585 return QualType();
3586 }
John McCall34376a62010-12-04 03:47:34 +00003587
Chris Lattnere267f5d2007-08-26 05:39:26 +00003588 // These operators return the element type of a complex type.
John Wiegley01296292011-04-08 18:41:53 +00003589 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>())
Chris Lattner30b5dd02007-08-24 21:16:53 +00003590 return CT->getElementType();
Mike Stump11289f42009-09-09 15:08:12 +00003591
Chris Lattnere267f5d2007-08-26 05:39:26 +00003592 // Otherwise they pass through real integer and floating point types here.
John Wiegley01296292011-04-08 18:41:53 +00003593 if (V.get()->getType()->isArithmeticType())
3594 return V.get()->getType();
Mike Stump11289f42009-09-09 15:08:12 +00003595
John McCall36226622010-10-12 02:09:17 +00003596 // Test for placeholders.
John McCall3aef3d82011-04-10 19:13:55 +00003597 ExprResult PR = S.CheckPlaceholderExpr(V.get());
John McCall36226622010-10-12 02:09:17 +00003598 if (PR.isInvalid()) return QualType();
John Wiegley01296292011-04-08 18:41:53 +00003599 if (PR.get() != V.get()) {
Benjamin Kramer62b95d82012-08-23 21:35:17 +00003600 V = PR;
Richard Trieuba63ce62011-09-09 01:45:06 +00003601 return CheckRealImagOperand(S, V, Loc, IsReal);
John McCall36226622010-10-12 02:09:17 +00003602 }
3603
Chris Lattnere267f5d2007-08-26 05:39:26 +00003604 // Reject anything else.
John Wiegley01296292011-04-08 18:41:53 +00003605 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType()
Richard Trieuba63ce62011-09-09 01:45:06 +00003606 << (IsReal ? "__real" : "__imag");
Chris Lattnere267f5d2007-08-26 05:39:26 +00003607 return QualType();
Chris Lattner30b5dd02007-08-24 21:16:53 +00003608}
3609
3610
Chris Lattnere168f762006-11-10 05:29:30 +00003611
John McCalldadc5752010-08-24 06:29:42 +00003612ExprResult
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003613Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
John McCallb268a282010-08-23 23:25:46 +00003614 tok::TokenKind Kind, Expr *Input) {
John McCalle3027922010-08-25 11:45:40 +00003615 UnaryOperatorKind Opc;
Chris Lattnere168f762006-11-10 05:29:30 +00003616 switch (Kind) {
David Blaikie83d382b2011-09-23 05:06:16 +00003617 default: llvm_unreachable("Unknown unary op!");
John McCalle3027922010-08-25 11:45:40 +00003618 case tok::plusplus: Opc = UO_PostInc; break;
3619 case tok::minusminus: Opc = UO_PostDec; break;
Chris Lattnere168f762006-11-10 05:29:30 +00003620 }
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003621
Sebastian Redla9351792012-02-11 23:51:47 +00003622 // Since this might is a postfix expression, get rid of ParenListExprs.
3623 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
3624 if (Result.isInvalid()) return ExprError();
3625 Input = Result.take();
3626
John McCallb268a282010-08-23 23:25:46 +00003627 return BuildUnaryOp(S, OpLoc, Opc, Input);
Chris Lattnere168f762006-11-10 05:29:30 +00003628}
3629
John McCallf2538342012-07-31 05:14:30 +00003630/// \brief Diagnose if arithmetic on the given ObjC pointer is illegal.
3631///
3632/// \return true on error
3633static bool checkArithmeticOnObjCPointer(Sema &S,
3634 SourceLocation opLoc,
3635 Expr *op) {
3636 assert(op->getType()->isObjCObjectPointerType());
Fariborz Jahaniane1e33f82013-11-01 21:58:17 +00003637 if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() &&
3638 !S.LangOpts.ObjCSubscriptingLegacyRuntime)
John McCallf2538342012-07-31 05:14:30 +00003639 return false;
3640
3641 S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
3642 << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
3643 << op->getSourceRange();
3644 return true;
3645}
3646
John McCalldadc5752010-08-24 06:29:42 +00003647ExprResult
John McCallf22d0ac2013-03-04 01:30:55 +00003648Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base, SourceLocation lbLoc,
3649 Expr *idx, SourceLocation rbLoc) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00003650 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCallf22d0ac2013-03-04 01:30:55 +00003651 if (isa<ParenListExpr>(base)) {
3652 ExprResult result = MaybeConvertParenListExprToParenExpr(S, base);
3653 if (result.isInvalid()) return ExprError();
3654 base = result.take();
3655 }
Nate Begeman5ec4b312009-08-10 23:49:36 +00003656
John McCallf22d0ac2013-03-04 01:30:55 +00003657 // Handle any non-overload placeholder types in the base and index
3658 // expressions. We can't handle overloads here because the other
3659 // operand might be an overloadable type, in which case the overload
3660 // resolution for the operator overload should get the first crack
3661 // at the overload.
3662 if (base->getType()->isNonOverloadPlaceholderType()) {
3663 ExprResult result = CheckPlaceholderExpr(base);
3664 if (result.isInvalid()) return ExprError();
3665 base = result.take();
3666 }
3667 if (idx->getType()->isNonOverloadPlaceholderType()) {
3668 ExprResult result = CheckPlaceholderExpr(idx);
3669 if (result.isInvalid()) return ExprError();
3670 idx = result.take();
3671 }
Mike Stump11289f42009-09-09 15:08:12 +00003672
John McCallf22d0ac2013-03-04 01:30:55 +00003673 // Build an unanalyzed expression if either operand is type-dependent.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003674 if (getLangOpts().CPlusPlus &&
John McCallf22d0ac2013-03-04 01:30:55 +00003675 (base->isTypeDependent() || idx->isTypeDependent())) {
3676 return Owned(new (Context) ArraySubscriptExpr(base, idx,
John McCall7decc9e2010-11-18 06:31:45 +00003677 Context.DependentTy,
3678 VK_LValue, OK_Ordinary,
John McCallf22d0ac2013-03-04 01:30:55 +00003679 rbLoc));
Douglas Gregor7a77a6b2009-05-19 00:01:19 +00003680 }
3681
John McCallf22d0ac2013-03-04 01:30:55 +00003682 // Use C++ overloaded-operator rules if either operand has record
3683 // type. The spec says to do this if either type is *overloadable*,
3684 // but enum types can't declare subscript operators or conversion
3685 // operators, so there's nothing interesting for overload resolution
3686 // to do if there aren't any record types involved.
3687 //
3688 // ObjC pointers have their own subscripting logic that is not tied
3689 // to overload resolution and so should not take this path.
David Blaikiebbafb8a2012-03-11 07:00:24 +00003690 if (getLangOpts().CPlusPlus &&
John McCallf22d0ac2013-03-04 01:30:55 +00003691 (base->getType()->isRecordType() ||
3692 (!base->getType()->isObjCObjectPointerType() &&
3693 idx->getType()->isRecordType()))) {
3694 return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx);
Douglas Gregor40412ac2008-11-19 17:17:41 +00003695 }
3696
John McCallf22d0ac2013-03-04 01:30:55 +00003697 return CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc);
Sebastian Redladba46e2009-10-29 20:17:01 +00003698}
3699
John McCalldadc5752010-08-24 06:29:42 +00003700ExprResult
John McCallb268a282010-08-23 23:25:46 +00003701Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00003702 Expr *Idx, SourceLocation RLoc) {
John McCallb268a282010-08-23 23:25:46 +00003703 Expr *LHSExp = Base;
3704 Expr *RHSExp = Idx;
Sebastian Redladba46e2009-10-29 20:17:01 +00003705
Chris Lattner36d572b2007-07-16 00:14:47 +00003706 // Perform default conversions.
John Wiegley01296292011-04-08 18:41:53 +00003707 if (!LHSExp->getType()->getAs<VectorType>()) {
3708 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
3709 if (Result.isInvalid())
3710 return ExprError();
3711 LHSExp = Result.take();
3712 }
3713 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
3714 if (Result.isInvalid())
3715 return ExprError();
3716 RHSExp = Result.take();
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003717
Chris Lattner36d572b2007-07-16 00:14:47 +00003718 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType();
John McCall7decc9e2010-11-18 06:31:45 +00003719 ExprValueKind VK = VK_LValue;
3720 ExprObjectKind OK = OK_Ordinary;
Steve Narofff1e53692007-03-23 22:27:02 +00003721
Steve Naroffc1aadb12007-03-28 21:49:40 +00003722 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent
Chris Lattnerf17bd422007-08-30 17:45:32 +00003723 // to the expression *((e1)+(e2)). This means the array "Base" may actually be
Mike Stump4e1f26a2009-02-19 03:04:26 +00003724 // in the subscript position. As a result, we need to derive the array base
Steve Narofff1e53692007-03-23 22:27:02 +00003725 // and index from the expression types.
Chris Lattner36d572b2007-07-16 00:14:47 +00003726 Expr *BaseExpr, *IndexExpr;
3727 QualType ResultType;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00003728 if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
3729 BaseExpr = LHSExp;
3730 IndexExpr = RHSExp;
3731 ResultType = Context.DependentTy;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003732 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) {
Chris Lattner36d572b2007-07-16 00:14:47 +00003733 BaseExpr = LHSExp;
3734 IndexExpr = RHSExp;
Chris Lattner36d572b2007-07-16 00:14:47 +00003735 ResultType = PTy->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00003736 } else if (const ObjCObjectPointerType *PTy =
John McCallf2538342012-07-31 05:14:30 +00003737 LHSTy->getAs<ObjCObjectPointerType>()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00003738 BaseExpr = LHSExp;
3739 IndexExpr = RHSExp;
John McCallf2538342012-07-31 05:14:30 +00003740
3741 // Use custom logic if this should be the pseudo-object subscript
3742 // expression.
Fariborz Jahaniane1e33f82013-11-01 21:58:17 +00003743 if (!LangOpts.isSubscriptPointerArithmetic())
John McCallf2538342012-07-31 05:14:30 +00003744 return BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, 0, 0);
3745
Steve Naroff7cae42b2009-07-10 23:34:53 +00003746 ResultType = PTy->getPointeeType();
Fariborz Jahanianba0afde2012-03-28 17:56:49 +00003747 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
3748 // Handle the uncommon case of "123[Ptr]".
3749 BaseExpr = RHSExp;
3750 IndexExpr = LHSExp;
3751 ResultType = PTy->getPointeeType();
Mike Stump11289f42009-09-09 15:08:12 +00003752 } else if (const ObjCObjectPointerType *PTy =
John McCall9dd450b2009-09-21 23:43:11 +00003753 RHSTy->getAs<ObjCObjectPointerType>()) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00003754 // Handle the uncommon case of "123[Ptr]".
3755 BaseExpr = RHSExp;
3756 IndexExpr = LHSExp;
3757 ResultType = PTy->getPointeeType();
Fariborz Jahaniane1e33f82013-11-01 21:58:17 +00003758 if (!LangOpts.isSubscriptPointerArithmetic()) {
John McCallf2538342012-07-31 05:14:30 +00003759 Diag(LLoc, diag::err_subscript_nonfragile_interface)
3760 << ResultType << BaseExpr->getSourceRange();
3761 return ExprError();
3762 }
John McCall9dd450b2009-09-21 23:43:11 +00003763 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) {
Chris Lattner41977962007-07-31 19:29:30 +00003764 BaseExpr = LHSExp; // vectors: V[123]
Chris Lattner36d572b2007-07-16 00:14:47 +00003765 IndexExpr = RHSExp;
John McCall7decc9e2010-11-18 06:31:45 +00003766 VK = LHSExp->getValueKind();
3767 if (VK != VK_RValue)
3768 OK = OK_VectorComponent;
Nate Begemanc1bf0612009-01-18 00:45:31 +00003769
Chris Lattner36d572b2007-07-16 00:14:47 +00003770 // FIXME: need to deal with const...
3771 ResultType = VTy->getElementType();
Eli Friedmanab2784f2009-04-25 23:46:54 +00003772 } else if (LHSTy->isArrayType()) {
3773 // If we see an array that wasn't promoted by
Douglas Gregorb92a1562010-02-03 00:27:59 +00003774 // DefaultFunctionArrayLvalueConversion, it must be an array that
Eli Friedmanab2784f2009-04-25 23:46:54 +00003775 // wasn't promoted because of the C90 rule that doesn't
3776 // allow promoting non-lvalue arrays. Warn, then
3777 // force the promotion here.
3778 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
3779 LHSExp->getSourceRange();
John Wiegley01296292011-04-08 18:41:53 +00003780 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
3781 CK_ArrayToPointerDecay).take();
Eli Friedmanab2784f2009-04-25 23:46:54 +00003782 LHSTy = LHSExp->getType();
3783
3784 BaseExpr = LHSExp;
3785 IndexExpr = RHSExp;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003786 ResultType = LHSTy->getAs<PointerType>()->getPointeeType();
Eli Friedmanab2784f2009-04-25 23:46:54 +00003787 } else if (RHSTy->isArrayType()) {
3788 // Same as previous, except for 123[f().a] case
3789 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) <<
3790 RHSExp->getSourceRange();
John Wiegley01296292011-04-08 18:41:53 +00003791 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
3792 CK_ArrayToPointerDecay).take();
Eli Friedmanab2784f2009-04-25 23:46:54 +00003793 RHSTy = RHSExp->getType();
3794
3795 BaseExpr = RHSExp;
3796 IndexExpr = LHSExp;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00003797 ResultType = RHSTy->getAs<PointerType>()->getPointeeType();
Steve Naroffb3096442007-06-09 03:47:53 +00003798 } else {
Chris Lattner003af242009-04-25 22:50:55 +00003799 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
3800 << LHSExp->getSourceRange() << RHSExp->getSourceRange());
Sebastian Redlc215cfc2009-01-19 00:08:26 +00003801 }
Steve Naroffc1aadb12007-03-28 21:49:40 +00003802 // C99 6.5.2.1p1
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00003803 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
Chris Lattner003af242009-04-25 22:50:55 +00003804 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer)
3805 << IndexExpr->getSourceRange());
Steve Naroffb29cdd52007-07-10 18:23:31 +00003806
Daniel Dunbar4782a6e2009-09-17 06:31:17 +00003807 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) ||
Sam Weinigb7608d72009-09-14 20:14:57 +00003808 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U))
3809 && !IndexExpr->isTypeDependent())
Sam Weinig914244e2009-09-14 01:58:58 +00003810 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange();
3811
Douglas Gregorac1fb652009-03-24 19:52:54 +00003812 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly,
Mike Stump11289f42009-09-09 15:08:12 +00003813 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object
3814 // type. Note that Functions are not objects, and that (in C99 parlance)
Douglas Gregorac1fb652009-03-24 19:52:54 +00003815 // incomplete types are not object types.
3816 if (ResultType->isFunctionType()) {
3817 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type)
3818 << ResultType << BaseExpr->getSourceRange();
3819 return ExprError();
3820 }
Mike Stump11289f42009-09-09 15:08:12 +00003821
David Blaikiebbafb8a2012-03-11 07:00:24 +00003822 if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
Abramo Bagnara3aabb4b2010-09-13 06:50:07 +00003823 // GNU extension: subscripting on pointer to void
Chandler Carruth4cc3f292011-06-27 16:32:27 +00003824 Diag(LLoc, diag::ext_gnu_subscript_void_type)
3825 << BaseExpr->getSourceRange();
John McCall4bc41ae2010-11-18 19:01:18 +00003826
3827 // C forbids expressions of unqualified void type from being l-values.
3828 // See IsCForbiddenLValueType.
3829 if (!ResultType.hasQualifiers()) VK = VK_RValue;
Abramo Bagnara3aabb4b2010-09-13 06:50:07 +00003830 } else if (!ResultType->isDependentType() &&
Mike Stump11289f42009-09-09 15:08:12 +00003831 RequireCompleteType(LLoc, ResultType,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00003832 diag::err_subscript_incomplete_type, BaseExpr))
Douglas Gregorac1fb652009-03-24 19:52:54 +00003833 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00003834
John McCall4bc41ae2010-11-18 19:01:18 +00003835 assert(VK == VK_RValue || LangOpts.CPlusPlus ||
Douglas Gregor5476205b2011-06-23 00:49:38 +00003836 !ResultType.isCForbiddenLValueType());
John McCall4bc41ae2010-11-18 19:01:18 +00003837
Mike Stump4e1f26a2009-02-19 03:04:26 +00003838 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp,
John McCall7decc9e2010-11-18 06:31:45 +00003839 ResultType, VK, OK, RLoc));
Chris Lattnere168f762006-11-10 05:29:30 +00003840}
3841
John McCalldadc5752010-08-24 06:29:42 +00003842ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
Nico Weber44887f62010-11-29 18:19:25 +00003843 FunctionDecl *FD,
3844 ParmVarDecl *Param) {
Anders Carlsson355933d2009-08-25 03:49:14 +00003845 if (Param->hasUnparsedDefaultArg()) {
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003846 Diag(CallLoc,
Nico Weberebd45a02010-11-30 04:44:33 +00003847 diag::err_use_of_default_argument_to_function_declared_later) <<
Anders Carlsson355933d2009-08-25 03:49:14 +00003848 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName();
Mike Stump11289f42009-09-09 15:08:12 +00003849 Diag(UnparsedDefaultArgLocs[Param],
Nico Weberebd45a02010-11-30 04:44:33 +00003850 diag::note_default_argument_declared_here);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003851 return ExprError();
3852 }
3853
3854 if (Param->hasUninstantiatedDefaultArg()) {
3855 Expr *UninstExpr = Param->getUninstantiatedDefaultArg();
Anders Carlsson355933d2009-08-25 03:49:14 +00003856
Richard Smith505df232012-07-22 23:45:10 +00003857 EnterExpressionEvaluationContext EvalContext(*this, PotentiallyEvaluated,
3858 Param);
3859
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003860 // Instantiate the expression.
Richard Smith47752e42013-05-03 23:46:09 +00003861 MultiLevelTemplateArgumentList MutiLevelArgList
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003862 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true);
Anders Carlsson657bad42009-09-05 05:14:19 +00003863
Richard Smith80934652012-07-16 01:09:10 +00003864 InstantiatingTemplate Inst(*this, CallLoc, Param,
Richard Smith47752e42013-05-03 23:46:09 +00003865 MutiLevelArgList.getInnermost());
Alp Tokerd4a72d52013-10-08 08:09:04 +00003866 if (Inst.isInvalid())
Richard Smith8a874c92012-07-08 02:38:24 +00003867 return ExprError();
Anders Carlsson355933d2009-08-25 03:49:14 +00003868
Nico Weber44887f62010-11-29 18:19:25 +00003869 ExprResult Result;
3870 {
3871 // C++ [dcl.fct.default]p5:
3872 // The names in the [default argument] expression are bound, and
3873 // the semantic constraints are checked, at the point where the
3874 // default argument expression appears.
Nico Weberebd45a02010-11-30 04:44:33 +00003875 ContextRAII SavedContext(*this, FD);
Douglas Gregora86bc002012-02-16 21:36:18 +00003876 LocalInstantiationScope Local(*this);
Richard Smith47752e42013-05-03 23:46:09 +00003877 Result = SubstExpr(UninstExpr, MutiLevelArgList);
Nico Weber44887f62010-11-29 18:19:25 +00003878 }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003879 if (Result.isInvalid())
3880 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00003881
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003882 // Check the expression as an initializer for the parameter.
3883 InitializedEntity Entity
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00003884 = InitializedEntity::InitializeParameter(Context, Param);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003885 InitializationKind Kind
3886 = InitializationKind::CreateCopy(Param->getLocation(),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00003887 /*FIXME:EqualLoc*/UninstExpr->getLocStart());
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003888 Expr *ResultE = Result.takeAs<Expr>();
Douglas Gregor25ab25f2009-12-23 18:19:08 +00003889
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00003890 InitializationSequence InitSeq(*this, Entity, Kind, ResultE);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00003891 Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003892 if (Result.isInvalid())
3893 return ExprError();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00003894
David Blaikief68e8092012-04-30 18:21:31 +00003895 Expr *Arg = Result.takeAs<Expr>();
Richard Smithc406cb72013-01-17 01:17:56 +00003896 CheckCompletedExpr(Arg, Param->getOuterLocStart());
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003897 // Build the default argument expression.
David Blaikief68e8092012-04-30 18:21:31 +00003898 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, Arg));
Anders Carlsson355933d2009-08-25 03:49:14 +00003899 }
3900
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003901 // If the default expression creates temporaries, we need to
3902 // push them to the current stack of expression temporaries so they'll
3903 // be properly destroyed.
3904 // FIXME: We should really be rebuilding the default argument with new
3905 // bound temporaries; see the comment in PR5810.
John McCall28fc7092011-11-10 05:35:25 +00003906 // We don't need to do that with block decls, though, because
3907 // blocks in default argument expression can never capture anything.
3908 if (isa<ExprWithCleanups>(Param->getInit())) {
3909 // Set the "needs cleanups" bit regardless of whether there are
3910 // any explicit objects.
John McCall31168b02011-06-15 23:02:42 +00003911 ExprNeedsCleanups = true;
John McCall28fc7092011-11-10 05:35:25 +00003912
3913 // Append all the objects to the cleanup list. Right now, this
3914 // should always be a no-op, because blocks in default argument
3915 // expressions should never be able to capture anything.
3916 assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() &&
3917 "default argument expression has capturing blocks?");
Douglas Gregor6ed2fee2010-09-14 22:55:20 +00003918 }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +00003919
3920 // We already type-checked the argument, so we know it works.
Douglas Gregor32b3de52010-09-11 23:32:50 +00003921 // Just mark all of the declarations in this potentially-evaluated expression
3922 // as being "referenced".
Douglas Gregor680e9e02012-02-21 19:11:17 +00003923 MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
3924 /*SkipLocalVariables=*/true);
Douglas Gregor033f6752009-12-23 23:03:06 +00003925 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param));
Anders Carlsson355933d2009-08-25 03:49:14 +00003926}
3927
Richard Smith55ce3522012-06-25 20:30:08 +00003928
3929Sema::VariadicCallType
3930Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto,
3931 Expr *Fn) {
3932 if (Proto && Proto->isVariadic()) {
3933 if (dyn_cast_or_null<CXXConstructorDecl>(FDecl))
3934 return VariadicConstructor;
3935 else if (Fn && Fn->getType()->isBlockPointerType())
3936 return VariadicBlock;
3937 else if (FDecl) {
3938 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
3939 if (Method->isInstance())
3940 return VariadicMethod;
Richard Trieu9be9c682013-06-22 02:30:38 +00003941 } else if (Fn && Fn->getType() == Context.BoundMemberTy)
3942 return VariadicMethod;
Richard Smith55ce3522012-06-25 20:30:08 +00003943 return VariadicFunction;
3944 }
3945 return VariadicDoesNotApply;
3946}
3947
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00003948namespace {
3949class FunctionCallCCC : public FunctionCallFilterCCC {
3950public:
3951 FunctionCallCCC(Sema &SemaRef, const IdentifierInfo *FuncName,
3952 unsigned NumArgs, bool HasExplicitTemplateArgs)
3953 : FunctionCallFilterCCC(SemaRef, NumArgs, HasExplicitTemplateArgs),
3954 FunctionName(FuncName) {}
3955
3956 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
3957 if (!candidate.getCorrectionSpecifier() ||
3958 candidate.getCorrectionAsIdentifierInfo() != FunctionName) {
3959 return false;
3960 }
3961
3962 return FunctionCallFilterCCC::ValidateCandidate(candidate);
3963 }
3964
3965private:
3966 const IdentifierInfo *const FunctionName;
3967};
3968}
3969
3970static TypoCorrection TryTypoCorrectionForCall(Sema &S,
3971 DeclarationNameInfo FuncName,
3972 ArrayRef<Expr *> Args) {
3973 FunctionCallCCC CCC(S, FuncName.getName().getAsIdentifierInfo(),
3974 Args.size(), false);
3975 if (TypoCorrection Corrected =
3976 S.CorrectTypo(FuncName, Sema::LookupOrdinaryName,
3977 S.getScopeForContext(S.CurContext), NULL, CCC)) {
3978 if (NamedDecl *ND = Corrected.getCorrectionDecl()) {
3979 if (Corrected.isOverloaded()) {
3980 OverloadCandidateSet OCS(FuncName.getLoc());
3981 OverloadCandidateSet::iterator Best;
3982 for (TypoCorrection::decl_iterator CD = Corrected.begin(),
3983 CDEnd = Corrected.end();
3984 CD != CDEnd; ++CD) {
3985 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD))
3986 S.AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args,
3987 OCS);
3988 }
3989 switch (OCS.BestViableFunction(S, FuncName.getLoc(), Best)) {
3990 case OR_Success:
3991 ND = Best->Function;
3992 Corrected.setCorrectionDecl(ND);
3993 break;
3994 default:
3995 break;
3996 }
3997 }
3998 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
3999 return Corrected;
4000 }
4001 }
4002 }
4003 return TypoCorrection();
4004}
4005
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004006/// ConvertArgumentsForCall - Converts the arguments specified in
4007/// Args/NumArgs to the parameter types of the function FDecl with
4008/// function prototype Proto. Call is the call expression itself, and
4009/// Fn is the function expression. For a C++ member function, this
4010/// routine does not attempt to convert the object argument. Returns
4011/// true if the call is ill-formed.
Mike Stump4e1f26a2009-02-19 03:04:26 +00004012bool
4013Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004014 FunctionDecl *FDecl,
Douglas Gregordeaad8c2009-02-26 23:50:07 +00004015 const FunctionProtoType *Proto,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004016 ArrayRef<Expr *> Args,
Peter Collingbourne619a8c72011-10-02 23:49:29 +00004017 SourceLocation RParenLoc,
4018 bool IsExecConfig) {
John McCallbebede42011-02-26 05:39:39 +00004019 // Bail out early if calling a builtin with custom typechecking.
4020 // We don't need to do this in the
4021 if (FDecl)
4022 if (unsigned ID = FDecl->getBuiltinID())
4023 if (Context.BuiltinInfo.hasCustomTypechecking(ID))
4024 return false;
4025
Mike Stump4e1f26a2009-02-19 03:04:26 +00004026 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004027 // assignment, to the types of the corresponding parameter, ...
4028 unsigned NumArgsInProto = Proto->getNumArgs();
Douglas Gregorb6b99612009-01-23 21:30:56 +00004029 bool Invalid = false;
Peter Collingbourne740afe22011-10-02 23:49:20 +00004030 unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumArgsInProto;
Peter Collingbourne619a8c72011-10-02 23:49:29 +00004031 unsigned FnKind = Fn->getType()->isBlockPointerType()
4032 ? 1 /* block */
4033 : (IsExecConfig ? 3 /* kernel function (exec config) */
4034 : 0 /* function */);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004035
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004036 // If too few arguments are available (and we don't have default
4037 // arguments for the remaining parameters), don't make the call.
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004038 if (Args.size() < NumArgsInProto) {
4039 if (Args.size() < MinArgs) {
Kaelyn Uhraindeedc3a2013-09-26 19:10:34 +00004040 MemberExpr *ME = dyn_cast<MemberExpr>(Fn);
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004041 TypoCorrection TC;
4042 if (FDecl && (TC = TryTypoCorrectionForCall(
4043 *this, DeclarationNameInfo(FDecl->getDeclName(),
Kaelyn Uhraindeedc3a2013-09-26 19:10:34 +00004044 (ME ? ME->getMemberLoc()
4045 : Fn->getLocStart())),
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004046 Args))) {
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004047 unsigned diag_id =
4048 MinArgs == NumArgsInProto && !Proto->isVariadic()
4049 ? diag::err_typecheck_call_too_few_args_suggest
4050 : diag::err_typecheck_call_too_few_args_at_least_suggest;
Richard Smithf9b15102013-08-17 00:46:16 +00004051 diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs
4052 << static_cast<unsigned>(Args.size())
4053 << Fn->getSourceRange());
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004054 } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName())
Richard Smith10ff50d2012-05-11 05:16:41 +00004055 Diag(RParenLoc, MinArgs == NumArgsInProto && !Proto->isVariadic()
4056 ? diag::err_typecheck_call_too_few_args_one
4057 : diag::err_typecheck_call_too_few_args_at_least_one)
4058 << FnKind
4059 << FDecl->getParamDecl(0) << Fn->getSourceRange();
4060 else
4061 Diag(RParenLoc, MinArgs == NumArgsInProto && !Proto->isVariadic()
4062 ? diag::err_typecheck_call_too_few_args
4063 : diag::err_typecheck_call_too_few_args_at_least)
4064 << FnKind
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004065 << MinArgs << static_cast<unsigned>(Args.size())
4066 << Fn->getSourceRange();
Peter Collingbourne3bc84ca2011-07-29 00:24:42 +00004067
4068 // Emit the location of the prototype.
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004069 if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
Peter Collingbourne3bc84ca2011-07-29 00:24:42 +00004070 Diag(FDecl->getLocStart(), diag::note_callee_decl)
4071 << FDecl;
4072
4073 return true;
4074 }
Ted Kremenek5a201952009-02-07 01:47:29 +00004075 Call->setNumArgs(Context, NumArgsInProto);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004076 }
4077
4078 // If too many are passed and not variadic, error on the extras and drop
4079 // them.
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004080 if (Args.size() > NumArgsInProto) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004081 if (!Proto->isVariadic()) {
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004082 TypoCorrection TC;
4083 if (FDecl && (TC = TryTypoCorrectionForCall(
4084 *this, DeclarationNameInfo(FDecl->getDeclName(),
4085 Fn->getLocStart()),
4086 Args))) {
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004087 unsigned diag_id =
4088 MinArgs == NumArgsInProto && !Proto->isVariadic()
4089 ? diag::err_typecheck_call_too_many_args_suggest
4090 : diag::err_typecheck_call_too_many_args_at_most_suggest;
Richard Smithf9b15102013-08-17 00:46:16 +00004091 diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumArgsInProto
4092 << static_cast<unsigned>(Args.size())
4093 << Fn->getSourceRange());
4094 } else if (NumArgsInProto == 1 && FDecl &&
4095 FDecl->getParamDecl(0)->getDeclName())
Richard Smithd72da152012-05-15 06:21:54 +00004096 Diag(Args[NumArgsInProto]->getLocStart(),
4097 MinArgs == NumArgsInProto
4098 ? diag::err_typecheck_call_too_many_args_one
4099 : diag::err_typecheck_call_too_many_args_at_most_one)
4100 << FnKind
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004101 << FDecl->getParamDecl(0) << static_cast<unsigned>(Args.size())
4102 << Fn->getSourceRange()
Richard Smithd72da152012-05-15 06:21:54 +00004103 << SourceRange(Args[NumArgsInProto]->getLocStart(),
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004104 Args.back()->getLocEnd());
Richard Smithd72da152012-05-15 06:21:54 +00004105 else
4106 Diag(Args[NumArgsInProto]->getLocStart(),
4107 MinArgs == NumArgsInProto
4108 ? diag::err_typecheck_call_too_many_args
4109 : diag::err_typecheck_call_too_many_args_at_most)
4110 << FnKind
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004111 << NumArgsInProto << static_cast<unsigned>(Args.size())
4112 << Fn->getSourceRange()
Richard Smithd72da152012-05-15 06:21:54 +00004113 << SourceRange(Args[NumArgsInProto]->getLocStart(),
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004114 Args.back()->getLocEnd());
Ted Kremenek99a337e2011-04-04 17:22:27 +00004115
4116 // Emit the location of the prototype.
Kaelyn Uhrain476c8232013-07-08 23:13:44 +00004117 if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
Peter Collingbourne3bc84ca2011-07-29 00:24:42 +00004118 Diag(FDecl->getLocStart(), diag::note_callee_decl)
4119 << FDecl;
Ted Kremenek99a337e2011-04-04 17:22:27 +00004120
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004121 // This deletes the extra arguments.
Ted Kremenek5a201952009-02-07 01:47:29 +00004122 Call->setNumArgs(Context, NumArgsInProto);
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004123 return true;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004124 }
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004125 }
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004126 SmallVector<Expr *, 8> AllArgs;
Richard Smith55ce3522012-06-25 20:30:08 +00004127 VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn);
4128
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004129 Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004130 Proto, 0, Args, AllArgs, CallType);
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004131 if (Invalid)
4132 return true;
4133 unsigned TotalNumArgs = AllArgs.size();
4134 for (unsigned i = 0; i < TotalNumArgs; ++i)
4135 Call->setArg(i, AllArgs[i]);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004136
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004137 return false;
4138}
Mike Stump4e1f26a2009-02-19 03:04:26 +00004139
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004140bool Sema::GatherArgumentsForCall(SourceLocation CallLoc,
4141 FunctionDecl *FDecl,
4142 const FunctionProtoType *Proto,
4143 unsigned FirstProtoArg,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004144 ArrayRef<Expr *> Args,
Craig Topper5603df42013-07-05 19:34:19 +00004145 SmallVectorImpl<Expr *> &AllArgs,
Douglas Gregor6073dca2012-02-24 23:56:31 +00004146 VariadicCallType CallType,
Richard Smith6b216962013-02-05 05:52:24 +00004147 bool AllowExplicit,
4148 bool IsListInitialization) {
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004149 unsigned NumArgsInProto = Proto->getNumArgs();
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004150 unsigned NumArgsToCheck = Args.size();
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004151 bool Invalid = false;
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004152 if (Args.size() != NumArgsInProto)
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004153 // Use default arguments for missing arguments
4154 NumArgsToCheck = NumArgsInProto;
4155 unsigned ArgIx = 0;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004156 // Continue to check argument types (even if we have too few/many args).
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004157 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) {
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004158 QualType ProtoArgType = Proto->getArgType(i);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004159
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004160 Expr *Arg;
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004161 ParmVarDecl *Param;
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004162 if (ArgIx < Args.size()) {
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004163 Arg = Args[ArgIx++];
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004164
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004165 if (RequireCompleteType(Arg->getLocStart(),
Eli Friedman3164fb12009-03-22 22:00:50 +00004166 ProtoArgType,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00004167 diag::err_call_incomplete_argument, Arg))
Eli Friedman3164fb12009-03-22 22:00:50 +00004168 return true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004169
Douglas Gregorbbeb5c32009-12-22 16:09:06 +00004170 // Pass the argument
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004171 Param = 0;
Douglas Gregorbbeb5c32009-12-22 16:09:06 +00004172 if (FDecl && i < FDecl->getNumParams())
4173 Param = FDecl->getParamDecl(i);
Douglas Gregor96596c92009-12-22 07:24:36 +00004174
John McCall4124c492011-10-17 18:40:02 +00004175 // Strip the unbridged-cast placeholder expression off, if applicable.
Fariborz Jahanian48d94c82013-07-31 18:39:08 +00004176 bool CFAudited = false;
John McCall4124c492011-10-17 18:40:02 +00004177 if (Arg->getType() == Context.ARCUnbridgedCastTy &&
4178 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
4179 (!Param || !Param->hasAttr<CFConsumedAttr>()))
4180 Arg = stripARCUnbridgedCast(Arg);
Fariborz Jahanian3a25d0d2013-07-31 23:19:34 +00004181 else if (getLangOpts().ObjCAutoRefCount &&
4182 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
Fariborz Jahanian48d94c82013-07-31 18:39:08 +00004183 (!Param || !Param->hasAttr<CFConsumedAttr>()))
4184 CFAudited = true;
John McCall4124c492011-10-17 18:40:02 +00004185
Rafael Espindola8778c282012-11-29 16:09:03 +00004186 InitializedEntity Entity = Param ?
4187 InitializedEntity::InitializeParameter(Context, Param, ProtoArgType)
4188 : InitializedEntity::InitializeParameter(Context, ProtoArgType,
4189 Proto->isArgConsumed(i));
Fariborz Jahanian131996b2013-07-31 18:21:45 +00004190
4191 // Remember that parameter belongs to a CF audited API.
Fariborz Jahanian48d94c82013-07-31 18:39:08 +00004192 if (CFAudited)
Fariborz Jahanian131996b2013-07-31 18:21:45 +00004193 Entity.setParameterCFAudited();
4194
John McCalldadc5752010-08-24 06:29:42 +00004195 ExprResult ArgE = PerformCopyInitialization(Entity,
John McCall34376a62010-12-04 03:47:34 +00004196 SourceLocation(),
Douglas Gregor6073dca2012-02-24 23:56:31 +00004197 Owned(Arg),
Richard Smith6b216962013-02-05 05:52:24 +00004198 IsListInitialization,
Douglas Gregor6073dca2012-02-24 23:56:31 +00004199 AllowExplicit);
Douglas Gregorbbeb5c32009-12-22 16:09:06 +00004200 if (ArgE.isInvalid())
4201 return true;
4202
4203 Arg = ArgE.takeAs<Expr>();
Anders Carlsson84613c42009-06-12 16:51:40 +00004204 } else {
Jordan Rose755a2ff2013-03-15 21:41:35 +00004205 assert(FDecl && "can't use default arguments without a known callee");
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004206 Param = FDecl->getParamDecl(i);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004207
John McCalldadc5752010-08-24 06:29:42 +00004208 ExprResult ArgExpr =
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004209 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param);
Anders Carlsson355933d2009-08-25 03:49:14 +00004210 if (ArgExpr.isInvalid())
4211 return true;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004212
Anders Carlsson355933d2009-08-25 03:49:14 +00004213 Arg = ArgExpr.takeAs<Expr>();
Anders Carlsson84613c42009-06-12 16:51:40 +00004214 }
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00004215
4216 // Check for array bounds violations for each argument to the call. This
4217 // check only triggers warnings when the argument isn't a more complex Expr
4218 // with its own checking, such as a BinaryOperator.
4219 CheckArrayAccess(Arg);
4220
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004221 // Check for violations of C99 static array rules (C99 6.7.5.3p7).
4222 CheckStaticArrayArgument(CallLoc, Param, Arg);
4223
Fariborz Jahanian835026e2009-11-24 18:29:37 +00004224 AllArgs.push_back(Arg);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004225 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004226
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004227 // If this is a variadic call, handle args passed through "...".
Fariborz Jahanian6f2d25e2009-11-24 19:27:49 +00004228 if (CallType != VariadicDoesNotApply) {
John McCall2979fe02011-04-12 00:42:48 +00004229 // Assume that extern "C" functions with variadic arguments that
4230 // return __unknown_anytype aren't *really* variadic.
4231 if (Proto->getResultType() == Context.UnknownAnyTy &&
4232 FDecl && FDecl->isExternC()) {
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004233 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) {
John McCallcc5788c2013-03-04 07:34:02 +00004234 QualType paramType; // ignored
4235 ExprResult arg = checkUnknownAnyArg(CallLoc, Args[i], paramType);
John McCall2979fe02011-04-12 00:42:48 +00004236 Invalid |= arg.isInvalid();
4237 AllArgs.push_back(arg.take());
4238 }
4239
4240 // Otherwise do argument promotion, (C99 6.5.2.2p7).
4241 } else {
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004242 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) {
Richard Trieucfc491d2011-08-02 04:35:43 +00004243 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType,
4244 FDecl);
John McCall2979fe02011-04-12 00:42:48 +00004245 Invalid |= Arg.isInvalid();
4246 AllArgs.push_back(Arg.take());
4247 }
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004248 }
Ted Kremenekd41f3462011-09-26 23:36:13 +00004249
4250 // Check for array bounds violations.
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004251 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i)
Ted Kremenekd41f3462011-09-26 23:36:13 +00004252 CheckArrayAccess(Args[i]);
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004253 }
Douglas Gregorb6b99612009-01-23 21:30:56 +00004254 return Invalid;
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004255}
4256
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004257static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) {
4258 TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc();
Reid Kleckner8a365022013-06-24 17:51:48 +00004259 if (DecayedTypeLoc DTL = TL.getAs<DecayedTypeLoc>())
4260 TL = DTL.getOriginalLoc();
David Blaikie6adc78e2013-02-18 22:06:02 +00004261 if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004262 S.Diag(PVD->getLocation(), diag::note_callee_static_array)
David Blaikie6adc78e2013-02-18 22:06:02 +00004263 << ATL.getLocalSourceRange();
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004264}
4265
4266/// CheckStaticArrayArgument - If the given argument corresponds to a static
4267/// array parameter, check that it is non-null, and that if it is formed by
4268/// array-to-pointer decay, the underlying array is sufficiently large.
4269///
4270/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the
4271/// array type derivation, then for each call to the function, the value of the
4272/// corresponding actual argument shall provide access to the first element of
4273/// an array with at least as many elements as specified by the size expression.
4274void
4275Sema::CheckStaticArrayArgument(SourceLocation CallLoc,
4276 ParmVarDecl *Param,
4277 const Expr *ArgExpr) {
4278 // Static array parameters are not supported in C++.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004279 if (!Param || getLangOpts().CPlusPlus)
Peter Collingbournea48f33f2011-10-19 00:16:45 +00004280 return;
4281
4282 QualType OrigTy = Param->getOriginalType();
4283
4284 const ArrayType *AT = Context.getAsArrayType(OrigTy);
4285 if (!AT || AT->getSizeModifier() != ArrayType::Static)
4286 return;
4287
4288 if (ArgExpr->isNullPointerConstant(Context,
4289 Expr::NPC_NeverValueDependent)) {
4290 Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();
4291 DiagnoseCalleeStaticArrayParam(*this, Param);
4292 return;
4293 }
4294
4295 const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT);
4296 if (!CAT)
4297 return;
4298
4299 const ConstantArrayType *ArgCAT =
4300 Context.getAsConstantArrayType(ArgExpr->IgnoreParenImpCasts()->getType());
4301 if (!ArgCAT)
4302 return;
4303
4304 if (ArgCAT->getSize().ult(CAT->getSize())) {
4305 Diag(CallLoc, diag::warn_static_array_too_small)
4306 << ArgExpr->getSourceRange()
4307 << (unsigned) ArgCAT->getSize().getZExtValue()
4308 << (unsigned) CAT->getSize().getZExtValue();
4309 DiagnoseCalleeStaticArrayParam(*this, Param);
4310 }
4311}
4312
John McCall2979fe02011-04-12 00:42:48 +00004313/// Given a function expression of unknown-any type, try to rebuild it
4314/// to have a function type.
4315static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn);
4316
John McCall5e77d762013-04-16 07:28:30 +00004317/// Is the given type a placeholder that we need to lower out
4318/// immediately during argument processing?
4319static bool isPlaceholderToRemoveAsArg(QualType type) {
4320 // Placeholders are never sugared.
4321 const BuiltinType *placeholder = dyn_cast<BuiltinType>(type);
4322 if (!placeholder) return false;
4323
4324 switch (placeholder->getKind()) {
4325 // Ignore all the non-placeholder types.
4326#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
4327#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
4328#include "clang/AST/BuiltinTypes.def"
4329 return false;
4330
4331 // We cannot lower out overload sets; they might validly be resolved
4332 // by the call machinery.
4333 case BuiltinType::Overload:
4334 return false;
4335
4336 // Unbridged casts in ARC can be handled in some call positions and
4337 // should be left in place.
4338 case BuiltinType::ARCUnbridgedCast:
4339 return false;
4340
4341 // Pseudo-objects should be converted as soon as possible.
4342 case BuiltinType::PseudoObject:
4343 return true;
4344
4345 // The debugger mode could theoretically but currently does not try
4346 // to resolve unknown-typed arguments based on known parameter types.
4347 case BuiltinType::UnknownAny:
4348 return true;
4349
4350 // These are always invalid as call arguments and should be reported.
4351 case BuiltinType::BoundMember:
4352 case BuiltinType::BuiltinFn:
4353 return true;
4354 }
4355 llvm_unreachable("bad builtin type kind");
4356}
4357
4358/// Check an argument list for placeholders that we won't try to
4359/// handle later.
4360static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args) {
4361 // Apply this processing to all the arguments at once instead of
4362 // dying at the first failure.
4363 bool hasInvalid = false;
4364 for (size_t i = 0, e = args.size(); i != e; i++) {
4365 if (isPlaceholderToRemoveAsArg(args[i]->getType())) {
4366 ExprResult result = S.CheckPlaceholderExpr(args[i]);
4367 if (result.isInvalid()) hasInvalid = true;
4368 else args[i] = result.take();
4369 }
4370 }
4371 return hasInvalid;
4372}
4373
Steve Naroff83895f72007-09-16 03:34:24 +00004374/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Chris Lattnere168f762006-11-10 05:29:30 +00004375/// This provides the location of the left/right parens and a list of comma
4376/// locations.
John McCalldadc5752010-08-24 06:29:42 +00004377ExprResult
John McCallb268a282010-08-23 23:25:46 +00004378Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00004379 MultiExprArg ArgExprs, SourceLocation RParenLoc,
Peter Collingbourne619a8c72011-10-02 23:49:29 +00004380 Expr *ExecConfig, bool IsExecConfig) {
Nate Begeman5ec4b312009-08-10 23:49:36 +00004381 // Since this might be a postfix expression, get rid of ParenListExprs.
John McCalldadc5752010-08-24 06:29:42 +00004382 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn);
John McCallb268a282010-08-23 23:25:46 +00004383 if (Result.isInvalid()) return ExprError();
4384 Fn = Result.take();
Mike Stump11289f42009-09-09 15:08:12 +00004385
John McCall5e77d762013-04-16 07:28:30 +00004386 if (checkArgsForPlaceholders(*this, ArgExprs))
4387 return ExprError();
4388
David Blaikiebbafb8a2012-03-11 07:00:24 +00004389 if (getLangOpts().CPlusPlus) {
Douglas Gregorad8a3362009-09-04 17:36:40 +00004390 // If this is a pseudo-destructor expression, build the call immediately.
4391 if (isa<CXXPseudoDestructorExpr>(Fn)) {
Benjamin Kramerc215e762012-08-24 11:54:20 +00004392 if (!ArgExprs.empty()) {
Douglas Gregorad8a3362009-09-04 17:36:40 +00004393 // Pseudo-destructor calls should not have any arguments.
4394 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args)
Douglas Gregora771f462010-03-31 17:46:05 +00004395 << FixItHint::CreateRemoval(
Benjamin Kramerc215e762012-08-24 11:54:20 +00004396 SourceRange(ArgExprs[0]->getLocStart(),
4397 ArgExprs.back()->getLocEnd()));
Douglas Gregorad8a3362009-09-04 17:36:40 +00004398 }
Mike Stump11289f42009-09-09 15:08:12 +00004399
Dmitri Gribenko78852e92013-05-05 20:40:26 +00004400 return Owned(new (Context) CallExpr(Context, Fn, None,
Benjamin Kramerc215e762012-08-24 11:54:20 +00004401 Context.VoidTy, VK_RValue,
4402 RParenLoc));
Douglas Gregorad8a3362009-09-04 17:36:40 +00004403 }
John McCall5e77d762013-04-16 07:28:30 +00004404 if (Fn->getType() == Context.PseudoObjectTy) {
4405 ExprResult result = CheckPlaceholderExpr(Fn);
4406 if (result.isInvalid()) return ExprError();
4407 Fn = result.take();
4408 }
Mike Stump11289f42009-09-09 15:08:12 +00004409
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004410 // Determine whether this is a dependent call inside a C++ template,
Mike Stump4e1f26a2009-02-19 03:04:26 +00004411 // in which case we won't do any semantic analysis now.
Mike Stump87c57ac2009-05-16 07:39:55 +00004412 // FIXME: Will need to cache the results of name lookup (including ADL) in
4413 // Fn.
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004414 bool Dependent = false;
4415 if (Fn->isTypeDependent())
4416 Dependent = true;
Benjamin Kramerc215e762012-08-24 11:54:20 +00004417 else if (Expr::hasAnyTypeDependentArguments(ArgExprs))
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004418 Dependent = true;
4419
Peter Collingbourne41f85462011-02-09 21:07:24 +00004420 if (Dependent) {
4421 if (ExecConfig) {
4422 return Owned(new (Context) CUDAKernelCallExpr(
Benjamin Kramerc215e762012-08-24 11:54:20 +00004423 Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
Peter Collingbourne41f85462011-02-09 21:07:24 +00004424 Context.DependentTy, VK_RValue, RParenLoc));
4425 } else {
Benjamin Kramerc215e762012-08-24 11:54:20 +00004426 return Owned(new (Context) CallExpr(Context, Fn, ArgExprs,
Peter Collingbourne41f85462011-02-09 21:07:24 +00004427 Context.DependentTy, VK_RValue,
4428 RParenLoc));
4429 }
4430 }
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004431
4432 // Determine whether this is a call to an object (C++ [over.call.object]).
4433 if (Fn->getType()->isRecordType())
Benjamin Kramerc215e762012-08-24 11:54:20 +00004434 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc,
Dmitri Gribenkod3b75562013-05-09 23:32:58 +00004435 ArgExprs, RParenLoc));
Douglas Gregorb8a9a412009-02-04 15:01:18 +00004436
John McCall2979fe02011-04-12 00:42:48 +00004437 if (Fn->getType() == Context.UnknownAnyTy) {
4438 ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
4439 if (result.isInvalid()) return ExprError();
4440 Fn = result.take();
4441 }
4442
John McCall0009fcc2011-04-26 20:42:42 +00004443 if (Fn->getType() == Context.BoundMemberTy) {
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004444 return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs, RParenLoc);
John McCall10eae182009-11-30 22:42:35 +00004445 }
John McCall0009fcc2011-04-26 20:42:42 +00004446 }
John McCall10eae182009-11-30 22:42:35 +00004447
John McCall0009fcc2011-04-26 20:42:42 +00004448 // Check for overloaded calls. This can happen even in C due to extensions.
4449 if (Fn->getType() == Context.OverloadTy) {
4450 OverloadExpr::FindResult find = OverloadExpr::find(Fn);
4451
Douglas Gregorcda22702011-10-13 18:10:35 +00004452 // We aren't supposed to apply this logic for if there's an '&' involved.
Douglas Gregorf4a06c22011-10-13 18:26:27 +00004453 if (!find.HasFormOfMemberPointer) {
John McCall0009fcc2011-04-26 20:42:42 +00004454 OverloadExpr *ovl = find.Expression;
4455 if (isa<UnresolvedLookupExpr>(ovl)) {
4456 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl);
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004457 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, ArgExprs,
4458 RParenLoc, ExecConfig);
John McCall0009fcc2011-04-26 20:42:42 +00004459 } else {
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004460 return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs,
4461 RParenLoc);
Anders Carlsson61914b52009-10-03 17:40:22 +00004462 }
4463 }
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004464 }
4465
Douglas Gregore254f902009-02-04 00:32:51 +00004466 // If we're directly calling a function, get the appropriate declaration.
Douglas Gregord8fb1e32011-12-01 01:37:36 +00004467 if (Fn->getType() == Context.UnknownAnyTy) {
4468 ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
4469 if (result.isInvalid()) return ExprError();
4470 Fn = result.take();
4471 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00004472
Eli Friedmane14b1992009-12-26 03:35:45 +00004473 Expr *NakedFn = Fn->IgnoreParens();
Douglas Gregor928479e2010-11-09 20:03:54 +00004474
John McCall57500772009-12-16 12:17:52 +00004475 NamedDecl *NDecl = 0;
Douglas Gregor59f16ed2010-10-25 20:48:33 +00004476 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn))
4477 if (UnOp->getOpcode() == UO_AddrOf)
4478 NakedFn = UnOp->getSubExpr()->IgnoreParens();
4479
John McCall57500772009-12-16 12:17:52 +00004480 if (isa<DeclRefExpr>(NakedFn))
4481 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl();
John McCall0009fcc2011-04-26 20:42:42 +00004482 else if (isa<MemberExpr>(NakedFn))
4483 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl();
John McCall57500772009-12-16 12:17:52 +00004484
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004485 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
4486 ExecConfig, IsExecConfig);
Peter Collingbourne41f85462011-02-09 21:07:24 +00004487}
4488
4489ExprResult
4490Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00004491 MultiExprArg ExecConfig, SourceLocation GGGLoc) {
Peter Collingbourne41f85462011-02-09 21:07:24 +00004492 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl();
4493 if (!ConfigDecl)
4494 return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use)
4495 << "cudaConfigureCall");
4496 QualType ConfigQTy = ConfigDecl->getType();
4497
4498 DeclRefExpr *ConfigDR = new (Context) DeclRefExpr(
John McCall113bee02012-03-10 09:33:50 +00004499 ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc);
Eli Friedmanfa0df832012-02-02 03:46:19 +00004500 MarkFunctionReferenced(LLLLoc, ConfigDecl);
Peter Collingbourne41f85462011-02-09 21:07:24 +00004501
Peter Collingbourne619a8c72011-10-02 23:49:29 +00004502 return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, 0,
4503 /*IsExecConfig=*/true);
John McCall2d74de92009-12-01 22:10:20 +00004504}
4505
Tanya Lattner55808c12011-06-04 00:47:47 +00004506/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
4507///
4508/// __builtin_astype( value, dst type )
4509///
Richard Trieuba63ce62011-09-09 01:45:06 +00004510ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
Tanya Lattner55808c12011-06-04 00:47:47 +00004511 SourceLocation BuiltinLoc,
4512 SourceLocation RParenLoc) {
4513 ExprValueKind VK = VK_RValue;
4514 ExprObjectKind OK = OK_Ordinary;
Richard Trieuba63ce62011-09-09 01:45:06 +00004515 QualType DstTy = GetTypeFromParser(ParsedDestTy);
4516 QualType SrcTy = E->getType();
Tanya Lattner55808c12011-06-04 00:47:47 +00004517 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy))
4518 return ExprError(Diag(BuiltinLoc,
4519 diag::err_invalid_astype_of_different_size)
Peter Collingbourne23f1bee2011-06-08 15:15:17 +00004520 << DstTy
4521 << SrcTy
Richard Trieuba63ce62011-09-09 01:45:06 +00004522 << E->getSourceRange());
4523 return Owned(new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc,
Richard Trieucfc491d2011-08-02 04:35:43 +00004524 RParenLoc));
Tanya Lattner55808c12011-06-04 00:47:47 +00004525}
4526
Hal Finkelc4d7c822013-09-18 03:29:45 +00004527/// ActOnConvertVectorExpr - create a new convert-vector expression from the
4528/// provided arguments.
4529///
4530/// __builtin_convertvector( value, dst type )
4531///
4532ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
4533 SourceLocation BuiltinLoc,
4534 SourceLocation RParenLoc) {
4535 TypeSourceInfo *TInfo;
4536 GetTypeFromParser(ParsedDestTy, &TInfo);
4537 return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
4538}
4539
John McCall57500772009-12-16 12:17:52 +00004540/// BuildResolvedCallExpr - Build a call to a resolved expression,
4541/// i.e. an expression not of \p OverloadTy. The expression should
John McCall2d74de92009-12-01 22:10:20 +00004542/// unary-convert to an expression of function-pointer or
4543/// block-pointer type.
4544///
4545/// \param NDecl the declaration being called, if available
John McCalldadc5752010-08-24 06:29:42 +00004546ExprResult
John McCall2d74de92009-12-01 22:10:20 +00004547Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
4548 SourceLocation LParenLoc,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004549 ArrayRef<Expr *> Args,
Peter Collingbourne41f85462011-02-09 21:07:24 +00004550 SourceLocation RParenLoc,
Peter Collingbourne619a8c72011-10-02 23:49:29 +00004551 Expr *Config, bool IsExecConfig) {
John McCall2d74de92009-12-01 22:10:20 +00004552 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
Eli Friedman34866c72012-08-31 00:14:07 +00004553 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0);
John McCall2d74de92009-12-01 22:10:20 +00004554
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00004555 // Promote the function operand.
Eli Friedman34866c72012-08-31 00:14:07 +00004556 // We special-case function promotion here because we only allow promoting
4557 // builtin functions to function pointers in the callee of a call.
4558 ExprResult Result;
4559 if (BuiltinID &&
4560 Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
4561 Result = ImpCastExprToType(Fn, Context.getPointerType(FDecl->getType()),
4562 CK_BuiltinFnToFnPtr).take();
4563 } else {
4564 Result = UsualUnaryConversions(Fn);
4565 }
John Wiegley01296292011-04-08 18:41:53 +00004566 if (Result.isInvalid())
4567 return ExprError();
4568 Fn = Result.take();
Chris Lattneraa9c7ae2008-04-08 04:40:51 +00004569
Chris Lattner08464942007-12-28 05:29:59 +00004570 // Make the call expr early, before semantic checks. This guarantees cleanup
4571 // of arguments and function on error.
Peter Collingbourne41f85462011-02-09 21:07:24 +00004572 CallExpr *TheCall;
Eric Christopher13586ab2012-05-30 01:14:28 +00004573 if (Config)
Peter Collingbourne41f85462011-02-09 21:07:24 +00004574 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn,
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004575 cast<CallExpr>(Config), Args,
4576 Context.BoolTy, VK_RValue,
Peter Collingbourne41f85462011-02-09 21:07:24 +00004577 RParenLoc);
Eric Christopher13586ab2012-05-30 01:14:28 +00004578 else
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004579 TheCall = new (Context) CallExpr(Context, Fn, Args, Context.BoolTy,
4580 VK_RValue, RParenLoc);
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004581
John McCallbebede42011-02-26 05:39:39 +00004582 // Bail out early if calling a builtin with custom typechecking.
4583 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID))
4584 return CheckBuiltinFunctionCall(BuiltinID, TheCall);
4585
John McCall31996342011-04-07 08:22:57 +00004586 retry:
Steve Naroff8de9c3a2008-09-05 22:11:13 +00004587 const FunctionType *FuncT;
John McCallbebede42011-02-26 05:39:39 +00004588 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) {
Steve Naroff8de9c3a2008-09-05 22:11:13 +00004589 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
4590 // have type pointer to function".
John McCall9dd450b2009-09-21 23:43:11 +00004591 FuncT = PT->getPointeeType()->getAs<FunctionType>();
John McCallbebede42011-02-26 05:39:39 +00004592 if (FuncT == 0)
4593 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
4594 << Fn->getType() << Fn->getSourceRange());
4595 } else if (const BlockPointerType *BPT =
4596 Fn->getType()->getAs<BlockPointerType>()) {
4597 FuncT = BPT->getPointeeType()->castAs<FunctionType>();
4598 } else {
John McCall31996342011-04-07 08:22:57 +00004599 // Handle calls to expressions of unknown-any type.
4600 if (Fn->getType() == Context.UnknownAnyTy) {
John McCall2979fe02011-04-12 00:42:48 +00004601 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn);
John McCall31996342011-04-07 08:22:57 +00004602 if (rewrite.isInvalid()) return ExprError();
4603 Fn = rewrite.take();
John McCall39439732011-04-09 22:50:59 +00004604 TheCall->setCallee(Fn);
John McCall31996342011-04-07 08:22:57 +00004605 goto retry;
4606 }
4607
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004608 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function)
4609 << Fn->getType() << Fn->getSourceRange());
John McCallbebede42011-02-26 05:39:39 +00004610 }
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004611
David Blaikiebbafb8a2012-03-11 07:00:24 +00004612 if (getLangOpts().CUDA) {
Peter Collingbourne4b66c472011-02-23 01:53:29 +00004613 if (Config) {
4614 // CUDA: Kernel calls must be to global functions
4615 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>())
4616 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function)
4617 << FDecl->getName() << Fn->getSourceRange());
4618
4619 // CUDA: Kernel function must have 'void' return type
4620 if (!FuncT->getResultType()->isVoidType())
4621 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return)
4622 << Fn->getType() << Fn->getSourceRange());
Peter Collingbourne34a20b02011-10-02 23:49:15 +00004623 } else {
4624 // CUDA: Calls to global functions must be configured
4625 if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())
4626 return ExprError(Diag(LParenLoc, diag::err_global_call_not_config)
4627 << FDecl->getName() << Fn->getSourceRange());
Peter Collingbourne4b66c472011-02-23 01:53:29 +00004628 }
4629 }
4630
Eli Friedman3164fb12009-03-22 22:00:50 +00004631 // Check for a valid return type
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004632 if (CheckCallReturnType(FuncT->getResultType(),
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004633 Fn->getLocStart(), TheCall,
Anders Carlsson7f84ed92009-10-09 23:51:55 +00004634 FDecl))
Eli Friedman3164fb12009-03-22 22:00:50 +00004635 return ExprError();
4636
Chris Lattner08464942007-12-28 05:29:59 +00004637 // We know the result type of the call, set it.
Douglas Gregor603d81b2010-07-13 08:18:22 +00004638 TheCall->setType(FuncT->getCallResultType(Context));
John McCall7decc9e2010-11-18 06:31:45 +00004639 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType()));
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004640
Richard Smith55ce3522012-06-25 20:30:08 +00004641 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT);
4642 if (Proto) {
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004643 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc,
4644 IsExecConfig))
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004645 return ExprError();
Chris Lattner08464942007-12-28 05:29:59 +00004646 } else {
Douglas Gregordeaad8c2009-02-26 23:50:07 +00004647 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004648
Douglas Gregord8e97de2009-04-02 15:37:10 +00004649 if (FDecl) {
4650 // Check if we have too few/too many template arguments, based
4651 // on our knowledge of the function definition.
4652 const FunctionDecl *Def = 0;
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004653 if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
Richard Smith55ce3522012-06-25 20:30:08 +00004654 Proto = Def->getType()->getAs<FunctionProtoType>();
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004655 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00004656 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004657 << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
Eli Friedmanfcbf7d22009-06-01 09:24:59 +00004658 }
Douglas Gregor8e09a722010-10-25 20:39:23 +00004659
4660 // If the function we're calling isn't a function prototype, but we have
4661 // a function prototype from a prior declaratiom, use that prototype.
4662 if (!FDecl->hasPrototype())
4663 Proto = FDecl->getType()->getAs<FunctionProtoType>();
Douglas Gregord8e97de2009-04-02 15:37:10 +00004664 }
4665
Steve Naroff0b661582007-08-28 23:30:39 +00004666 // Promote the arguments (C99 6.5.2.2p6).
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004667 for (unsigned i = 0, e = Args.size(); i != e; i++) {
Chris Lattner08464942007-12-28 05:29:59 +00004668 Expr *Arg = Args[i];
Douglas Gregor8e09a722010-10-25 20:39:23 +00004669
4670 if (Proto && i < Proto->getNumArgs()) {
Douglas Gregor8e09a722010-10-25 20:39:23 +00004671 InitializedEntity Entity
4672 = InitializedEntity::InitializeParameter(Context,
John McCall31168b02011-06-15 23:02:42 +00004673 Proto->getArgType(i),
4674 Proto->isArgConsumed(i));
Douglas Gregor8e09a722010-10-25 20:39:23 +00004675 ExprResult ArgE = PerformCopyInitialization(Entity,
4676 SourceLocation(),
4677 Owned(Arg));
4678 if (ArgE.isInvalid())
4679 return true;
4680
4681 Arg = ArgE.takeAs<Expr>();
4682
4683 } else {
John Wiegley01296292011-04-08 18:41:53 +00004684 ExprResult ArgE = DefaultArgumentPromotion(Arg);
4685
4686 if (ArgE.isInvalid())
4687 return true;
4688
4689 Arg = ArgE.takeAs<Expr>();
Douglas Gregor8e09a722010-10-25 20:39:23 +00004690 }
4691
Daniel Dunbar62ee6412012-03-09 18:35:03 +00004692 if (RequireCompleteType(Arg->getLocStart(),
Douglas Gregor83025412010-10-26 05:45:40 +00004693 Arg->getType(),
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00004694 diag::err_call_incomplete_argument, Arg))
Douglas Gregor83025412010-10-26 05:45:40 +00004695 return ExprError();
4696
Chris Lattner08464942007-12-28 05:29:59 +00004697 TheCall->setArg(i, Arg);
Steve Naroff0b661582007-08-28 23:30:39 +00004698 }
Steve Naroffae4143e2007-04-26 20:39:23 +00004699 }
Chris Lattner08464942007-12-28 05:29:59 +00004700
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004701 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
4702 if (!Method->isStatic())
Sebastian Redlc215cfc2009-01-19 00:08:26 +00004703 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object)
4704 << Fn->getSourceRange());
Douglas Gregor97fd6e22008-12-22 05:46:06 +00004705
Fariborz Jahanian0aa5c452009-05-15 20:33:25 +00004706 // Check for sentinels
4707 if (NDecl)
Dmitri Gribenko9c785c22013-05-09 21:02:07 +00004708 DiagnoseSentinelCalls(NDecl, LParenLoc, Args);
Mike Stump11289f42009-09-09 15:08:12 +00004709
Chris Lattnerb87b1b32007-08-10 20:18:51 +00004710 // Do special checking on direct calls to functions.
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004711 if (FDecl) {
Richard Smith55ce3522012-06-25 20:30:08 +00004712 if (CheckFunctionCall(FDecl, TheCall, Proto))
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004713 return ExprError();
Mike Stump11289f42009-09-09 15:08:12 +00004714
John McCallbebede42011-02-26 05:39:39 +00004715 if (BuiltinID)
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00004716 return CheckBuiltinFunctionCall(BuiltinID, TheCall);
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004717 } else if (NDecl) {
Richard Trieu664c4c62013-06-20 21:03:13 +00004718 if (CheckPointerCall(NDecl, TheCall, Proto))
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004719 return ExprError();
Richard Trieu41bc0992013-06-22 00:20:41 +00004720 } else {
4721 if (CheckOtherCall(TheCall, Proto))
4722 return ExprError();
Anders Carlssonbc4c1072009-08-16 01:56:34 +00004723 }
Chris Lattnerb87b1b32007-08-10 20:18:51 +00004724
John McCallb268a282010-08-23 23:25:46 +00004725 return MaybeBindToTemporary(TheCall);
Chris Lattnere168f762006-11-10 05:29:30 +00004726}
4727
John McCalldadc5752010-08-24 06:29:42 +00004728ExprResult
John McCallba7bf592010-08-24 05:47:05 +00004729Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
John McCallb268a282010-08-23 23:25:46 +00004730 SourceLocation RParenLoc, Expr *InitExpr) {
David Blaikie7d170102013-05-15 07:37:26 +00004731 assert(Ty && "ActOnCompoundLiteral(): missing type");
Steve Naroff57eb2c52007-07-19 21:32:11 +00004732 // FIXME: put back this assert when initializers are worked out.
Steve Naroff83895f72007-09-16 03:34:24 +00004733 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression");
John McCalle15bbff2010-01-18 19:35:47 +00004734
4735 TypeSourceInfo *TInfo;
4736 QualType literalType = GetTypeFromParser(Ty, &TInfo);
4737 if (!TInfo)
4738 TInfo = Context.getTrivialTypeSourceInfo(literalType);
4739
John McCallb268a282010-08-23 23:25:46 +00004740 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
John McCalle15bbff2010-01-18 19:35:47 +00004741}
4742
John McCalldadc5752010-08-24 06:29:42 +00004743ExprResult
John McCalle15bbff2010-01-18 19:35:47 +00004744Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
Richard Trieuba63ce62011-09-09 01:45:06 +00004745 SourceLocation RParenLoc, Expr *LiteralExpr) {
John McCalle15bbff2010-01-18 19:35:47 +00004746 QualType literalType = TInfo->getType();
Anders Carlsson2c1ec6d2007-12-05 07:24:19 +00004747
Eli Friedman37a186d2008-05-20 05:22:08 +00004748 if (literalType->isArrayType()) {
Argyrios Kyrtzidis85663562010-11-08 19:14:19 +00004749 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType),
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00004750 diag::err_illegal_decl_array_incomplete_type,
4751 SourceRange(LParenLoc,
4752 LiteralExpr->getSourceRange().getEnd())))
Argyrios Kyrtzidis85663562010-11-08 19:14:19 +00004753 return ExprError();
Chris Lattner7adf0762008-08-04 07:31:14 +00004754 if (literalType->isVariableArrayType())
Sebastian Redlb5d49352009-01-19 22:31:54 +00004755 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init)
Richard Trieuba63ce62011-09-09 01:45:06 +00004756 << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()));
Douglas Gregor1c37d9e2009-05-21 23:48:18 +00004757 } else if (!literalType->isDependentType() &&
4758 RequireCompleteType(LParenLoc, literalType,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00004759 diag::err_typecheck_decl_incomplete_type,
4760 SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
Sebastian Redlb5d49352009-01-19 22:31:54 +00004761 return ExprError();
Eli Friedman37a186d2008-05-20 05:22:08 +00004762
Douglas Gregor85dabae2009-12-16 01:38:02 +00004763 InitializedEntity Entity
Jordan Rose6c0505e2013-05-06 16:48:12 +00004764 = InitializedEntity::InitializeCompoundLiteralInit(TInfo);
Douglas Gregor85dabae2009-12-16 01:38:02 +00004765 InitializationKind Kind
John McCall31168b02011-06-15 23:02:42 +00004766 = InitializationKind::CreateCStyleCast(LParenLoc,
Sebastian Redl0501c632012-02-12 16:37:36 +00004767 SourceRange(LParenLoc, RParenLoc),
4768 /*InitList=*/true);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00004769 InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00004770 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
4771 &literalType);
Eli Friedmana553d4a2009-12-22 02:35:53 +00004772 if (Result.isInvalid())
Sebastian Redlb5d49352009-01-19 22:31:54 +00004773 return ExprError();
Richard Trieuba63ce62011-09-09 01:45:06 +00004774 LiteralExpr = Result.get();
Steve Naroffd32419d2008-01-14 18:19:28 +00004775
Chris Lattner79413952008-12-04 23:50:19 +00004776 bool isFileScope = getCurFunctionOrMethodDecl() == 0;
Eli Friedman4a962f02013-10-01 00:28:29 +00004777 if (isFileScope &&
4778 !LiteralExpr->isTypeDependent() &&
4779 !LiteralExpr->isValueDependent() &&
4780 !literalType->isDependentType()) { // 6.5.2.5p3
Richard Trieuba63ce62011-09-09 01:45:06 +00004781 if (CheckForConstantInitializer(LiteralExpr, literalType))
Sebastian Redlb5d49352009-01-19 22:31:54 +00004782 return ExprError();
Steve Naroff98f72032008-01-10 22:15:12 +00004783 }
Eli Friedmana553d4a2009-12-22 02:35:53 +00004784
John McCall7decc9e2010-11-18 06:31:45 +00004785 // In C, compound literals are l-values for some reason.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004786 ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue;
John McCall7decc9e2010-11-18 06:31:45 +00004787
Douglas Gregor9b71f0c2011-06-17 04:59:12 +00004788 return MaybeBindToTemporary(
4789 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType,
Richard Trieuba63ce62011-09-09 01:45:06 +00004790 VK, LiteralExpr, isFileScope));
Steve Narofffbd09832007-07-19 01:06:55 +00004791}
4792
John McCalldadc5752010-08-24 06:29:42 +00004793ExprResult
Richard Trieuba63ce62011-09-09 01:45:06 +00004794Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
Sebastian Redlb5d49352009-01-19 22:31:54 +00004795 SourceLocation RBraceLoc) {
John McCall526ab472011-10-25 17:37:35 +00004796 // Immediately handle non-overload placeholders. Overloads can be
4797 // resolved contextually, but everything else here can't.
Benjamin Kramerc215e762012-08-24 11:54:20 +00004798 for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) {
4799 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) {
4800 ExprResult result = CheckPlaceholderExpr(InitArgList[I]);
John McCall526ab472011-10-25 17:37:35 +00004801
4802 // Ignore failures; dropping the entire initializer list because
4803 // of one failure would be terrible for indexing/etc.
4804 if (result.isInvalid()) continue;
4805
Benjamin Kramerc215e762012-08-24 11:54:20 +00004806 InitArgList[I] = result.take();
John McCall526ab472011-10-25 17:37:35 +00004807 }
4808 }
4809
Steve Naroff30d242c2007-09-15 18:49:24 +00004810 // Semantic analysis for initializers is done by ActOnDeclarator() and
Mike Stump4e1f26a2009-02-19 03:04:26 +00004811 // CheckInitializer() - it requires knowledge of the object being intialized.
Sebastian Redlb5d49352009-01-19 22:31:54 +00004812
Benjamin Kramerc215e762012-08-24 11:54:20 +00004813 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
4814 RBraceLoc);
Chris Lattner24d5bfe2008-04-02 04:24:33 +00004815 E->setType(Context.VoidTy); // FIXME: just a place holder for now.
Sebastian Redlb5d49352009-01-19 22:31:54 +00004816 return Owned(E);
Steve Narofffbd09832007-07-19 01:06:55 +00004817}
4818
John McCallcd78e802011-09-10 01:16:55 +00004819/// Do an explicit extend of the given block pointer if we're in ARC.
4820static void maybeExtendBlockObject(Sema &S, ExprResult &E) {
4821 assert(E.get()->getType()->isBlockPointerType());
4822 assert(E.get()->isRValue());
4823
4824 // Only do this in an r-value context.
David Blaikiebbafb8a2012-03-11 07:00:24 +00004825 if (!S.getLangOpts().ObjCAutoRefCount) return;
John McCallcd78e802011-09-10 01:16:55 +00004826
4827 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(),
John McCall2d637d22011-09-10 06:18:15 +00004828 CK_ARCExtendBlockObject, E.get(),
John McCallcd78e802011-09-10 01:16:55 +00004829 /*base path*/ 0, VK_RValue);
4830 S.ExprNeedsCleanups = true;
4831}
4832
4833/// Prepare a conversion of the given expression to an ObjC object
4834/// pointer type.
4835CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) {
4836 QualType type = E.get()->getType();
4837 if (type->isObjCObjectPointerType()) {
4838 return CK_BitCast;
4839 } else if (type->isBlockPointerType()) {
4840 maybeExtendBlockObject(*this, E);
4841 return CK_BlockPointerToObjCPointerCast;
4842 } else {
4843 assert(type->isPointerType());
4844 return CK_CPointerToObjCPointerCast;
4845 }
4846}
4847
John McCalld7646252010-11-14 08:17:51 +00004848/// Prepares for a scalar cast, performing all the necessary stages
4849/// except the final cast and returning the kind required.
John McCall9776e432011-10-06 23:25:11 +00004850CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {
John McCalld7646252010-11-14 08:17:51 +00004851 // Both Src and Dest are scalar types, i.e. arithmetic or pointer.
4852 // Also, callers should have filtered out the invalid cases with
4853 // pointers. Everything else should be possible.
4854
John Wiegley01296292011-04-08 18:41:53 +00004855 QualType SrcTy = Src.get()->getType();
John McCall9776e432011-10-06 23:25:11 +00004856 if (Context.hasSameUnqualifiedType(SrcTy, DestTy))
John McCalle3027922010-08-25 11:45:40 +00004857 return CK_NoOp;
Anders Carlsson094c4592009-10-18 18:12:03 +00004858
John McCall9320b872011-09-09 05:25:32 +00004859 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) {
John McCall8cb679e2010-11-15 09:13:47 +00004860 case Type::STK_MemberPointer:
4861 llvm_unreachable("member pointer type in C");
Abramo Bagnaraba854972011-01-04 09:50:03 +00004862
John McCall9320b872011-09-09 05:25:32 +00004863 case Type::STK_CPointer:
4864 case Type::STK_BlockPointer:
4865 case Type::STK_ObjCObjectPointer:
John McCall8cb679e2010-11-15 09:13:47 +00004866 switch (DestTy->getScalarTypeKind()) {
David Tweede1468322013-12-11 13:39:46 +00004867 case Type::STK_CPointer: {
4868 unsigned SrcAS = SrcTy->getPointeeType().getAddressSpace();
4869 unsigned DestAS = DestTy->getPointeeType().getAddressSpace();
4870 if (SrcAS != DestAS)
4871 return CK_AddressSpaceConversion;
John McCall9320b872011-09-09 05:25:32 +00004872 return CK_BitCast;
David Tweede1468322013-12-11 13:39:46 +00004873 }
John McCall9320b872011-09-09 05:25:32 +00004874 case Type::STK_BlockPointer:
4875 return (SrcKind == Type::STK_BlockPointer
4876 ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
4877 case Type::STK_ObjCObjectPointer:
4878 if (SrcKind == Type::STK_ObjCObjectPointer)
4879 return CK_BitCast;
David Blaikie8a40f702012-01-17 06:56:22 +00004880 if (SrcKind == Type::STK_CPointer)
John McCall9320b872011-09-09 05:25:32 +00004881 return CK_CPointerToObjCPointerCast;
David Blaikie8a40f702012-01-17 06:56:22 +00004882 maybeExtendBlockObject(*this, Src);
4883 return CK_BlockPointerToObjCPointerCast;
John McCall8cb679e2010-11-15 09:13:47 +00004884 case Type::STK_Bool:
4885 return CK_PointerToBoolean;
4886 case Type::STK_Integral:
4887 return CK_PointerToIntegral;
4888 case Type::STK_Floating:
4889 case Type::STK_FloatingComplex:
4890 case Type::STK_IntegralComplex:
4891 case Type::STK_MemberPointer:
4892 llvm_unreachable("illegal cast from pointer");
4893 }
David Blaikie8a40f702012-01-17 06:56:22 +00004894 llvm_unreachable("Should have returned before this");
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004895
John McCall8cb679e2010-11-15 09:13:47 +00004896 case Type::STK_Bool: // casting from bool is like casting from an integer
4897 case Type::STK_Integral:
4898 switch (DestTy->getScalarTypeKind()) {
John McCall9320b872011-09-09 05:25:32 +00004899 case Type::STK_CPointer:
4900 case Type::STK_ObjCObjectPointer:
4901 case Type::STK_BlockPointer:
John McCall9776e432011-10-06 23:25:11 +00004902 if (Src.get()->isNullPointerConstant(Context,
Richard Trieucfc491d2011-08-02 04:35:43 +00004903 Expr::NPC_ValueDependentIsNull))
John McCalle84af4e2010-11-13 01:35:44 +00004904 return CK_NullToPointer;
John McCalle3027922010-08-25 11:45:40 +00004905 return CK_IntegralToPointer;
John McCall8cb679e2010-11-15 09:13:47 +00004906 case Type::STK_Bool:
4907 return CK_IntegralToBoolean;
4908 case Type::STK_Integral:
John McCalld7646252010-11-14 08:17:51 +00004909 return CK_IntegralCast;
John McCall8cb679e2010-11-15 09:13:47 +00004910 case Type::STK_Floating:
John McCalle3027922010-08-25 11:45:40 +00004911 return CK_IntegralToFloating;
John McCall8cb679e2010-11-15 09:13:47 +00004912 case Type::STK_IntegralComplex:
John McCall9776e432011-10-06 23:25:11 +00004913 Src = ImpCastExprToType(Src.take(),
4914 DestTy->castAs<ComplexType>()->getElementType(),
4915 CK_IntegralCast);
John McCalld7646252010-11-14 08:17:51 +00004916 return CK_IntegralRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004917 case Type::STK_FloatingComplex:
John McCall9776e432011-10-06 23:25:11 +00004918 Src = ImpCastExprToType(Src.take(),
4919 DestTy->castAs<ComplexType>()->getElementType(),
4920 CK_IntegralToFloating);
John McCalld7646252010-11-14 08:17:51 +00004921 return CK_FloatingRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004922 case Type::STK_MemberPointer:
4923 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004924 }
David Blaikie8a40f702012-01-17 06:56:22 +00004925 llvm_unreachable("Should have returned before this");
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00004926
John McCall8cb679e2010-11-15 09:13:47 +00004927 case Type::STK_Floating:
4928 switch (DestTy->getScalarTypeKind()) {
4929 case Type::STK_Floating:
John McCalle3027922010-08-25 11:45:40 +00004930 return CK_FloatingCast;
John McCall8cb679e2010-11-15 09:13:47 +00004931 case Type::STK_Bool:
4932 return CK_FloatingToBoolean;
4933 case Type::STK_Integral:
John McCalle3027922010-08-25 11:45:40 +00004934 return CK_FloatingToIntegral;
John McCall8cb679e2010-11-15 09:13:47 +00004935 case Type::STK_FloatingComplex:
John McCall9776e432011-10-06 23:25:11 +00004936 Src = ImpCastExprToType(Src.take(),
4937 DestTy->castAs<ComplexType>()->getElementType(),
4938 CK_FloatingCast);
John McCalld7646252010-11-14 08:17:51 +00004939 return CK_FloatingRealToComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004940 case Type::STK_IntegralComplex:
John McCall9776e432011-10-06 23:25:11 +00004941 Src = ImpCastExprToType(Src.take(),
4942 DestTy->castAs<ComplexType>()->getElementType(),
4943 CK_FloatingToIntegral);
John McCalld7646252010-11-14 08:17:51 +00004944 return CK_IntegralRealToComplex;
John McCall9320b872011-09-09 05:25:32 +00004945 case Type::STK_CPointer:
4946 case Type::STK_ObjCObjectPointer:
4947 case Type::STK_BlockPointer:
John McCall8cb679e2010-11-15 09:13:47 +00004948 llvm_unreachable("valid float->pointer cast?");
4949 case Type::STK_MemberPointer:
4950 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004951 }
David Blaikie8a40f702012-01-17 06:56:22 +00004952 llvm_unreachable("Should have returned before this");
John McCalld7646252010-11-14 08:17:51 +00004953
John McCall8cb679e2010-11-15 09:13:47 +00004954 case Type::STK_FloatingComplex:
4955 switch (DestTy->getScalarTypeKind()) {
4956 case Type::STK_FloatingComplex:
John McCalld7646252010-11-14 08:17:51 +00004957 return CK_FloatingComplexCast;
John McCall8cb679e2010-11-15 09:13:47 +00004958 case Type::STK_IntegralComplex:
John McCalld7646252010-11-14 08:17:51 +00004959 return CK_FloatingComplexToIntegralComplex;
John McCallfcef3cf2010-12-14 17:51:41 +00004960 case Type::STK_Floating: {
John McCall9776e432011-10-06 23:25:11 +00004961 QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
4962 if (Context.hasSameType(ET, DestTy))
John McCallfcef3cf2010-12-14 17:51:41 +00004963 return CK_FloatingComplexToReal;
John McCall9776e432011-10-06 23:25:11 +00004964 Src = ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal);
John McCallfcef3cf2010-12-14 17:51:41 +00004965 return CK_FloatingCast;
4966 }
John McCall8cb679e2010-11-15 09:13:47 +00004967 case Type::STK_Bool:
John McCalld7646252010-11-14 08:17:51 +00004968 return CK_FloatingComplexToBoolean;
John McCall8cb679e2010-11-15 09:13:47 +00004969 case Type::STK_Integral:
John McCall9776e432011-10-06 23:25:11 +00004970 Src = ImpCastExprToType(Src.take(),
4971 SrcTy->castAs<ComplexType>()->getElementType(),
4972 CK_FloatingComplexToReal);
John McCalld7646252010-11-14 08:17:51 +00004973 return CK_FloatingToIntegral;
John McCall9320b872011-09-09 05:25:32 +00004974 case Type::STK_CPointer:
4975 case Type::STK_ObjCObjectPointer:
4976 case Type::STK_BlockPointer:
John McCall8cb679e2010-11-15 09:13:47 +00004977 llvm_unreachable("valid complex float->pointer cast?");
4978 case Type::STK_MemberPointer:
4979 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00004980 }
David Blaikie8a40f702012-01-17 06:56:22 +00004981 llvm_unreachable("Should have returned before this");
John McCalld7646252010-11-14 08:17:51 +00004982
John McCall8cb679e2010-11-15 09:13:47 +00004983 case Type::STK_IntegralComplex:
4984 switch (DestTy->getScalarTypeKind()) {
4985 case Type::STK_FloatingComplex:
John McCalld7646252010-11-14 08:17:51 +00004986 return CK_IntegralComplexToFloatingComplex;
John McCall8cb679e2010-11-15 09:13:47 +00004987 case Type::STK_IntegralComplex:
John McCalld7646252010-11-14 08:17:51 +00004988 return CK_IntegralComplexCast;
John McCallfcef3cf2010-12-14 17:51:41 +00004989 case Type::STK_Integral: {
John McCall9776e432011-10-06 23:25:11 +00004990 QualType ET = SrcTy->castAs<ComplexType>()->getElementType();
4991 if (Context.hasSameType(ET, DestTy))
John McCallfcef3cf2010-12-14 17:51:41 +00004992 return CK_IntegralComplexToReal;
John McCall9776e432011-10-06 23:25:11 +00004993 Src = ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal);
John McCallfcef3cf2010-12-14 17:51:41 +00004994 return CK_IntegralCast;
4995 }
John McCall8cb679e2010-11-15 09:13:47 +00004996 case Type::STK_Bool:
John McCalld7646252010-11-14 08:17:51 +00004997 return CK_IntegralComplexToBoolean;
John McCall8cb679e2010-11-15 09:13:47 +00004998 case Type::STK_Floating:
John McCall9776e432011-10-06 23:25:11 +00004999 Src = ImpCastExprToType(Src.take(),
5000 SrcTy->castAs<ComplexType>()->getElementType(),
5001 CK_IntegralComplexToReal);
John McCalld7646252010-11-14 08:17:51 +00005002 return CK_IntegralToFloating;
John McCall9320b872011-09-09 05:25:32 +00005003 case Type::STK_CPointer:
5004 case Type::STK_ObjCObjectPointer:
5005 case Type::STK_BlockPointer:
John McCall8cb679e2010-11-15 09:13:47 +00005006 llvm_unreachable("valid complex int->pointer cast?");
5007 case Type::STK_MemberPointer:
5008 llvm_unreachable("member pointer type in C");
John McCalld7646252010-11-14 08:17:51 +00005009 }
David Blaikie8a40f702012-01-17 06:56:22 +00005010 llvm_unreachable("Should have returned before this");
Anders Carlsson094c4592009-10-18 18:12:03 +00005011 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005012
John McCalld7646252010-11-14 08:17:51 +00005013 llvm_unreachable("Unhandled scalar cast");
Anders Carlsson094c4592009-10-18 18:12:03 +00005014}
5015
Anders Carlsson525b76b2009-10-16 02:48:28 +00005016bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
John McCalle3027922010-08-25 11:45:40 +00005017 CastKind &Kind) {
Anders Carlssonde71adf2007-11-27 05:51:55 +00005018 assert(VectorTy->isVectorType() && "Not a vector type!");
Mike Stump4e1f26a2009-02-19 03:04:26 +00005019
Anders Carlssonde71adf2007-11-27 05:51:55 +00005020 if (Ty->isVectorType() || Ty->isIntegerType()) {
Chris Lattner37e05872008-03-05 18:54:05 +00005021 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty))
Anders Carlssonde71adf2007-11-27 05:51:55 +00005022 return Diag(R.getBegin(),
Mike Stump4e1f26a2009-02-19 03:04:26 +00005023 Ty->isVectorType() ?
Anders Carlssonde71adf2007-11-27 05:51:55 +00005024 diag::err_invalid_conversion_between_vectors :
Chris Lattner3b054132008-11-19 05:08:23 +00005025 diag::err_invalid_conversion_between_vector_and_integer)
Chris Lattner1e5665e2008-11-24 06:25:27 +00005026 << VectorTy << Ty << R;
Anders Carlssonde71adf2007-11-27 05:51:55 +00005027 } else
5028 return Diag(R.getBegin(),
Chris Lattner3b054132008-11-19 05:08:23 +00005029 diag::err_invalid_conversion_between_vector_and_scalar)
Chris Lattner1e5665e2008-11-24 06:25:27 +00005030 << VectorTy << Ty << R;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005031
John McCalle3027922010-08-25 11:45:40 +00005032 Kind = CK_BitCast;
Anders Carlssonde71adf2007-11-27 05:51:55 +00005033 return false;
5034}
5035
John Wiegley01296292011-04-08 18:41:53 +00005036ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
5037 Expr *CastExpr, CastKind &Kind) {
Nate Begemanc69b7402009-06-26 00:50:28 +00005038 assert(DestTy->isExtVectorType() && "Not an extended vector type!");
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005039
Anders Carlsson43d70f82009-10-16 05:23:41 +00005040 QualType SrcTy = CastExpr->getType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005041
Nate Begemanc8961a42009-06-27 22:05:55 +00005042 // If SrcTy is a VectorType, the total size must match to explicitly cast to
5043 // an ExtVectorType.
Tobias Grosser766bcc22011-09-22 13:03:14 +00005044 // In OpenCL, casts between vectors of different types are not allowed.
5045 // (See OpenCL 6.2).
Nate Begemanc69b7402009-06-26 00:50:28 +00005046 if (SrcTy->isVectorType()) {
Tobias Grosser766bcc22011-09-22 13:03:14 +00005047 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy)
David Blaikiebbafb8a2012-03-11 07:00:24 +00005048 || (getLangOpts().OpenCL &&
Tobias Grosser766bcc22011-09-22 13:03:14 +00005049 (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) {
John Wiegley01296292011-04-08 18:41:53 +00005050 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
Nate Begemanc69b7402009-06-26 00:50:28 +00005051 << DestTy << SrcTy << R;
John Wiegley01296292011-04-08 18:41:53 +00005052 return ExprError();
5053 }
John McCalle3027922010-08-25 11:45:40 +00005054 Kind = CK_BitCast;
John Wiegley01296292011-04-08 18:41:53 +00005055 return Owned(CastExpr);
Nate Begemanc69b7402009-06-26 00:50:28 +00005056 }
5057
Nate Begemanbd956c42009-06-28 02:36:38 +00005058 // All non-pointer scalars can be cast to ExtVector type. The appropriate
Nate Begemanc69b7402009-06-26 00:50:28 +00005059 // conversion will take place first from scalar to elt type, and then
5060 // splat from elt type to vector.
Nate Begemanbd956c42009-06-28 02:36:38 +00005061 if (SrcTy->isPointerType())
5062 return Diag(R.getBegin(),
5063 diag::err_invalid_conversion_between_vector_and_scalar)
5064 << DestTy << SrcTy << R;
Eli Friedman06ed2a52009-10-20 08:27:19 +00005065
5066 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType();
John Wiegley01296292011-04-08 18:41:53 +00005067 ExprResult CastExprRes = Owned(CastExpr);
John McCall9776e432011-10-06 23:25:11 +00005068 CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy);
John Wiegley01296292011-04-08 18:41:53 +00005069 if (CastExprRes.isInvalid())
5070 return ExprError();
5071 CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005072
John McCalle3027922010-08-25 11:45:40 +00005073 Kind = CK_VectorSplat;
John Wiegley01296292011-04-08 18:41:53 +00005074 return Owned(CastExpr);
Nate Begemanc69b7402009-06-26 00:50:28 +00005075}
5076
John McCalldadc5752010-08-24 06:29:42 +00005077ExprResult
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00005078Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
5079 Declarator &D, ParsedType &Ty,
Richard Trieuba63ce62011-09-09 01:45:06 +00005080 SourceLocation RParenLoc, Expr *CastExpr) {
5081 assert(!D.isInvalidType() && (CastExpr != 0) &&
Sebastian Redlb5d49352009-01-19 22:31:54 +00005082 "ActOnCastExpr(): missing type or expr");
Steve Naroff1a2cf6b2007-07-16 23:25:18 +00005083
Richard Trieuba63ce62011-09-09 01:45:06 +00005084 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType());
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00005085 if (D.isInvalidType())
5086 return ExprError();
5087
David Blaikiebbafb8a2012-03-11 07:00:24 +00005088 if (getLangOpts().CPlusPlus) {
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00005089 // Check that there are no default arguments (C++ only).
5090 CheckExtraCXXDefaultArguments(D);
5091 }
5092
John McCall42856de2011-10-01 05:17:03 +00005093 checkUnusedDeclAttributes(D);
5094
Argyrios Kyrtzidis7192a3b2011-07-01 22:22:59 +00005095 QualType castType = castTInfo->getType();
5096 Ty = CreateParsedType(castType, castTInfo);
Mike Stump11289f42009-09-09 15:08:12 +00005097
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005098 bool isVectorLiteral = false;
5099
5100 // Check for an altivec or OpenCL literal,
5101 // i.e. all the elements are integer constants.
Richard Trieuba63ce62011-09-09 01:45:06 +00005102 ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr);
5103 ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr);
David Blaikiebbafb8a2012-03-11 07:00:24 +00005104 if ((getLangOpts().AltiVec || getLangOpts().OpenCL)
Tobias Grosser0a3a22f2011-09-21 18:28:29 +00005105 && castType->isVectorType() && (PE || PLE)) {
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005106 if (PLE && PLE->getNumExprs() == 0) {
5107 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);
5108 return ExprError();
5109 }
5110 if (PE || PLE->getNumExprs() == 1) {
5111 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
5112 if (!E->getType()->isVectorType())
5113 isVectorLiteral = true;
5114 }
5115 else
5116 isVectorLiteral = true;
5117 }
5118
5119 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')'
5120 // then handle it as such.
5121 if (isVectorLiteral)
Richard Trieuba63ce62011-09-09 01:45:06 +00005122 return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo);
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005123
Nate Begeman5ec4b312009-08-10 23:49:36 +00005124 // If the Expr being casted is a ParenListExpr, handle it specially.
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005125 // This is not an AltiVec-style cast, so turn the ParenListExpr into a
5126 // sequence of BinOp comma operators.
Richard Trieuba63ce62011-09-09 01:45:06 +00005127 if (isa<ParenListExpr>(CastExpr)) {
5128 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005129 if (Result.isInvalid()) return ExprError();
Richard Trieuba63ce62011-09-09 01:45:06 +00005130 CastExpr = Result.take();
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005131 }
John McCallebe54742010-01-15 18:56:44 +00005132
Alp Toker15ab3732013-12-12 12:47:48 +00005133 if (getLangOpts().CPlusPlus && !castType->isVoidType() &&
5134 !getSourceManager().isInSystemMacro(LParenLoc))
5135 Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange();
Alp Tokerc7c1ebe2013-11-27 03:18:17 +00005136
Richard Trieuba63ce62011-09-09 01:45:06 +00005137 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr);
John McCallebe54742010-01-15 18:56:44 +00005138}
5139
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005140ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
5141 SourceLocation RParenLoc, Expr *E,
5142 TypeSourceInfo *TInfo) {
5143 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&
5144 "Expected paren or paren list expression");
5145
5146 Expr **exprs;
5147 unsigned numExprs;
5148 Expr *subExpr;
Richard Smith9ca91012013-02-05 05:55:57 +00005149 SourceLocation LiteralLParenLoc, LiteralRParenLoc;
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005150 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) {
Richard Smith9ca91012013-02-05 05:55:57 +00005151 LiteralLParenLoc = PE->getLParenLoc();
5152 LiteralRParenLoc = PE->getRParenLoc();
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005153 exprs = PE->getExprs();
5154 numExprs = PE->getNumExprs();
Richard Smith9ca91012013-02-05 05:55:57 +00005155 } else { // isa<ParenExpr> by assertion at function entrance
5156 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen();
5157 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen();
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005158 subExpr = cast<ParenExpr>(E)->getSubExpr();
5159 exprs = &subExpr;
5160 numExprs = 1;
5161 }
5162
5163 QualType Ty = TInfo->getType();
5164 assert(Ty->isVectorType() && "Expected vector type");
5165
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005166 SmallVector<Expr *, 8> initExprs;
Tanya Lattner83559382011-07-15 23:07:01 +00005167 const VectorType *VTy = Ty->getAs<VectorType>();
5168 unsigned numElems = Ty->getAs<VectorType>()->getNumElements();
5169
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005170 // '(...)' form of vector initialization in AltiVec: the number of
5171 // initializers must be one or must match the size of the vector.
5172 // If a single value is specified in the initializer then it will be
5173 // replicated to all the components of the vector
Tanya Lattner83559382011-07-15 23:07:01 +00005174 if (VTy->getVectorKind() == VectorType::AltiVecVector) {
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005175 // The number of initializers must be one or must match the size of the
5176 // vector. If a single value is specified in the initializer then it will
5177 // be replicated to all the components of the vector
5178 if (numExprs == 1) {
5179 QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
Richard Smith01ebacd2011-10-27 23:31:58 +00005180 ExprResult Literal = DefaultLvalueConversion(exprs[0]);
5181 if (Literal.isInvalid())
5182 return ExprError();
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005183 Literal = ImpCastExprToType(Literal.take(), ElemTy,
John McCall9776e432011-10-06 23:25:11 +00005184 PrepareScalarCast(Literal, ElemTy));
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005185 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take());
5186 }
5187 else if (numExprs < numElems) {
5188 Diag(E->getExprLoc(),
5189 diag::err_incorrect_number_of_vector_initializers);
5190 return ExprError();
5191 }
5192 else
Benjamin Kramer8001f742012-02-14 12:06:21 +00005193 initExprs.append(exprs, exprs + numExprs);
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005194 }
Tanya Lattner83559382011-07-15 23:07:01 +00005195 else {
5196 // For OpenCL, when the number of initializers is a single value,
5197 // it will be replicated to all components of the vector.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005198 if (getLangOpts().OpenCL &&
Tanya Lattner83559382011-07-15 23:07:01 +00005199 VTy->getVectorKind() == VectorType::GenericVector &&
5200 numExprs == 1) {
5201 QualType ElemTy = Ty->getAs<VectorType>()->getElementType();
Richard Smith01ebacd2011-10-27 23:31:58 +00005202 ExprResult Literal = DefaultLvalueConversion(exprs[0]);
5203 if (Literal.isInvalid())
5204 return ExprError();
Tanya Lattner83559382011-07-15 23:07:01 +00005205 Literal = ImpCastExprToType(Literal.take(), ElemTy,
John McCall9776e432011-10-06 23:25:11 +00005206 PrepareScalarCast(Literal, ElemTy));
Tanya Lattner83559382011-07-15 23:07:01 +00005207 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take());
5208 }
5209
Benjamin Kramer8001f742012-02-14 12:06:21 +00005210 initExprs.append(exprs, exprs + numExprs);
Tanya Lattner83559382011-07-15 23:07:01 +00005211 }
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005212 // FIXME: This means that pretty-printing the final AST will produce curly
5213 // braces instead of the original commas.
Richard Smith9ca91012013-02-05 05:55:57 +00005214 InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
5215 initExprs, LiteralRParenLoc);
Argyrios Kyrtzidisd8701b62011-07-01 22:22:54 +00005216 initE->setType(Ty);
5217 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE);
5218}
5219
Sebastian Redla9351792012-02-11 23:51:47 +00005220/// This is not an AltiVec-style cast or or C++ direct-initialization, so turn
5221/// the ParenListExpr into a sequence of comma binary operators.
John McCalldadc5752010-08-24 06:29:42 +00005222ExprResult
Richard Trieuba63ce62011-09-09 01:45:06 +00005223Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) {
5224 ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr);
Nate Begeman5ec4b312009-08-10 23:49:36 +00005225 if (!E)
Richard Trieuba63ce62011-09-09 01:45:06 +00005226 return Owned(OrigExpr);
Mike Stump11289f42009-09-09 15:08:12 +00005227
John McCalldadc5752010-08-24 06:29:42 +00005228 ExprResult Result(E->getExpr(0));
Mike Stump11289f42009-09-09 15:08:12 +00005229
Nate Begeman5ec4b312009-08-10 23:49:36 +00005230 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
John McCallb268a282010-08-23 23:25:46 +00005231 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
5232 E->getExpr(i));
Mike Stump11289f42009-09-09 15:08:12 +00005233
John McCallb268a282010-08-23 23:25:46 +00005234 if (Result.isInvalid()) return ExprError();
5235
5236 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
Nate Begeman5ec4b312009-08-10 23:49:36 +00005237}
5238
Sebastian Redla9351792012-02-11 23:51:47 +00005239ExprResult Sema::ActOnParenListExpr(SourceLocation L,
5240 SourceLocation R,
5241 MultiExprArg Val) {
Benjamin Kramerc215e762012-08-24 11:54:20 +00005242 Expr *expr = new (Context) ParenListExpr(Context, L, Val, R);
Nate Begeman5ec4b312009-08-10 23:49:36 +00005243 return Owned(expr);
5244}
5245
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005246/// \brief Emit a specialized diagnostic when one expression is a null pointer
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005247/// constant and the other is not a pointer. Returns true if a diagnostic is
5248/// emitted.
Richard Trieud33e46e2011-09-06 20:06:39 +00005249bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005250 SourceLocation QuestionLoc) {
Richard Trieud33e46e2011-09-06 20:06:39 +00005251 Expr *NullExpr = LHSExpr;
5252 Expr *NonPointerExpr = RHSExpr;
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005253 Expr::NullPointerConstantKind NullKind =
5254 NullExpr->isNullPointerConstant(Context,
5255 Expr::NPC_ValueDependentIsNotNull);
5256
5257 if (NullKind == Expr::NPCK_NotNull) {
Richard Trieud33e46e2011-09-06 20:06:39 +00005258 NullExpr = RHSExpr;
5259 NonPointerExpr = LHSExpr;
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005260 NullKind =
5261 NullExpr->isNullPointerConstant(Context,
5262 Expr::NPC_ValueDependentIsNotNull);
5263 }
5264
5265 if (NullKind == Expr::NPCK_NotNull)
5266 return false;
5267
David Blaikie1c7c8f72012-08-08 17:33:31 +00005268 if (NullKind == Expr::NPCK_ZeroExpression)
5269 return false;
5270
5271 if (NullKind == Expr::NPCK_ZeroLiteral) {
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005272 // In this case, check to make sure that we got here from a "NULL"
5273 // string in the source code.
5274 NullExpr = NullExpr->IgnoreParenImpCasts();
John McCall462c0552011-03-08 07:59:04 +00005275 SourceLocation loc = NullExpr->getExprLoc();
5276 if (!findMacroSpelling(loc, "NULL"))
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005277 return false;
5278 }
5279
Richard Smith89645bc2013-01-02 12:01:23 +00005280 int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr);
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005281 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null)
5282 << NonPointerExpr->getType() << DiagType
5283 << NonPointerExpr->getSourceRange();
5284 return true;
5285}
5286
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005287/// \brief Return false if the condition expression is valid, true otherwise.
5288static bool checkCondition(Sema &S, Expr *Cond) {
5289 QualType CondTy = Cond->getType();
5290
5291 // C99 6.5.15p2
5292 if (CondTy->isScalarType()) return false;
5293
Tanya Lattnerdaa74b92013-04-03 23:55:58 +00005294 // OpenCL v1.1 s6.3.i says the condition is allowed to be a vector or scalar.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005295 if (S.getLangOpts().OpenCL && CondTy->isVectorType())
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005296 return false;
5297
5298 // Emit the proper error message.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005299 S.Diag(Cond->getLocStart(), S.getLangOpts().OpenCL ?
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005300 diag::err_typecheck_cond_expect_scalar :
5301 diag::err_typecheck_cond_expect_scalar_or_vector)
5302 << CondTy;
5303 return true;
5304}
5305
5306/// \brief Return false if the two expressions can be converted to a vector,
5307/// true otherwise
5308static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS,
5309 ExprResult &RHS,
5310 QualType CondTy) {
5311 // Both operands should be of scalar type.
5312 if (!LHS.get()->getType()->isScalarType()) {
5313 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar)
5314 << CondTy;
5315 return true;
5316 }
5317 if (!RHS.get()->getType()->isScalarType()) {
5318 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar)
5319 << CondTy;
5320 return true;
5321 }
5322
5323 // Implicity convert these scalars to the type of the condition.
5324 LHS = S.ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast);
5325 RHS = S.ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast);
5326 return false;
5327}
5328
5329/// \brief Handle when one or both operands are void type.
5330static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS,
5331 ExprResult &RHS) {
5332 Expr *LHSExpr = LHS.get();
5333 Expr *RHSExpr = RHS.get();
5334
5335 if (!LHSExpr->getType()->isVoidType())
5336 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void)
5337 << RHSExpr->getSourceRange();
5338 if (!RHSExpr->getType()->isVoidType())
5339 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void)
5340 << LHSExpr->getSourceRange();
5341 LHS = S.ImpCastExprToType(LHS.take(), S.Context.VoidTy, CK_ToVoid);
5342 RHS = S.ImpCastExprToType(RHS.take(), S.Context.VoidTy, CK_ToVoid);
5343 return S.Context.VoidTy;
5344}
5345
5346/// \brief Return false if the NullExpr can be promoted to PointerTy,
5347/// true otherwise.
5348static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr,
5349 QualType PointerTy) {
5350 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) ||
5351 !NullExpr.get()->isNullPointerConstant(S.Context,
5352 Expr::NPC_ValueDependentIsNull))
5353 return true;
5354
5355 NullExpr = S.ImpCastExprToType(NullExpr.take(), PointerTy, CK_NullToPointer);
5356 return false;
5357}
5358
5359/// \brief Checks compatibility between two pointers and return the resulting
5360/// type.
5361static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS,
5362 ExprResult &RHS,
5363 SourceLocation Loc) {
5364 QualType LHSTy = LHS.get()->getType();
5365 QualType RHSTy = RHS.get()->getType();
5366
5367 if (S.Context.hasSameType(LHSTy, RHSTy)) {
5368 // Two identical pointers types are always compatible.
5369 return LHSTy;
5370 }
5371
5372 QualType lhptee, rhptee;
5373
5374 // Get the pointee types.
Fariborz Jahanian1edacec2013-06-07 16:07:38 +00005375 bool IsBlockPointer = false;
John McCall9320b872011-09-09 05:25:32 +00005376 if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) {
5377 lhptee = LHSBTy->getPointeeType();
5378 rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType();
Fariborz Jahanian1edacec2013-06-07 16:07:38 +00005379 IsBlockPointer = true;
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005380 } else {
John McCall9320b872011-09-09 05:25:32 +00005381 lhptee = LHSTy->castAs<PointerType>()->getPointeeType();
5382 rhptee = RHSTy->castAs<PointerType>()->getPointeeType();
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005383 }
5384
Eli Friedman57a75392012-04-05 22:30:04 +00005385 // C99 6.5.15p6: If both operands are pointers to compatible types or to
5386 // differently qualified versions of compatible types, the result type is
5387 // a pointer to an appropriately qualified version of the composite
5388 // type.
5389
5390 // Only CVR-qualifiers exist in the standard, and the differently-qualified
5391 // clause doesn't make sense for our extensions. E.g. address space 2 should
5392 // be incompatible with address space 3: they may live on different devices or
5393 // anything.
5394 Qualifiers lhQual = lhptee.getQualifiers();
5395 Qualifiers rhQual = rhptee.getQualifiers();
5396
5397 unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
5398 lhQual.removeCVRQualifiers();
5399 rhQual.removeCVRQualifiers();
5400
5401 lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual);
5402 rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual);
5403
5404 QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee);
5405
5406 if (CompositeTy.isNull()) {
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005407 S.Diag(Loc, diag::warn_typecheck_cond_incompatible_pointers)
5408 << LHSTy << RHSTy << LHS.get()->getSourceRange()
5409 << RHS.get()->getSourceRange();
5410 // In this situation, we assume void* type. No especially good
5411 // reason, but this is what gcc does, and we do have to pick
5412 // to get a consistent AST.
5413 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy);
5414 LHS = S.ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast);
5415 RHS = S.ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast);
5416 return incompatTy;
5417 }
5418
5419 // The pointer types are compatible.
Eli Friedman57a75392012-04-05 22:30:04 +00005420 QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual);
Fariborz Jahanian1edacec2013-06-07 16:07:38 +00005421 if (IsBlockPointer)
Fariborz Jahanian44d23b82013-06-07 00:48:14 +00005422 ResultTy = S.Context.getBlockPointerType(ResultTy);
5423 else
5424 ResultTy = S.Context.getPointerType(ResultTy);
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005425
Eli Friedman57a75392012-04-05 22:30:04 +00005426 LHS = S.ImpCastExprToType(LHS.take(), ResultTy, CK_BitCast);
5427 RHS = S.ImpCastExprToType(RHS.take(), ResultTy, CK_BitCast);
5428 return ResultTy;
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005429}
5430
5431/// \brief Return the resulting type when the operands are both block pointers.
5432static QualType checkConditionalBlockPointerCompatibility(Sema &S,
5433 ExprResult &LHS,
5434 ExprResult &RHS,
5435 SourceLocation Loc) {
5436 QualType LHSTy = LHS.get()->getType();
5437 QualType RHSTy = RHS.get()->getType();
5438
5439 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) {
5440 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) {
5441 QualType destType = S.Context.getPointerType(S.Context.VoidTy);
5442 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast);
5443 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast);
5444 return destType;
5445 }
5446 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
5447 << LHSTy << RHSTy << LHS.get()->getSourceRange()
5448 << RHS.get()->getSourceRange();
5449 return QualType();
5450 }
5451
5452 // We have 2 block pointer types.
5453 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
5454}
5455
5456/// \brief Return the resulting type when the operands are both pointers.
5457static QualType
5458checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
5459 ExprResult &RHS,
5460 SourceLocation Loc) {
5461 // get the pointer types
5462 QualType LHSTy = LHS.get()->getType();
5463 QualType RHSTy = RHS.get()->getType();
5464
5465 // get the "pointed to" types
5466 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
5467 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
5468
5469 // ignore qualifiers on void (C99 6.5.15p3, clause 6)
5470 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
5471 // Figure out necessary qualifiers (C99 6.5.15p6)
5472 QualType destPointee
5473 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
5474 QualType destType = S.Context.getPointerType(destPointee);
5475 // Add qualifiers if necessary.
5476 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_NoOp);
5477 // Promote to void*.
5478 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast);
5479 return destType;
5480 }
5481 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
5482 QualType destPointee
5483 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
5484 QualType destType = S.Context.getPointerType(destPointee);
5485 // Add qualifiers if necessary.
5486 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_NoOp);
5487 // Promote to void*.
5488 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast);
5489 return destType;
5490 }
5491
5492 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc);
5493}
5494
5495/// \brief Return false if the first expression is not an integer and the second
5496/// expression is not a pointer, true otherwise.
5497static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int,
5498 Expr* PointerExpr, SourceLocation Loc,
Richard Trieuba63ce62011-09-09 01:45:06 +00005499 bool IsIntFirstExpr) {
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005500 if (!PointerExpr->getType()->isPointerType() ||
5501 !Int.get()->getType()->isIntegerType())
5502 return false;
5503
Richard Trieuba63ce62011-09-09 01:45:06 +00005504 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr;
5505 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005506
5507 S.Diag(Loc, diag::warn_typecheck_cond_pointer_integer_mismatch)
5508 << Expr1->getType() << Expr2->getType()
5509 << Expr1->getSourceRange() << Expr2->getSourceRange();
5510 Int = S.ImpCastExprToType(Int.take(), PointerExpr->getType(),
5511 CK_IntegralToPointer);
5512 return true;
5513}
5514
Richard Trieud33e46e2011-09-06 20:06:39 +00005515/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
5516/// In that case, LHS = cond.
Chris Lattner2c486602009-02-18 04:38:20 +00005517/// C99 6.5.15
Richard Trieucfc491d2011-08-02 04:35:43 +00005518QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
5519 ExprResult &RHS, ExprValueKind &VK,
5520 ExprObjectKind &OK,
Chris Lattner2c486602009-02-18 04:38:20 +00005521 SourceLocation QuestionLoc) {
Douglas Gregor1beec452011-03-12 01:48:56 +00005522
Richard Trieud33e46e2011-09-06 20:06:39 +00005523 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get());
5524 if (!LHSResult.isUsable()) return QualType();
Benjamin Kramer62b95d82012-08-23 21:35:17 +00005525 LHS = LHSResult;
Douglas Gregor0124e9b2010-11-09 21:07:58 +00005526
Richard Trieud33e46e2011-09-06 20:06:39 +00005527 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get());
5528 if (!RHSResult.isUsable()) return QualType();
Benjamin Kramer62b95d82012-08-23 21:35:17 +00005529 RHS = RHSResult;
Douglas Gregor0124e9b2010-11-09 21:07:58 +00005530
Sebastian Redl1a99f442009-04-16 17:51:27 +00005531 // C++ is sufficiently different to merit its own checker.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005532 if (getLangOpts().CPlusPlus)
John McCallc07a0c72011-02-17 10:25:35 +00005533 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
John McCall7decc9e2010-11-18 06:31:45 +00005534
5535 VK = VK_RValue;
John McCall4bc41ae2010-11-18 19:01:18 +00005536 OK = OK_Ordinary;
Sebastian Redl1a99f442009-04-16 17:51:27 +00005537
Jin-Gu Kang09c22132013-09-02 20:32:37 +00005538 // First, check the condition.
John Wiegley01296292011-04-08 18:41:53 +00005539 Cond = UsualUnaryConversions(Cond.take());
5540 if (Cond.isInvalid())
5541 return QualType();
Jin-Gu Kang09c22132013-09-02 20:32:37 +00005542 if (checkCondition(*this, Cond.get()))
5543 return QualType();
5544
5545 // Now check the two expressions.
5546 if (LHS.get()->getType()->isVectorType() ||
5547 RHS.get()->getType()->isVectorType())
5548 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false);
5549
Eli Friedmane6d33952013-07-08 20:20:06 +00005550 UsualArithmeticConversions(LHS, RHS);
5551 if (LHS.isInvalid() || RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00005552 return QualType();
5553
5554 QualType CondTy = Cond.get()->getType();
5555 QualType LHSTy = LHS.get()->getType();
5556 QualType RHSTy = RHS.get()->getType();
Steve Naroff31090012007-07-16 21:54:35 +00005557
Tanya Lattnerdaa74b92013-04-03 23:55:58 +00005558 // If the condition is a vector, and both operands are scalar,
Nate Begemanabb5a732010-09-20 22:41:17 +00005559 // attempt to implicity convert them to the vector type to act like the
Tanya Lattnerdaa74b92013-04-03 23:55:58 +00005560 // built in select. (OpenCL v1.1 s6.3.i)
David Blaikiebbafb8a2012-03-11 07:00:24 +00005561 if (getLangOpts().OpenCL && CondTy->isVectorType())
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005562 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy))
Nate Begemanabb5a732010-09-20 22:41:17 +00005563 return QualType();
Nate Begemanabb5a732010-09-20 22:41:17 +00005564
Chris Lattnere2949f42008-01-06 22:42:25 +00005565 // If both operands have arithmetic type, do the usual arithmetic conversions
5566 // to find a common type: C99 6.5.15p3,5.
Eli Friedmane6d33952013-07-08 20:20:06 +00005567 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType())
John Wiegley01296292011-04-08 18:41:53 +00005568 return LHS.get()->getType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00005569
Chris Lattnere2949f42008-01-06 22:42:25 +00005570 // If both operands are the same structure or union type, the result is that
5571 // type.
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005572 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3
5573 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
Chris Lattner2ab40a62007-11-26 01:40:58 +00005574 if (LHSRT->getDecl() == RHSRT->getDecl())
Mike Stump4e1f26a2009-02-19 03:04:26 +00005575 // "If both the operands have structure or union type, the result has
Chris Lattnere2949f42008-01-06 22:42:25 +00005576 // that type." This implies that CV qualifiers are dropped.
Chris Lattner432cff52009-02-18 04:28:32 +00005577 return LHSTy.getUnqualifiedType();
Eli Friedmanba961a92009-03-23 00:24:07 +00005578 // FIXME: Type of conditional expression must be complete in C mode.
Steve Naroffa78fe7e2007-05-16 19:47:19 +00005579 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00005580
Chris Lattnere2949f42008-01-06 22:42:25 +00005581 // C99 6.5.15p5: "If both operands have void type, the result has void type."
Steve Naroffbf1516c2008-05-12 21:44:38 +00005582 // The following || allows only one side to be void (a GCC-ism).
Chris Lattner432cff52009-02-18 04:28:32 +00005583 if (LHSTy->isVoidType() || RHSTy->isVoidType()) {
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005584 return checkConditionalVoidType(*this, LHS, RHS);
Steve Naroffbf1516c2008-05-12 21:44:38 +00005585 }
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005586
Steve Naroff039ad3c2008-01-08 01:11:38 +00005587 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
5588 // the type of the other operand."
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005589 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy;
5590 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005591
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005592 // All objective-c pointer type analysis is done here.
5593 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS,
5594 QuestionLoc);
John Wiegley01296292011-04-08 18:41:53 +00005595 if (LHS.isInvalid() || RHS.isInvalid())
5596 return QualType();
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005597 if (!compositeType.isNull())
5598 return compositeType;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005599
5600
Steve Naroff05efa972009-07-01 14:36:47 +00005601 // Handle block pointer types.
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005602 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType())
5603 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS,
5604 QuestionLoc);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005605
Steve Naroff05efa972009-07-01 14:36:47 +00005606 // Check constraints for C object pointers types (C99 6.5.15p3,6).
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005607 if (LHSTy->isPointerType() && RHSTy->isPointerType())
5608 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS,
5609 QuestionLoc);
Mike Stump11289f42009-09-09 15:08:12 +00005610
John McCalle84af4e2010-11-13 01:35:44 +00005611 // GCC compatibility: soften pointer/integer mismatch. Note that
5612 // null pointers have been filtered out by this point.
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005613 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
5614 /*isIntFirstExpr=*/true))
Steve Naroff05efa972009-07-01 14:36:47 +00005615 return RHSTy;
Richard Trieu27ae4cb2011-09-02 01:51:02 +00005616 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
5617 /*isIntFirstExpr=*/false))
Steve Naroff05efa972009-07-01 14:36:47 +00005618 return LHSTy;
Daniel Dunbar484603b2008-09-11 23:12:46 +00005619
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005620 // Emit a better diagnostic if one of the expressions is a null pointer
5621 // constant and the other is not a pointer type. In this case, the user most
5622 // likely forgot to take the address of the other expression.
John Wiegley01296292011-04-08 18:41:53 +00005623 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
Chandler Carrutha8bea4b2011-02-18 23:54:50 +00005624 return QualType();
5625
Chris Lattnere2949f42008-01-06 22:42:25 +00005626 // Otherwise, the operands are not compatible.
Chris Lattner432cff52009-02-18 04:28:32 +00005627 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
Richard Trieucfc491d2011-08-02 04:35:43 +00005628 << LHSTy << RHSTy << LHS.get()->getSourceRange()
5629 << RHS.get()->getSourceRange();
Steve Naroffa78fe7e2007-05-16 19:47:19 +00005630 return QualType();
Steve Narofff8a28c52007-05-15 20:29:32 +00005631}
5632
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005633/// FindCompositeObjCPointerType - Helper method to find composite type of
5634/// two objective-c pointer types of the two input expressions.
John Wiegley01296292011-04-08 18:41:53 +00005635QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
Richard Trieucfc491d2011-08-02 04:35:43 +00005636 SourceLocation QuestionLoc) {
John Wiegley01296292011-04-08 18:41:53 +00005637 QualType LHSTy = LHS.get()->getType();
5638 QualType RHSTy = RHS.get()->getType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005639
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005640 // Handle things like Class and struct objc_class*. Here we case the result
5641 // to the pseudo-builtin, because that will be implicitly cast back to the
5642 // redefinition type if an attempt is made to access its fields.
5643 if (LHSTy->isObjCClassType() &&
Douglas Gregor97673472011-08-11 20:58:55 +00005644 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) {
John McCall9320b872011-09-09 05:25:32 +00005645 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005646 return LHSTy;
5647 }
5648 if (RHSTy->isObjCClassType() &&
Douglas Gregor97673472011-08-11 20:58:55 +00005649 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) {
John McCall9320b872011-09-09 05:25:32 +00005650 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005651 return RHSTy;
5652 }
5653 // And the same for struct objc_object* / id
5654 if (LHSTy->isObjCIdType() &&
Douglas Gregor97673472011-08-11 20:58:55 +00005655 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) {
John McCall9320b872011-09-09 05:25:32 +00005656 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005657 return LHSTy;
5658 }
5659 if (RHSTy->isObjCIdType() &&
Douglas Gregor97673472011-08-11 20:58:55 +00005660 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) {
John McCall9320b872011-09-09 05:25:32 +00005661 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005662 return RHSTy;
5663 }
5664 // And the same for struct objc_selector* / SEL
5665 if (Context.isObjCSelType(LHSTy) &&
Douglas Gregor97673472011-08-11 20:58:55 +00005666 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) {
John Wiegley01296292011-04-08 18:41:53 +00005667 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005668 return LHSTy;
5669 }
5670 if (Context.isObjCSelType(RHSTy) &&
Douglas Gregor97673472011-08-11 20:58:55 +00005671 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) {
John Wiegley01296292011-04-08 18:41:53 +00005672 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005673 return RHSTy;
5674 }
5675 // Check constraints for Objective-C object pointers types.
5676 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) {
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005677
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005678 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) {
5679 // Two identical object pointer types are always compatible.
5680 return LHSTy;
5681 }
John McCall9320b872011-09-09 05:25:32 +00005682 const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>();
5683 const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>();
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005684 QualType compositeType = LHSTy;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005685
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005686 // If both operands are interfaces and either operand can be
5687 // assigned to the other, use that type as the composite
5688 // type. This allows
5689 // xxx ? (A*) a : (B*) b
5690 // where B is a subclass of A.
5691 //
5692 // Additionally, as for assignment, if either type is 'id'
5693 // allow silent coercion. Finally, if the types are
5694 // incompatible then make sure to use 'id' as the composite
5695 // type so the result is acceptable for sending messages to.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005696
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005697 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'.
5698 // It could return the composite type.
5699 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) {
5700 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy;
5701 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) {
5702 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy;
5703 } else if ((LHSTy->isObjCQualifiedIdType() ||
5704 RHSTy->isObjCQualifiedIdType()) &&
5705 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) {
5706 // Need to handle "id<xx>" explicitly.
5707 // GCC allows qualified id and any Objective-C type to devolve to
5708 // id. Currently localizing to here until clear this should be
5709 // part of ObjCQualifiedIdTypesAreCompatible.
5710 compositeType = Context.getObjCIdType();
5711 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) {
5712 compositeType = Context.getObjCIdType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00005713 } else if (!(compositeType =
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005714 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull())
5715 ;
5716 else {
5717 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands)
5718 << LHSTy << RHSTy
John Wiegley01296292011-04-08 18:41:53 +00005719 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005720 QualType incompatTy = Context.getObjCIdType();
John Wiegley01296292011-04-08 18:41:53 +00005721 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast);
5722 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005723 return incompatTy;
5724 }
5725 // The object pointer types are compatible.
John Wiegley01296292011-04-08 18:41:53 +00005726 LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast);
5727 RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005728 return compositeType;
5729 }
5730 // Check Objective-C object pointer types and 'void *'
5731 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00005732 if (getLangOpts().ObjCAutoRefCount) {
Eli Friedman8a78a582012-02-25 00:23:44 +00005733 // ARC forbids the implicit conversion of object pointers to 'void *',
5734 // so these types are not compatible.
5735 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
5736 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5737 LHS = RHS = true;
5738 return QualType();
5739 }
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005740 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType();
5741 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
5742 QualType destPointee
5743 = Context.getQualifiedType(lhptee, rhptee.getQualifiers());
5744 QualType destType = Context.getPointerType(destPointee);
5745 // Add qualifiers if necessary.
John Wiegley01296292011-04-08 18:41:53 +00005746 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005747 // Promote to void*.
John Wiegley01296292011-04-08 18:41:53 +00005748 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005749 return destType;
5750 }
5751 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00005752 if (getLangOpts().ObjCAutoRefCount) {
Eli Friedman8a78a582012-02-25 00:23:44 +00005753 // ARC forbids the implicit conversion of object pointers to 'void *',
5754 // so these types are not compatible.
5755 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy
5756 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
5757 LHS = RHS = true;
5758 return QualType();
5759 }
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005760 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType();
5761 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType();
5762 QualType destPointee
5763 = Context.getQualifiedType(rhptee, lhptee.getQualifiers());
5764 QualType destType = Context.getPointerType(destPointee);
5765 // Add qualifiers if necessary.
John Wiegley01296292011-04-08 18:41:53 +00005766 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005767 // Promote to void*.
John Wiegley01296292011-04-08 18:41:53 +00005768 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast);
Fariborz Jahaniana430f712009-12-10 19:47:41 +00005769 return destType;
5770 }
5771 return QualType();
5772}
5773
Chandler Carruthb00e8c02011-06-16 01:05:14 +00005774/// SuggestParentheses - Emit a note with a fixit hint that wraps
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005775/// ParenRange in parentheses.
5776static void SuggestParentheses(Sema &Self, SourceLocation Loc,
Chandler Carruthb00e8c02011-06-16 01:05:14 +00005777 const PartialDiagnostic &Note,
5778 SourceRange ParenRange) {
5779 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd());
5780 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() &&
5781 EndLoc.isValid()) {
5782 Self.Diag(Loc, Note)
5783 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(")
5784 << FixItHint::CreateInsertion(EndLoc, ")");
5785 } else {
5786 // We can't display the parentheses, so just show the bare note.
5787 Self.Diag(Loc, Note) << ParenRange;
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005788 }
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005789}
5790
5791static bool IsArithmeticOp(BinaryOperatorKind Opc) {
5792 return Opc >= BO_Mul && Opc <= BO_Shr;
5793}
5794
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005795/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary
5796/// expression, either using a built-in or overloaded operator,
Richard Trieud33e46e2011-09-06 20:06:39 +00005797/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side
5798/// expression.
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005799static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode,
Richard Trieud33e46e2011-09-06 20:06:39 +00005800 Expr **RHSExprs) {
Hans Wennborgbe207b32011-09-12 12:07:30 +00005801 // Don't strip parenthesis: we should not warn if E is in parenthesis.
5802 E = E->IgnoreImpCasts();
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005803 E = E->IgnoreConversionOperator();
Hans Wennborgbe207b32011-09-12 12:07:30 +00005804 E = E->IgnoreImpCasts();
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005805
5806 // Built-in binary operator.
5807 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) {
5808 if (IsArithmeticOp(OP->getOpcode())) {
5809 *Opcode = OP->getOpcode();
Richard Trieud33e46e2011-09-06 20:06:39 +00005810 *RHSExprs = OP->getRHS();
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005811 return true;
5812 }
5813 }
5814
5815 // Overloaded operator.
5816 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) {
5817 if (Call->getNumArgs() != 2)
5818 return false;
5819
5820 // Make sure this is really a binary operator that is safe to pass into
5821 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
5822 OverloadedOperatorKind OO = Call->getOperator();
Benjamin Kramer0345f9f2013-03-30 11:56:00 +00005823 if (OO < OO_Plus || OO > OO_Arrow ||
5824 OO == OO_PlusPlus || OO == OO_MinusMinus)
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005825 return false;
5826
5827 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO);
5828 if (IsArithmeticOp(OpKind)) {
5829 *Opcode = OpKind;
Richard Trieud33e46e2011-09-06 20:06:39 +00005830 *RHSExprs = Call->getArg(1);
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005831 return true;
5832 }
5833 }
5834
5835 return false;
5836}
5837
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005838static bool IsLogicOp(BinaryOperatorKind Opc) {
5839 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr);
5840}
5841
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005842/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
5843/// or is a logical expression such as (x==y) which has int type, but is
5844/// commonly interpreted as boolean.
5845static bool ExprLooksBoolean(Expr *E) {
5846 E = E->IgnoreParenImpCasts();
5847
5848 if (E->getType()->isBooleanType())
5849 return true;
5850 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E))
5851 return IsLogicOp(OP->getOpcode());
5852 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E))
5853 return OP->getOpcode() == UO_LNot;
5854
5855 return false;
5856}
5857
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005858/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator
5859/// and binary operator are mixed in a way that suggests the programmer assumed
5860/// the conditional operator has higher precedence, for example:
5861/// "int x = a + someBinaryCondition ? 1 : 2".
5862static void DiagnoseConditionalPrecedence(Sema &Self,
5863 SourceLocation OpLoc,
Chandler Carruth08dc2ba2011-06-16 01:05:08 +00005864 Expr *Condition,
Richard Trieud33e46e2011-09-06 20:06:39 +00005865 Expr *LHSExpr,
5866 Expr *RHSExpr) {
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005867 BinaryOperatorKind CondOpcode;
5868 Expr *CondRHS;
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005869
Chandler Carruth08dc2ba2011-06-16 01:05:08 +00005870 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS))
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005871 return;
5872 if (!ExprLooksBoolean(CondRHS))
5873 return;
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005874
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005875 // The condition is an arithmetic binary expression, with a right-
5876 // hand side that looks boolean, so warn.
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005877
Chandler Carruthb00e8c02011-06-16 01:05:14 +00005878 Self.Diag(OpLoc, diag::warn_precedence_conditional)
Chandler Carruth08dc2ba2011-06-16 01:05:08 +00005879 << Condition->getSourceRange()
Hans Wennborgde2e67e2011-06-09 17:06:51 +00005880 << BinaryOperator::getOpcodeStr(CondOpcode);
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005881
Chandler Carruthb00e8c02011-06-16 01:05:14 +00005882 SuggestParentheses(Self, OpLoc,
David Blaikiedac86fd2012-10-08 01:19:49 +00005883 Self.PDiag(diag::note_precedence_silence)
Chandler Carruthb00e8c02011-06-16 01:05:14 +00005884 << BinaryOperator::getOpcodeStr(CondOpcode),
5885 SourceRange(Condition->getLocStart(), Condition->getLocEnd()));
Chandler Carruthf51c5a52011-06-21 23:04:18 +00005886
5887 SuggestParentheses(Self, OpLoc,
5888 Self.PDiag(diag::note_precedence_conditional_first),
Richard Trieud33e46e2011-09-06 20:06:39 +00005889 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd()));
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005890}
5891
Steve Naroff83895f72007-09-16 03:34:24 +00005892/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Chris Lattnere168f762006-11-10 05:29:30 +00005893/// in the case of a the GNU conditional expr extension.
John McCalldadc5752010-08-24 06:29:42 +00005894ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
John McCallc07a0c72011-02-17 10:25:35 +00005895 SourceLocation ColonLoc,
5896 Expr *CondExpr, Expr *LHSExpr,
5897 Expr *RHSExpr) {
Chris Lattner2ab40a62007-11-26 01:40:58 +00005898 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS
5899 // was the condition.
John McCallc07a0c72011-02-17 10:25:35 +00005900 OpaqueValueExpr *opaqueValue = 0;
5901 Expr *commonExpr = 0;
5902 if (LHSExpr == 0) {
5903 commonExpr = CondExpr;
Fariborz Jahanian3caab6c2013-05-17 16:29:36 +00005904 // Lower out placeholder types first. This is important so that we don't
5905 // try to capture a placeholder. This happens in few cases in C++; such
5906 // as Objective-C++'s dictionary subscripting syntax.
5907 if (commonExpr->hasPlaceholderType()) {
5908 ExprResult result = CheckPlaceholderExpr(commonExpr);
5909 if (!result.isUsable()) return ExprError();
5910 commonExpr = result.take();
5911 }
John McCallc07a0c72011-02-17 10:25:35 +00005912 // We usually want to apply unary conversions *before* saving, except
5913 // in the special case of a C++ l-value conditional.
David Blaikiebbafb8a2012-03-11 07:00:24 +00005914 if (!(getLangOpts().CPlusPlus
John McCallc07a0c72011-02-17 10:25:35 +00005915 && !commonExpr->isTypeDependent()
5916 && commonExpr->getValueKind() == RHSExpr->getValueKind()
5917 && commonExpr->isGLValue()
5918 && commonExpr->isOrdinaryOrBitFieldObject()
5919 && RHSExpr->isOrdinaryOrBitFieldObject()
5920 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
John Wiegley01296292011-04-08 18:41:53 +00005921 ExprResult commonRes = UsualUnaryConversions(commonExpr);
5922 if (commonRes.isInvalid())
5923 return ExprError();
5924 commonExpr = commonRes.take();
John McCallc07a0c72011-02-17 10:25:35 +00005925 }
5926
5927 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(),
5928 commonExpr->getType(),
5929 commonExpr->getValueKind(),
Douglas Gregor2d5aea02012-02-23 22:17:26 +00005930 commonExpr->getObjectKind(),
5931 commonExpr);
John McCallc07a0c72011-02-17 10:25:35 +00005932 LHSExpr = CondExpr = opaqueValue;
Fariborz Jahanianc6bf0bd2010-08-31 18:02:20 +00005933 }
Sebastian Redlb5d49352009-01-19 22:31:54 +00005934
John McCall7decc9e2010-11-18 06:31:45 +00005935 ExprValueKind VK = VK_RValue;
John McCall4bc41ae2010-11-18 19:01:18 +00005936 ExprObjectKind OK = OK_Ordinary;
John Wiegley01296292011-04-08 18:41:53 +00005937 ExprResult Cond = Owned(CondExpr), LHS = Owned(LHSExpr), RHS = Owned(RHSExpr);
5938 QualType result = CheckConditionalOperands(Cond, LHS, RHS,
John McCallc07a0c72011-02-17 10:25:35 +00005939 VK, OK, QuestionLoc);
John Wiegley01296292011-04-08 18:41:53 +00005940 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
5941 RHS.isInvalid())
Sebastian Redlb5d49352009-01-19 22:31:54 +00005942 return ExprError();
5943
Hans Wennborgcf9bac42011-06-03 18:00:36 +00005944 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(),
5945 RHS.get());
5946
John McCallc07a0c72011-02-17 10:25:35 +00005947 if (!commonExpr)
John Wiegley01296292011-04-08 18:41:53 +00005948 return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc,
5949 LHS.take(), ColonLoc,
5950 RHS.take(), result, VK, OK));
John McCallc07a0c72011-02-17 10:25:35 +00005951
5952 return Owned(new (Context)
John Wiegley01296292011-04-08 18:41:53 +00005953 BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(),
Richard Trieucfc491d2011-08-02 04:35:43 +00005954 RHS.take(), QuestionLoc, ColonLoc, result, VK,
5955 OK));
Chris Lattnere168f762006-11-10 05:29:30 +00005956}
5957
John McCallaba90822011-01-31 23:13:11 +00005958// checkPointerTypesForAssignment - This is a very tricky routine (despite
Mike Stump4e1f26a2009-02-19 03:04:26 +00005959// being closely modeled after the C99 spec:-). The odd characteristic of this
Steve Naroff3f597292007-05-11 22:18:03 +00005960// routine is it effectively iqnores the qualifiers on the top level pointee.
5961// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
5962// FIXME: add a couple examples in this comment.
John McCallaba90822011-01-31 23:13:11 +00005963static Sema::AssignConvertType
Richard Trieua871b972011-09-06 20:21:22 +00005964checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
5965 assert(LHSType.isCanonical() && "LHS not canonicalized!");
5966 assert(RHSType.isCanonical() && "RHS not canonicalized!");
Mike Stump4e1f26a2009-02-19 03:04:26 +00005967
Steve Naroff1f4d7272007-05-11 04:00:31 +00005968 // get the "pointed to" type (ignoring qualifiers at the top level)
John McCall4fff8f62011-02-01 00:10:29 +00005969 const Type *lhptee, *rhptee;
5970 Qualifiers lhq, rhq;
Richard Trieua871b972011-09-06 20:21:22 +00005971 llvm::tie(lhptee, lhq) = cast<PointerType>(LHSType)->getPointeeType().split();
5972 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split();
Mike Stump4e1f26a2009-02-19 03:04:26 +00005973
John McCallaba90822011-01-31 23:13:11 +00005974 Sema::AssignConvertType ConvTy = Sema::Compatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00005975
5976 // C99 6.5.16.1p1: This following citation is common to constraints
5977 // 3 & 4 (below). ...and the type *pointed to* by the left has all the
5978 // qualifiers of the type *pointed to* by the right;
John McCall4fff8f62011-02-01 00:10:29 +00005979
John McCall31168b02011-06-15 23:02:42 +00005980 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay.
5981 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() &&
5982 lhq.compatiblyIncludesObjCLifetime(rhq)) {
5983 // Ignore lifetime for further calculation.
5984 lhq.removeObjCLifetime();
5985 rhq.removeObjCLifetime();
5986 }
5987
John McCall4fff8f62011-02-01 00:10:29 +00005988 if (!lhq.compatiblyIncludes(rhq)) {
5989 // Treat address-space mismatches as fatal. TODO: address subspaces
5990 if (lhq.getAddressSpace() != rhq.getAddressSpace())
5991 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers;
5992
John McCall31168b02011-06-15 23:02:42 +00005993 // It's okay to add or remove GC or lifetime qualifiers when converting to
John McCall78535952011-03-26 02:56:45 +00005994 // and from void*.
John McCall18ce25e2012-02-08 00:46:36 +00005995 else if (lhq.withoutObjCGCAttr().withoutObjCLifetime()
John McCall31168b02011-06-15 23:02:42 +00005996 .compatiblyIncludes(
John McCall18ce25e2012-02-08 00:46:36 +00005997 rhq.withoutObjCGCAttr().withoutObjCLifetime())
John McCall78535952011-03-26 02:56:45 +00005998 && (lhptee->isVoidType() || rhptee->isVoidType()))
5999 ; // keep old
6000
John McCall31168b02011-06-15 23:02:42 +00006001 // Treat lifetime mismatches as fatal.
6002 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime())
6003 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers;
6004
John McCall4fff8f62011-02-01 00:10:29 +00006005 // For GCC compatibility, other qualifier mismatches are treated
6006 // as still compatible in C.
6007 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers;
6008 }
Steve Naroff3f597292007-05-11 22:18:03 +00006009
Mike Stump4e1f26a2009-02-19 03:04:26 +00006010 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or
6011 // incomplete type and the other is a pointer to a qualified or unqualified
Steve Naroff3f597292007-05-11 22:18:03 +00006012 // version of void...
Chris Lattner0a788432008-01-03 22:56:36 +00006013 if (lhptee->isVoidType()) {
Chris Lattnerb3a176d2008-04-02 06:59:01 +00006014 if (rhptee->isIncompleteOrObjectType())
Chris Lattner9bad62c2008-01-04 18:04:52 +00006015 return ConvTy;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006016
Chris Lattner0a788432008-01-03 22:56:36 +00006017 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattnerb3a176d2008-04-02 06:59:01 +00006018 assert(rhptee->isFunctionType());
John McCallaba90822011-01-31 23:13:11 +00006019 return Sema::FunctionVoidPointer;
Chris Lattner0a788432008-01-03 22:56:36 +00006020 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006021
Chris Lattner0a788432008-01-03 22:56:36 +00006022 if (rhptee->isVoidType()) {
Chris Lattnerb3a176d2008-04-02 06:59:01 +00006023 if (lhptee->isIncompleteOrObjectType())
Chris Lattner9bad62c2008-01-04 18:04:52 +00006024 return ConvTy;
Chris Lattner0a788432008-01-03 22:56:36 +00006025
6026 // As an extension, we allow cast to/from void* to function pointer.
Chris Lattnerb3a176d2008-04-02 06:59:01 +00006027 assert(lhptee->isFunctionType());
John McCallaba90822011-01-31 23:13:11 +00006028 return Sema::FunctionVoidPointer;
Chris Lattner0a788432008-01-03 22:56:36 +00006029 }
John McCall4fff8f62011-02-01 00:10:29 +00006030
Mike Stump4e1f26a2009-02-19 03:04:26 +00006031 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or
Steve Naroff3f597292007-05-11 22:18:03 +00006032 // unqualified versions of compatible types, ...
John McCall4fff8f62011-02-01 00:10:29 +00006033 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0);
6034 if (!S.Context.typesAreCompatible(ltrans, rtrans)) {
Eli Friedman80160bd2009-03-22 23:59:44 +00006035 // Check if the pointee types are compatible ignoring the sign.
6036 // We explicitly check for char so that we catch "char" vs
6037 // "unsigned char" on systems where "char" is unsigned.
Chris Lattnerec3a1562009-10-17 20:33:28 +00006038 if (lhptee->isCharType())
John McCall4fff8f62011-02-01 00:10:29 +00006039 ltrans = S.Context.UnsignedCharTy;
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00006040 else if (lhptee->hasSignedIntegerRepresentation())
John McCall4fff8f62011-02-01 00:10:29 +00006041 ltrans = S.Context.getCorrespondingUnsignedType(ltrans);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006042
Chris Lattnerec3a1562009-10-17 20:33:28 +00006043 if (rhptee->isCharType())
John McCall4fff8f62011-02-01 00:10:29 +00006044 rtrans = S.Context.UnsignedCharTy;
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00006045 else if (rhptee->hasSignedIntegerRepresentation())
John McCall4fff8f62011-02-01 00:10:29 +00006046 rtrans = S.Context.getCorrespondingUnsignedType(rtrans);
Chris Lattnerec3a1562009-10-17 20:33:28 +00006047
John McCall4fff8f62011-02-01 00:10:29 +00006048 if (ltrans == rtrans) {
Eli Friedman80160bd2009-03-22 23:59:44 +00006049 // Types are compatible ignoring the sign. Qualifier incompatibility
6050 // takes priority over sign incompatibility because the sign
6051 // warning can be disabled.
John McCallaba90822011-01-31 23:13:11 +00006052 if (ConvTy != Sema::Compatible)
Eli Friedman80160bd2009-03-22 23:59:44 +00006053 return ConvTy;
John McCall4fff8f62011-02-01 00:10:29 +00006054
John McCallaba90822011-01-31 23:13:11 +00006055 return Sema::IncompatiblePointerSign;
Eli Friedman80160bd2009-03-22 23:59:44 +00006056 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006057
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00006058 // If we are a multi-level pointer, it's possible that our issue is simply
6059 // one of qualification - e.g. char ** -> const char ** is not allowed. If
6060 // the eventual target type is the same and the pointers have the same
6061 // level of indirection, this must be the issue.
John McCallaba90822011-01-31 23:13:11 +00006062 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00006063 do {
John McCall4fff8f62011-02-01 00:10:29 +00006064 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr();
6065 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr();
John McCallaba90822011-01-31 23:13:11 +00006066 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006067
John McCall4fff8f62011-02-01 00:10:29 +00006068 if (lhptee == rhptee)
John McCallaba90822011-01-31 23:13:11 +00006069 return Sema::IncompatibleNestedPointerQualifiers;
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +00006070 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006071
Eli Friedman80160bd2009-03-22 23:59:44 +00006072 // General pointer incompatibility takes priority over qualifiers.
John McCallaba90822011-01-31 23:13:11 +00006073 return Sema::IncompatiblePointer;
Eli Friedman80160bd2009-03-22 23:59:44 +00006074 }
David Blaikiebbafb8a2012-03-11 07:00:24 +00006075 if (!S.getLangOpts().CPlusPlus &&
Fariborz Jahanian48c69102011-10-05 00:05:34 +00006076 S.IsNoReturnConversion(ltrans, rtrans, ltrans))
6077 return Sema::IncompatiblePointer;
Chris Lattner9bad62c2008-01-04 18:04:52 +00006078 return ConvTy;
Steve Naroff1f4d7272007-05-11 04:00:31 +00006079}
6080
John McCallaba90822011-01-31 23:13:11 +00006081/// checkBlockPointerTypesForAssignment - This routine determines whether two
Steve Naroff081c7422008-09-04 15:10:53 +00006082/// block pointer types are compatible or whether a block and normal pointer
6083/// are compatible. It is more restrict than comparing two function pointer
6084// types.
John McCallaba90822011-01-31 23:13:11 +00006085static Sema::AssignConvertType
Richard Trieua871b972011-09-06 20:21:22 +00006086checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType,
6087 QualType RHSType) {
6088 assert(LHSType.isCanonical() && "LHS not canonicalized!");
6089 assert(RHSType.isCanonical() && "RHS not canonicalized!");
John McCallaba90822011-01-31 23:13:11 +00006090
Steve Naroff081c7422008-09-04 15:10:53 +00006091 QualType lhptee, rhptee;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006092
Steve Naroff081c7422008-09-04 15:10:53 +00006093 // get the "pointed to" type (ignoring qualifiers at the top level)
Richard Trieua871b972011-09-06 20:21:22 +00006094 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType();
6095 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006096
John McCallaba90822011-01-31 23:13:11 +00006097 // In C++, the types have to match exactly.
David Blaikiebbafb8a2012-03-11 07:00:24 +00006098 if (S.getLangOpts().CPlusPlus)
John McCallaba90822011-01-31 23:13:11 +00006099 return Sema::IncompatibleBlockPointer;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006100
John McCallaba90822011-01-31 23:13:11 +00006101 Sema::AssignConvertType ConvTy = Sema::Compatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006102
Steve Naroff081c7422008-09-04 15:10:53 +00006103 // For blocks we enforce that qualifiers are identical.
John McCallaba90822011-01-31 23:13:11 +00006104 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers())
6105 ConvTy = Sema::CompatiblePointerDiscardsQualifiers;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006106
Richard Trieua871b972011-09-06 20:21:22 +00006107 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType))
John McCallaba90822011-01-31 23:13:11 +00006108 return Sema::IncompatibleBlockPointer;
6109
Steve Naroff081c7422008-09-04 15:10:53 +00006110 return ConvTy;
6111}
6112
John McCallaba90822011-01-31 23:13:11 +00006113/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00006114/// for assignment compatibility.
John McCallaba90822011-01-31 23:13:11 +00006115static Sema::AssignConvertType
Richard Trieua871b972011-09-06 20:21:22 +00006116checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType,
6117 QualType RHSType) {
6118 assert(LHSType.isCanonical() && "LHS was not canonicalized!");
6119 assert(RHSType.isCanonical() && "RHS was not canonicalized!");
John McCallaba90822011-01-31 23:13:11 +00006120
Richard Trieua871b972011-09-06 20:21:22 +00006121 if (LHSType->isObjCBuiltinType()) {
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00006122 // Class is not compatible with ObjC object pointers.
Richard Trieua871b972011-09-06 20:21:22 +00006123 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() &&
6124 !RHSType->isObjCQualifiedClassType())
John McCallaba90822011-01-31 23:13:11 +00006125 return Sema::IncompatiblePointer;
6126 return Sema::Compatible;
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00006127 }
Richard Trieua871b972011-09-06 20:21:22 +00006128 if (RHSType->isObjCBuiltinType()) {
Richard Trieua871b972011-09-06 20:21:22 +00006129 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() &&
6130 !LHSType->isObjCQualifiedClassType())
Fariborz Jahaniand923eb02011-09-15 20:40:18 +00006131 return Sema::IncompatiblePointer;
John McCallaba90822011-01-31 23:13:11 +00006132 return Sema::Compatible;
Fariborz Jahaniand5bb8cb2010-03-19 18:06:10 +00006133 }
Richard Trieua871b972011-09-06 20:21:22 +00006134 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
6135 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006136
Fariborz Jahaniane74d47e2012-01-12 22:12:08 +00006137 if (!lhptee.isAtLeastAsQualifiedAs(rhptee) &&
6138 // make an exception for id<P>
6139 !LHSType->isObjCQualifiedIdType())
John McCallaba90822011-01-31 23:13:11 +00006140 return Sema::CompatiblePointerDiscardsQualifiers;
6141
Richard Trieua871b972011-09-06 20:21:22 +00006142 if (S.Context.typesAreCompatible(LHSType, RHSType))
John McCallaba90822011-01-31 23:13:11 +00006143 return Sema::Compatible;
Richard Trieua871b972011-09-06 20:21:22 +00006144 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType())
John McCallaba90822011-01-31 23:13:11 +00006145 return Sema::IncompatibleObjCQualifiedId;
6146 return Sema::IncompatiblePointer;
Fariborz Jahanian410f2eb2009-12-08 18:24:49 +00006147}
6148
John McCall29600e12010-11-16 02:32:08 +00006149Sema::AssignConvertType
Douglas Gregorc03a1082011-01-28 02:26:04 +00006150Sema::CheckAssignmentConstraints(SourceLocation Loc,
Richard Trieua871b972011-09-06 20:21:22 +00006151 QualType LHSType, QualType RHSType) {
John McCall29600e12010-11-16 02:32:08 +00006152 // Fake up an opaque expression. We don't actually care about what
6153 // cast operations are required, so if CheckAssignmentConstraints
6154 // adds casts to this they'll be wasted, but fortunately that doesn't
6155 // usually happen on valid code.
Richard Trieua871b972011-09-06 20:21:22 +00006156 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue);
6157 ExprResult RHSPtr = &RHSExpr;
John McCall29600e12010-11-16 02:32:08 +00006158 CastKind K = CK_Invalid;
6159
Richard Trieua871b972011-09-06 20:21:22 +00006160 return CheckAssignmentConstraints(LHSType, RHSPtr, K);
John McCall29600e12010-11-16 02:32:08 +00006161}
6162
Mike Stump4e1f26a2009-02-19 03:04:26 +00006163/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
6164/// has code to accommodate several GCC extensions when type checking
Steve Naroff17f76e02007-05-03 21:03:48 +00006165/// pointers. Here are some objectionable examples that GCC considers warnings:
6166///
6167/// int a, *pint;
6168/// short *pshort;
6169/// struct foo *pfoo;
6170///
6171/// pint = pshort; // warning: assignment from incompatible pointer type
6172/// a = pint; // warning: assignment makes integer from pointer without a cast
6173/// pint = a; // warning: assignment makes pointer from integer without a cast
6174/// pint = pfoo; // warning: assignment from incompatible pointer type
6175///
6176/// As a result, the code for dealing with pointers is more complex than the
Mike Stump4e1f26a2009-02-19 03:04:26 +00006177/// C99 spec dictates.
Steve Naroff17f76e02007-05-03 21:03:48 +00006178///
John McCall8cb679e2010-11-15 09:13:47 +00006179/// Sets 'Kind' for any result kind except Incompatible.
Chris Lattner9bad62c2008-01-04 18:04:52 +00006180Sema::AssignConvertType
Richard Trieude4958f2011-09-06 20:30:53 +00006181Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS,
John McCall8cb679e2010-11-15 09:13:47 +00006182 CastKind &Kind) {
Richard Trieude4958f2011-09-06 20:30:53 +00006183 QualType RHSType = RHS.get()->getType();
6184 QualType OrigLHSType = LHSType;
John McCall29600e12010-11-16 02:32:08 +00006185
Chris Lattnera52c2f22008-01-04 23:18:45 +00006186 // Get canonical types. We're not formatting these types, just comparing
6187 // them.
Richard Trieude4958f2011-09-06 20:30:53 +00006188 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType();
6189 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType();
Eli Friedman3360d892008-05-30 18:07:22 +00006190
John McCalle5255932011-01-31 22:28:28 +00006191 // Common case: no conversion required.
Richard Trieude4958f2011-09-06 20:30:53 +00006192 if (LHSType == RHSType) {
John McCall8cb679e2010-11-15 09:13:47 +00006193 Kind = CK_NoOp;
John McCall8cb679e2010-11-15 09:13:47 +00006194 return Compatible;
David Chisnall9f57c292009-08-17 16:35:33 +00006195 }
6196
Eli Friedman93ee5ca2012-06-16 02:19:17 +00006197 // If we have an atomic type, try a non-atomic assignment, then just add an
6198 // atomic qualification step.
David Chisnallfa35df62012-01-16 17:27:18 +00006199 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) {
Eli Friedman93ee5ca2012-06-16 02:19:17 +00006200 Sema::AssignConvertType result =
6201 CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind);
6202 if (result != Compatible)
6203 return result;
6204 if (Kind != CK_NoOp)
6205 RHS = ImpCastExprToType(RHS.take(), AtomicTy->getValueType(), Kind);
6206 Kind = CK_NonAtomicToAtomic;
6207 return Compatible;
David Chisnallfa35df62012-01-16 17:27:18 +00006208 }
6209
Douglas Gregor6b754842008-10-28 00:22:11 +00006210 // If the left-hand side is a reference type, then we are in a
6211 // (rare!) case where we've allowed the use of references in C,
6212 // e.g., as a parameter type in a built-in function. In this case,
6213 // just make sure that the type referenced is compatible with the
6214 // right-hand side type. The caller is responsible for adjusting
Richard Trieude4958f2011-09-06 20:30:53 +00006215 // LHSType so that the resulting expression does not have reference
Douglas Gregor6b754842008-10-28 00:22:11 +00006216 // type.
Richard Trieude4958f2011-09-06 20:30:53 +00006217 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) {
6218 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) {
John McCall8cb679e2010-11-15 09:13:47 +00006219 Kind = CK_LValueBitCast;
Anders Carlsson24ebce62007-10-12 23:56:29 +00006220 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006221 }
Chris Lattnera52c2f22008-01-04 23:18:45 +00006222 return Incompatible;
Fariborz Jahaniana1e34202007-12-19 17:45:58 +00006223 }
John McCalle5255932011-01-31 22:28:28 +00006224
Nate Begemanbd956c42009-06-28 02:36:38 +00006225 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
6226 // to the same ExtVector type.
Richard Trieude4958f2011-09-06 20:30:53 +00006227 if (LHSType->isExtVectorType()) {
6228 if (RHSType->isExtVectorType())
John McCall8cb679e2010-11-15 09:13:47 +00006229 return Incompatible;
Richard Trieude4958f2011-09-06 20:30:53 +00006230 if (RHSType->isArithmeticType()) {
John McCall29600e12010-11-16 02:32:08 +00006231 // CK_VectorSplat does T -> vector T, so first cast to the
6232 // element type.
Richard Trieude4958f2011-09-06 20:30:53 +00006233 QualType elType = cast<ExtVectorType>(LHSType)->getElementType();
6234 if (elType != RHSType) {
John McCall9776e432011-10-06 23:25:11 +00006235 Kind = PrepareScalarCast(RHS, elType);
Richard Trieude4958f2011-09-06 20:30:53 +00006236 RHS = ImpCastExprToType(RHS.take(), elType, Kind);
John McCall29600e12010-11-16 02:32:08 +00006237 }
6238 Kind = CK_VectorSplat;
Nate Begemanbd956c42009-06-28 02:36:38 +00006239 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006240 }
Nate Begemanbd956c42009-06-28 02:36:38 +00006241 }
Mike Stump11289f42009-09-09 15:08:12 +00006242
John McCalle5255932011-01-31 22:28:28 +00006243 // Conversions to or from vector type.
Richard Trieude4958f2011-09-06 20:30:53 +00006244 if (LHSType->isVectorType() || RHSType->isVectorType()) {
6245 if (LHSType->isVectorType() && RHSType->isVectorType()) {
Bob Wilson01856f32010-12-02 00:25:15 +00006246 // Allow assignments of an AltiVec vector type to an equivalent GCC
6247 // vector type and vice versa
Richard Trieude4958f2011-09-06 20:30:53 +00006248 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) {
Bob Wilson01856f32010-12-02 00:25:15 +00006249 Kind = CK_BitCast;
6250 return Compatible;
6251 }
6252
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006253 // If we are allowing lax vector conversions, and LHS and RHS are both
6254 // vectors, the total size only needs to be the same. This is a bitcast;
6255 // no bits are changed but the result type is different.
David Blaikiebbafb8a2012-03-11 07:00:24 +00006256 if (getLangOpts().LaxVectorConversions &&
Richard Trieude4958f2011-09-06 20:30:53 +00006257 (Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType))) {
John McCall3065d042010-11-15 10:08:00 +00006258 Kind = CK_BitCast;
Anders Carlssondb5a9b62009-01-30 23:17:46 +00006259 return IncompatibleVectors;
John McCall8cb679e2010-11-15 09:13:47 +00006260 }
Chris Lattner881a2122008-01-04 23:32:24 +00006261 }
6262 return Incompatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00006263 }
Eli Friedman3360d892008-05-30 18:07:22 +00006264
John McCalle5255932011-01-31 22:28:28 +00006265 // Arithmetic conversions.
Richard Trieude4958f2011-09-06 20:30:53 +00006266 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00006267 !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
John McCall9776e432011-10-06 23:25:11 +00006268 Kind = PrepareScalarCast(RHS, LHSType);
Steve Naroff98cf3e92007-06-06 18:38:38 +00006269 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006270 }
Eli Friedman3360d892008-05-30 18:07:22 +00006271
John McCalle5255932011-01-31 22:28:28 +00006272 // Conversions to normal pointers.
Richard Trieude4958f2011-09-06 20:30:53 +00006273 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
John McCalle5255932011-01-31 22:28:28 +00006274 // U* -> T*
Richard Trieude4958f2011-09-06 20:30:53 +00006275 if (isa<PointerType>(RHSType)) {
John McCall8cb679e2010-11-15 09:13:47 +00006276 Kind = CK_BitCast;
Richard Trieude4958f2011-09-06 20:30:53 +00006277 return checkPointerTypesForAssignment(*this, LHSType, RHSType);
John McCall8cb679e2010-11-15 09:13:47 +00006278 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006279
John McCalle5255932011-01-31 22:28:28 +00006280 // int -> T*
Richard Trieude4958f2011-09-06 20:30:53 +00006281 if (RHSType->isIntegerType()) {
John McCalle5255932011-01-31 22:28:28 +00006282 Kind = CK_IntegralToPointer; // FIXME: null?
6283 return IntToPointer;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006284 }
John McCalle5255932011-01-31 22:28:28 +00006285
6286 // C pointers are not compatible with ObjC object pointers,
6287 // with two exceptions:
Richard Trieude4958f2011-09-06 20:30:53 +00006288 if (isa<ObjCObjectPointerType>(RHSType)) {
John McCalle5255932011-01-31 22:28:28 +00006289 // - conversions to void*
Richard Trieude4958f2011-09-06 20:30:53 +00006290 if (LHSPointer->getPointeeType()->isVoidType()) {
John McCall9320b872011-09-09 05:25:32 +00006291 Kind = CK_BitCast;
John McCalle5255932011-01-31 22:28:28 +00006292 return Compatible;
6293 }
6294
6295 // - conversions from 'Class' to the redefinition type
Richard Trieude4958f2011-09-06 20:30:53 +00006296 if (RHSType->isObjCClassType() &&
6297 Context.hasSameType(LHSType,
Douglas Gregor97673472011-08-11 20:58:55 +00006298 Context.getObjCClassRedefinitionType())) {
John McCall8cb679e2010-11-15 09:13:47 +00006299 Kind = CK_BitCast;
Douglas Gregore7dd1452008-11-27 00:44:28 +00006300 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006301 }
Douglas Gregor486b74e2011-09-27 16:10:05 +00006302
John McCalle5255932011-01-31 22:28:28 +00006303 Kind = CK_BitCast;
6304 return IncompatiblePointer;
6305 }
6306
6307 // U^ -> void*
Richard Trieude4958f2011-09-06 20:30:53 +00006308 if (RHSType->getAs<BlockPointerType>()) {
6309 if (LHSPointer->getPointeeType()->isVoidType()) {
John McCalle5255932011-01-31 22:28:28 +00006310 Kind = CK_BitCast;
Steve Naroff32d072c2008-09-29 18:10:17 +00006311 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006312 }
Steve Naroff32d072c2008-09-29 18:10:17 +00006313 }
John McCalle5255932011-01-31 22:28:28 +00006314
Steve Naroff081c7422008-09-04 15:10:53 +00006315 return Incompatible;
6316 }
6317
John McCalle5255932011-01-31 22:28:28 +00006318 // Conversions to block pointers.
Richard Trieude4958f2011-09-06 20:30:53 +00006319 if (isa<BlockPointerType>(LHSType)) {
John McCalle5255932011-01-31 22:28:28 +00006320 // U^ -> T^
Richard Trieude4958f2011-09-06 20:30:53 +00006321 if (RHSType->isBlockPointerType()) {
John McCall9320b872011-09-09 05:25:32 +00006322 Kind = CK_BitCast;
Richard Trieude4958f2011-09-06 20:30:53 +00006323 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType);
John McCalle5255932011-01-31 22:28:28 +00006324 }
6325
6326 // int or null -> T^
Richard Trieude4958f2011-09-06 20:30:53 +00006327 if (RHSType->isIntegerType()) {
John McCall8cb679e2010-11-15 09:13:47 +00006328 Kind = CK_IntegralToPointer; // FIXME: null
Eli Friedman8163b7a2009-02-25 04:20:42 +00006329 return IntToBlockPointer;
John McCall8cb679e2010-11-15 09:13:47 +00006330 }
6331
John McCalle5255932011-01-31 22:28:28 +00006332 // id -> T^
David Blaikiebbafb8a2012-03-11 07:00:24 +00006333 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) {
John McCalle5255932011-01-31 22:28:28 +00006334 Kind = CK_AnyPointerToBlockPointerCast;
Steve Naroff32d072c2008-09-29 18:10:17 +00006335 return Compatible;
John McCalle5255932011-01-31 22:28:28 +00006336 }
Steve Naroff32d072c2008-09-29 18:10:17 +00006337
John McCalle5255932011-01-31 22:28:28 +00006338 // void* -> T^
Richard Trieude4958f2011-09-06 20:30:53 +00006339 if (const PointerType *RHSPT = RHSType->getAs<PointerType>())
John McCalle5255932011-01-31 22:28:28 +00006340 if (RHSPT->getPointeeType()->isVoidType()) {
6341 Kind = CK_AnyPointerToBlockPointerCast;
Douglas Gregore7dd1452008-11-27 00:44:28 +00006342 return Compatible;
John McCalle5255932011-01-31 22:28:28 +00006343 }
John McCall8cb679e2010-11-15 09:13:47 +00006344
Chris Lattnera52c2f22008-01-04 23:18:45 +00006345 return Incompatible;
6346 }
6347
John McCalle5255932011-01-31 22:28:28 +00006348 // Conversions to Objective-C pointers.
Richard Trieude4958f2011-09-06 20:30:53 +00006349 if (isa<ObjCObjectPointerType>(LHSType)) {
John McCalle5255932011-01-31 22:28:28 +00006350 // A* -> B*
Richard Trieude4958f2011-09-06 20:30:53 +00006351 if (RHSType->isObjCObjectPointerType()) {
John McCalle5255932011-01-31 22:28:28 +00006352 Kind = CK_BitCast;
Fariborz Jahanian6f472e82011-07-07 18:55:47 +00006353 Sema::AssignConvertType result =
Richard Trieude4958f2011-09-06 20:30:53 +00006354 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType);
David Blaikiebbafb8a2012-03-11 07:00:24 +00006355 if (getLangOpts().ObjCAutoRefCount &&
Fariborz Jahanian6f472e82011-07-07 18:55:47 +00006356 result == Compatible &&
Richard Trieude4958f2011-09-06 20:30:53 +00006357 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType))
Fariborz Jahanian7fcce682011-07-07 23:04:17 +00006358 result = IncompatibleObjCWeakRef;
Fariborz Jahanian6f472e82011-07-07 18:55:47 +00006359 return result;
John McCalle5255932011-01-31 22:28:28 +00006360 }
6361
6362 // int or null -> A*
Richard Trieude4958f2011-09-06 20:30:53 +00006363 if (RHSType->isIntegerType()) {
John McCall8cb679e2010-11-15 09:13:47 +00006364 Kind = CK_IntegralToPointer; // FIXME: null
Steve Naroff7cae42b2009-07-10 23:34:53 +00006365 return IntToPointer;
John McCall8cb679e2010-11-15 09:13:47 +00006366 }
6367
John McCalle5255932011-01-31 22:28:28 +00006368 // In general, C pointers are not compatible with ObjC object pointers,
6369 // with two exceptions:
Richard Trieude4958f2011-09-06 20:30:53 +00006370 if (isa<PointerType>(RHSType)) {
John McCall9320b872011-09-09 05:25:32 +00006371 Kind = CK_CPointerToObjCPointerCast;
6372
John McCalle5255932011-01-31 22:28:28 +00006373 // - conversions from 'void*'
Richard Trieude4958f2011-09-06 20:30:53 +00006374 if (RHSType->isVoidPointerType()) {
Steve Naroffaccc4882009-07-20 17:56:53 +00006375 return Compatible;
John McCalle5255932011-01-31 22:28:28 +00006376 }
6377
6378 // - conversions to 'Class' from its redefinition type
Richard Trieude4958f2011-09-06 20:30:53 +00006379 if (LHSType->isObjCClassType() &&
6380 Context.hasSameType(RHSType,
Douglas Gregor97673472011-08-11 20:58:55 +00006381 Context.getObjCClassRedefinitionType())) {
John McCalle5255932011-01-31 22:28:28 +00006382 return Compatible;
6383 }
6384
Steve Naroffaccc4882009-07-20 17:56:53 +00006385 return IncompatiblePointer;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006386 }
John McCalle5255932011-01-31 22:28:28 +00006387
6388 // T^ -> A*
Richard Trieude4958f2011-09-06 20:30:53 +00006389 if (RHSType->isBlockPointerType()) {
John McCallcd78e802011-09-10 01:16:55 +00006390 maybeExtendBlockObject(*this, RHS);
John McCall9320b872011-09-09 05:25:32 +00006391 Kind = CK_BlockPointerToObjCPointerCast;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006392 return Compatible;
John McCalle5255932011-01-31 22:28:28 +00006393 }
6394
Steve Naroff7cae42b2009-07-10 23:34:53 +00006395 return Incompatible;
6396 }
John McCalle5255932011-01-31 22:28:28 +00006397
6398 // Conversions from pointers that are not covered by the above.
Richard Trieude4958f2011-09-06 20:30:53 +00006399 if (isa<PointerType>(RHSType)) {
John McCalle5255932011-01-31 22:28:28 +00006400 // T* -> _Bool
Richard Trieude4958f2011-09-06 20:30:53 +00006401 if (LHSType == Context.BoolTy) {
John McCall8cb679e2010-11-15 09:13:47 +00006402 Kind = CK_PointerToBoolean;
Eli Friedman3360d892008-05-30 18:07:22 +00006403 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006404 }
Eli Friedman3360d892008-05-30 18:07:22 +00006405
John McCalle5255932011-01-31 22:28:28 +00006406 // T* -> int
Richard Trieude4958f2011-09-06 20:30:53 +00006407 if (LHSType->isIntegerType()) {
John McCall8cb679e2010-11-15 09:13:47 +00006408 Kind = CK_PointerToIntegral;
Chris Lattner940cfeb2008-01-04 18:22:42 +00006409 return PointerToInt;
John McCall8cb679e2010-11-15 09:13:47 +00006410 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006411
Chris Lattnera52c2f22008-01-04 23:18:45 +00006412 return Incompatible;
Chris Lattnera52c2f22008-01-04 23:18:45 +00006413 }
John McCalle5255932011-01-31 22:28:28 +00006414
6415 // Conversions from Objective-C pointers that are not covered by the above.
Richard Trieude4958f2011-09-06 20:30:53 +00006416 if (isa<ObjCObjectPointerType>(RHSType)) {
John McCalle5255932011-01-31 22:28:28 +00006417 // T* -> _Bool
Richard Trieude4958f2011-09-06 20:30:53 +00006418 if (LHSType == Context.BoolTy) {
John McCall8cb679e2010-11-15 09:13:47 +00006419 Kind = CK_PointerToBoolean;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006420 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006421 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00006422
John McCalle5255932011-01-31 22:28:28 +00006423 // T* -> int
Richard Trieude4958f2011-09-06 20:30:53 +00006424 if (LHSType->isIntegerType()) {
John McCall8cb679e2010-11-15 09:13:47 +00006425 Kind = CK_PointerToIntegral;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006426 return PointerToInt;
John McCall8cb679e2010-11-15 09:13:47 +00006427 }
6428
Steve Naroff7cae42b2009-07-10 23:34:53 +00006429 return Incompatible;
6430 }
Eli Friedman3360d892008-05-30 18:07:22 +00006431
John McCalle5255932011-01-31 22:28:28 +00006432 // struct A -> struct B
Richard Trieude4958f2011-09-06 20:30:53 +00006433 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) {
6434 if (Context.typesAreCompatible(LHSType, RHSType)) {
John McCall8cb679e2010-11-15 09:13:47 +00006435 Kind = CK_NoOp;
Steve Naroff98cf3e92007-06-06 18:38:38 +00006436 return Compatible;
John McCall8cb679e2010-11-15 09:13:47 +00006437 }
Bill Wendling216423b2007-05-30 06:30:29 +00006438 }
John McCalle5255932011-01-31 22:28:28 +00006439
Steve Naroff98cf3e92007-06-06 18:38:38 +00006440 return Incompatible;
Steve Naroff9eb24652007-05-02 21:58:15 +00006441}
6442
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006443/// \brief Constructs a transparent union from an expression that is
6444/// used to initialize the transparent union.
Richard Trieucfc491d2011-08-02 04:35:43 +00006445static void ConstructTransparentUnion(Sema &S, ASTContext &C,
6446 ExprResult &EResult, QualType UnionType,
6447 FieldDecl *Field) {
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006448 // Build an initializer list that designates the appropriate member
6449 // of the transparent union.
John Wiegley01296292011-04-08 18:41:53 +00006450 Expr *E = EResult.take();
Ted Kremenekac034612010-04-13 23:39:13 +00006451 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(),
Benjamin Kramerc215e762012-08-24 11:54:20 +00006452 E, SourceLocation());
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006453 Initializer->setType(UnionType);
6454 Initializer->setInitializedFieldInUnion(Field);
6455
6456 // Build a compound literal constructing a value of the transparent
6457 // union type from this initializer list.
John McCalle15bbff2010-01-18 19:35:47 +00006458 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType);
John Wiegley01296292011-04-08 18:41:53 +00006459 EResult = S.Owned(
6460 new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType,
6461 VK_RValue, Initializer, false));
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006462}
6463
6464Sema::AssignConvertType
Richard Trieucfc491d2011-08-02 04:35:43 +00006465Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType,
Richard Trieueb299142011-09-06 20:40:12 +00006466 ExprResult &RHS) {
6467 QualType RHSType = RHS.get()->getType();
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006468
Mike Stump11289f42009-09-09 15:08:12 +00006469 // If the ArgType is a Union type, we want to handle a potential
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006470 // transparent_union GCC extension.
6471 const RecordType *UT = ArgType->getAsUnionType();
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00006472 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006473 return Incompatible;
6474
6475 // The field to initialize within the transparent union.
6476 RecordDecl *UD = UT->getDecl();
6477 FieldDecl *InitField = 0;
6478 // It's compatible if the expression matches any of the fields.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00006479 for (RecordDecl::field_iterator it = UD->field_begin(),
6480 itend = UD->field_end();
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006481 it != itend; ++it) {
6482 if (it->getType()->isPointerType()) {
6483 // If the transparent union contains a pointer type, we allow:
6484 // 1) void pointer
6485 // 2) null pointer constant
Richard Trieueb299142011-09-06 20:40:12 +00006486 if (RHSType->isPointerType())
John McCall9320b872011-09-09 05:25:32 +00006487 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
Richard Trieueb299142011-09-06 20:40:12 +00006488 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast);
David Blaikie40ed2972012-06-06 20:45:41 +00006489 InitField = *it;
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006490 break;
6491 }
Mike Stump11289f42009-09-09 15:08:12 +00006492
Richard Trieueb299142011-09-06 20:40:12 +00006493 if (RHS.get()->isNullPointerConstant(Context,
6494 Expr::NPC_ValueDependentIsNull)) {
6495 RHS = ImpCastExprToType(RHS.take(), it->getType(),
6496 CK_NullToPointer);
David Blaikie40ed2972012-06-06 20:45:41 +00006497 InitField = *it;
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006498 break;
6499 }
6500 }
6501
John McCall8cb679e2010-11-15 09:13:47 +00006502 CastKind Kind = CK_Invalid;
Richard Trieueb299142011-09-06 20:40:12 +00006503 if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006504 == Compatible) {
Richard Trieueb299142011-09-06 20:40:12 +00006505 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind);
David Blaikie40ed2972012-06-06 20:45:41 +00006506 InitField = *it;
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006507 break;
6508 }
6509 }
6510
6511 if (!InitField)
6512 return Incompatible;
6513
Richard Trieueb299142011-09-06 20:40:12 +00006514 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField);
Douglas Gregor0cfbdab2009-04-29 22:16:16 +00006515 return Compatible;
6516}
6517
Chris Lattner9bad62c2008-01-04 18:04:52 +00006518Sema::AssignConvertType
Sebastian Redlb49c46c2011-09-24 17:48:00 +00006519Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS,
Fariborz Jahanian25eef192013-07-31 21:40:51 +00006520 bool Diagnose,
6521 bool DiagnoseCFAudited) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006522 if (getLangOpts().CPlusPlus) {
Eli Friedman0dfb8892011-10-06 23:00:33 +00006523 if (!LHSType->isRecordType() && !LHSType->isAtomicType()) {
Douglas Gregor9a657932008-10-21 23:43:52 +00006524 // C++ 5.17p3: If the left operand is not of class type, the
6525 // expression is implicitly converted (C++ 4) to the
6526 // cv-unqualified type of the left operand.
Sebastian Redlcc152642011-10-16 18:19:06 +00006527 ExprResult Res;
6528 if (Diagnose) {
6529 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
6530 AA_Assigning);
6531 } else {
6532 ImplicitConversionSequence ICS =
6533 TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
6534 /*SuppressUserConversions=*/false,
6535 /*AllowExplicit=*/false,
6536 /*InOverloadResolution=*/false,
6537 /*CStyle=*/false,
6538 /*AllowObjCWritebackConversion=*/false);
6539 if (ICS.isFailure())
6540 return Incompatible;
6541 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
6542 ICS, AA_Assigning);
6543 }
John Wiegley01296292011-04-08 18:41:53 +00006544 if (Res.isInvalid())
Douglas Gregor9a657932008-10-21 23:43:52 +00006545 return Incompatible;
Fariborz Jahanian7fcce682011-07-07 23:04:17 +00006546 Sema::AssignConvertType result = Compatible;
David Blaikiebbafb8a2012-03-11 07:00:24 +00006547 if (getLangOpts().ObjCAutoRefCount &&
Richard Trieueb299142011-09-06 20:40:12 +00006548 !CheckObjCARCUnavailableWeakConversion(LHSType,
6549 RHS.get()->getType()))
Fariborz Jahanian7fcce682011-07-07 23:04:17 +00006550 result = IncompatibleObjCWeakRef;
Benjamin Kramer62b95d82012-08-23 21:35:17 +00006551 RHS = Res;
Fariborz Jahanian7fcce682011-07-07 23:04:17 +00006552 return result;
Douglas Gregor9a657932008-10-21 23:43:52 +00006553 }
6554
6555 // FIXME: Currently, we fall through and treat C++ classes like C
6556 // structures.
Eli Friedman0dfb8892011-10-06 23:00:33 +00006557 // FIXME: We also fall through for atomics; not sure what should
6558 // happen there, though.
Sebastian Redlb49c46c2011-09-24 17:48:00 +00006559 }
Douglas Gregor9a657932008-10-21 23:43:52 +00006560
Steve Naroff0ee0b0a2007-11-27 17:58:44 +00006561 // C99 6.5.16.1p1: the left operand is a pointer and the right is
6562 // a null pointer constant.
Richard Smithe934d7c2013-11-21 01:53:02 +00006563 if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() ||
6564 LHSType->isBlockPointerType()) &&
6565 RHS.get()->isNullPointerConstant(Context,
6566 Expr::NPC_ValueDependentIsNull)) {
6567 CastKind Kind;
6568 CXXCastPath Path;
6569 CheckPointerConversion(RHS.get(), LHSType, Kind, Path, false);
6570 RHS = ImpCastExprToType(RHS.take(), LHSType, Kind, VK_RValue, &Path);
Steve Naroff0ee0b0a2007-11-27 17:58:44 +00006571 return Compatible;
6572 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00006573
Chris Lattnere6dcd502007-10-16 02:55:40 +00006574 // This check seems unnatural, however it is necessary to ensure the proper
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00006575 // conversion of functions/arrays. If the conversion were done for all
Douglas Gregora121b752009-11-03 16:56:39 +00006576 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
Nick Lewyckyef7c0ff2010-08-05 06:27:49 +00006577 // expressions that suppress this implicit conversion (&, sizeof).
Chris Lattnere6dcd502007-10-16 02:55:40 +00006578 //
Mike Stump4e1f26a2009-02-19 03:04:26 +00006579 // Suppress this for references: C++ 8.5.3p5.
Richard Trieueb299142011-09-06 20:40:12 +00006580 if (!LHSType->isReferenceType()) {
6581 RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
6582 if (RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00006583 return Incompatible;
6584 }
Steve Naroff0c1c7ed2007-08-24 22:33:52 +00006585
John McCall8cb679e2010-11-15 09:13:47 +00006586 CastKind Kind = CK_Invalid;
Chris Lattner9bad62c2008-01-04 18:04:52 +00006587 Sema::AssignConvertType result =
Richard Trieueb299142011-09-06 20:40:12 +00006588 CheckAssignmentConstraints(LHSType, RHS, Kind);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006589
Steve Naroff0c1c7ed2007-08-24 22:33:52 +00006590 // C99 6.5.16.1p2: The value of the right operand is converted to the
6591 // type of the assignment expression.
Douglas Gregor6b754842008-10-28 00:22:11 +00006592 // CheckAssignmentConstraints allows the left-hand side to be a reference,
6593 // so that we can use references in built-in functions even in C.
6594 // The getNonReferenceType() call makes sure that the resulting expression
6595 // does not have reference type.
Fariborz Jahanian374089e2013-07-31 17:12:26 +00006596 if (result != Incompatible && RHS.get()->getType() != LHSType) {
6597 QualType Ty = LHSType.getNonLValueExprType(Context);
6598 Expr *E = RHS.take();
6599 if (getLangOpts().ObjCAutoRefCount)
Fariborz Jahanian25eef192013-07-31 21:40:51 +00006600 CheckObjCARCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion,
6601 DiagnoseCFAudited);
Fariborz Jahanian381edf52013-12-16 22:54:37 +00006602 if (getLangOpts().ObjC1 &&
Fariborz Jahanian283bf892013-12-18 21:04:43 +00006603 (CheckObjCBridgeRelatedConversions(E->getLocStart(),
6604 LHSType, E->getType(), E) ||
6605 ConversionToObjCStringLiteralCheck(LHSType, E))) {
Fariborz Jahanian381edf52013-12-16 22:54:37 +00006606 RHS = Owned(E);
6607 return Compatible;
6608 }
6609
Fariborz Jahanian374089e2013-07-31 17:12:26 +00006610 RHS = ImpCastExprToType(E, Ty, Kind);
6611 }
Steve Naroff0c1c7ed2007-08-24 22:33:52 +00006612 return result;
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00006613}
6614
Richard Trieueb299142011-09-06 20:40:12 +00006615QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS,
6616 ExprResult &RHS) {
Chris Lattner377d1f82008-11-18 22:52:51 +00006617 Diag(Loc, diag::err_typecheck_invalid_operands)
Richard Trieueb299142011-09-06 20:40:12 +00006618 << LHS.get()->getType() << RHS.get()->getType()
6619 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Chris Lattner5c11c412007-12-12 05:47:28 +00006620 return QualType();
Steve Naroff6f49f5d2007-05-29 14:23:36 +00006621}
6622
Richard Trieu859d23f2011-09-06 21:01:04 +00006623QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
Richard Trieuba63ce62011-09-09 01:45:06 +00006624 SourceLocation Loc, bool IsCompAssign) {
Richard Smith508ebf32011-10-28 03:31:48 +00006625 if (!IsCompAssign) {
6626 LHS = DefaultFunctionArrayLvalueConversion(LHS.take());
6627 if (LHS.isInvalid())
6628 return QualType();
6629 }
6630 RHS = DefaultFunctionArrayLvalueConversion(RHS.take());
6631 if (RHS.isInvalid())
6632 return QualType();
6633
Mike Stump4e1f26a2009-02-19 03:04:26 +00006634 // For conversion purposes, we ignore any qualifiers.
Nate Begeman002e4bd2008-04-04 01:30:25 +00006635 // For example, "const float" and "float" are equivalent.
Richard Trieu859d23f2011-09-06 21:01:04 +00006636 QualType LHSType =
6637 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
6638 QualType RHSType =
6639 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006640
Nate Begeman191a6b12008-07-14 18:02:46 +00006641 // If the vector types are identical, return.
Richard Trieu859d23f2011-09-06 21:01:04 +00006642 if (LHSType == RHSType)
6643 return LHSType;
Nate Begeman330aaa72007-12-30 02:59:45 +00006644
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006645 // Handle the case of equivalent AltiVec and GCC vector types
Richard Trieu859d23f2011-09-06 21:01:04 +00006646 if (LHSType->isVectorType() && RHSType->isVectorType() &&
6647 Context.areCompatibleVectorTypes(LHSType, RHSType)) {
6648 if (LHSType->isExtVectorType()) {
6649 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast);
6650 return LHSType;
Eli Friedman1408bc92011-06-23 18:10:35 +00006651 }
6652
Richard Trieuba63ce62011-09-09 01:45:06 +00006653 if (!IsCompAssign)
Richard Trieu859d23f2011-09-06 21:01:04 +00006654 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
6655 return RHSType;
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006656 }
6657
David Blaikiebbafb8a2012-03-11 07:00:24 +00006658 if (getLangOpts().LaxVectorConversions &&
Richard Trieu859d23f2011-09-06 21:01:04 +00006659 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) {
Eli Friedman1408bc92011-06-23 18:10:35 +00006660 // If we are allowing lax vector conversions, and LHS and RHS are both
6661 // vectors, the total size only needs to be the same. This is a
6662 // bitcast; no bits are changed but the result type is different.
6663 // FIXME: Should we really be allowing this?
Richard Trieu859d23f2011-09-06 21:01:04 +00006664 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast);
6665 return LHSType;
Eli Friedman1408bc92011-06-23 18:10:35 +00006666 }
6667
Nate Begemanbd956c42009-06-28 02:36:38 +00006668 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can
6669 // swap back (so that we don't reverse the inputs to a subtract, for instance.
6670 bool swapped = false;
Richard Trieuba63ce62011-09-09 01:45:06 +00006671 if (RHSType->isExtVectorType() && !IsCompAssign) {
Nate Begemanbd956c42009-06-28 02:36:38 +00006672 swapped = true;
Richard Trieu859d23f2011-09-06 21:01:04 +00006673 std::swap(RHS, LHS);
6674 std::swap(RHSType, LHSType);
Nate Begemanbd956c42009-06-28 02:36:38 +00006675 }
Mike Stump11289f42009-09-09 15:08:12 +00006676
Nate Begeman886448d2009-06-28 19:12:57 +00006677 // Handle the case of an ext vector and scalar.
Richard Trieu859d23f2011-09-06 21:01:04 +00006678 if (const ExtVectorType *LV = LHSType->getAs<ExtVectorType>()) {
Nate Begemanbd956c42009-06-28 02:36:38 +00006679 QualType EltTy = LV->getElementType();
Richard Trieu859d23f2011-09-06 21:01:04 +00006680 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) {
6681 int order = Context.getIntegerTypeOrder(EltTy, RHSType);
John McCall8cb679e2010-11-15 09:13:47 +00006682 if (order > 0)
Richard Trieu859d23f2011-09-06 21:01:04 +00006683 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_IntegralCast);
John McCall8cb679e2010-11-15 09:13:47 +00006684 if (order >= 0) {
Richard Trieu859d23f2011-09-06 21:01:04 +00006685 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat);
6686 if (swapped) std::swap(RHS, LHS);
6687 return LHSType;
Nate Begemanbd956c42009-06-28 02:36:38 +00006688 }
6689 }
Jin-Gu Kang0b5ca602013-06-08 02:15:36 +00006690 if (EltTy->isRealFloatingType() && RHSType->isScalarType()) {
6691 if (RHSType->isRealFloatingType()) {
6692 int order = Context.getFloatingTypeOrder(EltTy, RHSType);
6693 if (order > 0)
6694 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_FloatingCast);
6695 if (order >= 0) {
6696 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat);
6697 if (swapped) std::swap(RHS, LHS);
6698 return LHSType;
6699 }
6700 }
6701 if (RHSType->isIntegralType(Context)) {
6702 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_IntegralToFloating);
Richard Trieu859d23f2011-09-06 21:01:04 +00006703 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat);
6704 if (swapped) std::swap(RHS, LHS);
6705 return LHSType;
Nate Begemanbd956c42009-06-28 02:36:38 +00006706 }
Nate Begeman330aaa72007-12-30 02:59:45 +00006707 }
6708 }
Mike Stump11289f42009-09-09 15:08:12 +00006709
Nate Begeman886448d2009-06-28 19:12:57 +00006710 // Vectors of different size or scalar and non-ext-vector are errors.
Richard Trieu859d23f2011-09-06 21:01:04 +00006711 if (swapped) std::swap(RHS, LHS);
Chris Lattner377d1f82008-11-18 22:52:51 +00006712 Diag(Loc, diag::err_typecheck_vector_not_convertable)
Richard Trieu859d23f2011-09-06 21:01:04 +00006713 << LHS.get()->getType() << RHS.get()->getType()
6714 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Steve Naroff84ff4b42007-07-09 21:31:10 +00006715 return QualType();
Sebastian Redl112a97662009-02-07 00:15:38 +00006716}
6717
Richard Trieuf8916e12011-09-16 00:53:10 +00006718// checkArithmeticNull - Detect when a NULL constant is used improperly in an
6719// expression. These are mainly cases where the null pointer is used as an
6720// integer instead of a pointer.
6721static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS,
6722 SourceLocation Loc, bool IsCompare) {
6723 // The canonical way to check for a GNU null is with isNullPointerConstant,
6724 // but we use a bit of a hack here for speed; this is a relatively
6725 // hot path, and isNullPointerConstant is slow.
6726 bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts());
6727 bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts());
6728
6729 QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType();
6730
6731 // Avoid analyzing cases where the result will either be invalid (and
6732 // diagnosed as such) or entirely valid and not something to warn about.
6733 if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() ||
6734 NonNullType->isMemberPointerType() || NonNullType->isFunctionType())
6735 return;
6736
6737 // Comparison operations would not make sense with a null pointer no matter
6738 // what the other expression is.
6739 if (!IsCompare) {
6740 S.Diag(Loc, diag::warn_null_in_arithmetic_operation)
6741 << (LHSNull ? LHS.get()->getSourceRange() : SourceRange())
6742 << (RHSNull ? RHS.get()->getSourceRange() : SourceRange());
6743 return;
6744 }
6745
6746 // The rest of the operations only make sense with a null pointer
6747 // if the other expression is a pointer.
6748 if (LHSNull == RHSNull || NonNullType->isAnyPointerType() ||
6749 NonNullType->canDecayToPointerType())
6750 return;
6751
6752 S.Diag(Loc, diag::warn_null_in_comparison_operation)
6753 << LHSNull /* LHS is NULL */ << NonNullType
6754 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
6755}
6756
Richard Trieu859d23f2011-09-06 21:01:04 +00006757QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
Richard Trieucfc491d2011-08-02 04:35:43 +00006758 SourceLocation Loc,
Richard Trieuba63ce62011-09-09 01:45:06 +00006759 bool IsCompAssign, bool IsDiv) {
Richard Trieuf8916e12011-09-16 00:53:10 +00006760 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
6761
Richard Trieu859d23f2011-09-06 21:01:04 +00006762 if (LHS.get()->getType()->isVectorType() ||
6763 RHS.get()->getType()->isVectorType())
Richard Trieuba63ce62011-09-09 01:45:06 +00006764 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign);
Mike Stump4e1f26a2009-02-19 03:04:26 +00006765
Richard Trieuba63ce62011-09-09 01:45:06 +00006766 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
Richard Trieu859d23f2011-09-06 21:01:04 +00006767 if (LHS.isInvalid() || RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00006768 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006769
David Chisnallfa35df62012-01-16 17:27:18 +00006770
Eli Friedman93ee5ca2012-06-16 02:19:17 +00006771 if (compType.isNull() || !compType->isArithmeticType())
Richard Trieu859d23f2011-09-06 21:01:04 +00006772 return InvalidOperands(Loc, LHS, RHS);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006773
Chris Lattnerfaa54172010-01-12 21:23:57 +00006774 // Check for division by zero.
Chandler Carruthc41c8b32013-06-14 08:57:18 +00006775 llvm::APSInt RHSValue;
6776 if (IsDiv && !RHS.get()->isValueDependent() &&
6777 RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0)
6778 DiagRuntimeBehavior(Loc, RHS.get(),
6779 PDiag(diag::warn_division_by_zero)
6780 << RHS.get()->getSourceRange());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006781
Chris Lattnerfaa54172010-01-12 21:23:57 +00006782 return compType;
Steve Naroff26c8ea52007-03-21 21:08:52 +00006783}
6784
Chris Lattnerfaa54172010-01-12 21:23:57 +00006785QualType Sema::CheckRemainderOperands(
Richard Trieuba63ce62011-09-09 01:45:06 +00006786 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
Richard Trieuf8916e12011-09-16 00:53:10 +00006787 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
6788
Richard Trieu859d23f2011-09-06 21:01:04 +00006789 if (LHS.get()->getType()->isVectorType() ||
6790 RHS.get()->getType()->isVectorType()) {
6791 if (LHS.get()->getType()->hasIntegerRepresentation() &&
6792 RHS.get()->getType()->hasIntegerRepresentation())
Richard Trieuba63ce62011-09-09 01:45:06 +00006793 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign);
Richard Trieu859d23f2011-09-06 21:01:04 +00006794 return InvalidOperands(Loc, LHS, RHS);
Daniel Dunbar0d2bfec2009-01-05 22:55:36 +00006795 }
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00006796
Richard Trieuba63ce62011-09-09 01:45:06 +00006797 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign);
Richard Trieu859d23f2011-09-06 21:01:04 +00006798 if (LHS.isInvalid() || RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00006799 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00006800
Eli Friedman93ee5ca2012-06-16 02:19:17 +00006801 if (compType.isNull() || !compType->isIntegerType())
Richard Trieu859d23f2011-09-06 21:01:04 +00006802 return InvalidOperands(Loc, LHS, RHS);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006803
Chris Lattnerfaa54172010-01-12 21:23:57 +00006804 // Check for remainder by zero.
Chandler Carruthc41c8b32013-06-14 08:57:18 +00006805 llvm::APSInt RHSValue;
6806 if (!RHS.get()->isValueDependent() &&
6807 RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0)
6808 DiagRuntimeBehavior(Loc, RHS.get(),
6809 PDiag(diag::warn_remainder_by_zero)
6810 << RHS.get()->getSourceRange());
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00006811
Chris Lattnerfaa54172010-01-12 21:23:57 +00006812 return compType;
Steve Naroff218bc2b2007-05-04 21:54:46 +00006813}
6814
Chandler Carruthc9332212011-06-27 08:02:19 +00006815/// \brief Diagnose invalid arithmetic on two void pointers.
6816static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc,
Richard Trieu4ae7e972011-09-06 21:13:51 +00006817 Expr *LHSExpr, Expr *RHSExpr) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006818 S.Diag(Loc, S.getLangOpts().CPlusPlus
Chandler Carruthc9332212011-06-27 08:02:19 +00006819 ? diag::err_typecheck_pointer_arith_void_type
6820 : diag::ext_gnu_void_ptr)
Richard Trieu4ae7e972011-09-06 21:13:51 +00006821 << 1 /* two pointers */ << LHSExpr->getSourceRange()
6822 << RHSExpr->getSourceRange();
Chandler Carruthc9332212011-06-27 08:02:19 +00006823}
6824
6825/// \brief Diagnose invalid arithmetic on a void pointer.
6826static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc,
6827 Expr *Pointer) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006828 S.Diag(Loc, S.getLangOpts().CPlusPlus
Chandler Carruthc9332212011-06-27 08:02:19 +00006829 ? diag::err_typecheck_pointer_arith_void_type
6830 : diag::ext_gnu_void_ptr)
6831 << 0 /* one pointer */ << Pointer->getSourceRange();
6832}
6833
6834/// \brief Diagnose invalid arithmetic on two function pointers.
6835static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc,
6836 Expr *LHS, Expr *RHS) {
6837 assert(LHS->getType()->isAnyPointerType());
6838 assert(RHS->getType()->isAnyPointerType());
David Blaikiebbafb8a2012-03-11 07:00:24 +00006839 S.Diag(Loc, S.getLangOpts().CPlusPlus
Chandler Carruthc9332212011-06-27 08:02:19 +00006840 ? diag::err_typecheck_pointer_arith_function_type
6841 : diag::ext_gnu_ptr_func_arith)
6842 << 1 /* two pointers */ << LHS->getType()->getPointeeType()
6843 // We only show the second type if it differs from the first.
6844 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
6845 RHS->getType())
6846 << RHS->getType()->getPointeeType()
6847 << LHS->getSourceRange() << RHS->getSourceRange();
6848}
6849
6850/// \brief Diagnose invalid arithmetic on a function pointer.
6851static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc,
6852 Expr *Pointer) {
6853 assert(Pointer->getType()->isAnyPointerType());
David Blaikiebbafb8a2012-03-11 07:00:24 +00006854 S.Diag(Loc, S.getLangOpts().CPlusPlus
Chandler Carruthc9332212011-06-27 08:02:19 +00006855 ? diag::err_typecheck_pointer_arith_function_type
6856 : diag::ext_gnu_ptr_func_arith)
6857 << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
6858 << 0 /* one pointer, so only one type */
6859 << Pointer->getSourceRange();
6860}
6861
Richard Trieu993f3ab2011-09-12 18:08:02 +00006862/// \brief Emit error if Operand is incomplete pointer type
Richard Trieuaba22802011-09-02 02:15:37 +00006863///
6864/// \returns True if pointer has incomplete type
6865static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc,
6866 Expr *Operand) {
John McCallf2538342012-07-31 05:14:30 +00006867 assert(Operand->getType()->isAnyPointerType() &&
6868 !Operand->getType()->isDependentType());
6869 QualType PointeeTy = Operand->getType()->getPointeeType();
6870 return S.RequireCompleteType(Loc, PointeeTy,
6871 diag::err_typecheck_arithmetic_incomplete_type,
6872 PointeeTy, Operand->getSourceRange());
Richard Trieuaba22802011-09-02 02:15:37 +00006873}
6874
Chandler Carruthc9332212011-06-27 08:02:19 +00006875/// \brief Check the validity of an arithmetic pointer operand.
6876///
6877/// If the operand has pointer type, this code will check for pointer types
6878/// which are invalid in arithmetic operations. These will be diagnosed
6879/// appropriately, including whether or not the use is supported as an
6880/// extension.
6881///
6882/// \returns True when the operand is valid to use (even if as an extension).
6883static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
6884 Expr *Operand) {
6885 if (!Operand->getType()->isAnyPointerType()) return true;
6886
6887 QualType PointeeTy = Operand->getType()->getPointeeType();
6888 if (PointeeTy->isVoidType()) {
6889 diagnoseArithmeticOnVoidPointer(S, Loc, Operand);
David Blaikiebbafb8a2012-03-11 07:00:24 +00006890 return !S.getLangOpts().CPlusPlus;
Chandler Carruthc9332212011-06-27 08:02:19 +00006891 }
6892 if (PointeeTy->isFunctionType()) {
6893 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand);
David Blaikiebbafb8a2012-03-11 07:00:24 +00006894 return !S.getLangOpts().CPlusPlus;
Chandler Carruthc9332212011-06-27 08:02:19 +00006895 }
6896
Richard Trieuaba22802011-09-02 02:15:37 +00006897 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false;
Chandler Carruthc9332212011-06-27 08:02:19 +00006898
6899 return true;
6900}
6901
6902/// \brief Check the validity of a binary arithmetic operation w.r.t. pointer
6903/// operands.
6904///
6905/// This routine will diagnose any invalid arithmetic on pointer operands much
6906/// like \see checkArithmeticOpPointerOperand. However, it has special logic
6907/// for emitting a single diagnostic even for operations where both LHS and RHS
6908/// are (potentially problematic) pointers.
6909///
6910/// \returns True when the operand is valid to use (even if as an extension).
6911static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
Richard Trieu4ae7e972011-09-06 21:13:51 +00006912 Expr *LHSExpr, Expr *RHSExpr) {
6913 bool isLHSPointer = LHSExpr->getType()->isAnyPointerType();
6914 bool isRHSPointer = RHSExpr->getType()->isAnyPointerType();
Chandler Carruthc9332212011-06-27 08:02:19 +00006915 if (!isLHSPointer && !isRHSPointer) return true;
6916
6917 QualType LHSPointeeTy, RHSPointeeTy;
Richard Trieu4ae7e972011-09-06 21:13:51 +00006918 if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
6919 if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
Chandler Carruthc9332212011-06-27 08:02:19 +00006920
6921 // Check for arithmetic on pointers to incomplete types.
6922 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType();
6923 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType();
6924 if (isLHSVoidPtr || isRHSVoidPtr) {
Richard Trieu4ae7e972011-09-06 21:13:51 +00006925 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
6926 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
6927 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
Chandler Carruthc9332212011-06-27 08:02:19 +00006928
David Blaikiebbafb8a2012-03-11 07:00:24 +00006929 return !S.getLangOpts().CPlusPlus;
Chandler Carruthc9332212011-06-27 08:02:19 +00006930 }
6931
6932 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType();
6933 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType();
6934 if (isLHSFuncPtr || isRHSFuncPtr) {
Richard Trieu4ae7e972011-09-06 21:13:51 +00006935 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
6936 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
6937 RHSExpr);
6938 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
Chandler Carruthc9332212011-06-27 08:02:19 +00006939
David Blaikiebbafb8a2012-03-11 07:00:24 +00006940 return !S.getLangOpts().CPlusPlus;
Chandler Carruthc9332212011-06-27 08:02:19 +00006941 }
6942
John McCallf2538342012-07-31 05:14:30 +00006943 if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr))
6944 return false;
6945 if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr))
6946 return false;
Richard Trieuaba22802011-09-02 02:15:37 +00006947
Chandler Carruthc9332212011-06-27 08:02:19 +00006948 return true;
6949}
6950
Nico Weberccec40d2012-03-02 22:01:22 +00006951/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
6952/// literal.
6953static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
6954 Expr *LHSExpr, Expr *RHSExpr) {
6955 StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
6956 Expr* IndexExpr = RHSExpr;
6957 if (!StrExpr) {
6958 StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts());
6959 IndexExpr = LHSExpr;
6960 }
6961
6962 bool IsStringPlusInt = StrExpr &&
6963 IndexExpr->getType()->isIntegralOrUnscopedEnumerationType();
6964 if (!IsStringPlusInt)
6965 return;
6966
6967 llvm::APSInt index;
6968 if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) {
6969 unsigned StrLenWithNull = StrExpr->getLength() + 1;
6970 if (index.isNonNegative() &&
6971 index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull),
6972 index.isUnsigned()))
6973 return;
6974 }
6975
6976 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
6977 Self.Diag(OpLoc, diag::warn_string_plus_int)
6978 << DiagRange << IndexExpr->IgnoreImpCasts()->getType();
6979
6980 // Only print a fixit for "str" + int, not for int + "str".
6981 if (IndexExpr == RHSExpr) {
6982 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd());
Jordan Rose55659412013-10-25 16:52:00 +00006983 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
Nico Weberccec40d2012-03-02 22:01:22 +00006984 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&")
6985 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[")
6986 << FixItHint::CreateInsertion(EndLoc, "]");
6987 } else
Jordan Rose55659412013-10-25 16:52:00 +00006988 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
6989}
6990
6991/// \brief Emit a warning when adding a char literal to a string.
6992static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
6993 Expr *LHSExpr, Expr *RHSExpr) {
6994 const DeclRefExpr *StringRefExpr =
6995 dyn_cast<DeclRefExpr>(LHSExpr->IgnoreImpCasts());
6996 const CharacterLiteral *CharExpr =
6997 dyn_cast<CharacterLiteral>(RHSExpr->IgnoreImpCasts());
6998 if (!StringRefExpr) {
6999 StringRefExpr = dyn_cast<DeclRefExpr>(RHSExpr->IgnoreImpCasts());
7000 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->IgnoreImpCasts());
7001 }
7002
7003 if (!CharExpr || !StringRefExpr)
7004 return;
7005
7006 const QualType StringType = StringRefExpr->getType();
7007
7008 // Return if not a PointerType.
7009 if (!StringType->isAnyPointerType())
7010 return;
7011
7012 // Return if not a CharacterType.
7013 if (!StringType->getPointeeType()->isAnyCharacterType())
7014 return;
7015
7016 ASTContext &Ctx = Self.getASTContext();
7017 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd());
7018
7019 const QualType CharType = CharExpr->getType();
7020 if (!CharType->isAnyCharacterType() &&
7021 CharType->isIntegerType() &&
7022 llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
7023 Self.Diag(OpLoc, diag::warn_string_plus_char)
7024 << DiagRange << Ctx.CharTy;
7025 } else {
7026 Self.Diag(OpLoc, diag::warn_string_plus_char)
7027 << DiagRange << CharExpr->getType();
7028 }
7029
7030 // Only print a fixit for str + char, not for char + str.
7031 if (isa<CharacterLiteral>(RHSExpr->IgnoreImpCasts())) {
7032 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd());
7033 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence)
7034 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&")
7035 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[")
7036 << FixItHint::CreateInsertion(EndLoc, "]");
7037 } else {
7038 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence);
7039 }
Nico Weberccec40d2012-03-02 22:01:22 +00007040}
7041
Richard Trieu993f3ab2011-09-12 18:08:02 +00007042/// \brief Emit error when two pointers are incompatible.
Richard Trieub10c6312011-09-01 22:53:23 +00007043static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc,
Richard Trieu4ae7e972011-09-06 21:13:51 +00007044 Expr *LHSExpr, Expr *RHSExpr) {
7045 assert(LHSExpr->getType()->isAnyPointerType());
7046 assert(RHSExpr->getType()->isAnyPointerType());
Richard Trieub10c6312011-09-01 22:53:23 +00007047 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
Richard Trieu4ae7e972011-09-06 21:13:51 +00007048 << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
7049 << RHSExpr->getSourceRange();
Richard Trieub10c6312011-09-01 22:53:23 +00007050}
7051
Chris Lattnerfaa54172010-01-12 21:23:57 +00007052QualType Sema::CheckAdditionOperands( // C99 6.5.6
Nico Weberccec40d2012-03-02 22:01:22 +00007053 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc,
7054 QualType* CompLHSTy) {
Richard Trieuf8916e12011-09-16 00:53:10 +00007055 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7056
Richard Trieu4ae7e972011-09-06 21:13:51 +00007057 if (LHS.get()->getType()->isVectorType() ||
7058 RHS.get()->getType()->isVectorType()) {
7059 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007060 if (CompLHSTy) *CompLHSTy = compType;
7061 return compType;
7062 }
Steve Naroff7a5af782007-07-13 16:58:59 +00007063
Richard Trieu4ae7e972011-09-06 21:13:51 +00007064 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
7065 if (LHS.isInvalid() || RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00007066 return QualType();
Eli Friedman8e122982008-05-18 18:08:51 +00007067
Jordan Rose55659412013-10-25 16:52:00 +00007068 // Diagnose "string literal" '+' int and string '+' "char literal".
7069 if (Opc == BO_Add) {
Nico Weberccec40d2012-03-02 22:01:22 +00007070 diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get());
Jordan Rose55659412013-10-25 16:52:00 +00007071 diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get());
7072 }
Nico Weberccec40d2012-03-02 22:01:22 +00007073
Steve Naroffe4718892007-04-27 18:30:00 +00007074 // handle the common case first (both operands are arithmetic).
Eli Friedman93ee5ca2012-06-16 02:19:17 +00007075 if (!compType.isNull() && compType->isArithmeticType()) {
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007076 if (CompLHSTy) *CompLHSTy = compType;
Steve Naroffbe4c4d12007-08-24 19:07:16 +00007077 return compType;
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007078 }
Steve Naroff218bc2b2007-05-04 21:54:46 +00007079
John McCallf2538342012-07-31 05:14:30 +00007080 // Type-checking. Ultimately the pointer's going to be in PExp;
7081 // note that we bias towards the LHS being the pointer.
7082 Expr *PExp = LHS.get(), *IExp = RHS.get();
Eli Friedman8e122982008-05-18 18:08:51 +00007083
John McCallf2538342012-07-31 05:14:30 +00007084 bool isObjCPointer;
7085 if (PExp->getType()->isPointerType()) {
7086 isObjCPointer = false;
7087 } else if (PExp->getType()->isObjCObjectPointerType()) {
7088 isObjCPointer = true;
7089 } else {
7090 std::swap(PExp, IExp);
7091 if (PExp->getType()->isPointerType()) {
7092 isObjCPointer = false;
7093 } else if (PExp->getType()->isObjCObjectPointerType()) {
7094 isObjCPointer = true;
7095 } else {
7096 return InvalidOperands(Loc, LHS, RHS);
7097 }
7098 }
7099 assert(PExp->getType()->isAnyPointerType());
Chandler Carruthc9332212011-06-27 08:02:19 +00007100
Richard Trieub420bca2011-09-12 18:37:54 +00007101 if (!IExp->getType()->isIntegerType())
7102 return InvalidOperands(Loc, LHS, RHS);
Mike Stump11289f42009-09-09 15:08:12 +00007103
Richard Trieub420bca2011-09-12 18:37:54 +00007104 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp))
7105 return QualType();
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00007106
John McCallf2538342012-07-31 05:14:30 +00007107 if (isObjCPointer && checkArithmeticOnObjCPointer(*this, Loc, PExp))
Richard Trieub420bca2011-09-12 18:37:54 +00007108 return QualType();
7109
7110 // Check array bounds for pointer arithemtic
7111 CheckArrayAccess(PExp, IExp);
7112
7113 if (CompLHSTy) {
7114 QualType LHSTy = Context.isPromotableBitField(LHS.get());
7115 if (LHSTy.isNull()) {
7116 LHSTy = LHS.get()->getType();
7117 if (LHSTy->isPromotableIntegerType())
7118 LHSTy = Context.getPromotedIntegerType(LHSTy);
Eli Friedman8e122982008-05-18 18:08:51 +00007119 }
Richard Trieub420bca2011-09-12 18:37:54 +00007120 *CompLHSTy = LHSTy;
Eli Friedman8e122982008-05-18 18:08:51 +00007121 }
7122
Richard Trieub420bca2011-09-12 18:37:54 +00007123 return PExp->getType();
Steve Naroff26c8ea52007-03-21 21:08:52 +00007124}
7125
Chris Lattner2a3569b2008-04-07 05:30:13 +00007126// C99 6.5.6
Richard Trieu4ae7e972011-09-06 21:13:51 +00007127QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
Richard Trieucfc491d2011-08-02 04:35:43 +00007128 SourceLocation Loc,
7129 QualType* CompLHSTy) {
Richard Trieuf8916e12011-09-16 00:53:10 +00007130 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7131
Richard Trieu4ae7e972011-09-06 21:13:51 +00007132 if (LHS.get()->getType()->isVectorType() ||
7133 RHS.get()->getType()->isVectorType()) {
7134 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007135 if (CompLHSTy) *CompLHSTy = compType;
7136 return compType;
7137 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007138
Richard Trieu4ae7e972011-09-06 21:13:51 +00007139 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy);
7140 if (LHS.isInvalid() || RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00007141 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00007142
Chris Lattner4d62f422007-12-09 21:53:25 +00007143 // Enforce type constraints: C99 6.5.6p3.
Mike Stump4e1f26a2009-02-19 03:04:26 +00007144
Chris Lattner4d62f422007-12-09 21:53:25 +00007145 // Handle the common case first (both operands are arithmetic).
Eli Friedman93ee5ca2012-06-16 02:19:17 +00007146 if (!compType.isNull() && compType->isArithmeticType()) {
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007147 if (CompLHSTy) *CompLHSTy = compType;
Steve Naroffbe4c4d12007-08-24 19:07:16 +00007148 return compType;
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007149 }
Mike Stump11289f42009-09-09 15:08:12 +00007150
Chris Lattner4d62f422007-12-09 21:53:25 +00007151 // Either ptr - int or ptr - ptr.
Richard Trieu4ae7e972011-09-06 21:13:51 +00007152 if (LHS.get()->getType()->isAnyPointerType()) {
7153 QualType lpointee = LHS.get()->getType()->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00007154
Chris Lattner12bdebb2009-04-24 23:50:08 +00007155 // Diagnose bad cases where we step over interface counts.
John McCallf2538342012-07-31 05:14:30 +00007156 if (LHS.get()->getType()->isObjCObjectPointerType() &&
7157 checkArithmeticOnObjCPointer(*this, Loc, LHS.get()))
Chris Lattner12bdebb2009-04-24 23:50:08 +00007158 return QualType();
Mike Stump11289f42009-09-09 15:08:12 +00007159
Chris Lattner4d62f422007-12-09 21:53:25 +00007160 // The result type of a pointer-int computation is the pointer type.
Richard Trieu4ae7e972011-09-06 21:13:51 +00007161 if (RHS.get()->getType()->isIntegerType()) {
7162 if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get()))
Chandler Carruthc9332212011-06-27 08:02:19 +00007163 return QualType();
Douglas Gregorac1fb652009-03-24 19:52:54 +00007164
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00007165 // Check array bounds for pointer arithemtic
Richard Smith13f67182011-12-16 19:31:14 +00007166 CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/0,
7167 /*AllowOnePastEnd*/true, /*IndexNegated*/true);
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00007168
Richard Trieu4ae7e972011-09-06 21:13:51 +00007169 if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
7170 return LHS.get()->getType();
Douglas Gregorac1fb652009-03-24 19:52:54 +00007171 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007172
Chris Lattner4d62f422007-12-09 21:53:25 +00007173 // Handle pointer-pointer subtractions.
Richard Trieucfc491d2011-08-02 04:35:43 +00007174 if (const PointerType *RHSPTy
Richard Trieu4ae7e972011-09-06 21:13:51 +00007175 = RHS.get()->getType()->getAs<PointerType>()) {
Eli Friedman1974e532008-02-08 01:19:44 +00007176 QualType rpointee = RHSPTy->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00007177
David Blaikiebbafb8a2012-03-11 07:00:24 +00007178 if (getLangOpts().CPlusPlus) {
Eli Friedman168fe152009-05-16 13:54:38 +00007179 // Pointee types must be the same: C++ [expr.add]
7180 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) {
Richard Trieu4ae7e972011-09-06 21:13:51 +00007181 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
Eli Friedman168fe152009-05-16 13:54:38 +00007182 }
7183 } else {
7184 // Pointee types must be compatible C99 6.5.6p3
7185 if (!Context.typesAreCompatible(
7186 Context.getCanonicalType(lpointee).getUnqualifiedType(),
7187 Context.getCanonicalType(rpointee).getUnqualifiedType())) {
Richard Trieu4ae7e972011-09-06 21:13:51 +00007188 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get());
Eli Friedman168fe152009-05-16 13:54:38 +00007189 return QualType();
7190 }
Chris Lattner4d62f422007-12-09 21:53:25 +00007191 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007192
Chandler Carruthc9332212011-06-27 08:02:19 +00007193 if (!checkArithmeticBinOpPointerOperands(*this, Loc,
Richard Trieu4ae7e972011-09-06 21:13:51 +00007194 LHS.get(), RHS.get()))
Chandler Carruthc9332212011-06-27 08:02:19 +00007195 return QualType();
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007196
Richard Smith84c6b3d2013-09-10 21:34:14 +00007197 // The pointee type may have zero size. As an extension, a structure or
7198 // union may have zero size or an array may have zero length. In this
7199 // case subtraction does not make sense.
7200 if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
7201 CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
7202 if (ElementSize.isZero()) {
7203 Diag(Loc,diag::warn_sub_ptr_zero_size_types)
7204 << rpointee.getUnqualifiedType()
7205 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
7206 }
7207 }
7208
Richard Trieu4ae7e972011-09-06 21:13:51 +00007209 if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
Chris Lattner4d62f422007-12-09 21:53:25 +00007210 return Context.getPointerDiffType();
7211 }
7212 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007213
Richard Trieu4ae7e972011-09-06 21:13:51 +00007214 return InvalidOperands(Loc, LHS, RHS);
Steve Naroff218bc2b2007-05-04 21:54:46 +00007215}
7216
Douglas Gregor0bf31402010-10-08 23:50:27 +00007217static bool isScopedEnumerationType(QualType T) {
7218 if (const EnumType *ET = dyn_cast<EnumType>(T))
7219 return ET->getDecl()->isScoped();
7220 return false;
7221}
7222
Richard Trieue4a19fb2011-09-06 21:21:28 +00007223static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS,
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007224 SourceLocation Loc, unsigned Opc,
Richard Trieue4a19fb2011-09-06 21:21:28 +00007225 QualType LHSType) {
David Tweed042e0882013-01-07 16:43:27 +00007226 // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined),
7227 // so skip remaining warnings as we don't want to modify values within Sema.
7228 if (S.getLangOpts().OpenCL)
7229 return;
7230
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007231 llvm::APSInt Right;
7232 // Check right/shifter operand
Richard Trieue4a19fb2011-09-06 21:21:28 +00007233 if (RHS.get()->isValueDependent() ||
7234 !RHS.get()->isIntegerConstantExpr(Right, S.Context))
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007235 return;
7236
7237 if (Right.isNegative()) {
Richard Trieue4a19fb2011-09-06 21:21:28 +00007238 S.DiagRuntimeBehavior(Loc, RHS.get(),
Ted Kremenek63657fe2011-03-01 18:09:31 +00007239 S.PDiag(diag::warn_shift_negative)
Richard Trieue4a19fb2011-09-06 21:21:28 +00007240 << RHS.get()->getSourceRange());
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007241 return;
7242 }
7243 llvm::APInt LeftBits(Right.getBitWidth(),
Richard Trieue4a19fb2011-09-06 21:21:28 +00007244 S.Context.getTypeSize(LHS.get()->getType()));
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007245 if (Right.uge(LeftBits)) {
Richard Trieue4a19fb2011-09-06 21:21:28 +00007246 S.DiagRuntimeBehavior(Loc, RHS.get(),
Ted Kremenek26bbc3d2011-03-01 19:13:22 +00007247 S.PDiag(diag::warn_shift_gt_typewidth)
Richard Trieue4a19fb2011-09-06 21:21:28 +00007248 << RHS.get()->getSourceRange());
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007249 return;
7250 }
7251 if (Opc != BO_Shl)
7252 return;
7253
7254 // When left shifting an ICE which is signed, we can check for overflow which
7255 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned
7256 // integers have defined behavior modulo one more than the maximum value
7257 // representable in the result type, so never warn for those.
7258 llvm::APSInt Left;
Richard Trieue4a19fb2011-09-06 21:21:28 +00007259 if (LHS.get()->isValueDependent() ||
7260 !LHS.get()->isIntegerConstantExpr(Left, S.Context) ||
7261 LHSType->hasUnsignedIntegerRepresentation())
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007262 return;
7263 llvm::APInt ResultBits =
7264 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits();
7265 if (LeftBits.uge(ResultBits))
7266 return;
7267 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue());
7268 Result = Result.shl(Right);
7269
Ted Kremenek70f05fd2011-06-15 00:54:52 +00007270 // Print the bit representation of the signed integer as an unsigned
7271 // hexadecimal number.
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00007272 SmallString<40> HexResult;
Ted Kremenek70f05fd2011-06-15 00:54:52 +00007273 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true);
7274
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007275 // If we are only missing a sign bit, this is less likely to result in actual
7276 // bugs -- if the result is cast back to an unsigned type, it will have the
7277 // expected value. Thus we place this behind a different warning that can be
7278 // turned off separately if needed.
7279 if (LeftBits == ResultBits - 1) {
Ted Kremenek70f05fd2011-06-15 00:54:52 +00007280 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
Richard Trieue4a19fb2011-09-06 21:21:28 +00007281 << HexResult.str() << LHSType
7282 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007283 return;
7284 }
7285
7286 S.Diag(Loc, diag::warn_shift_result_gt_typewidth)
Richard Trieue4a19fb2011-09-06 21:21:28 +00007287 << HexResult.str() << Result.getMinSignedBits() << LHSType
7288 << Left.getBitWidth() << LHS.get()->getSourceRange()
7289 << RHS.get()->getSourceRange();
Chandler Carruth4c6fdca2011-02-23 23:34:11 +00007290}
7291
Chris Lattner2a3569b2008-04-07 05:30:13 +00007292// C99 6.5.7
Richard Trieue4a19fb2011-09-06 21:21:28 +00007293QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS,
Richard Trieucfc491d2011-08-02 04:35:43 +00007294 SourceLocation Loc, unsigned Opc,
Richard Trieuba63ce62011-09-09 01:45:06 +00007295 bool IsCompAssign) {
Richard Trieuf8916e12011-09-16 00:53:10 +00007296 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
7297
Nate Begemane46ee9a2009-10-25 02:26:48 +00007298 // Vector shifts promote their scalar inputs to vector type.
Richard Trieue4a19fb2011-09-06 21:21:28 +00007299 if (LHS.get()->getType()->isVectorType() ||
7300 RHS.get()->getType()->isVectorType())
Richard Trieuba63ce62011-09-09 01:45:06 +00007301 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign);
Nate Begemane46ee9a2009-10-25 02:26:48 +00007302
Chris Lattner5c11c412007-12-12 05:47:28 +00007303 // Shifts don't perform usual arithmetic conversions, they just do integer
7304 // promotions on each operand. C99 6.5.7p3
Eli Friedman8b7b1b12009-03-28 01:22:36 +00007305
John McCall57cdd882010-12-16 19:28:59 +00007306 // For the LHS, do usual unary conversions, but then reset them away
7307 // if this is a compound assignment.
Richard Trieue4a19fb2011-09-06 21:21:28 +00007308 ExprResult OldLHS = LHS;
7309 LHS = UsualUnaryConversions(LHS.take());
7310 if (LHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00007311 return QualType();
Richard Trieue4a19fb2011-09-06 21:21:28 +00007312 QualType LHSType = LHS.get()->getType();
Richard Trieuba63ce62011-09-09 01:45:06 +00007313 if (IsCompAssign) LHS = OldLHS;
John McCall57cdd882010-12-16 19:28:59 +00007314
7315 // The RHS is simpler.
Richard Trieue4a19fb2011-09-06 21:21:28 +00007316 RHS = UsualUnaryConversions(RHS.take());
7317 if (RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00007318 return QualType();
Douglas Gregor8997dac2013-04-16 15:41:08 +00007319 QualType RHSType = RHS.get()->getType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00007320
Douglas Gregor8997dac2013-04-16 15:41:08 +00007321 // C99 6.5.7p2: Each of the operands shall have integer type.
7322 if (!LHSType->hasIntegerRepresentation() ||
7323 !RHSType->hasIntegerRepresentation())
7324 return InvalidOperands(Loc, LHS, RHS);
7325
7326 // C++0x: Don't allow scoped enums. FIXME: Use something better than
7327 // hasIntegerRepresentation() above instead of this.
7328 if (isScopedEnumerationType(LHSType) ||
7329 isScopedEnumerationType(RHSType)) {
7330 return InvalidOperands(Loc, LHS, RHS);
7331 }
Ryan Flynnf53fab82009-08-07 16:20:20 +00007332 // Sanity-check shift operands
Richard Trieue4a19fb2011-09-06 21:21:28 +00007333 DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType);
Ryan Flynnf53fab82009-08-07 16:20:20 +00007334
Chris Lattner5c11c412007-12-12 05:47:28 +00007335 // "The type of the result is that of the promoted left operand."
Richard Trieue4a19fb2011-09-06 21:21:28 +00007336 return LHSType;
Steve Naroff26c8ea52007-03-21 21:08:52 +00007337}
7338
Chandler Carruth17773fc2010-07-10 12:30:03 +00007339static bool IsWithinTemplateSpecialization(Decl *D) {
7340 if (DeclContext *DC = D->getDeclContext()) {
7341 if (isa<ClassTemplateSpecializationDecl>(DC))
7342 return true;
7343 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))
7344 return FD->isFunctionTemplateSpecialization();
7345 }
7346 return false;
7347}
7348
Richard Trieueea56f72011-09-02 03:48:46 +00007349/// If two different enums are compared, raise a warning.
Ted Kremenekf2ca8ec2013-01-30 19:10:21 +00007350static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS,
7351 Expr *RHS) {
7352 QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType();
7353 QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType();
Richard Trieueea56f72011-09-02 03:48:46 +00007354
7355 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>();
7356 if (!LHSEnumType)
7357 return;
7358 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>();
7359 if (!RHSEnumType)
7360 return;
7361
7362 // Ignore anonymous enums.
7363 if (!LHSEnumType->getDecl()->getIdentifier())
7364 return;
7365 if (!RHSEnumType->getDecl()->getIdentifier())
7366 return;
7367
7368 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType))
7369 return;
7370
7371 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types)
7372 << LHSStrippedType << RHSStrippedType
Ted Kremenekf2ca8ec2013-01-30 19:10:21 +00007373 << LHS->getSourceRange() << RHS->getSourceRange();
Richard Trieueea56f72011-09-02 03:48:46 +00007374}
7375
Richard Trieudd82a5c2011-09-02 02:55:45 +00007376/// \brief Diagnose bad pointer comparisons.
7377static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc,
Richard Trieu1762d7c2011-09-06 21:27:33 +00007378 ExprResult &LHS, ExprResult &RHS,
Richard Trieuba63ce62011-09-09 01:45:06 +00007379 bool IsError) {
7380 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
Richard Trieudd82a5c2011-09-02 02:55:45 +00007381 : diag::ext_typecheck_comparison_of_distinct_pointers)
Richard Trieu1762d7c2011-09-06 21:27:33 +00007382 << LHS.get()->getType() << RHS.get()->getType()
7383 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Richard Trieudd82a5c2011-09-02 02:55:45 +00007384}
7385
7386/// \brief Returns false if the pointers are converted to a composite type,
7387/// true otherwise.
7388static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc,
Richard Trieu1762d7c2011-09-06 21:27:33 +00007389 ExprResult &LHS, ExprResult &RHS) {
Richard Trieudd82a5c2011-09-02 02:55:45 +00007390 // C++ [expr.rel]p2:
7391 // [...] Pointer conversions (4.10) and qualification
7392 // conversions (4.4) are performed on pointer operands (or on
7393 // a pointer operand and a null pointer constant) to bring
7394 // them to their composite pointer type. [...]
7395 //
7396 // C++ [expr.eq]p1 uses the same notion for (in)equality
7397 // comparisons of pointers.
7398
7399 // C++ [expr.eq]p2:
7400 // In addition, pointers to members can be compared, or a pointer to
7401 // member and a null pointer constant. Pointer to member conversions
7402 // (4.11) and qualification conversions (4.4) are performed to bring
7403 // them to a common type. If one operand is a null pointer constant,
7404 // the common type is the type of the other operand. Otherwise, the
7405 // common type is a pointer to member type similar (4.4) to the type
7406 // of one of the operands, with a cv-qualification signature (4.4)
7407 // that is the union of the cv-qualification signatures of the operand
7408 // types.
7409
Richard Trieu1762d7c2011-09-06 21:27:33 +00007410 QualType LHSType = LHS.get()->getType();
7411 QualType RHSType = RHS.get()->getType();
7412 assert((LHSType->isPointerType() && RHSType->isPointerType()) ||
7413 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType()));
Richard Trieudd82a5c2011-09-02 02:55:45 +00007414
7415 bool NonStandardCompositeType = false;
Richard Trieu48277e52011-09-02 21:44:27 +00007416 bool *BoolPtr = S.isSFINAEContext() ? 0 : &NonStandardCompositeType;
Richard Trieu1762d7c2011-09-06 21:27:33 +00007417 QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr);
Richard Trieudd82a5c2011-09-02 02:55:45 +00007418 if (T.isNull()) {
Richard Trieu1762d7c2011-09-06 21:27:33 +00007419 diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
Richard Trieudd82a5c2011-09-02 02:55:45 +00007420 return true;
7421 }
7422
7423 if (NonStandardCompositeType)
7424 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard)
Richard Trieu1762d7c2011-09-06 21:27:33 +00007425 << LHSType << RHSType << T << LHS.get()->getSourceRange()
7426 << RHS.get()->getSourceRange();
Richard Trieudd82a5c2011-09-02 02:55:45 +00007427
Richard Trieu1762d7c2011-09-06 21:27:33 +00007428 LHS = S.ImpCastExprToType(LHS.take(), T, CK_BitCast);
7429 RHS = S.ImpCastExprToType(RHS.take(), T, CK_BitCast);
Richard Trieudd82a5c2011-09-02 02:55:45 +00007430 return false;
7431}
7432
7433static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc,
Richard Trieu1762d7c2011-09-06 21:27:33 +00007434 ExprResult &LHS,
7435 ExprResult &RHS,
Richard Trieuba63ce62011-09-09 01:45:06 +00007436 bool IsError) {
7437 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
7438 : diag::ext_typecheck_comparison_of_fptr_to_void)
Richard Trieu1762d7c2011-09-06 21:27:33 +00007439 << LHS.get()->getType() << RHS.get()->getType()
7440 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
Richard Trieudd82a5c2011-09-02 02:55:45 +00007441}
7442
Jordan Rosed49a33e2012-06-08 21:14:25 +00007443static bool isObjCObjectLiteral(ExprResult &E) {
Jordan Rosee2028132012-11-09 23:55:21 +00007444 switch (E.get()->IgnoreParenImpCasts()->getStmtClass()) {
Jordan Rosed49a33e2012-06-08 21:14:25 +00007445 case Stmt::ObjCArrayLiteralClass:
7446 case Stmt::ObjCDictionaryLiteralClass:
7447 case Stmt::ObjCStringLiteralClass:
7448 case Stmt::ObjCBoxedExprClass:
7449 return true;
7450 default:
7451 // Note that ObjCBoolLiteral is NOT an object literal!
7452 return false;
7453 }
7454}
7455
Jordan Rose7660f782012-07-17 17:46:40 +00007456static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
Benjamin Kramer25c05102013-02-15 15:17:50 +00007457 const ObjCObjectPointerType *Type =
7458 LHS->getType()->getAs<ObjCObjectPointerType>();
7459
7460 // If this is not actually an Objective-C object, bail out.
7461 if (!Type)
Jordan Rose7660f782012-07-17 17:46:40 +00007462 return false;
Benjamin Kramer25c05102013-02-15 15:17:50 +00007463
7464 // Get the LHS object's interface type.
7465 QualType InterfaceType = Type->getPointeeType();
7466 if (const ObjCObjectType *iQFaceTy =
7467 InterfaceType->getAsObjCQualifiedInterfaceType())
7468 InterfaceType = iQFaceTy->getBaseType();
Jordan Rose7660f782012-07-17 17:46:40 +00007469
7470 // If the RHS isn't an Objective-C object, bail out.
7471 if (!RHS->getType()->isObjCObjectPointerType())
7472 return false;
7473
7474 // Try to find the -isEqual: method.
7475 Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector();
7476 ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel,
7477 InterfaceType,
7478 /*instance=*/true);
7479 if (!Method) {
7480 if (Type->isObjCIdType()) {
7481 // For 'id', just check the global pool.
7482 Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(),
7483 /*receiverId=*/true,
7484 /*warn=*/false);
7485 } else {
7486 // Check protocols.
Benjamin Kramer25c05102013-02-15 15:17:50 +00007487 Method = S.LookupMethodInQualifiedType(IsEqualSel, Type,
Jordan Rose7660f782012-07-17 17:46:40 +00007488 /*instance=*/true);
7489 }
7490 }
7491
7492 if (!Method)
7493 return false;
7494
7495 QualType T = Method->param_begin()[0]->getType();
7496 if (!T->isObjCObjectPointerType())
7497 return false;
7498
7499 QualType R = Method->getResultType();
7500 if (!R->isScalarType())
7501 return false;
7502
7503 return true;
7504}
7505
Ted Kremenek01a33f82012-12-21 21:59:36 +00007506Sema::ObjCLiteralKind Sema::CheckLiteralKind(Expr *FromE) {
7507 FromE = FromE->IgnoreParenImpCasts();
7508 switch (FromE->getStmtClass()) {
7509 default:
7510 break;
7511 case Stmt::ObjCStringLiteralClass:
7512 // "string literal"
7513 return LK_String;
7514 case Stmt::ObjCArrayLiteralClass:
7515 // "array literal"
7516 return LK_Array;
7517 case Stmt::ObjCDictionaryLiteralClass:
7518 // "dictionary literal"
7519 return LK_Dictionary;
Ted Kremenek64873352012-12-21 22:46:35 +00007520 case Stmt::BlockExprClass:
7521 return LK_Block;
Ted Kremenek01a33f82012-12-21 21:59:36 +00007522 case Stmt::ObjCBoxedExprClass: {
Ted Kremenek44c2a2a2012-12-21 21:59:39 +00007523 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens();
Ted Kremenek01a33f82012-12-21 21:59:36 +00007524 switch (Inner->getStmtClass()) {
7525 case Stmt::IntegerLiteralClass:
7526 case Stmt::FloatingLiteralClass:
7527 case Stmt::CharacterLiteralClass:
7528 case Stmt::ObjCBoolLiteralExprClass:
7529 case Stmt::CXXBoolLiteralExprClass:
7530 // "numeric literal"
7531 return LK_Numeric;
7532 case Stmt::ImplicitCastExprClass: {
7533 CastKind CK = cast<CastExpr>(Inner)->getCastKind();
7534 // Boolean literals can be represented by implicit casts.
7535 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast)
7536 return LK_Numeric;
7537 break;
7538 }
7539 default:
7540 break;
7541 }
7542 return LK_Boxed;
7543 }
7544 }
7545 return LK_None;
7546}
7547
Jordan Rose7660f782012-07-17 17:46:40 +00007548static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc,
7549 ExprResult &LHS, ExprResult &RHS,
7550 BinaryOperator::Opcode Opc){
Jordan Rose63ffaa82012-07-17 17:46:48 +00007551 Expr *Literal;
7552 Expr *Other;
7553 if (isObjCObjectLiteral(LHS)) {
7554 Literal = LHS.get();
7555 Other = RHS.get();
7556 } else {
7557 Literal = RHS.get();
7558 Other = LHS.get();
7559 }
7560
7561 // Don't warn on comparisons against nil.
7562 Other = Other->IgnoreParenCasts();
7563 if (Other->isNullPointerConstant(S.getASTContext(),
7564 Expr::NPC_ValueDependentIsNotNull))
7565 return;
Jordan Rosed49a33e2012-06-08 21:14:25 +00007566
Jordan Roseea70bf72012-07-17 17:46:44 +00007567 // This should be kept in sync with warn_objc_literal_comparison.
Ted Kremenek01a33f82012-12-21 21:59:36 +00007568 // LK_String should always be after the other literals, since it has its own
7569 // warning flag.
7570 Sema::ObjCLiteralKind LiteralKind = S.CheckLiteralKind(Literal);
Ted Kremenek64873352012-12-21 22:46:35 +00007571 assert(LiteralKind != Sema::LK_Block);
Ted Kremenek01a33f82012-12-21 21:59:36 +00007572 if (LiteralKind == Sema::LK_None) {
Jordan Rosed49a33e2012-06-08 21:14:25 +00007573 llvm_unreachable("Unknown Objective-C object literal kind");
7574 }
7575
Ted Kremenek01a33f82012-12-21 21:59:36 +00007576 if (LiteralKind == Sema::LK_String)
Jordan Roseea70bf72012-07-17 17:46:44 +00007577 S.Diag(Loc, diag::warn_objc_string_literal_comparison)
7578 << Literal->getSourceRange();
7579 else
7580 S.Diag(Loc, diag::warn_objc_literal_comparison)
7581 << LiteralKind << Literal->getSourceRange();
Jordan Rosed49a33e2012-06-08 21:14:25 +00007582
Jordan Rose7660f782012-07-17 17:46:40 +00007583 if (BinaryOperator::isEqualityOp(Opc) &&
7584 hasIsEqualMethod(S, LHS.get(), RHS.get())) {
7585 SourceLocation Start = LHS.get()->getLocStart();
7586 SourceLocation End = S.PP.getLocForEndOfToken(RHS.get()->getLocEnd());
Fariborz Jahanian4dca1d32013-02-01 20:04:49 +00007587 CharSourceRange OpRange =
7588 CharSourceRange::getCharRange(Loc, S.PP.getLocForEndOfToken(Loc));
Jordan Rosef9198032012-07-09 16:54:44 +00007589
Jordan Rose7660f782012-07-17 17:46:40 +00007590 S.Diag(Loc, diag::note_objc_literal_comparison_isequal)
7591 << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
Fariborz Jahanian4dca1d32013-02-01 20:04:49 +00007592 << FixItHint::CreateReplacement(OpRange, " isEqual:")
Jordan Rose7660f782012-07-17 17:46:40 +00007593 << FixItHint::CreateInsertion(End, "]");
Jordan Rosed49a33e2012-06-08 21:14:25 +00007594 }
Jordan Rosed49a33e2012-06-08 21:14:25 +00007595}
7596
Richard Trieubb4b8942013-06-10 18:52:07 +00007597static void diagnoseLogicalNotOnLHSofComparison(Sema &S, ExprResult &LHS,
7598 ExprResult &RHS,
7599 SourceLocation Loc,
7600 unsigned OpaqueOpc) {
7601 // This checking requires bools.
7602 if (!S.getLangOpts().Bool) return;
7603
7604 // Check that left hand side is !something.
Richard Trieu949abc32013-07-04 00:50:18 +00007605 UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts());
Richard Trieubb4b8942013-06-10 18:52:07 +00007606 if (!UO || UO->getOpcode() != UO_LNot) return;
7607
7608 // Only check if the right hand side is non-bool arithmetic type.
7609 if (RHS.get()->getType()->isBooleanType()) return;
7610
7611 // Make sure that the something in !something is not bool.
7612 Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
7613 if (SubExpr->getType()->isBooleanType()) return;
7614
7615 // Emit warning.
7616 S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_comparison)
7617 << Loc;
7618
7619 // First note suggest !(x < y)
7620 SourceLocation FirstOpen = SubExpr->getLocStart();
7621 SourceLocation FirstClose = RHS.get()->getLocEnd();
7622 FirstClose = S.getPreprocessor().getLocForEndOfToken(FirstClose);
Eli Friedmanef0b4a32013-07-22 23:09:39 +00007623 if (FirstClose.isInvalid())
7624 FirstOpen = SourceLocation();
Richard Trieubb4b8942013-06-10 18:52:07 +00007625 S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
7626 << FixItHint::CreateInsertion(FirstOpen, "(")
7627 << FixItHint::CreateInsertion(FirstClose, ")");
7628
7629 // Second note suggests (!x) < y
7630 SourceLocation SecondOpen = LHS.get()->getLocStart();
7631 SourceLocation SecondClose = LHS.get()->getLocEnd();
7632 SecondClose = S.getPreprocessor().getLocForEndOfToken(SecondClose);
Eli Friedmanef0b4a32013-07-22 23:09:39 +00007633 if (SecondClose.isInvalid())
7634 SecondOpen = SourceLocation();
Richard Trieubb4b8942013-06-10 18:52:07 +00007635 S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens)
7636 << FixItHint::CreateInsertion(SecondOpen, "(")
7637 << FixItHint::CreateInsertion(SecondClose, ")");
7638}
7639
Eli Friedman5a722e92013-09-06 03:13:09 +00007640// Get the decl for a simple expression: a reference to a variable,
7641// an implicit C++ field reference, or an implicit ObjC ivar reference.
7642static ValueDecl *getCompareDecl(Expr *E) {
7643 if (DeclRefExpr* DR = dyn_cast<DeclRefExpr>(E))
7644 return DR->getDecl();
7645 if (ObjCIvarRefExpr* Ivar = dyn_cast<ObjCIvarRefExpr>(E)) {
7646 if (Ivar->isFreeIvar())
7647 return Ivar->getDecl();
7648 }
7649 if (MemberExpr* Mem = dyn_cast<MemberExpr>(E)) {
7650 if (Mem->isImplicitAccess())
7651 return Mem->getMemberDecl();
7652 }
7653 return 0;
7654}
7655
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00007656// C99 6.5.8, C++ [expr.rel]
Richard Trieub80728f2011-09-06 21:43:51 +00007657QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
Richard Trieucfc491d2011-08-02 04:35:43 +00007658 SourceLocation Loc, unsigned OpaqueOpc,
Richard Trieuba63ce62011-09-09 01:45:06 +00007659 bool IsRelational) {
Richard Trieuf8916e12011-09-16 00:53:10 +00007660 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true);
7661
John McCalle3027922010-08-25 11:45:40 +00007662 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc;
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007663
Chris Lattner9a152e22009-12-05 05:40:13 +00007664 // Handle vector comparisons separately.
Richard Trieub80728f2011-09-06 21:43:51 +00007665 if (LHS.get()->getType()->isVectorType() ||
7666 RHS.get()->getType()->isVectorType())
Richard Trieuba63ce62011-09-09 01:45:06 +00007667 return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational);
Mike Stump4e1f26a2009-02-19 03:04:26 +00007668
Richard Trieub80728f2011-09-06 21:43:51 +00007669 QualType LHSType = LHS.get()->getType();
7670 QualType RHSType = RHS.get()->getType();
Benjamin Kramera66aaa92011-09-03 08:46:20 +00007671
Richard Trieub80728f2011-09-06 21:43:51 +00007672 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts();
7673 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts();
Chandler Carruth712563b2011-02-17 08:37:06 +00007674
Ted Kremenekf2ca8ec2013-01-30 19:10:21 +00007675 checkEnumComparison(*this, Loc, LHS.get(), RHS.get());
Richard Trieubb4b8942013-06-10 18:52:07 +00007676 diagnoseLogicalNotOnLHSofComparison(*this, LHS, RHS, Loc, OpaqueOpc);
Chandler Carruth712563b2011-02-17 08:37:06 +00007677
Richard Trieub80728f2011-09-06 21:43:51 +00007678 if (!LHSType->hasFloatingRepresentation() &&
Richard Trieuba63ce62011-09-09 01:45:06 +00007679 !(LHSType->isBlockPointerType() && IsRelational) &&
Richard Trieub80728f2011-09-06 21:43:51 +00007680 !LHS.get()->getLocStart().isMacroID() &&
Richard Trieu30bfa362013-11-02 02:11:23 +00007681 !RHS.get()->getLocStart().isMacroID() &&
7682 ActiveTemplateInstantiations.empty()) {
Chris Lattner222b8bd2009-03-08 19:39:53 +00007683 // For non-floating point types, check for self-comparisons of the form
7684 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
7685 // often indicate logic errors in the program.
Chandler Carruth65a38182010-07-12 06:23:38 +00007686 //
7687 // NOTE: Don't warn about comparison expressions resulting from macro
7688 // expansion. Also don't warn about comparisons which are only self
7689 // comparisons within a template specialization. The warnings should catch
7690 // obvious cases in the definition of the template anyways. The idea is to
7691 // warn when the typed comparison operator will always evaluate to the same
7692 // result.
Eli Friedman5a722e92013-09-06 03:13:09 +00007693 ValueDecl *DL = getCompareDecl(LHSStripped);
7694 ValueDecl *DR = getCompareDecl(RHSStripped);
7695 if (DL && DR && DL == DR && !IsWithinTemplateSpecialization(DL)) {
7696 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always)
7697 << 0 // self-
7698 << (Opc == BO_EQ
7699 || Opc == BO_LE
7700 || Opc == BO_GE));
7701 } else if (DL && DR && LHSType->isArrayType() && RHSType->isArrayType() &&
7702 !DL->getType()->isReferenceType() &&
7703 !DR->getType()->isReferenceType()) {
7704 // what is it always going to eval to?
7705 char always_evals_to;
7706 switch(Opc) {
7707 case BO_EQ: // e.g. array1 == array2
7708 always_evals_to = 0; // false
7709 break;
7710 case BO_NE: // e.g. array1 != array2
7711 always_evals_to = 1; // true
7712 break;
7713 default:
7714 // best we can say is 'a constant'
7715 always_evals_to = 2; // e.g. array1 <= array2
7716 break;
Douglas Gregorec170db2010-06-08 19:50:34 +00007717 }
Eli Friedman5a722e92013-09-06 03:13:09 +00007718 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always)
7719 << 1 // array
7720 << always_evals_to);
Chandler Carruth17773fc2010-07-10 12:30:03 +00007721 }
Mike Stump11289f42009-09-09 15:08:12 +00007722
Chris Lattner222b8bd2009-03-08 19:39:53 +00007723 if (isa<CastExpr>(LHSStripped))
7724 LHSStripped = LHSStripped->IgnoreParenCasts();
7725 if (isa<CastExpr>(RHSStripped))
7726 RHSStripped = RHSStripped->IgnoreParenCasts();
Mike Stump11289f42009-09-09 15:08:12 +00007727
Chris Lattner222b8bd2009-03-08 19:39:53 +00007728 // Warn about comparisons against a string constant (unless the other
7729 // operand is null), the user probably wants strcmp.
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007730 Expr *literalString = 0;
7731 Expr *literalStringStripped = 0;
Chris Lattner222b8bd2009-03-08 19:39:53 +00007732 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) &&
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007733 !RHSStripped->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00007734 Expr::NPC_ValueDependentIsNull)) {
Richard Trieub80728f2011-09-06 21:43:51 +00007735 literalString = LHS.get();
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007736 literalStringStripped = LHSStripped;
Mike Stump12b8ce12009-08-04 21:02:39 +00007737 } else if ((isa<StringLiteral>(RHSStripped) ||
7738 isa<ObjCEncodeExpr>(RHSStripped)) &&
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00007739 !LHSStripped->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00007740 Expr::NPC_ValueDependentIsNull)) {
Richard Trieub80728f2011-09-06 21:43:51 +00007741 literalString = RHS.get();
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007742 literalStringStripped = RHSStripped;
7743 }
7744
7745 if (literalString) {
Ted Kremenek3427fac2011-02-23 01:52:04 +00007746 DiagRuntimeBehavior(Loc, 0,
Douglas Gregor49862b82010-01-12 23:18:54 +00007747 PDiag(diag::warn_stringcompare)
7748 << isa<ObjCEncodeExpr>(literalStringStripped)
Ted Kremenek800b66b2010-04-09 20:26:53 +00007749 << literalString->getSourceRange());
Douglas Gregor7a5bc762009-04-06 18:45:53 +00007750 }
Ted Kremeneke451eae2007-10-29 16:58:49 +00007751 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007752
Douglas Gregorec170db2010-06-08 19:50:34 +00007753 // C99 6.5.8p3 / C99 6.5.9p4
Eli Friedmane6d33952013-07-08 20:20:06 +00007754 UsualArithmeticConversions(LHS, RHS);
7755 if (LHS.isInvalid() || RHS.isInvalid())
7756 return QualType();
Douglas Gregorec170db2010-06-08 19:50:34 +00007757
Richard Trieub80728f2011-09-06 21:43:51 +00007758 LHSType = LHS.get()->getType();
7759 RHSType = RHS.get()->getType();
Douglas Gregorec170db2010-06-08 19:50:34 +00007760
Douglas Gregorca63811b2008-11-19 03:25:36 +00007761 // The result of comparisons is 'bool' in C++, 'int' in C.
Argyrios Kyrtzidis1bdd6882011-02-18 20:55:15 +00007762 QualType ResultTy = Context.getLogicalOperationType();
Douglas Gregorca63811b2008-11-19 03:25:36 +00007763
Richard Trieuba63ce62011-09-09 01:45:06 +00007764 if (IsRelational) {
Richard Trieub80728f2011-09-06 21:43:51 +00007765 if (LHSType->isRealType() && RHSType->isRealType())
Douglas Gregorca63811b2008-11-19 03:25:36 +00007766 return ResultTy;
Chris Lattnerb620c342007-08-26 01:18:55 +00007767 } else {
Ted Kremeneke2763b02007-10-29 17:13:39 +00007768 // Check for comparisons of floating point operands using != and ==.
Richard Trieub80728f2011-09-06 21:43:51 +00007769 if (LHSType->hasFloatingRepresentation())
7770 CheckFloatComparison(Loc, LHS.get(), RHS.get());
Mike Stump4e1f26a2009-02-19 03:04:26 +00007771
Richard Trieub80728f2011-09-06 21:43:51 +00007772 if (LHSType->isArithmeticType() && RHSType->isArithmeticType())
Douglas Gregorca63811b2008-11-19 03:25:36 +00007773 return ResultTy;
Chris Lattnerb620c342007-08-26 01:18:55 +00007774 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00007775
Richard Trieub80728f2011-09-06 21:43:51 +00007776 bool LHSIsNull = LHS.get()->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00007777 Expr::NPC_ValueDependentIsNull);
Richard Trieub80728f2011-09-06 21:43:51 +00007778 bool RHSIsNull = RHS.get()->isNullPointerConstant(Context,
Douglas Gregor56751b52009-09-25 04:25:58 +00007779 Expr::NPC_ValueDependentIsNull);
Mike Stump4e1f26a2009-02-19 03:04:26 +00007780
Douglas Gregorf267edd2010-06-15 21:38:40 +00007781 // All of the following pointer-related warnings are GCC extensions, except
7782 // when handling null pointer constants.
Richard Trieub80728f2011-09-06 21:43:51 +00007783 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2
Chris Lattner3a0702e2008-04-03 05:07:25 +00007784 QualType LCanPointeeTy =
John McCall9320b872011-09-09 05:25:32 +00007785 LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
Chris Lattner3a0702e2008-04-03 05:07:25 +00007786 QualType RCanPointeeTy =
John McCall9320b872011-09-09 05:25:32 +00007787 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00007788
David Blaikiebbafb8a2012-03-11 07:00:24 +00007789 if (getLangOpts().CPlusPlus) {
Eli Friedman16c209612009-08-23 00:27:47 +00007790 if (LCanPointeeTy == RCanPointeeTy)
7791 return ResultTy;
Richard Trieuba63ce62011-09-09 01:45:06 +00007792 if (!IsRelational &&
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00007793 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
7794 // Valid unless comparison between non-null pointer and function pointer
7795 // This is a gcc extension compatibility comparison.
Douglas Gregorf267edd2010-06-15 21:38:40 +00007796 // In a SFINAE context, we treat this as a hard error to maintain
7797 // conformance with the C++ standard.
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00007798 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
7799 && !LHSIsNull && !RHSIsNull) {
Richard Trieudd82a5c2011-09-02 02:55:45 +00007800 diagnoseFunctionPointerToVoidComparison(
David Blaikie3a3c4e02013-02-21 06:05:05 +00007801 *this, Loc, LHS, RHS, /*isError*/ (bool)isSFINAEContext());
Douglas Gregorf267edd2010-06-15 21:38:40 +00007802
7803 if (isSFINAEContext())
7804 return QualType();
7805
Richard Trieub80728f2011-09-06 21:43:51 +00007806 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast);
Fariborz Jahanianffc420c2009-12-21 18:19:17 +00007807 return ResultTy;
7808 }
7809 }
Anders Carlssona95069c2010-11-04 03:17:43 +00007810
Richard Trieub80728f2011-09-06 21:43:51 +00007811 if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00007812 return QualType();
Richard Trieudd82a5c2011-09-02 02:55:45 +00007813 else
7814 return ResultTy;
Douglas Gregor5b07c7e2009-05-04 06:07:12 +00007815 }
Eli Friedman16c209612009-08-23 00:27:47 +00007816 // C99 6.5.9p2 and C99 6.5.8p2
7817 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
7818 RCanPointeeTy.getUnqualifiedType())) {
7819 // Valid unless a relational comparison of function pointers
Richard Trieuba63ce62011-09-09 01:45:06 +00007820 if (IsRelational && LCanPointeeTy->isFunctionType()) {
Eli Friedman16c209612009-08-23 00:27:47 +00007821 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers)
Richard Trieub80728f2011-09-06 21:43:51 +00007822 << LHSType << RHSType << LHS.get()->getSourceRange()
7823 << RHS.get()->getSourceRange();
Eli Friedman16c209612009-08-23 00:27:47 +00007824 }
Richard Trieuba63ce62011-09-09 01:45:06 +00007825 } else if (!IsRelational &&
Eli Friedman16c209612009-08-23 00:27:47 +00007826 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
7827 // Valid unless comparison between non-null pointer and function pointer
7828 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
Richard Trieudd82a5c2011-09-02 02:55:45 +00007829 && !LHSIsNull && !RHSIsNull)
Richard Trieub80728f2011-09-06 21:43:51 +00007830 diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
Richard Trieudd82a5c2011-09-02 02:55:45 +00007831 /*isError*/false);
Eli Friedman16c209612009-08-23 00:27:47 +00007832 } else {
7833 // Invalid
Richard Trieub80728f2011-09-06 21:43:51 +00007834 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
Steve Naroff75c17232007-06-13 21:41:08 +00007835 }
John McCall7684dde2011-03-11 04:25:25 +00007836 if (LCanPointeeTy != RCanPointeeTy) {
David Tweede1468322013-12-11 13:39:46 +00007837 unsigned AddrSpaceL = LCanPointeeTy.getAddressSpace();
7838 unsigned AddrSpaceR = RCanPointeeTy.getAddressSpace();
7839 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
7840 : CK_BitCast;
John McCall7684dde2011-03-11 04:25:25 +00007841 if (LHSIsNull && !RHSIsNull)
David Tweede1468322013-12-11 13:39:46 +00007842 LHS = ImpCastExprToType(LHS.take(), RHSType, Kind);
John McCall7684dde2011-03-11 04:25:25 +00007843 else
David Tweede1468322013-12-11 13:39:46 +00007844 RHS = ImpCastExprToType(RHS.take(), LHSType, Kind);
John McCall7684dde2011-03-11 04:25:25 +00007845 }
Douglas Gregorca63811b2008-11-19 03:25:36 +00007846 return ResultTy;
Steve Naroffcdee44c2007-08-16 21:48:38 +00007847 }
Mike Stump11289f42009-09-09 15:08:12 +00007848
David Blaikiebbafb8a2012-03-11 07:00:24 +00007849 if (getLangOpts().CPlusPlus) {
Anders Carlssona95069c2010-11-04 03:17:43 +00007850 // Comparison of nullptr_t with itself.
Richard Trieub80728f2011-09-06 21:43:51 +00007851 if (LHSType->isNullPtrType() && RHSType->isNullPtrType())
Anders Carlssona95069c2010-11-04 03:17:43 +00007852 return ResultTy;
7853
Mike Stump11289f42009-09-09 15:08:12 +00007854 // Comparison of pointers with null pointer constants and equality
Douglas Gregorb00b10e2009-08-24 17:42:35 +00007855 // comparisons of member pointers to null pointer constants.
Mike Stump11289f42009-09-09 15:08:12 +00007856 if (RHSIsNull &&
Richard Trieub80728f2011-09-06 21:43:51 +00007857 ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) ||
Richard Trieuba63ce62011-09-09 01:45:06 +00007858 (!IsRelational &&
Richard Trieub80728f2011-09-06 21:43:51 +00007859 (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) {
7860 RHS = ImpCastExprToType(RHS.take(), LHSType,
7861 LHSType->isMemberPointerType()
John McCalle3027922010-08-25 11:45:40 +00007862 ? CK_NullToMemberPointer
John McCalle84af4e2010-11-13 01:35:44 +00007863 : CK_NullToPointer);
Sebastian Redl576fd422009-05-10 18:38:11 +00007864 return ResultTy;
7865 }
Douglas Gregorb00b10e2009-08-24 17:42:35 +00007866 if (LHSIsNull &&
Richard Trieub80728f2011-09-06 21:43:51 +00007867 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) ||
Richard Trieuba63ce62011-09-09 01:45:06 +00007868 (!IsRelational &&
Richard Trieub80728f2011-09-06 21:43:51 +00007869 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) {
7870 LHS = ImpCastExprToType(LHS.take(), RHSType,
7871 RHSType->isMemberPointerType()
John McCalle3027922010-08-25 11:45:40 +00007872 ? CK_NullToMemberPointer
John McCalle84af4e2010-11-13 01:35:44 +00007873 : CK_NullToPointer);
Sebastian Redl576fd422009-05-10 18:38:11 +00007874 return ResultTy;
7875 }
Douglas Gregorb00b10e2009-08-24 17:42:35 +00007876
7877 // Comparison of member pointers.
Richard Trieuba63ce62011-09-09 01:45:06 +00007878 if (!IsRelational &&
Richard Trieub80728f2011-09-06 21:43:51 +00007879 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) {
7880 if (convertPointersToCompositeType(*this, Loc, LHS, RHS))
Douglas Gregorb00b10e2009-08-24 17:42:35 +00007881 return QualType();
Richard Trieudd82a5c2011-09-02 02:55:45 +00007882 else
7883 return ResultTy;
Douglas Gregorb00b10e2009-08-24 17:42:35 +00007884 }
Douglas Gregor48e6bbf2011-03-01 17:16:20 +00007885
7886 // Handle scoped enumeration types specifically, since they don't promote
7887 // to integers.
Richard Trieub80728f2011-09-06 21:43:51 +00007888 if (LHS.get()->getType()->isEnumeralType() &&
7889 Context.hasSameUnqualifiedType(LHS.get()->getType(),
7890 RHS.get()->getType()))
Douglas Gregor48e6bbf2011-03-01 17:16:20 +00007891 return ResultTy;
Sebastian Redl576fd422009-05-10 18:38:11 +00007892 }
Mike Stump11289f42009-09-09 15:08:12 +00007893
Steve Naroff081c7422008-09-04 15:10:53 +00007894 // Handle block pointer types.
Richard Trieuba63ce62011-09-09 01:45:06 +00007895 if (!IsRelational && LHSType->isBlockPointerType() &&
Richard Trieub80728f2011-09-06 21:43:51 +00007896 RHSType->isBlockPointerType()) {
John McCall9320b872011-09-09 05:25:32 +00007897 QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType();
7898 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00007899
Steve Naroff081c7422008-09-04 15:10:53 +00007900 if (!LHSIsNull && !RHSIsNull &&
Eli Friedmana6638ca2009-06-08 05:08:54 +00007901 !Context.typesAreCompatible(lpointee, rpointee)) {
Chris Lattner377d1f82008-11-18 22:52:51 +00007902 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
Richard Trieub80728f2011-09-06 21:43:51 +00007903 << LHSType << RHSType << LHS.get()->getSourceRange()
7904 << RHS.get()->getSourceRange();
Steve Naroff081c7422008-09-04 15:10:53 +00007905 }
Richard Trieub80728f2011-09-06 21:43:51 +00007906 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00007907 return ResultTy;
Steve Naroff081c7422008-09-04 15:10:53 +00007908 }
John Wiegley01296292011-04-08 18:41:53 +00007909
Steve Naroffe18f94c2008-09-28 01:11:11 +00007910 // Allow block pointers to be compared with null pointer constants.
Richard Trieuba63ce62011-09-09 01:45:06 +00007911 if (!IsRelational
Richard Trieub80728f2011-09-06 21:43:51 +00007912 && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
7913 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
Steve Naroffe18f94c2008-09-28 01:11:11 +00007914 if (!LHSIsNull && !RHSIsNull) {
Richard Trieub80728f2011-09-06 21:43:51 +00007915 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
Mike Stump1b821b42009-05-07 03:14:14 +00007916 ->getPointeeType()->isVoidType())
Richard Trieub80728f2011-09-06 21:43:51 +00007917 || (LHSType->isPointerType() && LHSType->castAs<PointerType>()
Mike Stump1b821b42009-05-07 03:14:14 +00007918 ->getPointeeType()->isVoidType())))
7919 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
Richard Trieub80728f2011-09-06 21:43:51 +00007920 << LHSType << RHSType << LHS.get()->getSourceRange()
7921 << RHS.get()->getSourceRange();
Steve Naroffe18f94c2008-09-28 01:11:11 +00007922 }
John McCall7684dde2011-03-11 04:25:25 +00007923 if (LHSIsNull && !RHSIsNull)
John McCall9320b872011-09-09 05:25:32 +00007924 LHS = ImpCastExprToType(LHS.take(), RHSType,
7925 RHSType->isPointerType() ? CK_BitCast
7926 : CK_AnyPointerToBlockPointerCast);
John McCall7684dde2011-03-11 04:25:25 +00007927 else
John McCall9320b872011-09-09 05:25:32 +00007928 RHS = ImpCastExprToType(RHS.take(), LHSType,
7929 LHSType->isPointerType() ? CK_BitCast
7930 : CK_AnyPointerToBlockPointerCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00007931 return ResultTy;
Steve Naroffe18f94c2008-09-28 01:11:11 +00007932 }
Steve Naroff081c7422008-09-04 15:10:53 +00007933
Richard Trieub80728f2011-09-06 21:43:51 +00007934 if (LHSType->isObjCObjectPointerType() ||
7935 RHSType->isObjCObjectPointerType()) {
7936 const PointerType *LPT = LHSType->getAs<PointerType>();
7937 const PointerType *RPT = RHSType->getAs<PointerType>();
John McCall7684dde2011-03-11 04:25:25 +00007938 if (LPT || RPT) {
7939 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false;
7940 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false;
Mike Stump4e1f26a2009-02-19 03:04:26 +00007941
Steve Naroff753567f2008-11-17 19:49:16 +00007942 if (!LPtrToVoid && !RPtrToVoid &&
Richard Trieub80728f2011-09-06 21:43:51 +00007943 !Context.typesAreCompatible(LHSType, RHSType)) {
7944 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
Richard Trieudd82a5c2011-09-02 02:55:45 +00007945 /*isError*/false);
Steve Naroff1d4a9a32008-10-27 10:33:19 +00007946 }
Fariborz Jahanian374089e2013-07-31 17:12:26 +00007947 if (LHSIsNull && !RHSIsNull) {
7948 Expr *E = LHS.take();
7949 if (getLangOpts().ObjCAutoRefCount)
7950 CheckObjCARCConversion(SourceRange(), RHSType, E, CCK_ImplicitConversion);
7951 LHS = ImpCastExprToType(E, RHSType,
John McCall9320b872011-09-09 05:25:32 +00007952 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
Fariborz Jahanian374089e2013-07-31 17:12:26 +00007953 }
7954 else {
7955 Expr *E = RHS.take();
7956 if (getLangOpts().ObjCAutoRefCount)
7957 CheckObjCARCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion);
7958 RHS = ImpCastExprToType(E, LHSType,
John McCall9320b872011-09-09 05:25:32 +00007959 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
Fariborz Jahanian374089e2013-07-31 17:12:26 +00007960 }
Douglas Gregorca63811b2008-11-19 03:25:36 +00007961 return ResultTy;
Steve Naroffea54d9e2008-10-20 18:19:10 +00007962 }
Richard Trieub80728f2011-09-06 21:43:51 +00007963 if (LHSType->isObjCObjectPointerType() &&
7964 RHSType->isObjCObjectPointerType()) {
7965 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
7966 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
Richard Trieudd82a5c2011-09-02 02:55:45 +00007967 /*isError*/false);
Jordan Rosed49a33e2012-06-08 21:14:25 +00007968 if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS))
Jordan Rose7660f782012-07-17 17:46:40 +00007969 diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc);
Jordan Rosed49a33e2012-06-08 21:14:25 +00007970
John McCall7684dde2011-03-11 04:25:25 +00007971 if (LHSIsNull && !RHSIsNull)
Richard Trieub80728f2011-09-06 21:43:51 +00007972 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast);
John McCall7684dde2011-03-11 04:25:25 +00007973 else
Richard Trieub80728f2011-09-06 21:43:51 +00007974 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast);
Douglas Gregorca63811b2008-11-19 03:25:36 +00007975 return ResultTy;
Steve Naroffb788d9b2008-06-03 14:04:54 +00007976 }
Fariborz Jahanian134cbef2007-12-20 01:06:58 +00007977 }
Richard Trieub80728f2011-09-06 21:43:51 +00007978 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) ||
7979 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) {
Chris Lattnerd99bd522009-08-23 00:03:44 +00007980 unsigned DiagID = 0;
Douglas Gregorf267edd2010-06-15 21:38:40 +00007981 bool isError = false;
Douglas Gregor0064c592012-09-14 04:35:37 +00007982 if (LangOpts.DebuggerSupport) {
7983 // Under a debugger, allow the comparison of pointers to integers,
7984 // since users tend to want to compare addresses.
7985 } else if ((LHSIsNull && LHSType->isIntegerType()) ||
Richard Trieub80728f2011-09-06 21:43:51 +00007986 (RHSIsNull && RHSType->isIntegerType())) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00007987 if (IsRelational && !getLangOpts().CPlusPlus)
Chris Lattnerd99bd522009-08-23 00:03:44 +00007988 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
David Blaikiebbafb8a2012-03-11 07:00:24 +00007989 } else if (IsRelational && !getLangOpts().CPlusPlus)
Chris Lattnerd99bd522009-08-23 00:03:44 +00007990 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer;
David Blaikiebbafb8a2012-03-11 07:00:24 +00007991 else if (getLangOpts().CPlusPlus) {
Douglas Gregorf267edd2010-06-15 21:38:40 +00007992 DiagID = diag::err_typecheck_comparison_of_pointer_integer;
7993 isError = true;
7994 } else
Chris Lattnerd99bd522009-08-23 00:03:44 +00007995 DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
Mike Stump11289f42009-09-09 15:08:12 +00007996
Chris Lattnerd99bd522009-08-23 00:03:44 +00007997 if (DiagID) {
Chris Lattnerf8344db2009-08-22 18:58:31 +00007998 Diag(Loc, DiagID)
Richard Trieub80728f2011-09-06 21:43:51 +00007999 << LHSType << RHSType << LHS.get()->getSourceRange()
8000 << RHS.get()->getSourceRange();
Douglas Gregorf267edd2010-06-15 21:38:40 +00008001 if (isError)
8002 return QualType();
Chris Lattnerf8344db2009-08-22 18:58:31 +00008003 }
Douglas Gregorf267edd2010-06-15 21:38:40 +00008004
Richard Trieub80728f2011-09-06 21:43:51 +00008005 if (LHSType->isIntegerType())
8006 LHS = ImpCastExprToType(LHS.take(), RHSType,
John McCalle84af4e2010-11-13 01:35:44 +00008007 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
Chris Lattnerd99bd522009-08-23 00:03:44 +00008008 else
Richard Trieub80728f2011-09-06 21:43:51 +00008009 RHS = ImpCastExprToType(RHS.take(), LHSType,
John McCalle84af4e2010-11-13 01:35:44 +00008010 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
Douglas Gregorca63811b2008-11-19 03:25:36 +00008011 return ResultTy;
Steve Naroff043d45d2007-05-15 02:32:35 +00008012 }
Douglas Gregorf267edd2010-06-15 21:38:40 +00008013
Steve Naroff4b191572008-09-04 16:56:14 +00008014 // Handle block pointers.
Richard Trieuba63ce62011-09-09 01:45:06 +00008015 if (!IsRelational && RHSIsNull
Richard Trieub80728f2011-09-06 21:43:51 +00008016 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
8017 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer);
Douglas Gregorca63811b2008-11-19 03:25:36 +00008018 return ResultTy;
Steve Naroff4b191572008-09-04 16:56:14 +00008019 }
Richard Trieuba63ce62011-09-09 01:45:06 +00008020 if (!IsRelational && LHSIsNull
Richard Trieub80728f2011-09-06 21:43:51 +00008021 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
8022 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer);
Douglas Gregorca63811b2008-11-19 03:25:36 +00008023 return ResultTy;
Steve Naroff4b191572008-09-04 16:56:14 +00008024 }
Douglas Gregor48e6bbf2011-03-01 17:16:20 +00008025
Richard Trieub80728f2011-09-06 21:43:51 +00008026 return InvalidOperands(Loc, LHS, RHS);
Steve Naroff26c8ea52007-03-21 21:08:52 +00008027}
8028
Tanya Lattner20248222012-01-16 21:02:28 +00008029
8030// Return a signed type that is of identical size and number of elements.
8031// For floating point vectors, return an integer type of identical size
8032// and number of elements.
8033QualType Sema::GetSignedVectorType(QualType V) {
8034 const VectorType *VTy = V->getAs<VectorType>();
8035 unsigned TypeSize = Context.getTypeSize(VTy->getElementType());
8036 if (TypeSize == Context.getTypeSize(Context.CharTy))
8037 return Context.getExtVectorType(Context.CharTy, VTy->getNumElements());
8038 else if (TypeSize == Context.getTypeSize(Context.ShortTy))
8039 return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements());
8040 else if (TypeSize == Context.getTypeSize(Context.IntTy))
8041 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
8042 else if (TypeSize == Context.getTypeSize(Context.LongTy))
8043 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
8044 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&
8045 "Unhandled vector element size in vector compare");
8046 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
8047}
8048
Nate Begeman191a6b12008-07-14 18:02:46 +00008049/// CheckVectorCompareOperands - vector comparisons are a clang extension that
Mike Stump4e1f26a2009-02-19 03:04:26 +00008050/// operates on extended vector types. Instead of producing an IntTy result,
Nate Begeman191a6b12008-07-14 18:02:46 +00008051/// like a scalar comparison, a vector comparison produces a vector of integer
8052/// types.
Richard Trieubcce2f72011-09-07 01:19:57 +00008053QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
Chris Lattner326f7572008-11-18 01:30:42 +00008054 SourceLocation Loc,
Richard Trieuba63ce62011-09-09 01:45:06 +00008055 bool IsRelational) {
Nate Begeman191a6b12008-07-14 18:02:46 +00008056 // Check to make sure we're operating on vectors of the same type and width,
8057 // Allowing one side to be a scalar of element type.
Richard Trieubcce2f72011-09-07 01:19:57 +00008058 QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false);
Nate Begeman191a6b12008-07-14 18:02:46 +00008059 if (vType.isNull())
8060 return vType;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008061
Richard Trieubcce2f72011-09-07 01:19:57 +00008062 QualType LHSType = LHS.get()->getType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00008063
Anton Yartsev530deb92011-03-27 15:36:07 +00008064 // If AltiVec, the comparison results in a numeric type, i.e.
8065 // bool for C++, int for C
Anton Yartsev93900c72011-03-28 21:00:05 +00008066 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector)
Anton Yartsev530deb92011-03-27 15:36:07 +00008067 return Context.getLogicalOperationType();
8068
Nate Begeman191a6b12008-07-14 18:02:46 +00008069 // For non-floating point types, check for self-comparisons of the form
8070 // x == x, x != x, x < x, etc. These always evaluate to a constant, and
8071 // often indicate logic errors in the program.
Richard Trieu30bfa362013-11-02 02:11:23 +00008072 if (!LHSType->hasFloatingRepresentation() &&
8073 ActiveTemplateInstantiations.empty()) {
Richard Smith508ebf32011-10-28 03:31:48 +00008074 if (DeclRefExpr* DRL
8075 = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts()))
8076 if (DeclRefExpr* DRR
8077 = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts()))
Nate Begeman191a6b12008-07-14 18:02:46 +00008078 if (DRL->getDecl() == DRR->getDecl())
Ted Kremenek3427fac2011-02-23 01:52:04 +00008079 DiagRuntimeBehavior(Loc, 0,
Douglas Gregorec170db2010-06-08 19:50:34 +00008080 PDiag(diag::warn_comparison_always)
8081 << 0 // self-
8082 << 2 // "a constant"
8083 );
Nate Begeman191a6b12008-07-14 18:02:46 +00008084 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008085
Nate Begeman191a6b12008-07-14 18:02:46 +00008086 // Check for comparisons of floating point operands using != and ==.
Richard Trieuba63ce62011-09-09 01:45:06 +00008087 if (!IsRelational && LHSType->hasFloatingRepresentation()) {
David Blaikieca043222012-01-16 05:16:03 +00008088 assert (RHS.get()->getType()->hasFloatingRepresentation());
Richard Trieubcce2f72011-09-07 01:19:57 +00008089 CheckFloatComparison(Loc, LHS.get(), RHS.get());
Nate Begeman191a6b12008-07-14 18:02:46 +00008090 }
Tanya Lattner20248222012-01-16 21:02:28 +00008091
8092 // Return a signed type for the vector.
8093 return GetSignedVectorType(LHSType);
8094}
Mike Stump4e1f26a2009-02-19 03:04:26 +00008095
Tanya Lattner3dd33b22012-01-19 01:16:16 +00008096QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
8097 SourceLocation Loc) {
Tanya Lattner20248222012-01-16 21:02:28 +00008098 // Ensure that either both operands are of the same vector type, or
8099 // one operand is of a vector type and the other is of its element type.
8100 QualType vType = CheckVectorOperands(LHS, RHS, Loc, false);
Joey Gouly7d00f002013-02-21 11:49:56 +00008101 if (vType.isNull())
8102 return InvalidOperands(Loc, LHS, RHS);
8103 if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 &&
8104 vType->hasFloatingRepresentation())
Tanya Lattner20248222012-01-16 21:02:28 +00008105 return InvalidOperands(Loc, LHS, RHS);
8106
8107 return GetSignedVectorType(LHS.get()->getType());
Nate Begeman191a6b12008-07-14 18:02:46 +00008108}
8109
Steve Naroff218bc2b2007-05-04 21:54:46 +00008110inline QualType Sema::CheckBitwiseOperands(
Richard Trieuba63ce62011-09-09 01:45:06 +00008111 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
Richard Trieuf8916e12011-09-16 00:53:10 +00008112 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false);
8113
Richard Trieubcce2f72011-09-07 01:19:57 +00008114 if (LHS.get()->getType()->isVectorType() ||
8115 RHS.get()->getType()->isVectorType()) {
8116 if (LHS.get()->getType()->hasIntegerRepresentation() &&
8117 RHS.get()->getType()->hasIntegerRepresentation())
Richard Trieuba63ce62011-09-09 01:45:06 +00008118 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign);
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00008119
Richard Trieubcce2f72011-09-07 01:19:57 +00008120 return InvalidOperands(Loc, LHS, RHS);
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00008121 }
Steve Naroffb8ea4fb2007-07-13 23:32:42 +00008122
Richard Trieubcce2f72011-09-07 01:19:57 +00008123 ExprResult LHSResult = Owned(LHS), RHSResult = Owned(RHS);
8124 QualType compType = UsualArithmeticConversions(LHSResult, RHSResult,
Richard Trieuba63ce62011-09-09 01:45:06 +00008125 IsCompAssign);
Richard Trieubcce2f72011-09-07 01:19:57 +00008126 if (LHSResult.isInvalid() || RHSResult.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00008127 return QualType();
Richard Trieubcce2f72011-09-07 01:19:57 +00008128 LHS = LHSResult.take();
8129 RHS = RHSResult.take();
Mike Stump4e1f26a2009-02-19 03:04:26 +00008130
Eli Friedman93ee5ca2012-06-16 02:19:17 +00008131 if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType())
Steve Naroffbe4c4d12007-08-24 19:07:16 +00008132 return compType;
Richard Trieubcce2f72011-09-07 01:19:57 +00008133 return InvalidOperands(Loc, LHS, RHS);
Steve Naroff26c8ea52007-03-21 21:08:52 +00008134}
8135
Steve Naroff218bc2b2007-05-04 21:54:46 +00008136inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14]
Richard Trieubcce2f72011-09-07 01:19:57 +00008137 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) {
Chris Lattner8406c512010-07-13 19:41:32 +00008138
Tanya Lattner20248222012-01-16 21:02:28 +00008139 // Check vector operands differently.
8140 if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType())
8141 return CheckVectorLogicalOperands(LHS, RHS, Loc);
8142
Chris Lattner8406c512010-07-13 19:41:32 +00008143 // Diagnose cases where the user write a logical and/or but probably meant a
8144 // bitwise one. We do this when the LHS is a non-bool integer and the RHS
8145 // is a constant.
Richard Trieubcce2f72011-09-07 01:19:57 +00008146 if (LHS.get()->getType()->isIntegerType() &&
8147 !LHS.get()->getType()->isBooleanType() &&
8148 RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() &&
Richard Trieucfe39262011-07-15 00:00:51 +00008149 // Don't warn in macros or template instantiations.
8150 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) {
Chris Lattner938533d2010-07-24 01:10:11 +00008151 // If the RHS can be constant folded, and if it constant folds to something
8152 // that isn't 0 or 1 (which indicate a potential logical operation that
8153 // happened to fold to true/false) then warn.
Chandler Carruthe54ff6c2011-05-31 05:41:42 +00008154 // Parens on the RHS are ignored.
Richard Smith00ab3ae2011-10-16 23:01:09 +00008155 llvm::APSInt Result;
8156 if (RHS.get()->EvaluateAsInt(Result, Context))
David Blaikiebbafb8a2012-03-11 07:00:24 +00008157 if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType()) ||
Richard Smith00ab3ae2011-10-16 23:01:09 +00008158 (Result != 0 && Result != 1)) {
Chandler Carruthe54ff6c2011-05-31 05:41:42 +00008159 Diag(Loc, diag::warn_logical_instead_of_bitwise)
Richard Trieubcce2f72011-09-07 01:19:57 +00008160 << RHS.get()->getSourceRange()
Matt Beaumont-Gay0a0ba9d2011-08-15 17:50:06 +00008161 << (Opc == BO_LAnd ? "&&" : "||");
8162 // Suggest replacing the logical operator with the bitwise version
8163 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator)
8164 << (Opc == BO_LAnd ? "&" : "|")
8165 << FixItHint::CreateReplacement(SourceRange(
8166 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00008167 getLangOpts())),
Matt Beaumont-Gay0a0ba9d2011-08-15 17:50:06 +00008168 Opc == BO_LAnd ? "&" : "|");
8169 if (Opc == BO_LAnd)
8170 // Suggest replacing "Foo() && kNonZero" with "Foo()"
8171 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant)
8172 << FixItHint::CreateRemoval(
8173 SourceRange(
Richard Trieubcce2f72011-09-07 01:19:57 +00008174 Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(),
Matt Beaumont-Gay0a0ba9d2011-08-15 17:50:06 +00008175 0, getSourceManager(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00008176 getLangOpts()),
Richard Trieubcce2f72011-09-07 01:19:57 +00008177 RHS.get()->getLocEnd()));
Matt Beaumont-Gay0a0ba9d2011-08-15 17:50:06 +00008178 }
Chris Lattner938533d2010-07-24 01:10:11 +00008179 }
Joey Gouly7d00f002013-02-21 11:49:56 +00008180
David Blaikiebbafb8a2012-03-11 07:00:24 +00008181 if (!Context.getLangOpts().CPlusPlus) {
Joey Gouly7d00f002013-02-21 11:49:56 +00008182 // OpenCL v1.1 s6.3.g: The logical operators and (&&), or (||) do
8183 // not operate on the built-in scalar and vector float types.
8184 if (Context.getLangOpts().OpenCL &&
8185 Context.getLangOpts().OpenCLVersion < 120) {
8186 if (LHS.get()->getType()->isFloatingType() ||
8187 RHS.get()->getType()->isFloatingType())
8188 return InvalidOperands(Loc, LHS, RHS);
8189 }
8190
Richard Trieubcce2f72011-09-07 01:19:57 +00008191 LHS = UsualUnaryConversions(LHS.take());
8192 if (LHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00008193 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00008194
Richard Trieubcce2f72011-09-07 01:19:57 +00008195 RHS = UsualUnaryConversions(RHS.take());
8196 if (RHS.isInvalid())
John Wiegley01296292011-04-08 18:41:53 +00008197 return QualType();
8198
Richard Trieubcce2f72011-09-07 01:19:57 +00008199 if (!LHS.get()->getType()->isScalarType() ||
8200 !RHS.get()->getType()->isScalarType())
8201 return InvalidOperands(Loc, LHS, RHS);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008202
Anders Carlsson2e7bc112009-11-23 21:47:44 +00008203 return Context.IntTy;
Anders Carlsson35a99d92009-10-16 01:44:21 +00008204 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008205
John McCall4a2429a2010-06-04 00:29:51 +00008206 // The following is safe because we only use this method for
8207 // non-overloadable operands.
8208
Anders Carlsson2e7bc112009-11-23 21:47:44 +00008209 // C++ [expr.log.and]p1
8210 // C++ [expr.log.or]p1
John McCall4a2429a2010-06-04 00:29:51 +00008211 // The operands are both contextually converted to type bool.
Richard Trieubcce2f72011-09-07 01:19:57 +00008212 ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get());
8213 if (LHSRes.isInvalid())
8214 return InvalidOperands(Loc, LHS, RHS);
Benjamin Kramer62b95d82012-08-23 21:35:17 +00008215 LHS = LHSRes;
John Wiegley01296292011-04-08 18:41:53 +00008216
Richard Trieubcce2f72011-09-07 01:19:57 +00008217 ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get());
8218 if (RHSRes.isInvalid())
8219 return InvalidOperands(Loc, LHS, RHS);
Benjamin Kramer62b95d82012-08-23 21:35:17 +00008220 RHS = RHSRes;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00008221
Anders Carlsson2e7bc112009-11-23 21:47:44 +00008222 // C++ [expr.log.and]p2
8223 // C++ [expr.log.or]p2
8224 // The result is a bool.
8225 return Context.BoolTy;
Steve Naroffae4143e2007-04-26 20:39:23 +00008226}
8227
Fariborz Jahanian071caef2011-03-26 19:48:30 +00008228static bool IsReadonlyMessage(Expr *E, Sema &S) {
John McCall526ab472011-10-25 17:37:35 +00008229 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
8230 if (!ME) return false;
8231 if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
8232 ObjCMessageExpr *Base =
8233 dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts());
8234 if (!Base) return false;
8235 return Base->getMethodDecl() != 0;
Fariborz Jahanian071caef2011-03-26 19:48:30 +00008236}
8237
John McCall5fa2ef42012-03-13 00:37:01 +00008238/// Is the given expression (which must be 'const') a reference to a
8239/// variable which was originally non-const, but which has become
8240/// 'const' due to being captured within a block?
8241enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda };
8242static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
8243 assert(E->isLValue() && E->getType().isConstQualified());
8244 E = E->IgnoreParens();
8245
8246 // Must be a reference to a declaration from an enclosing scope.
8247 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
8248 if (!DRE) return NCCK_None;
8249 if (!DRE->refersToEnclosingLocal()) return NCCK_None;
8250
8251 // The declaration must be a variable which is not declared 'const'.
8252 VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
8253 if (!var) return NCCK_None;
8254 if (var->getType().isConstQualified()) return NCCK_None;
8255 assert(var->hasLocalStorage() && "capture added 'const' to non-local?");
8256
8257 // Decide whether the first capture was for a block or a lambda.
Richard Smith75e3f692013-09-28 04:31:26 +00008258 DeclContext *DC = S.CurContext, *Prev = 0;
8259 while (DC != var->getDeclContext()) {
8260 Prev = DC;
John McCall5fa2ef42012-03-13 00:37:01 +00008261 DC = DC->getParent();
Richard Smith75e3f692013-09-28 04:31:26 +00008262 }
8263 // Unless we have an init-capture, we've gone one step too far.
8264 if (!var->isInitCapture())
8265 DC = Prev;
John McCall5fa2ef42012-03-13 00:37:01 +00008266 return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda);
8267}
8268
Chris Lattner30bd3272008-11-18 01:22:49 +00008269/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not,
8270/// emit an error and return true. If so, return false.
8271static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
Fariborz Jahanianca5c5972012-04-10 17:30:10 +00008272 assert(!E->hasPlaceholderType(BuiltinType::PseudoObject));
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00008273 SourceLocation OrigLoc = Loc;
Mike Stump11289f42009-09-09 15:08:12 +00008274 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00008275 &Loc);
Eli Friedmanaa205c42013-06-27 01:36:36 +00008276 if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
Fariborz Jahanian071caef2011-03-26 19:48:30 +00008277 IsLV = Expr::MLV_InvalidMessageExpression;
Chris Lattner30bd3272008-11-18 01:22:49 +00008278 if (IsLV == Expr::MLV_Valid)
8279 return false;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008280
Chris Lattner30bd3272008-11-18 01:22:49 +00008281 unsigned Diag = 0;
8282 bool NeedType = false;
8283 switch (IsLV) { // C99 6.5.16p2
John McCall31168b02011-06-15 23:02:42 +00008284 case Expr::MLV_ConstQualified:
8285 Diag = diag::err_typecheck_assign_const;
8286
John McCall5fa2ef42012-03-13 00:37:01 +00008287 // Use a specialized diagnostic when we're assigning to an object
8288 // from an enclosing function or block.
8289 if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) {
8290 if (NCCK == NCCK_Block)
8291 Diag = diag::err_block_decl_ref_not_modifiable_lvalue;
8292 else
8293 Diag = diag::err_lambda_decl_ref_not_modifiable_lvalue;
8294 break;
8295 }
8296
John McCalld4631322011-06-17 06:42:21 +00008297 // In ARC, use some specialized diagnostics for occasions where we
8298 // infer 'const'. These are always pseudo-strong variables.
David Blaikiebbafb8a2012-03-11 07:00:24 +00008299 if (S.getLangOpts().ObjCAutoRefCount) {
John McCall31168b02011-06-15 23:02:42 +00008300 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts());
8301 if (declRef && isa<VarDecl>(declRef->getDecl())) {
8302 VarDecl *var = cast<VarDecl>(declRef->getDecl());
8303
John McCalld4631322011-06-17 06:42:21 +00008304 // Use the normal diagnostic if it's pseudo-__strong but the
8305 // user actually wrote 'const'.
8306 if (var->isARCPseudoStrong() &&
8307 (!var->getTypeSourceInfo() ||
8308 !var->getTypeSourceInfo()->getType().isConstQualified())) {
8309 // There are two pseudo-strong cases:
8310 // - self
John McCall31168b02011-06-15 23:02:42 +00008311 ObjCMethodDecl *method = S.getCurMethodDecl();
8312 if (method && var == method->getSelfDecl())
Ted Kremenek1fcdaa92011-11-14 21:59:25 +00008313 Diag = method->isClassMethod()
8314 ? diag::err_typecheck_arc_assign_self_class_method
8315 : diag::err_typecheck_arc_assign_self;
John McCalld4631322011-06-17 06:42:21 +00008316
8317 // - fast enumeration variables
8318 else
John McCall31168b02011-06-15 23:02:42 +00008319 Diag = diag::err_typecheck_arr_assign_enumeration;
John McCalld4631322011-06-17 06:42:21 +00008320
John McCall31168b02011-06-15 23:02:42 +00008321 SourceRange Assign;
8322 if (Loc != OrigLoc)
8323 Assign = SourceRange(OrigLoc, OrigLoc);
8324 S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
8325 // We need to preserve the AST regardless, so migration tool
8326 // can do its job.
8327 return false;
8328 }
8329 }
8330 }
8331
8332 break;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008333 case Expr::MLV_ArrayType:
Richard Smitheb3cad52012-06-04 22:27:30 +00008334 case Expr::MLV_ArrayTemporary:
Chris Lattner30bd3272008-11-18 01:22:49 +00008335 Diag = diag::err_typecheck_array_not_modifiable_lvalue;
8336 NeedType = true;
8337 break;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008338 case Expr::MLV_NotObjectType:
Chris Lattner30bd3272008-11-18 01:22:49 +00008339 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue;
8340 NeedType = true;
8341 break;
Chris Lattner9b3bbe92008-11-17 19:51:54 +00008342 case Expr::MLV_LValueCast:
Chris Lattner30bd3272008-11-18 01:22:49 +00008343 Diag = diag::err_typecheck_lvalue_casts_not_supported;
8344 break;
Douglas Gregorb154fdc2010-02-16 21:39:57 +00008345 case Expr::MLV_Valid:
8346 llvm_unreachable("did not take early return for MLV_Valid");
Chris Lattner9bad62c2008-01-04 18:04:52 +00008347 case Expr::MLV_InvalidExpression:
Douglas Gregorb154fdc2010-02-16 21:39:57 +00008348 case Expr::MLV_MemberFunction:
8349 case Expr::MLV_ClassTemporary:
Chris Lattner30bd3272008-11-18 01:22:49 +00008350 Diag = diag::err_typecheck_expression_not_modifiable_lvalue;
8351 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008352 case Expr::MLV_IncompleteType:
8353 case Expr::MLV_IncompleteVoidType:
Douglas Gregored0cfbd2009-03-09 16:13:40 +00008354 return S.RequireCompleteType(Loc, E->getType(),
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00008355 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
Chris Lattner9bad62c2008-01-04 18:04:52 +00008356 case Expr::MLV_DuplicateVectorComponents:
Chris Lattner30bd3272008-11-18 01:22:49 +00008357 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
8358 break;
Fariborz Jahanian5118c412008-11-22 20:25:50 +00008359 case Expr::MLV_NoSetterProperty:
John McCall526ab472011-10-25 17:37:35 +00008360 llvm_unreachable("readonly properties should be processed differently");
Fariborz Jahanian071caef2011-03-26 19:48:30 +00008361 case Expr::MLV_InvalidMessageExpression:
8362 Diag = diag::error_readonly_message_assignment;
8363 break;
Fariborz Jahaniane8d28902009-12-15 23:59:41 +00008364 case Expr::MLV_SubObjCPropertySetting:
8365 Diag = diag::error_no_subobject_property_setting;
8366 break;
Steve Naroff218bc2b2007-05-04 21:54:46 +00008367 }
Steve Naroffad373bd2007-07-31 12:34:36 +00008368
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00008369 SourceRange Assign;
8370 if (Loc != OrigLoc)
8371 Assign = SourceRange(OrigLoc, OrigLoc);
Chris Lattner30bd3272008-11-18 01:22:49 +00008372 if (NeedType)
Daniel Dunbarc2223ab2009-04-15 00:08:05 +00008373 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign;
Chris Lattner30bd3272008-11-18 01:22:49 +00008374 else
Mike Stump11289f42009-09-09 15:08:12 +00008375 S.Diag(Loc, Diag) << E->getSourceRange() << Assign;
Chris Lattner30bd3272008-11-18 01:22:49 +00008376 return true;
8377}
8378
Nico Weberb8124d12012-07-03 02:03:06 +00008379static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
8380 SourceLocation Loc,
8381 Sema &Sema) {
8382 // C / C++ fields
Nico Weber33fd5232012-06-28 23:53:12 +00008383 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr);
8384 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr);
8385 if (ML && MR && ML->getMemberDecl() == MR->getMemberDecl()) {
8386 if (isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase()))
Nico Weberb8124d12012-07-03 02:03:06 +00008387 Sema.Diag(Loc, diag::warn_identity_field_assign) << 0;
Nico Weber33fd5232012-06-28 23:53:12 +00008388 }
Chris Lattner30bd3272008-11-18 01:22:49 +00008389
Nico Weberb8124d12012-07-03 02:03:06 +00008390 // Objective-C instance variables
Nico Weber33fd5232012-06-28 23:53:12 +00008391 ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr);
8392 ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr);
8393 if (OL && OR && OL->getDecl() == OR->getDecl()) {
8394 DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts());
8395 DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts());
8396 if (RL && RR && RL->getDecl() == RR->getDecl())
Nico Weberb8124d12012-07-03 02:03:06 +00008397 Sema.Diag(Loc, diag::warn_identity_field_assign) << 1;
Nico Weber33fd5232012-06-28 23:53:12 +00008398 }
8399}
Chris Lattner30bd3272008-11-18 01:22:49 +00008400
8401// C99 6.5.16.1
Richard Trieuda4f43a62011-09-07 01:33:52 +00008402QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
Chris Lattner326f7572008-11-18 01:30:42 +00008403 SourceLocation Loc,
8404 QualType CompoundType) {
John McCall526ab472011-10-25 17:37:35 +00008405 assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject));
8406
Chris Lattner326f7572008-11-18 01:30:42 +00008407 // Verify that LHS is a modifiable lvalue, and emit error if not.
Richard Trieuda4f43a62011-09-07 01:33:52 +00008408 if (CheckForModifiableLvalue(LHSExpr, Loc, *this))
Chris Lattner30bd3272008-11-18 01:22:49 +00008409 return QualType();
Chris Lattner326f7572008-11-18 01:30:42 +00008410
Richard Trieuda4f43a62011-09-07 01:33:52 +00008411 QualType LHSType = LHSExpr->getType();
Richard Trieucfc491d2011-08-02 04:35:43 +00008412 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
8413 CompoundType;
Chris Lattner9bad62c2008-01-04 18:04:52 +00008414 AssignConvertType ConvTy;
Chris Lattner326f7572008-11-18 01:30:42 +00008415 if (CompoundType.isNull()) {
Nico Weber33fd5232012-06-28 23:53:12 +00008416 Expr *RHSCheck = RHS.get();
8417
Nico Weberb8124d12012-07-03 02:03:06 +00008418 CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this);
Nico Weber33fd5232012-06-28 23:53:12 +00008419
Fariborz Jahanianbe21aa32010-06-07 22:02:01 +00008420 QualType LHSTy(LHSType);
Fariborz Jahanianbe21aa32010-06-07 22:02:01 +00008421 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
John Wiegley01296292011-04-08 18:41:53 +00008422 if (RHS.isInvalid())
8423 return QualType();
Fariborz Jahanian255c0952009-01-13 23:34:40 +00008424 // Special case of NSObject attributes on c-style pointer types.
8425 if (ConvTy == IncompatiblePointer &&
8426 ((Context.isObjCNSObjectType(LHSType) &&
Steve Naroff79d12152009-07-16 15:41:00 +00008427 RHSType->isObjCObjectPointerType()) ||
Fariborz Jahanian255c0952009-01-13 23:34:40 +00008428 (Context.isObjCNSObjectType(RHSType) &&
Steve Naroff79d12152009-07-16 15:41:00 +00008429 LHSType->isObjCObjectPointerType())))
Fariborz Jahanian255c0952009-01-13 23:34:40 +00008430 ConvTy = Compatible;
Mike Stump4e1f26a2009-02-19 03:04:26 +00008431
John McCall7decc9e2010-11-18 06:31:45 +00008432 if (ConvTy == Compatible &&
Fariborz Jahaniane2a77762012-01-24 19:40:13 +00008433 LHSType->isObjCObjectType())
Fariborz Jahanian3c4225a2012-01-24 18:05:45 +00008434 Diag(Loc, diag::err_objc_object_assignment)
8435 << LHSType;
John McCall7decc9e2010-11-18 06:31:45 +00008436
Chris Lattnerea714382008-08-21 18:04:13 +00008437 // If the RHS is a unary plus or minus, check to see if they = and + are
8438 // right next to each other. If so, the user may have typo'd "x =+ 4"
8439 // instead of "x += 4".
Chris Lattnerea714382008-08-21 18:04:13 +00008440 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck))
8441 RHSCheck = ICE->getSubExpr();
8442 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) {
John McCalle3027922010-08-25 11:45:40 +00008443 if ((UO->getOpcode() == UO_Plus ||
8444 UO->getOpcode() == UO_Minus) &&
Chris Lattner326f7572008-11-18 01:30:42 +00008445 Loc.isFileID() && UO->getOperatorLoc().isFileID() &&
Chris Lattnerea714382008-08-21 18:04:13 +00008446 // Only if the two operators are exactly adjacent.
Argyrios Kyrtzidise6e67de2011-09-19 20:40:19 +00008447 Loc.getLocWithOffset(1) == UO->getOperatorLoc() &&
Chris Lattner36c39c92009-03-08 06:51:10 +00008448 // And there is a space or other character before the subexpr of the
8449 // unary +/-. We don't want to warn on "x=-1".
Argyrios Kyrtzidise6e67de2011-09-19 20:40:19 +00008450 Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() &&
Chris Lattnered9f14c2009-03-09 07:11:10 +00008451 UO->getSubExpr()->getLocStart().isFileID()) {
Chris Lattner29e812b2008-11-20 06:06:08 +00008452 Diag(Loc, diag::warn_not_compound_assign)
John McCalle3027922010-08-25 11:45:40 +00008453 << (UO->getOpcode() == UO_Plus ? "+" : "-")
Chris Lattner29e812b2008-11-20 06:06:08 +00008454 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
Chris Lattner36c39c92009-03-08 06:51:10 +00008455 }
Chris Lattnerea714382008-08-21 18:04:13 +00008456 }
John McCall31168b02011-06-15 23:02:42 +00008457
8458 if (ConvTy == Compatible) {
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00008459 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) {
8460 // Warn about retain cycles where a block captures the LHS, but
8461 // not if the LHS is a simple variable into which the block is
8462 // being stored...unless that variable can be captured by reference!
8463 const Expr *InnerLHS = LHSExpr->IgnoreParenCasts();
8464 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS);
8465 if (!DRE || DRE->getDecl()->hasAttr<BlocksAttr>())
8466 checkRetainCycles(LHSExpr, RHS.get());
8467
Jordan Rosed3934582012-09-28 22:21:30 +00008468 // It is safe to assign a weak reference into a strong variable.
8469 // Although this code can still have problems:
8470 // id x = self.weakProp;
8471 // id y = self.weakProp;
8472 // we do not warn to warn spuriously when 'x' and 'y' are on separate
8473 // paths through the function. This should be revisited if
8474 // -Wrepeated-use-of-weak is made flow-sensitive.
8475 DiagnosticsEngine::Level Level =
8476 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak,
8477 RHS.get()->getLocStart());
8478 if (Level != DiagnosticsEngine::Ignored)
8479 getCurFunction()->markSafeWeakUse(RHS.get());
8480
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00008481 } else if (getLangOpts().ObjCAutoRefCount) {
Richard Trieuda4f43a62011-09-07 01:33:52 +00008482 checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get());
Jordan Rosefa9e4ba2012-09-15 02:48:31 +00008483 }
John McCall31168b02011-06-15 23:02:42 +00008484 }
Chris Lattnerea714382008-08-21 18:04:13 +00008485 } else {
8486 // Compound assignment "x += y"
Douglas Gregorc03a1082011-01-28 02:26:04 +00008487 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType);
Chris Lattnerea714382008-08-21 18:04:13 +00008488 }
Chris Lattner9bad62c2008-01-04 18:04:52 +00008489
Chris Lattner326f7572008-11-18 01:30:42 +00008490 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType,
John Wiegley01296292011-04-08 18:41:53 +00008491 RHS.get(), AA_Assigning))
Chris Lattner9bad62c2008-01-04 18:04:52 +00008492 return QualType();
Mike Stump4e1f26a2009-02-19 03:04:26 +00008493
Richard Trieuda4f43a62011-09-07 01:33:52 +00008494 CheckForNullPointerDereference(*this, LHSExpr);
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00008495
Steve Naroff98cf3e92007-06-06 18:38:38 +00008496 // C99 6.5.16p3: The type of an assignment expression is the type of the
8497 // left operand unless the left operand has qualified type, in which case
Mike Stump4e1f26a2009-02-19 03:04:26 +00008498 // it is the unqualified version of the type of the left operand.
Steve Naroff98cf3e92007-06-06 18:38:38 +00008499 // C99 6.5.16.1p2: In simple assignment, the value of the right operand
8500 // is converted to the type of the assignment expression (above).
Chris Lattnerf17bd422007-08-30 17:45:32 +00008501 // C++ 5.17p1: the type of the assignment expression is that of its left
Douglas Gregord2c2d172009-05-02 00:36:19 +00008502 // operand.
David Blaikiebbafb8a2012-03-11 07:00:24 +00008503 return (getLangOpts().CPlusPlus
John McCall01cbf2d2010-10-12 02:19:57 +00008504 ? LHSType : LHSType.getUnqualifiedType());
Steve Naroffae4143e2007-04-26 20:39:23 +00008505}
8506
Chris Lattner326f7572008-11-18 01:30:42 +00008507// C99 6.5.17
John Wiegley01296292011-04-08 18:41:53 +00008508static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS,
John McCall4bc41ae2010-11-18 19:01:18 +00008509 SourceLocation Loc) {
John McCall3aef3d82011-04-10 19:13:55 +00008510 LHS = S.CheckPlaceholderExpr(LHS.take());
8511 RHS = S.CheckPlaceholderExpr(RHS.take());
John Wiegley01296292011-04-08 18:41:53 +00008512 if (LHS.isInvalid() || RHS.isInvalid())
Douglas Gregor0124e9b2010-11-09 21:07:58 +00008513 return QualType();
8514
John McCall73d36182010-10-12 07:14:40 +00008515 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its
8516 // operands, but not unary promotions.
8517 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1).
Eli Friedmanba961a92009-03-23 00:24:07 +00008518
John McCall34376a62010-12-04 03:47:34 +00008519 // So we treat the LHS as a ignored value, and in C++ we allow the
8520 // containing site to determine what should be done with the RHS.
John Wiegley01296292011-04-08 18:41:53 +00008521 LHS = S.IgnoredValueConversions(LHS.take());
8522 if (LHS.isInvalid())
8523 return QualType();
John McCall34376a62010-12-04 03:47:34 +00008524
Eli Friedmanc11535c2012-05-24 00:47:05 +00008525 S.DiagnoseUnusedExprResult(LHS.get());
8526
David Blaikiebbafb8a2012-03-11 07:00:24 +00008527 if (!S.getLangOpts().CPlusPlus) {
John Wiegley01296292011-04-08 18:41:53 +00008528 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take());
8529 if (RHS.isInvalid())
8530 return QualType();
8531 if (!RHS.get()->getType()->isVoidType())
Richard Trieucfc491d2011-08-02 04:35:43 +00008532 S.RequireCompleteType(Loc, RHS.get()->getType(),
8533 diag::err_incomplete_type);
John McCall73d36182010-10-12 07:14:40 +00008534 }
Eli Friedmanba961a92009-03-23 00:24:07 +00008535
John Wiegley01296292011-04-08 18:41:53 +00008536 return RHS.get()->getType();
Steve Naroff95af0132007-03-30 23:47:58 +00008537}
8538
Steve Naroff7a5af782007-07-13 16:58:59 +00008539/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
8540/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
John McCall4bc41ae2010-11-18 19:01:18 +00008541static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
8542 ExprValueKind &VK,
8543 SourceLocation OpLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00008544 bool IsInc, bool IsPrefix) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008545 if (Op->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00008546 return S.Context.DependentTy;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008547
Chris Lattner6b0cf142008-11-21 07:05:48 +00008548 QualType ResType = Op->getType();
David Chisnallfa35df62012-01-16 17:27:18 +00008549 // Atomic types can be used for increment / decrement where the non-atomic
8550 // versions can, so ignore the _Atomic() specifier for the purpose of
8551 // checking.
8552 if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
8553 ResType = ResAtomicType->getValueType();
8554
Chris Lattner6b0cf142008-11-21 07:05:48 +00008555 assert(!ResType.isNull() && "no type for increment/decrement expression");
Steve Naroffd50c88e2007-04-05 21:15:20 +00008556
David Blaikiebbafb8a2012-03-11 07:00:24 +00008557 if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) {
Sebastian Redle10c2c32008-12-20 09:35:34 +00008558 // Decrement of bool is not allowed.
Richard Trieuba63ce62011-09-09 01:45:06 +00008559 if (!IsInc) {
John McCall4bc41ae2010-11-18 19:01:18 +00008560 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange();
Sebastian Redle10c2c32008-12-20 09:35:34 +00008561 return QualType();
8562 }
8563 // Increment of bool sets it to true, but is deprecated.
John McCall4bc41ae2010-11-18 19:01:18 +00008564 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange();
Richard Trieu493df1a2013-08-08 01:50:23 +00008565 } else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {
8566 // Error on enum increments and decrements in C++ mode
8567 S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
8568 return QualType();
Sebastian Redle10c2c32008-12-20 09:35:34 +00008569 } else if (ResType->isRealType()) {
Chris Lattner6b0cf142008-11-21 07:05:48 +00008570 // OK!
John McCallf2538342012-07-31 05:14:30 +00008571 } else if (ResType->isPointerType()) {
Chris Lattner6b0cf142008-11-21 07:05:48 +00008572 // C99 6.5.2.4p2, 6.5.6p2
Chandler Carruthc9332212011-06-27 08:02:19 +00008573 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op))
Douglas Gregordd430f72009-01-19 19:26:10 +00008574 return QualType();
John McCallf2538342012-07-31 05:14:30 +00008575 } else if (ResType->isObjCObjectPointerType()) {
8576 // On modern runtimes, ObjC pointer arithmetic is forbidden.
8577 // Otherwise, we just need a complete type.
8578 if (checkArithmeticIncompletePointerType(S, OpLoc, Op) ||
8579 checkArithmeticOnObjCPointer(S, OpLoc, Op))
8580 return QualType();
Eli Friedman090addd2010-01-03 00:20:48 +00008581 } else if (ResType->isAnyComplexType()) {
Chris Lattner6b0cf142008-11-21 07:05:48 +00008582 // C99 does not support ++/-- on complex types, we allow as an extension.
John McCall4bc41ae2010-11-18 19:01:18 +00008583 S.Diag(OpLoc, diag::ext_integer_increment_complex)
Chris Lattner1e5665e2008-11-24 06:25:27 +00008584 << ResType << Op->getSourceRange();
John McCall36226622010-10-12 02:09:17 +00008585 } else if (ResType->isPlaceholderType()) {
John McCall3aef3d82011-04-10 19:13:55 +00008586 ExprResult PR = S.CheckPlaceholderExpr(Op);
John McCall36226622010-10-12 02:09:17 +00008587 if (PR.isInvalid()) return QualType();
John McCall4bc41ae2010-11-18 19:01:18 +00008588 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00008589 IsInc, IsPrefix);
David Blaikiebbafb8a2012-03-11 07:00:24 +00008590 } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) {
Anton Yartsev85129b82011-02-07 02:17:30 +00008591 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 )
David Tweed16574d82013-09-06 09:58:08 +00008592 } else if(S.getLangOpts().OpenCL && ResType->isVectorType() &&
8593 ResType->getAs<VectorType>()->getElementType()->isIntegerType()) {
8594 // OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types.
Chris Lattner6b0cf142008-11-21 07:05:48 +00008595 } else {
John McCall4bc41ae2010-11-18 19:01:18 +00008596 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
Richard Trieuba63ce62011-09-09 01:45:06 +00008597 << ResType << int(IsInc) << Op->getSourceRange();
Chris Lattner6b0cf142008-11-21 07:05:48 +00008598 return QualType();
Steve Naroff46ba1eb2007-04-03 23:13:13 +00008599 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008600 // At this point, we know we have a real, complex or pointer type.
Steve Naroff9e1e5512007-08-23 21:37:33 +00008601 // Now make sure the operand is a modifiable lvalue.
John McCall4bc41ae2010-11-18 19:01:18 +00008602 if (CheckForModifiableLvalue(Op, OpLoc, S))
Steve Naroff35d85152007-05-07 00:24:15 +00008603 return QualType();
Alexis Huntc46382e2010-04-28 23:02:27 +00008604 // In C++, a prefix increment is the same type as the operand. Otherwise
8605 // (in C or with postfix), the increment is the unqualified type of the
8606 // operand.
David Blaikiebbafb8a2012-03-11 07:00:24 +00008607 if (IsPrefix && S.getLangOpts().CPlusPlus) {
John McCall4bc41ae2010-11-18 19:01:18 +00008608 VK = VK_LValue;
8609 return ResType;
8610 } else {
8611 VK = VK_RValue;
8612 return ResType.getUnqualifiedType();
8613 }
Steve Naroff26c8ea52007-03-21 21:08:52 +00008614}
Fariborz Jahanian805b74e2010-09-14 23:02:38 +00008615
8616
Anders Carlsson806700f2008-02-01 07:15:58 +00008617/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
Steve Naroff47500512007-04-19 23:00:49 +00008618/// This routine allows us to typecheck complex/recursive expressions
Daniel Dunbarb692ef42008-08-04 20:02:37 +00008619/// where the declaration is needed for type checking. We only need to
8620/// handle cases when the expression references a function designator
8621/// or is an lvalue. Here are some examples:
8622/// - &(x) => x
8623/// - &*****f => f for f a function designator.
8624/// - &s.xx => s
8625/// - &s.zz[1].yy -> s, if zz is an array
8626/// - *(x + 1) -> x, if x is an array
8627/// - &"123"[2] -> 0
8628/// - & __real__ x -> x
John McCallf3a88602011-02-03 08:15:49 +00008629static ValueDecl *getPrimaryDecl(Expr *E) {
Chris Lattner24d5bfe2008-04-02 04:24:33 +00008630 switch (E->getStmtClass()) {
Steve Naroff47500512007-04-19 23:00:49 +00008631 case Stmt::DeclRefExprClass:
Chris Lattner24d5bfe2008-04-02 04:24:33 +00008632 return cast<DeclRefExpr>(E)->getDecl();
Steve Naroff47500512007-04-19 23:00:49 +00008633 case Stmt::MemberExprClass:
Eli Friedman3a1e6922009-04-20 08:23:18 +00008634 // If this is an arrow operator, the address is an offset from
8635 // the base's value, so the object the base refers to is
8636 // irrelevant.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00008637 if (cast<MemberExpr>(E)->isArrow())
Chris Lattner48d52842007-11-16 17:46:48 +00008638 return 0;
Eli Friedman3a1e6922009-04-20 08:23:18 +00008639 // Otherwise, the expression refers to a part of the base
Chris Lattner24d5bfe2008-04-02 04:24:33 +00008640 return getPrimaryDecl(cast<MemberExpr>(E)->getBase());
Anders Carlsson806700f2008-02-01 07:15:58 +00008641 case Stmt::ArraySubscriptExprClass: {
Mike Stump87c57ac2009-05-16 07:39:55 +00008642 // FIXME: This code shouldn't be necessary! We should catch the implicit
8643 // promotion of register arrays earlier.
Eli Friedman3a1e6922009-04-20 08:23:18 +00008644 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
8645 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
8646 if (ICE->getSubExpr()->getType()->isArrayType())
8647 return getPrimaryDecl(ICE->getSubExpr());
8648 }
8649 return 0;
Anders Carlsson806700f2008-02-01 07:15:58 +00008650 }
Daniel Dunbarb692ef42008-08-04 20:02:37 +00008651 case Stmt::UnaryOperatorClass: {
8652 UnaryOperator *UO = cast<UnaryOperator>(E);
Mike Stump4e1f26a2009-02-19 03:04:26 +00008653
Daniel Dunbarb692ef42008-08-04 20:02:37 +00008654 switch(UO->getOpcode()) {
John McCalle3027922010-08-25 11:45:40 +00008655 case UO_Real:
8656 case UO_Imag:
8657 case UO_Extension:
Daniel Dunbarb692ef42008-08-04 20:02:37 +00008658 return getPrimaryDecl(UO->getSubExpr());
8659 default:
8660 return 0;
8661 }
8662 }
Steve Naroff47500512007-04-19 23:00:49 +00008663 case Stmt::ParenExprClass:
Chris Lattner24d5bfe2008-04-02 04:24:33 +00008664 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr());
Chris Lattner48d52842007-11-16 17:46:48 +00008665 case Stmt::ImplicitCastExprClass:
Eli Friedman3a1e6922009-04-20 08:23:18 +00008666 // If the result of an implicit cast is an l-value, we care about
8667 // the sub-expression; otherwise, the result here doesn't matter.
Chris Lattner24d5bfe2008-04-02 04:24:33 +00008668 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr());
Steve Naroff47500512007-04-19 23:00:49 +00008669 default:
8670 return 0;
8671 }
8672}
8673
Richard Trieu5f376f62011-09-07 21:46:33 +00008674namespace {
8675 enum {
8676 AO_Bit_Field = 0,
8677 AO_Vector_Element = 1,
8678 AO_Property_Expansion = 2,
8679 AO_Register_Variable = 3,
8680 AO_No_Error = 4
8681 };
8682}
Richard Trieu3fd7bb82011-09-02 00:47:55 +00008683/// \brief Diagnose invalid operand for address of operations.
8684///
8685/// \param Type The type of operand which cannot have its address taken.
Richard Trieu3fd7bb82011-09-02 00:47:55 +00008686static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc,
8687 Expr *E, unsigned Type) {
8688 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
8689}
8690
Steve Naroff47500512007-04-19 23:00:49 +00008691/// CheckAddressOfOperand - The operand of & must be either a function
Mike Stump4e1f26a2009-02-19 03:04:26 +00008692/// designator or an lvalue designating an object. If it is an lvalue, the
Steve Naroff47500512007-04-19 23:00:49 +00008693/// object cannot be declared with storage class register or be a bit field.
Mike Stump4e1f26a2009-02-19 03:04:26 +00008694/// Note: The usual conversions are *not* applied to the operand of the &
Steve Naroffa78fe7e2007-05-16 19:47:19 +00008695/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
Mike Stump4e1f26a2009-02-19 03:04:26 +00008696/// In C++, the operand might be an overloaded function name, in which case
Douglas Gregorcd695e52008-11-10 20:40:00 +00008697/// we allow the '&' but retain the overloaded-function type.
Richard Smithaf9de912013-07-11 02:26:56 +00008698QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
John McCall526ab472011-10-25 17:37:35 +00008699 if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){
8700 if (PTy->getKind() == BuiltinType::Overload) {
David Majnemer0f328442013-07-05 06:23:33 +00008701 Expr *E = OrigOp.get()->IgnoreParens();
8702 if (!isa<OverloadExpr>(E)) {
8703 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
Richard Smithaf9de912013-07-11 02:26:56 +00008704 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
John McCall526ab472011-10-25 17:37:35 +00008705 << OrigOp.get()->getSourceRange();
8706 return QualType();
8707 }
David Majnemer66ad5742013-06-11 03:56:29 +00008708
David Majnemer0f328442013-07-05 06:23:33 +00008709 OverloadExpr *Ovl = cast<OverloadExpr>(E);
David Majnemer66ad5742013-06-11 03:56:29 +00008710 if (isa<UnresolvedMemberExpr>(Ovl))
Richard Smithaf9de912013-07-11 02:26:56 +00008711 if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
8712 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
David Majnemer66ad5742013-06-11 03:56:29 +00008713 << OrigOp.get()->getSourceRange();
8714 return QualType();
8715 }
8716
Richard Smithaf9de912013-07-11 02:26:56 +00008717 return Context.OverloadTy;
John McCall526ab472011-10-25 17:37:35 +00008718 }
8719
8720 if (PTy->getKind() == BuiltinType::UnknownAny)
Richard Smithaf9de912013-07-11 02:26:56 +00008721 return Context.UnknownAnyTy;
John McCall526ab472011-10-25 17:37:35 +00008722
8723 if (PTy->getKind() == BuiltinType::BoundMember) {
Richard Smithaf9de912013-07-11 02:26:56 +00008724 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
John McCall526ab472011-10-25 17:37:35 +00008725 << OrigOp.get()->getSourceRange();
Douglas Gregor668d3622011-10-09 19:10:41 +00008726 return QualType();
8727 }
John McCall526ab472011-10-25 17:37:35 +00008728
Richard Smithaf9de912013-07-11 02:26:56 +00008729 OrigOp = CheckPlaceholderExpr(OrigOp.take());
John McCall526ab472011-10-25 17:37:35 +00008730 if (OrigOp.isInvalid()) return QualType();
John McCall0009fcc2011-04-26 20:42:42 +00008731 }
John McCall8d08b9b2010-08-27 09:08:28 +00008732
John McCall526ab472011-10-25 17:37:35 +00008733 if (OrigOp.get()->isTypeDependent())
Richard Smithaf9de912013-07-11 02:26:56 +00008734 return Context.DependentTy;
John McCall526ab472011-10-25 17:37:35 +00008735
8736 assert(!OrigOp.get()->getType()->isPlaceholderType());
John McCall36226622010-10-12 02:09:17 +00008737
John McCall8d08b9b2010-08-27 09:08:28 +00008738 // Make sure to ignore parentheses in subsequent checks
John McCall526ab472011-10-25 17:37:35 +00008739 Expr *op = OrigOp.get()->IgnoreParens();
Douglas Gregor19b8c4f2008-12-17 22:52:20 +00008740
Richard Smithaf9de912013-07-11 02:26:56 +00008741 if (getLangOpts().C99) {
Steve Naroff826e91a2008-01-13 17:10:08 +00008742 // Implement C99-only parts of addressof rules.
8743 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
John McCalle3027922010-08-25 11:45:40 +00008744 if (uOp->getOpcode() == UO_Deref)
Steve Naroff826e91a2008-01-13 17:10:08 +00008745 // Per C99 6.5.3.2, the address of a deref always returns a valid result
8746 // (assuming the deref expression is valid).
8747 return uOp->getSubExpr()->getType();
8748 }
8749 // Technically, there should be a check for array subscript
8750 // expressions here, but the result of one is always an lvalue anyway.
8751 }
John McCallf3a88602011-02-03 08:15:49 +00008752 ValueDecl *dcl = getPrimaryDecl(op);
Richard Smithaf9de912013-07-11 02:26:56 +00008753 Expr::LValueClassification lval = op->ClassifyLValue(Context);
Richard Trieu5f376f62011-09-07 21:46:33 +00008754 unsigned AddressOfError = AO_No_Error;
Nuno Lopes17f345f2008-12-16 22:59:47 +00008755
Richard Smithc084bd282013-02-02 02:14:45 +00008756 if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {
Richard Smithaf9de912013-07-11 02:26:56 +00008757 bool sfinae = (bool)isSFINAEContext();
8758 Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary
8759 : diag::ext_typecheck_addrof_temporary)
Douglas Gregorb154fdc2010-02-16 21:39:57 +00008760 << op->getType() << op->getSourceRange();
John McCall4bc41ae2010-11-18 19:01:18 +00008761 if (sfinae)
Douglas Gregorb154fdc2010-02-16 21:39:57 +00008762 return QualType();
Richard Smith9f8400e2013-05-01 19:00:39 +00008763 // Materialize the temporary as an lvalue so that we can take its address.
Richard Smithaf9de912013-07-11 02:26:56 +00008764 OrigOp = op = new (Context)
Richard Smithe6c01442013-06-05 00:46:14 +00008765 MaterializeTemporaryExpr(op->getType(), OrigOp.take(), true, 0);
John McCall8d08b9b2010-08-27 09:08:28 +00008766 } else if (isa<ObjCSelectorExpr>(op)) {
Richard Smithaf9de912013-07-11 02:26:56 +00008767 return Context.getPointerType(op->getType());
John McCall8d08b9b2010-08-27 09:08:28 +00008768 } else if (lval == Expr::LV_MemberFunction) {
8769 // If it's an instance method, make a member pointer.
8770 // The expression must have exactly the form &A::foo.
8771
8772 // If the underlying expression isn't a decl ref, give up.
8773 if (!isa<DeclRefExpr>(op)) {
Richard Smithaf9de912013-07-11 02:26:56 +00008774 Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
John McCall526ab472011-10-25 17:37:35 +00008775 << OrigOp.get()->getSourceRange();
John McCall8d08b9b2010-08-27 09:08:28 +00008776 return QualType();
8777 }
8778 DeclRefExpr *DRE = cast<DeclRefExpr>(op);
8779 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());
8780
8781 // The id-expression was parenthesized.
John McCall526ab472011-10-25 17:37:35 +00008782 if (OrigOp.get() != DRE) {
Richard Smithaf9de912013-07-11 02:26:56 +00008783 Diag(OpLoc, diag::err_parens_pointer_member_function)
John McCall526ab472011-10-25 17:37:35 +00008784 << OrigOp.get()->getSourceRange();
John McCall8d08b9b2010-08-27 09:08:28 +00008785
8786 // The method was named without a qualifier.
8787 } else if (!DRE->getQualifier()) {
David Blaikiec2ff8e12012-10-11 22:55:07 +00008788 if (MD->getParent()->getName().empty())
Richard Smithaf9de912013-07-11 02:26:56 +00008789 Diag(OpLoc, diag::err_unqualified_pointer_member_function)
David Blaikiec2ff8e12012-10-11 22:55:07 +00008790 << op->getSourceRange();
8791 else {
8792 SmallString<32> Str;
8793 StringRef Qual = (MD->getParent()->getName() + "::").toStringRef(Str);
Richard Smithaf9de912013-07-11 02:26:56 +00008794 Diag(OpLoc, diag::err_unqualified_pointer_member_function)
David Blaikiec2ff8e12012-10-11 22:55:07 +00008795 << op->getSourceRange()
8796 << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual);
8797 }
John McCall8d08b9b2010-08-27 09:08:28 +00008798 }
8799
Benjamin Kramer915d1692013-10-10 09:44:41 +00008800 // Taking the address of a dtor is illegal per C++ [class.dtor]p2.
8801 if (isa<CXXDestructorDecl>(MD))
8802 Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange();
8803
Richard Smithaf9de912013-07-11 02:26:56 +00008804 return Context.getMemberPointerType(op->getType(),
8805 Context.getTypeDeclType(MD->getParent()).getTypePtr());
John McCall8d08b9b2010-08-27 09:08:28 +00008806 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
Eli Friedmance7f9002009-05-16 23:27:50 +00008807 // C99 6.5.3.2p1
Eli Friedman3a1e6922009-04-20 08:23:18 +00008808 // The operand must be either an l-value or a function designator
Eli Friedmance7f9002009-05-16 23:27:50 +00008809 if (!op->getType()->isFunctionType()) {
John McCall526ab472011-10-25 17:37:35 +00008810 // Use a special diagnostic for loads from property references.
John McCallfe96e0b2011-11-06 09:01:30 +00008811 if (isa<PseudoObjectExpr>(op)) {
John McCall526ab472011-10-25 17:37:35 +00008812 AddressOfError = AO_Property_Expansion;
8813 } else {
Richard Smithaf9de912013-07-11 02:26:56 +00008814 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
Richard Smithc084bd282013-02-02 02:14:45 +00008815 << op->getType() << op->getSourceRange();
John McCall526ab472011-10-25 17:37:35 +00008816 return QualType();
8817 }
Steve Naroff35d85152007-05-07 00:24:15 +00008818 }
John McCall086a4642010-11-24 05:12:34 +00008819 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1
Eli Friedman3a1e6922009-04-20 08:23:18 +00008820 // The operand cannot be a bit-field
Richard Trieu5f376f62011-09-07 21:46:33 +00008821 AddressOfError = AO_Bit_Field;
John McCall086a4642010-11-24 05:12:34 +00008822 } else if (op->getObjectKind() == OK_VectorComponent) {
Eli Friedman3a1e6922009-04-20 08:23:18 +00008823 // The operand cannot be an element of a vector
Richard Trieu5f376f62011-09-07 21:46:33 +00008824 AddressOfError = AO_Vector_Element;
Steve Naroffb96e4ab62008-02-29 23:30:25 +00008825 } else if (dcl) { // C99 6.5.3.2p1
Mike Stump4e1f26a2009-02-19 03:04:26 +00008826 // We have an lvalue with a decl. Make sure the decl is not declared
Steve Naroff47500512007-04-19 23:00:49 +00008827 // with the register storage-class specifier.
8828 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
Fariborz Jahaniane0fd5a92010-08-24 22:21:48 +00008829 // in C++ it is not error to take address of a register
8830 // variable (c++03 7.1.1P3)
John McCall8e7d6562010-08-26 03:08:43 +00008831 if (vd->getStorageClass() == SC_Register &&
Richard Smithaf9de912013-07-11 02:26:56 +00008832 !getLangOpts().CPlusPlus) {
Richard Trieu5f376f62011-09-07 21:46:33 +00008833 AddressOfError = AO_Register_Variable;
Steve Naroff35d85152007-05-07 00:24:15 +00008834 }
John McCalld14a8642009-11-21 08:51:07 +00008835 } else if (isa<FunctionTemplateDecl>(dcl)) {
Richard Smithaf9de912013-07-11 02:26:56 +00008836 return Context.OverloadTy;
John McCallf3a88602011-02-03 08:15:49 +00008837 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) {
Douglas Gregor9aa8b552008-12-10 21:26:49 +00008838 // Okay: we can take the address of a field.
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00008839 // Could be a pointer to member, though, if there is an explicit
8840 // scope qualifier for the class.
Douglas Gregor4bd90e52009-10-23 18:54:35 +00008841 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) {
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00008842 DeclContext *Ctx = dcl->getDeclContext();
Anders Carlsson0b675f52009-07-08 21:45:58 +00008843 if (Ctx && Ctx->isRecord()) {
John McCallf3a88602011-02-03 08:15:49 +00008844 if (dcl->getType()->isReferenceType()) {
Richard Smithaf9de912013-07-11 02:26:56 +00008845 Diag(OpLoc,
8846 diag::err_cannot_form_pointer_to_member_of_reference_type)
John McCallf3a88602011-02-03 08:15:49 +00008847 << dcl->getDeclName() << dcl->getType();
Anders Carlsson0b675f52009-07-08 21:45:58 +00008848 return QualType();
8849 }
Mike Stump11289f42009-09-09 15:08:12 +00008850
Argyrios Kyrtzidis8322b422011-01-31 07:04:29 +00008851 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion())
8852 Ctx = Ctx->getParent();
Richard Smithaf9de912013-07-11 02:26:56 +00008853 return Context.getMemberPointerType(op->getType(),
8854 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr());
Anders Carlsson0b675f52009-07-08 21:45:58 +00008855 }
Sebastian Redl3d3f75a2009-02-03 20:19:35 +00008856 }
Eli Friedman755c0c92011-08-26 20:28:17 +00008857 } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl))
David Blaikie83d382b2011-09-23 05:06:16 +00008858 llvm_unreachable("Unknown/unexpected decl type");
Steve Naroff47500512007-04-19 23:00:49 +00008859 }
Sebastian Redl18f8ff62009-02-04 21:23:32 +00008860
Richard Trieu5f376f62011-09-07 21:46:33 +00008861 if (AddressOfError != AO_No_Error) {
Richard Smithaf9de912013-07-11 02:26:56 +00008862 diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError);
Richard Trieu5f376f62011-09-07 21:46:33 +00008863 return QualType();
8864 }
8865
Eli Friedmance7f9002009-05-16 23:27:50 +00008866 if (lval == Expr::LV_IncompleteVoidType) {
8867 // Taking the address of a void variable is technically illegal, but we
8868 // allow it in cases which are otherwise valid.
8869 // Example: "extern void x; void* y = &x;".
Richard Smithaf9de912013-07-11 02:26:56 +00008870 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange();
Eli Friedmance7f9002009-05-16 23:27:50 +00008871 }
8872
Steve Naroff47500512007-04-19 23:00:49 +00008873 // If the operand has type "type", the result has type "pointer to type".
Douglas Gregor0bdcb8a2010-07-29 16:05:45 +00008874 if (op->getType()->isObjCObjectType())
Richard Smithaf9de912013-07-11 02:26:56 +00008875 return Context.getObjCObjectPointerType(op->getType());
8876 return Context.getPointerType(op->getType());
Steve Naroff47500512007-04-19 23:00:49 +00008877}
8878
Chris Lattner9156f1b2010-07-05 19:17:26 +00008879/// CheckIndirectionOperand - Type check unary indirection (prefix '*').
John McCall4bc41ae2010-11-18 19:01:18 +00008880static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
8881 SourceLocation OpLoc) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008882 if (Op->isTypeDependent())
John McCall4bc41ae2010-11-18 19:01:18 +00008883 return S.Context.DependentTy;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00008884
John Wiegley01296292011-04-08 18:41:53 +00008885 ExprResult ConvResult = S.UsualUnaryConversions(Op);
8886 if (ConvResult.isInvalid())
8887 return QualType();
8888 Op = ConvResult.take();
Chris Lattner9156f1b2010-07-05 19:17:26 +00008889 QualType OpTy = Op->getType();
8890 QualType Result;
Argyrios Kyrtzidis69a2c922011-05-02 18:21:19 +00008891
8892 if (isa<CXXReinterpretCastExpr>(Op)) {
8893 QualType OpOrigType = Op->IgnoreParenCasts()->getType();
8894 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
8895 Op->getSourceRange());
8896 }
8897
Chris Lattner9156f1b2010-07-05 19:17:26 +00008898 // Note that per both C89 and C99, indirection is always legal, even if OpTy
8899 // is an incomplete type or void. It would be possible to warn about
8900 // dereferencing a void pointer, but it's completely well-defined, and such a
8901 // warning is unlikely to catch any mistakes.
8902 if (const PointerType *PT = OpTy->getAs<PointerType>())
8903 Result = PT->getPointeeType();
8904 else if (const ObjCObjectPointerType *OPT =
8905 OpTy->getAs<ObjCObjectPointerType>())
8906 Result = OPT->getPointeeType();
John McCall36226622010-10-12 02:09:17 +00008907 else {
John McCall3aef3d82011-04-10 19:13:55 +00008908 ExprResult PR = S.CheckPlaceholderExpr(Op);
John McCall36226622010-10-12 02:09:17 +00008909 if (PR.isInvalid()) return QualType();
John McCall4bc41ae2010-11-18 19:01:18 +00008910 if (PR.take() != Op)
8911 return CheckIndirectionOperand(S, PR.take(), VK, OpLoc);
John McCall36226622010-10-12 02:09:17 +00008912 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00008913
Chris Lattner9156f1b2010-07-05 19:17:26 +00008914 if (Result.isNull()) {
John McCall4bc41ae2010-11-18 19:01:18 +00008915 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
Chris Lattner9156f1b2010-07-05 19:17:26 +00008916 << OpTy << Op->getSourceRange();
8917 return QualType();
8918 }
John McCall4bc41ae2010-11-18 19:01:18 +00008919
8920 // Dereferences are usually l-values...
8921 VK = VK_LValue;
8922
8923 // ...except that certain expressions are never l-values in C.
David Blaikiebbafb8a2012-03-11 07:00:24 +00008924 if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType())
John McCall4bc41ae2010-11-18 19:01:18 +00008925 VK = VK_RValue;
Chris Lattner9156f1b2010-07-05 19:17:26 +00008926
8927 return Result;
Steve Naroff1926c832007-04-24 00:23:05 +00008928}
Steve Naroff218bc2b2007-05-04 21:54:46 +00008929
John McCalle3027922010-08-25 11:45:40 +00008930static inline BinaryOperatorKind ConvertTokenKindToBinaryOpcode(
Steve Naroff218bc2b2007-05-04 21:54:46 +00008931 tok::TokenKind Kind) {
John McCalle3027922010-08-25 11:45:40 +00008932 BinaryOperatorKind Opc;
Steve Naroff218bc2b2007-05-04 21:54:46 +00008933 switch (Kind) {
David Blaikie83d382b2011-09-23 05:06:16 +00008934 default: llvm_unreachable("Unknown binop!");
John McCalle3027922010-08-25 11:45:40 +00008935 case tok::periodstar: Opc = BO_PtrMemD; break;
8936 case tok::arrowstar: Opc = BO_PtrMemI; break;
8937 case tok::star: Opc = BO_Mul; break;
8938 case tok::slash: Opc = BO_Div; break;
8939 case tok::percent: Opc = BO_Rem; break;
8940 case tok::plus: Opc = BO_Add; break;
8941 case tok::minus: Opc = BO_Sub; break;
8942 case tok::lessless: Opc = BO_Shl; break;
8943 case tok::greatergreater: Opc = BO_Shr; break;
8944 case tok::lessequal: Opc = BO_LE; break;
8945 case tok::less: Opc = BO_LT; break;
8946 case tok::greaterequal: Opc = BO_GE; break;
8947 case tok::greater: Opc = BO_GT; break;
8948 case tok::exclaimequal: Opc = BO_NE; break;
8949 case tok::equalequal: Opc = BO_EQ; break;
8950 case tok::amp: Opc = BO_And; break;
8951 case tok::caret: Opc = BO_Xor; break;
8952 case tok::pipe: Opc = BO_Or; break;
8953 case tok::ampamp: Opc = BO_LAnd; break;
8954 case tok::pipepipe: Opc = BO_LOr; break;
8955 case tok::equal: Opc = BO_Assign; break;
8956 case tok::starequal: Opc = BO_MulAssign; break;
8957 case tok::slashequal: Opc = BO_DivAssign; break;
8958 case tok::percentequal: Opc = BO_RemAssign; break;
8959 case tok::plusequal: Opc = BO_AddAssign; break;
8960 case tok::minusequal: Opc = BO_SubAssign; break;
8961 case tok::lesslessequal: Opc = BO_ShlAssign; break;
8962 case tok::greatergreaterequal: Opc = BO_ShrAssign; break;
8963 case tok::ampequal: Opc = BO_AndAssign; break;
8964 case tok::caretequal: Opc = BO_XorAssign; break;
8965 case tok::pipeequal: Opc = BO_OrAssign; break;
8966 case tok::comma: Opc = BO_Comma; break;
Steve Naroff218bc2b2007-05-04 21:54:46 +00008967 }
8968 return Opc;
8969}
8970
John McCalle3027922010-08-25 11:45:40 +00008971static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
Steve Naroff35d85152007-05-07 00:24:15 +00008972 tok::TokenKind Kind) {
John McCalle3027922010-08-25 11:45:40 +00008973 UnaryOperatorKind Opc;
Steve Naroff35d85152007-05-07 00:24:15 +00008974 switch (Kind) {
David Blaikie83d382b2011-09-23 05:06:16 +00008975 default: llvm_unreachable("Unknown unary op!");
John McCalle3027922010-08-25 11:45:40 +00008976 case tok::plusplus: Opc = UO_PreInc; break;
8977 case tok::minusminus: Opc = UO_PreDec; break;
8978 case tok::amp: Opc = UO_AddrOf; break;
8979 case tok::star: Opc = UO_Deref; break;
8980 case tok::plus: Opc = UO_Plus; break;
8981 case tok::minus: Opc = UO_Minus; break;
8982 case tok::tilde: Opc = UO_Not; break;
8983 case tok::exclaim: Opc = UO_LNot; break;
8984 case tok::kw___real: Opc = UO_Real; break;
8985 case tok::kw___imag: Opc = UO_Imag; break;
8986 case tok::kw___extension__: Opc = UO_Extension; break;
Steve Naroff35d85152007-05-07 00:24:15 +00008987 }
8988 return Opc;
8989}
8990
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00008991/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
8992/// This warning is only emitted for builtin assignment operations. It is also
8993/// suppressed in the event of macro expansions.
Richard Trieuda4f43a62011-09-07 01:33:52 +00008994static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00008995 SourceLocation OpLoc) {
8996 if (!S.ActiveTemplateInstantiations.empty())
8997 return;
8998 if (OpLoc.isInvalid() || OpLoc.isMacroID())
8999 return;
Richard Trieuda4f43a62011-09-07 01:33:52 +00009000 LHSExpr = LHSExpr->IgnoreParenImpCasts();
9001 RHSExpr = RHSExpr->IgnoreParenImpCasts();
9002 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
9003 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
9004 if (!LHSDeclRef || !RHSDeclRef ||
9005 LHSDeclRef->getLocation().isMacroID() ||
9006 RHSDeclRef->getLocation().isMacroID())
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00009007 return;
Richard Trieuda4f43a62011-09-07 01:33:52 +00009008 const ValueDecl *LHSDecl =
9009 cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
9010 const ValueDecl *RHSDecl =
9011 cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
9012 if (LHSDecl != RHSDecl)
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00009013 return;
Richard Trieuda4f43a62011-09-07 01:33:52 +00009014 if (LHSDecl->getType().isVolatileQualified())
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00009015 return;
Richard Trieuda4f43a62011-09-07 01:33:52 +00009016 if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>())
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00009017 if (RefTy->getPointeeType().isVolatileQualified())
9018 return;
9019
9020 S.Diag(OpLoc, diag::warn_self_assignment)
Richard Trieuda4f43a62011-09-07 01:33:52 +00009021 << LHSDeclRef->getType()
9022 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange();
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00009023}
9024
Ted Kremenekebeabab2013-04-22 22:46:52 +00009025/// Check if a bitwise-& is performed on an Objective-C pointer. This
9026/// is usually indicative of introspection within the Objective-C pointer.
9027static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
9028 SourceLocation OpLoc) {
9029 if (!S.getLangOpts().ObjC1)
9030 return;
9031
9032 const Expr *ObjCPointerExpr = 0, *OtherExpr = 0;
9033 const Expr *LHS = L.get();
9034 const Expr *RHS = R.get();
9035
9036 if (LHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
9037 ObjCPointerExpr = LHS;
9038 OtherExpr = RHS;
9039 }
9040 else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
9041 ObjCPointerExpr = RHS;
9042 OtherExpr = LHS;
9043 }
9044
9045 // This warning is deliberately made very specific to reduce false
9046 // positives with logic that uses '&' for hashing. This logic mainly
9047 // looks for code trying to introspect into tagged pointers, which
9048 // code should generally never do.
9049 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) {
Ted Kremenek009d61d2013-06-24 21:35:39 +00009050 unsigned Diag = diag::warn_objc_pointer_masking;
9051 // Determine if we are introspecting the result of performSelectorXXX.
9052 const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts();
9053 // Special case messages to -performSelector and friends, which
9054 // can return non-pointer values boxed in a pointer value.
9055 // Some clients may wish to silence warnings in this subcase.
9056 if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) {
9057 Selector S = ME->getSelector();
9058 StringRef SelArg0 = S.getNameForSlot(0);
9059 if (SelArg0.startswith("performSelector"))
9060 Diag = diag::warn_objc_pointer_masking_performSelector;
9061 }
9062
9063 S.Diag(OpLoc, Diag)
Ted Kremenekebeabab2013-04-22 22:46:52 +00009064 << ObjCPointerExpr->getSourceRange();
9065 }
9066}
9067
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009068/// CreateBuiltinBinOp - Creates a new built-in binary operation with
9069/// operator @p Opc at location @c TokLoc. This routine only supports
9070/// built-in operations; ActOnBinOp handles overloaded operators.
John McCalldadc5752010-08-24 06:29:42 +00009071ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
Argyrios Kyrtzidis7a808c02011-01-05 20:09:36 +00009072 BinaryOperatorKind Opc,
Richard Trieu4a287fb2011-09-07 01:49:20 +00009073 Expr *LHSExpr, Expr *RHSExpr) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +00009074 if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) {
Sebastian Redl67766732012-02-27 20:34:02 +00009075 // The syntax only allows initializer lists on the RHS of assignment,
9076 // so we don't need to worry about accepting invalid code for
9077 // non-assignment operators.
9078 // C++11 5.17p9:
9079 // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning
9080 // of x = {} is x = T().
9081 InitializationKind Kind =
9082 InitializationKind::CreateDirectList(RHSExpr->getLocStart());
9083 InitializedEntity Entity =
9084 InitializedEntity::InitializeTemporary(LHSExpr->getType());
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +00009085 InitializationSequence InitSeq(*this, Entity, Kind, RHSExpr);
Benjamin Kramercc4c49d2012-08-23 23:38:35 +00009086 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr);
Sebastian Redl67766732012-02-27 20:34:02 +00009087 if (Init.isInvalid())
9088 return Init;
9089 RHSExpr = Init.take();
9090 }
9091
Richard Trieu4a287fb2011-09-07 01:49:20 +00009092 ExprResult LHS = Owned(LHSExpr), RHS = Owned(RHSExpr);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009093 QualType ResultTy; // Result type of the binary operator.
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009094 // The following two variables are used for compound assignment operators
9095 QualType CompLHSTy; // Type of LHS after promotions for computation
9096 QualType CompResultTy; // Type of computation result
John McCall7decc9e2010-11-18 06:31:45 +00009097 ExprValueKind VK = VK_RValue;
9098 ExprObjectKind OK = OK_Ordinary;
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009099
9100 switch (Opc) {
John McCalle3027922010-08-25 11:45:40 +00009101 case BO_Assign:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009102 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType());
David Blaikiebbafb8a2012-03-11 07:00:24 +00009103 if (getLangOpts().CPlusPlus &&
Richard Trieu4a287fb2011-09-07 01:49:20 +00009104 LHS.get()->getObjectKind() != OK_ObjCProperty) {
9105 VK = LHS.get()->getValueKind();
9106 OK = LHS.get()->getObjectKind();
John McCall7decc9e2010-11-18 06:31:45 +00009107 }
Chandler Carruthe0cee6a2011-01-04 06:52:15 +00009108 if (!ResultTy.isNull())
Richard Trieu4a287fb2011-09-07 01:49:20 +00009109 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009110 break;
John McCalle3027922010-08-25 11:45:40 +00009111 case BO_PtrMemD:
9112 case BO_PtrMemI:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009113 ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
John McCalle3027922010-08-25 11:45:40 +00009114 Opc == BO_PtrMemI);
Sebastian Redl112a97662009-02-07 00:15:38 +00009115 break;
John McCalle3027922010-08-25 11:45:40 +00009116 case BO_Mul:
9117 case BO_Div:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009118 ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false,
John McCalle3027922010-08-25 11:45:40 +00009119 Opc == BO_Div);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009120 break;
John McCalle3027922010-08-25 11:45:40 +00009121 case BO_Rem:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009122 ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009123 break;
John McCalle3027922010-08-25 11:45:40 +00009124 case BO_Add:
Nico Weberccec40d2012-03-02 22:01:22 +00009125 ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009126 break;
John McCalle3027922010-08-25 11:45:40 +00009127 case BO_Sub:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009128 ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009129 break;
John McCalle3027922010-08-25 11:45:40 +00009130 case BO_Shl:
9131 case BO_Shr:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009132 ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009133 break;
John McCalle3027922010-08-25 11:45:40 +00009134 case BO_LE:
9135 case BO_LT:
9136 case BO_GE:
9137 case BO_GT:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009138 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, true);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009139 break;
John McCalle3027922010-08-25 11:45:40 +00009140 case BO_EQ:
9141 case BO_NE:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009142 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, false);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009143 break;
John McCalle3027922010-08-25 11:45:40 +00009144 case BO_And:
Ted Kremenekebeabab2013-04-22 22:46:52 +00009145 checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc);
John McCalle3027922010-08-25 11:45:40 +00009146 case BO_Xor:
9147 case BO_Or:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009148 ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009149 break;
John McCalle3027922010-08-25 11:45:40 +00009150 case BO_LAnd:
9151 case BO_LOr:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009152 ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009153 break;
John McCalle3027922010-08-25 11:45:40 +00009154 case BO_MulAssign:
9155 case BO_DivAssign:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009156 CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true,
John McCall7decc9e2010-11-18 06:31:45 +00009157 Opc == BO_DivAssign);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009158 CompLHSTy = CompResultTy;
Richard Trieu4a287fb2011-09-07 01:49:20 +00009159 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
9160 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009161 break;
John McCalle3027922010-08-25 11:45:40 +00009162 case BO_RemAssign:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009163 CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009164 CompLHSTy = CompResultTy;
Richard Trieu4a287fb2011-09-07 01:49:20 +00009165 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
9166 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009167 break;
John McCalle3027922010-08-25 11:45:40 +00009168 case BO_AddAssign:
Nico Weberccec40d2012-03-02 22:01:22 +00009169 CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy);
Richard Trieu4a287fb2011-09-07 01:49:20 +00009170 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
9171 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009172 break;
John McCalle3027922010-08-25 11:45:40 +00009173 case BO_SubAssign:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009174 CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy);
9175 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
9176 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009177 break;
John McCalle3027922010-08-25 11:45:40 +00009178 case BO_ShlAssign:
9179 case BO_ShrAssign:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009180 CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009181 CompLHSTy = CompResultTy;
Richard Trieu4a287fb2011-09-07 01:49:20 +00009182 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
9183 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009184 break;
John McCalle3027922010-08-25 11:45:40 +00009185 case BO_AndAssign:
9186 case BO_XorAssign:
9187 case BO_OrAssign:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009188 CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, true);
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009189 CompLHSTy = CompResultTy;
Richard Trieu4a287fb2011-09-07 01:49:20 +00009190 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid())
9191 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy);
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009192 break;
John McCalle3027922010-08-25 11:45:40 +00009193 case BO_Comma:
Richard Trieu4a287fb2011-09-07 01:49:20 +00009194 ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc);
David Blaikiebbafb8a2012-03-11 07:00:24 +00009195 if (getLangOpts().CPlusPlus && !RHS.isInvalid()) {
Richard Trieu4a287fb2011-09-07 01:49:20 +00009196 VK = RHS.get()->getValueKind();
9197 OK = RHS.get()->getObjectKind();
John McCall7decc9e2010-11-18 06:31:45 +00009198 }
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009199 break;
9200 }
Richard Trieu4a287fb2011-09-07 01:49:20 +00009201 if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid())
Sebastian Redlb5d49352009-01-19 22:31:54 +00009202 return ExprError();
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00009203
9204 // Check for array bounds violations for both sides of the BinaryOperator
Richard Trieu4a287fb2011-09-07 01:49:20 +00009205 CheckArrayAccess(LHS.get());
9206 CheckArrayAccess(RHS.get());
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00009207
Fariborz Jahanian06bb7f72013-03-28 19:50:55 +00009208 if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
9209 NamedDecl *ObjectSetClass = LookupSingleName(TUScope,
9210 &Context.Idents.get("object_setClass"),
9211 SourceLocation(), LookupOrdinaryName);
9212 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {
9213 SourceLocation RHSLocEnd = PP.getLocForEndOfToken(RHS.get()->getLocEnd());
9214 Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign) <<
9215 FixItHint::CreateInsertion(LHS.get()->getLocStart(), "object_setClass(") <<
9216 FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc), ",") <<
9217 FixItHint::CreateInsertion(RHSLocEnd, ")");
9218 }
9219 else
9220 Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);
9221 }
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +00009222 else if (const ObjCIvarRefExpr *OIRE =
9223 dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
Fariborz Jahanianf12ff4df2013-04-02 18:57:54 +00009224 DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());
Fariborz Jahanian3b602ce2013-03-28 23:39:11 +00009225
Eli Friedman8b7b1b12009-03-28 01:22:36 +00009226 if (CompResultTy.isNull())
Richard Trieu4a287fb2011-09-07 01:49:20 +00009227 return Owned(new (Context) BinaryOperator(LHS.take(), RHS.take(), Opc,
Lang Hames5de91cc2012-10-02 04:45:10 +00009228 ResultTy, VK, OK, OpLoc,
9229 FPFeatures.fp_contract));
David Blaikiebbafb8a2012-03-11 07:00:24 +00009230 if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
Richard Trieucfc491d2011-08-02 04:35:43 +00009231 OK_ObjCProperty) {
John McCall7decc9e2010-11-18 06:31:45 +00009232 VK = VK_LValue;
Richard Trieu4a287fb2011-09-07 01:49:20 +00009233 OK = LHS.get()->getObjectKind();
John McCall7decc9e2010-11-18 06:31:45 +00009234 }
Richard Trieu4a287fb2011-09-07 01:49:20 +00009235 return Owned(new (Context) CompoundAssignOperator(LHS.take(), RHS.take(), Opc,
John Wiegley01296292011-04-08 18:41:53 +00009236 ResultTy, VK, OK, CompLHSTy,
Lang Hames5de91cc2012-10-02 04:45:10 +00009237 CompResultTy, OpLoc,
9238 FPFeatures.fp_contract));
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009239}
9240
Sebastian Redl44615072009-10-27 12:10:02 +00009241/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
9242/// operators are mixed in a way that suggests that the programmer forgot that
9243/// comparison operators have higher precedence. The most typical example of
9244/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
John McCalle3027922010-08-25 11:45:40 +00009245static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc,
Richard Trieu4a287fb2011-09-07 01:49:20 +00009246 SourceLocation OpLoc, Expr *LHSExpr,
9247 Expr *RHSExpr) {
Eli Friedman37feb2d2012-11-15 00:29:07 +00009248 BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr);
9249 BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr);
Sebastian Redl43028242009-10-26 15:24:15 +00009250
Eli Friedman37feb2d2012-11-15 00:29:07 +00009251 // Check that one of the sides is a comparison operator.
9252 bool isLeftComp = LHSBO && LHSBO->isComparisonOp();
9253 bool isRightComp = RHSBO && RHSBO->isComparisonOp();
9254 if (!isLeftComp && !isRightComp)
Sebastian Redl43028242009-10-26 15:24:15 +00009255 return;
9256
9257 // Bitwise operations are sometimes used as eager logical ops.
9258 // Don't diagnose this.
Eli Friedman37feb2d2012-11-15 00:29:07 +00009259 bool isLeftBitwise = LHSBO && LHSBO->isBitwiseOp();
9260 bool isRightBitwise = RHSBO && RHSBO->isBitwiseOp();
9261 if ((isLeftComp || isLeftBitwise) && (isRightComp || isRightBitwise))
Sebastian Redl43028242009-10-26 15:24:15 +00009262 return;
9263
Richard Trieu4a287fb2011-09-07 01:49:20 +00009264 SourceRange DiagRange = isLeftComp ? SourceRange(LHSExpr->getLocStart(),
9265 OpLoc)
9266 : SourceRange(OpLoc, RHSExpr->getLocEnd());
Eli Friedman37feb2d2012-11-15 00:29:07 +00009267 StringRef OpStr = isLeftComp ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr();
Richard Trieu73088052011-08-10 22:41:34 +00009268 SourceRange ParensRange = isLeftComp ?
Eli Friedman37feb2d2012-11-15 00:29:07 +00009269 SourceRange(LHSBO->getRHS()->getLocStart(), RHSExpr->getLocEnd())
9270 : SourceRange(LHSExpr->getLocStart(), RHSBO->getLHS()->getLocStart());
Richard Trieu73088052011-08-10 22:41:34 +00009271
9272 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
Eli Friedman37feb2d2012-11-15 00:29:07 +00009273 << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
Richard Trieu73088052011-08-10 22:41:34 +00009274 SuggestParentheses(Self, OpLoc,
David Blaikiedac86fd2012-10-08 01:19:49 +00009275 Self.PDiag(diag::note_precedence_silence) << OpStr,
Nico Webercdfb1ae2012-06-03 07:07:00 +00009276 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
Richard Trieu73088052011-08-10 22:41:34 +00009277 SuggestParentheses(Self, OpLoc,
Eli Friedman37feb2d2012-11-15 00:29:07 +00009278 Self.PDiag(diag::note_precedence_bitwise_first)
9279 << BinaryOperator::getOpcodeStr(Opc),
Richard Trieu73088052011-08-10 22:41:34 +00009280 ParensRange);
Sebastian Redl43028242009-10-26 15:24:15 +00009281}
9282
Argyrios Kyrtzidis01bf7772011-06-20 18:41:26 +00009283/// \brief It accepts a '&' expr that is inside a '|' one.
9284/// Emit a diagnostic together with a fixit hint that wraps the '&' expression
9285/// in parentheses.
9286static void
9287EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc,
9288 BinaryOperator *Bop) {
9289 assert(Bop->getOpcode() == BO_And);
9290 Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or)
9291 << Bop->getSourceRange() << OpLoc;
9292 SuggestParentheses(Self, Bop->getOperatorLoc(),
David Blaikiedac86fd2012-10-08 01:19:49 +00009293 Self.PDiag(diag::note_precedence_silence)
9294 << Bop->getOpcodeStr(),
Argyrios Kyrtzidis01bf7772011-06-20 18:41:26 +00009295 Bop->getSourceRange());
9296}
9297
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009298/// \brief It accepts a '&&' expr that is inside a '||' one.
9299/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
9300/// in parentheses.
9301static void
9302EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
Argyrios Kyrtzidisad8b4d42011-04-22 19:16:27 +00009303 BinaryOperator *Bop) {
9304 assert(Bop->getOpcode() == BO_LAnd);
Chandler Carruthb00e8c02011-06-16 01:05:14 +00009305 Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)
9306 << Bop->getSourceRange() << OpLoc;
Argyrios Kyrtzidisad8b4d42011-04-22 19:16:27 +00009307 SuggestParentheses(Self, Bop->getOperatorLoc(),
David Blaikiedac86fd2012-10-08 01:19:49 +00009308 Self.PDiag(diag::note_precedence_silence)
9309 << Bop->getOpcodeStr(),
Chandler Carruthb00e8c02011-06-16 01:05:14 +00009310 Bop->getSourceRange());
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009311}
9312
9313/// \brief Returns true if the given expression can be evaluated as a constant
9314/// 'true'.
9315static bool EvaluatesAsTrue(Sema &S, Expr *E) {
9316 bool Res;
Richard Smitha6c87032013-08-19 22:06:05 +00009317 return !E->isValueDependent() &&
9318 E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res;
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009319}
9320
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00009321/// \brief Returns true if the given expression can be evaluated as a constant
9322/// 'false'.
9323static bool EvaluatesAsFalse(Sema &S, Expr *E) {
9324 bool Res;
Richard Smitha6c87032013-08-19 22:06:05 +00009325 return !E->isValueDependent() &&
9326 E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res;
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00009327}
9328
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009329/// \brief Look for '&&' in the left hand of a '||' expr.
9330static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc,
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009331 Expr *LHSExpr, Expr *RHSExpr) {
9332 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) {
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00009333 if (Bop->getOpcode() == BO_LAnd) {
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00009334 // If it's "a && b || 0" don't warn since the precedence doesn't matter.
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009335 if (EvaluatesAsFalse(S, RHSExpr))
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00009336 return;
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009337 // If it's "1 && a || b" don't warn since the precedence doesn't matter.
9338 if (!EvaluatesAsTrue(S, Bop->getLHS()))
9339 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
9340 } else if (Bop->getOpcode() == BO_LOr) {
9341 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
9342 // If it's "a || b && 1 || c" we didn't warn earlier for
9343 // "a || b && 1", but warn now.
9344 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS()))
9345 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop);
9346 }
9347 }
9348 }
9349}
9350
9351/// \brief Look for '&&' in the right hand of a '||' expr.
9352static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc,
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009353 Expr *LHSExpr, Expr *RHSExpr) {
9354 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) {
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009355 if (Bop->getOpcode() == BO_LAnd) {
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00009356 // If it's "0 || a && b" don't warn since the precedence doesn't matter.
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009357 if (EvaluatesAsFalse(S, LHSExpr))
Argyrios Kyrtzidis56e879d2010-11-17 19:18:19 +00009358 return;
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009359 // If it's "a || b && 1" don't warn since the precedence doesn't matter.
9360 if (!EvaluatesAsTrue(S, Bop->getRHS()))
9361 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00009362 }
9363 }
9364}
9365
Argyrios Kyrtzidis01bf7772011-06-20 18:41:26 +00009366/// \brief Look for '&' in the left or right hand of a '|' expr.
9367static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc,
9368 Expr *OrArg) {
9369 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) {
9370 if (Bop->getOpcode() == BO_And)
9371 return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop);
9372 }
9373}
9374
David Blaikie15f17cb2012-10-05 00:41:03 +00009375static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc,
David Blaikie82d3ab92012-10-19 18:26:06 +00009376 Expr *SubExpr, StringRef Shift) {
David Blaikie15f17cb2012-10-05 00:41:03 +00009377 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
9378 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {
David Blaikiedac86fd2012-10-08 01:19:49 +00009379 StringRef Op = Bop->getOpcodeStr();
David Blaikie15f17cb2012-10-05 00:41:03 +00009380 S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
David Blaikie82d3ab92012-10-19 18:26:06 +00009381 << Bop->getSourceRange() << OpLoc << Shift << Op;
David Blaikie15f17cb2012-10-05 00:41:03 +00009382 SuggestParentheses(S, Bop->getOperatorLoc(),
David Blaikiedac86fd2012-10-08 01:19:49 +00009383 S.PDiag(diag::note_precedence_silence) << Op,
David Blaikie15f17cb2012-10-05 00:41:03 +00009384 Bop->getSourceRange());
9385 }
9386 }
9387}
9388
Richard Trieufe042e62013-04-17 02:12:45 +00009389static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc,
9390 Expr *LHSExpr, Expr *RHSExpr) {
9391 CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr);
9392 if (!OCE)
9393 return;
9394
9395 FunctionDecl *FD = OCE->getDirectCallee();
9396 if (!FD || !FD->isOverloadedOperator())
9397 return;
9398
9399 OverloadedOperatorKind Kind = FD->getOverloadedOperator();
9400 if (Kind != OO_LessLess && Kind != OO_GreaterGreater)
9401 return;
9402
9403 S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison)
9404 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange()
9405 << (Kind == OO_LessLess);
Richard Trieufe042e62013-04-17 02:12:45 +00009406 SuggestParentheses(S, OCE->getOperatorLoc(),
9407 S.PDiag(diag::note_precedence_silence)
9408 << (Kind == OO_LessLess ? "<<" : ">>"),
9409 OCE->getSourceRange());
Richard Trieue0894972013-04-18 01:04:37 +00009410 SuggestParentheses(S, OpLoc,
9411 S.PDiag(diag::note_evaluate_comparison_first),
9412 SourceRange(OCE->getArg(1)->getLocStart(),
9413 RHSExpr->getLocEnd()));
Richard Trieufe042e62013-04-17 02:12:45 +00009414}
9415
Sebastian Redl43028242009-10-26 15:24:15 +00009416/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00009417/// precedence.
John McCalle3027922010-08-25 11:45:40 +00009418static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009419 SourceLocation OpLoc, Expr *LHSExpr,
9420 Expr *RHSExpr){
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00009421 // Diagnose "arg1 'bitwise' arg2 'eq' arg3".
Sebastian Redl44615072009-10-27 12:10:02 +00009422 if (BinaryOperator::isBitwiseOp(Opc))
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009423 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr);
Argyrios Kyrtzidis01bf7772011-06-20 18:41:26 +00009424
9425 // Diagnose "arg1 & arg2 | arg3"
9426 if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) {
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009427 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, LHSExpr);
9428 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, RHSExpr);
Argyrios Kyrtzidis01bf7772011-06-20 18:41:26 +00009429 }
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00009430
Argyrios Kyrtzidis14a96622010-11-17 18:26:36 +00009431 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
9432 // We don't warn for 'assert(a || b && "bad")' since this is safe.
Argyrios Kyrtzidisb94e5a32010-11-17 18:54:22 +00009433 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009434 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr);
9435 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr);
Argyrios Kyrtzidisf89a56c2010-11-16 21:00:12 +00009436 }
David Blaikie15f17cb2012-10-05 00:41:03 +00009437
9438 if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
9439 || Opc == BO_Shr) {
David Blaikie82d3ab92012-10-19 18:26:06 +00009440 StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
9441 DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
9442 DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
David Blaikie15f17cb2012-10-05 00:41:03 +00009443 }
Richard Trieufe042e62013-04-17 02:12:45 +00009444
9445 // Warn on overloaded shift operators and comparisons, such as:
9446 // cout << 5 == 4;
9447 if (BinaryOperator::isComparisonOp(Opc))
9448 DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr);
Sebastian Redl43028242009-10-26 15:24:15 +00009449}
9450
Steve Naroff218bc2b2007-05-04 21:54:46 +00009451// Binary Operators. 'Tok' is the token for the operator.
John McCalldadc5752010-08-24 06:29:42 +00009452ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
John McCalle3027922010-08-25 11:45:40 +00009453 tok::TokenKind Kind,
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009454 Expr *LHSExpr, Expr *RHSExpr) {
John McCalle3027922010-08-25 11:45:40 +00009455 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009456 assert((LHSExpr != 0) && "ActOnBinOp(): missing left expression");
9457 assert((RHSExpr != 0) && "ActOnBinOp(): missing right expression");
Steve Naroff218bc2b2007-05-04 21:54:46 +00009458
Sebastian Redl43028242009-10-26 15:24:15 +00009459 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009460 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);
Sebastian Redl43028242009-10-26 15:24:15 +00009461
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009462 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
Douglas Gregor5287f092009-11-05 00:51:44 +00009463}
9464
John McCall526ab472011-10-25 17:37:35 +00009465/// Build an overloaded binary operator expression in the given scope.
9466static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
9467 BinaryOperatorKind Opc,
9468 Expr *LHS, Expr *RHS) {
9469 // Find all of the overloaded operators visible from this
9470 // point. We perform both an operator-name lookup from the local
9471 // scope and an argument-dependent lookup based on the types of
9472 // the arguments.
9473 UnresolvedSet<16> Functions;
9474 OverloadedOperatorKind OverOp
9475 = BinaryOperator::getOverloadedOperator(Opc);
9476 if (Sc && OverOp != OO_None)
9477 S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(),
9478 RHS->getType(), Functions);
9479
9480 // Build the (potentially-overloaded, potentially-dependent)
9481 // binary operation.
9482 return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
9483}
9484
John McCalldadc5752010-08-24 06:29:42 +00009485ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
John McCalle3027922010-08-25 11:45:40 +00009486 BinaryOperatorKind Opc,
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009487 Expr *LHSExpr, Expr *RHSExpr) {
John McCall9a43e122011-10-28 01:04:34 +00009488 // We want to end up calling one of checkPseudoObjectAssignment
9489 // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if
9490 // both expressions are overloadable or either is type-dependent),
9491 // or CreateBuiltinBinOp (in any other case). We also want to get
9492 // any placeholder types out of the way.
9493
John McCall526ab472011-10-25 17:37:35 +00009494 // Handle pseudo-objects in the LHS.
9495 if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) {
9496 // Assignments with a pseudo-object l-value need special analysis.
9497 if (pty->getKind() == BuiltinType::PseudoObject &&
9498 BinaryOperator::isAssignmentOp(Opc))
9499 return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr);
9500
9501 // Don't resolve overloads if the other type is overloadable.
9502 if (pty->getKind() == BuiltinType::Overload) {
9503 // We can't actually test that if we still have a placeholder,
9504 // though. Fortunately, none of the exceptions we see in that
John McCall9a43e122011-10-28 01:04:34 +00009505 // code below are valid when the LHS is an overload set. Note
9506 // that an overload set can be dependently-typed, but it never
9507 // instantiates to having an overloadable type.
John McCall526ab472011-10-25 17:37:35 +00009508 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
9509 if (resolvedRHS.isInvalid()) return ExprError();
9510 RHSExpr = resolvedRHS.take();
9511
John McCall9a43e122011-10-28 01:04:34 +00009512 if (RHSExpr->isTypeDependent() ||
9513 RHSExpr->getType()->isOverloadableType())
John McCall526ab472011-10-25 17:37:35 +00009514 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
9515 }
9516
9517 ExprResult LHS = CheckPlaceholderExpr(LHSExpr);
9518 if (LHS.isInvalid()) return ExprError();
9519 LHSExpr = LHS.take();
9520 }
9521
9522 // Handle pseudo-objects in the RHS.
9523 if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) {
9524 // An overload in the RHS can potentially be resolved by the type
9525 // being assigned to.
John McCall9a43e122011-10-28 01:04:34 +00009526 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) {
9527 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
9528 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
9529
Eli Friedman419b1ff2012-01-17 21:27:43 +00009530 if (LHSExpr->getType()->isOverloadableType())
9531 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
9532
John McCall526ab472011-10-25 17:37:35 +00009533 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
John McCall9a43e122011-10-28 01:04:34 +00009534 }
John McCall526ab472011-10-25 17:37:35 +00009535
9536 // Don't resolve overloads if the other type is overloadable.
9537 if (pty->getKind() == BuiltinType::Overload &&
9538 LHSExpr->getType()->isOverloadableType())
9539 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
9540
9541 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
9542 if (!resolvedRHS.isUsable()) return ExprError();
9543 RHSExpr = resolvedRHS.take();
9544 }
9545
David Blaikiebbafb8a2012-03-11 07:00:24 +00009546 if (getLangOpts().CPlusPlus) {
John McCall9a43e122011-10-28 01:04:34 +00009547 // If either expression is type-dependent, always build an
9548 // overloaded op.
9549 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
9550 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009551
John McCall9a43e122011-10-28 01:04:34 +00009552 // Otherwise, build an overloaded op if either expression has an
9553 // overloadable type.
9554 if (LHSExpr->getType()->isOverloadableType() ||
9555 RHSExpr->getType()->isOverloadableType())
John McCall526ab472011-10-25 17:37:35 +00009556 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
Sebastian Redlb5d49352009-01-19 22:31:54 +00009557 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009558
Douglas Gregor7d5fc7e2008-11-06 23:29:22 +00009559 // Build a built-in binary operation.
Richard Trieuf9bd0f52011-09-07 02:02:10 +00009560 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr);
Steve Naroff218bc2b2007-05-04 21:54:46 +00009561}
9562
John McCalldadc5752010-08-24 06:29:42 +00009563ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
Argyrios Kyrtzidis7a808c02011-01-05 20:09:36 +00009564 UnaryOperatorKind Opc,
John Wiegley01296292011-04-08 18:41:53 +00009565 Expr *InputExpr) {
9566 ExprResult Input = Owned(InputExpr);
John McCall7decc9e2010-11-18 06:31:45 +00009567 ExprValueKind VK = VK_RValue;
9568 ExprObjectKind OK = OK_Ordinary;
Steve Naroff35d85152007-05-07 00:24:15 +00009569 QualType resultType;
9570 switch (Opc) {
John McCalle3027922010-08-25 11:45:40 +00009571 case UO_PreInc:
9572 case UO_PreDec:
9573 case UO_PostInc:
9574 case UO_PostDec:
John Wiegley01296292011-04-08 18:41:53 +00009575 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OpLoc,
John McCalle3027922010-08-25 11:45:40 +00009576 Opc == UO_PreInc ||
9577 Opc == UO_PostInc,
9578 Opc == UO_PreInc ||
9579 Opc == UO_PreDec);
Steve Naroff35d85152007-05-07 00:24:15 +00009580 break;
John McCalle3027922010-08-25 11:45:40 +00009581 case UO_AddrOf:
Richard Smithaf9de912013-07-11 02:26:56 +00009582 resultType = CheckAddressOfOperand(Input, OpLoc);
Steve Naroff35d85152007-05-07 00:24:15 +00009583 break;
John McCall31996342011-04-07 08:22:57 +00009584 case UO_Deref: {
John Wiegley01296292011-04-08 18:41:53 +00009585 Input = DefaultFunctionArrayLvalueConversion(Input.take());
Eli Friedman34866c72012-08-31 00:14:07 +00009586 if (Input.isInvalid()) return ExprError();
John Wiegley01296292011-04-08 18:41:53 +00009587 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc);
Steve Naroff35d85152007-05-07 00:24:15 +00009588 break;
John McCall31996342011-04-07 08:22:57 +00009589 }
John McCalle3027922010-08-25 11:45:40 +00009590 case UO_Plus:
9591 case UO_Minus:
John Wiegley01296292011-04-08 18:41:53 +00009592 Input = UsualUnaryConversions(Input.take());
9593 if (Input.isInvalid()) return ExprError();
9594 resultType = Input.get()->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00009595 if (resultType->isDependentType())
9596 break;
Douglas Gregora3208f92010-06-22 23:41:02 +00009597 if (resultType->isArithmeticType() || // C99 6.5.3.3p1
9598 resultType->isVectorType())
Douglas Gregord08452f2008-11-19 15:42:04 +00009599 break;
David Blaikiebbafb8a2012-03-11 07:00:24 +00009600 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
John McCalle3027922010-08-25 11:45:40 +00009601 Opc == UO_Plus &&
Douglas Gregord08452f2008-11-19 15:42:04 +00009602 resultType->isPointerType())
9603 break;
9604
Sebastian Redlc215cfc2009-01-19 00:08:26 +00009605 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
John Wiegley01296292011-04-08 18:41:53 +00009606 << resultType << Input.get()->getSourceRange());
9607
John McCalle3027922010-08-25 11:45:40 +00009608 case UO_Not: // bitwise complement
John Wiegley01296292011-04-08 18:41:53 +00009609 Input = UsualUnaryConversions(Input.take());
Joey Gouly7d00f002013-02-21 11:49:56 +00009610 if (Input.isInvalid())
9611 return ExprError();
John Wiegley01296292011-04-08 18:41:53 +00009612 resultType = Input.get()->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00009613 if (resultType->isDependentType())
9614 break;
Chris Lattner0d707612008-07-25 23:52:49 +00009615 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.
9616 if (resultType->isComplexType() || resultType->isComplexIntegerType())
9617 // C99 does not support '~' for complex conjugation.
Chris Lattner29e812b2008-11-20 06:06:08 +00009618 Diag(OpLoc, diag::ext_integer_complement_complex)
Joey Gouly7d00f002013-02-21 11:49:56 +00009619 << resultType << Input.get()->getSourceRange();
John McCall36226622010-10-12 02:09:17 +00009620 else if (resultType->hasIntegerRepresentation())
9621 break;
Joey Gouly7d00f002013-02-21 11:49:56 +00009622 else if (resultType->isExtVectorType()) {
9623 if (Context.getLangOpts().OpenCL) {
9624 // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate
9625 // on vector float types.
9626 QualType T = resultType->getAs<ExtVectorType>()->getElementType();
9627 if (!T->isIntegerType())
9628 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
9629 << resultType << Input.get()->getSourceRange());
9630 }
9631 break;
9632 } else {
Sebastian Redlc215cfc2009-01-19 00:08:26 +00009633 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
Joey Gouly7d00f002013-02-21 11:49:56 +00009634 << resultType << Input.get()->getSourceRange());
John McCall36226622010-10-12 02:09:17 +00009635 }
Steve Naroff35d85152007-05-07 00:24:15 +00009636 break;
John Wiegley01296292011-04-08 18:41:53 +00009637
John McCalle3027922010-08-25 11:45:40 +00009638 case UO_LNot: // logical negation
Steve Naroff71b59a92007-06-04 22:22:31 +00009639 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5).
John Wiegley01296292011-04-08 18:41:53 +00009640 Input = DefaultFunctionArrayLvalueConversion(Input.take());
9641 if (Input.isInvalid()) return ExprError();
9642 resultType = Input.get()->getType();
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00009643
9644 // Though we still have to promote half FP to float...
Joey Goulydd7f4562013-01-23 11:56:20 +00009645 if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) {
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00009646 Input = ImpCastExprToType(Input.take(), Context.FloatTy, CK_FloatingCast).take();
9647 resultType = Context.FloatTy;
9648 }
9649
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00009650 if (resultType->isDependentType())
9651 break;
Abramo Bagnara7ccce982011-04-07 09:26:19 +00009652 if (resultType->isScalarType()) {
9653 // C99 6.5.3.3p1: ok, fallthrough;
David Blaikiebbafb8a2012-03-11 07:00:24 +00009654 if (Context.getLangOpts().CPlusPlus) {
Abramo Bagnara7ccce982011-04-07 09:26:19 +00009655 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9:
9656 // operand contextually converted to bool.
John Wiegley01296292011-04-08 18:41:53 +00009657 Input = ImpCastExprToType(Input.take(), Context.BoolTy,
9658 ScalarTypeToBooleanCastKind(resultType));
Joey Gouly7d00f002013-02-21 11:49:56 +00009659 } else if (Context.getLangOpts().OpenCL &&
9660 Context.getLangOpts().OpenCLVersion < 120) {
9661 // OpenCL v1.1 6.3.h: The logical operator not (!) does not
9662 // operate on scalar float types.
9663 if (!resultType->isIntegerType())
9664 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
9665 << resultType << Input.get()->getSourceRange());
Abramo Bagnara7ccce982011-04-07 09:26:19 +00009666 }
Tanya Lattner3dd33b22012-01-19 01:16:16 +00009667 } else if (resultType->isExtVectorType()) {
Joey Gouly7d00f002013-02-21 11:49:56 +00009668 if (Context.getLangOpts().OpenCL &&
9669 Context.getLangOpts().OpenCLVersion < 120) {
9670 // OpenCL v1.1 6.3.h: The logical operator not (!) does not
9671 // operate on vector float types.
9672 QualType T = resultType->getAs<ExtVectorType>()->getElementType();
9673 if (!T->isIntegerType())
9674 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
9675 << resultType << Input.get()->getSourceRange());
9676 }
Tanya Lattner20248222012-01-16 21:02:28 +00009677 // Vector logical not returns the signed variant of the operand type.
9678 resultType = GetSignedVectorType(resultType);
9679 break;
John McCall36226622010-10-12 02:09:17 +00009680 } else {
Sebastian Redlc215cfc2009-01-19 00:08:26 +00009681 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
John Wiegley01296292011-04-08 18:41:53 +00009682 << resultType << Input.get()->getSourceRange());
John McCall36226622010-10-12 02:09:17 +00009683 }
Douglas Gregordb8c6fd2010-09-20 17:13:33 +00009684
Chris Lattnerbe31ed82007-06-02 19:11:33 +00009685 // LNot always has type int. C99 6.5.3.3p5.
Sebastian Redlc215cfc2009-01-19 00:08:26 +00009686 // In C++, it's bool. C++ 5.3.1p8
Argyrios Kyrtzidis1bdd6882011-02-18 20:55:15 +00009687 resultType = Context.getLogicalOperationType();
Steve Naroff35d85152007-05-07 00:24:15 +00009688 break;
John McCalle3027922010-08-25 11:45:40 +00009689 case UO_Real:
9690 case UO_Imag:
John McCall4bc41ae2010-11-18 19:01:18 +00009691 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real);
Richard Smith0b6b8e42012-02-18 20:53:32 +00009692 // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary
9693 // complex l-values to ordinary l-values and all other values to r-values.
John Wiegley01296292011-04-08 18:41:53 +00009694 if (Input.isInvalid()) return ExprError();
Richard Smith0b6b8e42012-02-18 20:53:32 +00009695 if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) {
9696 if (Input.get()->getValueKind() != VK_RValue &&
9697 Input.get()->getObjectKind() == OK_Ordinary)
9698 VK = Input.get()->getValueKind();
David Blaikiebbafb8a2012-03-11 07:00:24 +00009699 } else if (!getLangOpts().CPlusPlus) {
Richard Smith0b6b8e42012-02-18 20:53:32 +00009700 // In C, a volatile scalar is read by __imag. In C++, it is not.
9701 Input = DefaultLvalueConversion(Input.take());
9702 }
Chris Lattner30b5dd02007-08-24 21:16:53 +00009703 break;
John McCalle3027922010-08-25 11:45:40 +00009704 case UO_Extension:
John Wiegley01296292011-04-08 18:41:53 +00009705 resultType = Input.get()->getType();
9706 VK = Input.get()->getValueKind();
9707 OK = Input.get()->getObjectKind();
Steve Naroff043d45d2007-05-15 02:32:35 +00009708 break;
Steve Naroff35d85152007-05-07 00:24:15 +00009709 }
John Wiegley01296292011-04-08 18:41:53 +00009710 if (resultType.isNull() || Input.isInvalid())
Sebastian Redlc215cfc2009-01-19 00:08:26 +00009711 return ExprError();
Douglas Gregor084d8552009-03-13 23:49:33 +00009712
Kaelyn Uhrain2e7aa5a2011-08-05 23:18:04 +00009713 // Check for array bounds violations in the operand of the UnaryOperator,
9714 // except for the '*' and '&' operators that have to be handled specially
9715 // by CheckArrayAccess (as there are special cases like &array[arraysize]
9716 // that are explicitly defined as valid by the standard).
9717 if (Opc != UO_AddrOf && Opc != UO_Deref)
9718 CheckArrayAccess(Input.get());
9719
John Wiegley01296292011-04-08 18:41:53 +00009720 return Owned(new (Context) UnaryOperator(Input.take(), Opc, resultType,
John McCall7decc9e2010-11-18 06:31:45 +00009721 VK, OK, OpLoc));
Steve Naroff35d85152007-05-07 00:24:15 +00009722}
Chris Lattnereefa10e2007-05-28 06:56:27 +00009723
Douglas Gregor72341032011-12-14 21:23:13 +00009724/// \brief Determine whether the given expression is a qualified member
9725/// access expression, of a form that could be turned into a pointer to member
9726/// with the address-of operator.
9727static bool isQualifiedMemberAccess(Expr *E) {
9728 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
9729 if (!DRE->getQualifier())
9730 return false;
9731
9732 ValueDecl *VD = DRE->getDecl();
9733 if (!VD->isCXXClassMember())
9734 return false;
9735
9736 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD))
9737 return true;
9738 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD))
9739 return Method->isInstance();
9740
9741 return false;
9742 }
9743
9744 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
9745 if (!ULE->getQualifier())
9746 return false;
9747
9748 for (UnresolvedLookupExpr::decls_iterator D = ULE->decls_begin(),
9749 DEnd = ULE->decls_end();
9750 D != DEnd; ++D) {
9751 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*D)) {
9752 if (Method->isInstance())
9753 return true;
9754 } else {
9755 // Overload set does not contain methods.
9756 break;
9757 }
9758 }
9759
9760 return false;
9761 }
9762
9763 return false;
9764}
9765
John McCalldadc5752010-08-24 06:29:42 +00009766ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +00009767 UnaryOperatorKind Opc, Expr *Input) {
John McCall526ab472011-10-25 17:37:35 +00009768 // First things first: handle placeholders so that the
9769 // overloaded-operator check considers the right type.
9770 if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) {
9771 // Increment and decrement of pseudo-object references.
9772 if (pty->getKind() == BuiltinType::PseudoObject &&
9773 UnaryOperator::isIncrementDecrementOp(Opc))
9774 return checkPseudoObjectIncDec(S, OpLoc, Opc, Input);
9775
9776 // extension is always a builtin operator.
9777 if (Opc == UO_Extension)
9778 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
9779
9780 // & gets special logic for several kinds of placeholder.
9781 // The builtin code knows what to do.
9782 if (Opc == UO_AddrOf &&
9783 (pty->getKind() == BuiltinType::Overload ||
9784 pty->getKind() == BuiltinType::UnknownAny ||
9785 pty->getKind() == BuiltinType::BoundMember))
9786 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
9787
9788 // Anything else needs to be handled now.
9789 ExprResult Result = CheckPlaceholderExpr(Input);
9790 if (Result.isInvalid()) return ExprError();
9791 Input = Result.take();
9792 }
9793
David Blaikiebbafb8a2012-03-11 07:00:24 +00009794 if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() &&
Douglas Gregor72341032011-12-14 21:23:13 +00009795 UnaryOperator::getOverloadedOperator(Opc) != OO_None &&
9796 !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) {
Douglas Gregor084d8552009-03-13 23:49:33 +00009797 // Find all of the overloaded operators visible from this
9798 // point. We perform both an operator-name lookup from the local
9799 // scope and an argument-dependent lookup based on the types of
9800 // the arguments.
John McCall4c4c1df2010-01-26 03:27:55 +00009801 UnresolvedSet<16> Functions;
Douglas Gregor084d8552009-03-13 23:49:33 +00009802 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
John McCall4c4c1df2010-01-26 03:27:55 +00009803 if (S && OverOp != OO_None)
9804 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
9805 Functions);
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009806
John McCallb268a282010-08-23 23:25:46 +00009807 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
Douglas Gregor084d8552009-03-13 23:49:33 +00009808 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +00009809
John McCallb268a282010-08-23 23:25:46 +00009810 return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
Douglas Gregor084d8552009-03-13 23:49:33 +00009811}
9812
Douglas Gregor5287f092009-11-05 00:51:44 +00009813// Unary Operators. 'Tok' is the token for the operator.
John McCalldadc5752010-08-24 06:29:42 +00009814ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
John McCall424cec92011-01-19 06:33:43 +00009815 tok::TokenKind Op, Expr *Input) {
John McCallb268a282010-08-23 23:25:46 +00009816 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
Douglas Gregor5287f092009-11-05 00:51:44 +00009817}
9818
Steve Naroff66356bd2007-09-16 14:56:35 +00009819/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Chris Lattnerc8e630e2011-02-17 07:39:24 +00009820ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
Chris Lattnercab02a62011-02-17 20:34:02 +00009821 LabelDecl *TheDecl) {
Eli Friedman276dd182013-09-05 00:02:25 +00009822 TheDecl->markUsed(Context);
Chris Lattnereefa10e2007-05-28 06:56:27 +00009823 // Create the AST node. The address of a label always has type 'void*'.
Chris Lattnerc8e630e2011-02-17 07:39:24 +00009824 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00009825 Context.getPointerType(Context.VoidTy)));
Chris Lattnereefa10e2007-05-28 06:56:27 +00009826}
9827
John McCall31168b02011-06-15 23:02:42 +00009828/// Given the last statement in a statement-expression, check whether
9829/// the result is a producing expression (like a call to an
9830/// ns_returns_retained function) and, if so, rebuild it to hoist the
9831/// release out of the full-expression. Otherwise, return null.
9832/// Cannot fail.
Richard Trieuba63ce62011-09-09 01:45:06 +00009833static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) {
John McCall31168b02011-06-15 23:02:42 +00009834 // Should always be wrapped with one of these.
Richard Trieuba63ce62011-09-09 01:45:06 +00009835 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Statement);
John McCall31168b02011-06-15 23:02:42 +00009836 if (!cleanups) return 0;
9837
9838 ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr());
John McCall2d637d22011-09-10 06:18:15 +00009839 if (!cast || cast->getCastKind() != CK_ARCConsumeObject)
John McCall31168b02011-06-15 23:02:42 +00009840 return 0;
9841
9842 // Splice out the cast. This shouldn't modify any interesting
9843 // features of the statement.
9844 Expr *producer = cast->getSubExpr();
9845 assert(producer->getType() == cast->getType());
9846 assert(producer->getValueKind() == cast->getValueKind());
9847 cleanups->setSubExpr(producer);
9848 return cleanups;
9849}
9850
John McCall3abee492012-04-04 01:27:53 +00009851void Sema::ActOnStartStmtExpr() {
9852 PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
9853}
9854
9855void Sema::ActOnStmtExprError() {
John McCalled7b2782012-04-06 18:20:53 +00009856 // Note that function is also called by TreeTransform when leaving a
9857 // StmtExpr scope without rebuilding anything.
9858
John McCall3abee492012-04-04 01:27:53 +00009859 DiscardCleanupsInEvaluationContext();
9860 PopExpressionEvaluationContext();
9861}
9862
John McCalldadc5752010-08-24 06:29:42 +00009863ExprResult
John McCallb268a282010-08-23 23:25:46 +00009864Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
Sebastian Redl6d4256c2009-03-15 17:47:39 +00009865 SourceLocation RPLoc) { // "({..})"
Chris Lattner366727f2007-07-24 16:58:17 +00009866 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!");
9867 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);
9868
John McCall3abee492012-04-04 01:27:53 +00009869 if (hasAnyUnrecoverableErrorsInThisFunction())
9870 DiscardCleanupsInEvaluationContext();
9871 assert(!ExprNeedsCleanups && "cleanups within StmtExpr not correctly bound!");
9872 PopExpressionEvaluationContext();
9873
Douglas Gregor6cf3f3c2010-03-10 04:54:39 +00009874 bool isFileScope
9875 = (getCurFunctionOrMethodDecl() == 0) && (getCurBlock() == 0);
Chris Lattnera69b0762009-04-25 19:11:05 +00009876 if (isFileScope)
Sebastian Redl6d4256c2009-03-15 17:47:39 +00009877 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope));
Eli Friedman52cc0162009-01-24 23:09:00 +00009878
Chris Lattner366727f2007-07-24 16:58:17 +00009879 // FIXME: there are a variety of strange constraints to enforce here, for
9880 // example, it is not possible to goto into a stmt expression apparently.
9881 // More semantic analysis is needed.
Mike Stump4e1f26a2009-02-19 03:04:26 +00009882
Alp Toker028ed912013-12-06 17:56:43 +00009883 // If there are sub-stmts in the compound stmt, take the type of the last one
Chris Lattner366727f2007-07-24 16:58:17 +00009884 // as the type of the stmtexpr.
9885 QualType Ty = Context.VoidTy;
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009886 bool StmtExprMayBindToTemp = false;
Chris Lattner944d3062008-07-26 19:51:01 +00009887 if (!Compound->body_empty()) {
9888 Stmt *LastStmt = Compound->body_back();
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009889 LabelStmt *LastLabelStmt = 0;
Chris Lattner944d3062008-07-26 19:51:01 +00009890 // If LastStmt is a label, skip down through into the body.
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009891 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) {
9892 LastLabelStmt = Label;
Chris Lattner944d3062008-07-26 19:51:01 +00009893 LastStmt = Label->getSubStmt();
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009894 }
John McCall31168b02011-06-15 23:02:42 +00009895
John Wiegley01296292011-04-08 18:41:53 +00009896 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) {
John McCall34376a62010-12-04 03:47:34 +00009897 // Do function/array conversion on the last expression, but not
9898 // lvalue-to-rvalue. However, initialize an unqualified type.
John Wiegley01296292011-04-08 18:41:53 +00009899 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE);
9900 if (LastExpr.isInvalid())
9901 return ExprError();
9902 Ty = LastExpr.get()->getType().getUnqualifiedType();
John McCall34376a62010-12-04 03:47:34 +00009903
John Wiegley01296292011-04-08 18:41:53 +00009904 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) {
John McCall31168b02011-06-15 23:02:42 +00009905 // In ARC, if the final expression ends in a consume, splice
9906 // the consume out and bind it later. In the alternate case
9907 // (when dealing with a retainable type), the result
9908 // initialization will create a produce. In both cases the
9909 // result will be +1, and we'll need to balance that out with
9910 // a bind.
9911 if (Expr *rebuiltLastStmt
9912 = maybeRebuildARCConsumingStmt(LastExpr.get())) {
9913 LastExpr = rebuiltLastStmt;
9914 } else {
9915 LastExpr = PerformCopyInitialization(
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009916 InitializedEntity::InitializeResult(LPLoc,
9917 Ty,
9918 false),
9919 SourceLocation(),
John McCall31168b02011-06-15 23:02:42 +00009920 LastExpr);
9921 }
9922
John Wiegley01296292011-04-08 18:41:53 +00009923 if (LastExpr.isInvalid())
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009924 return ExprError();
John Wiegley01296292011-04-08 18:41:53 +00009925 if (LastExpr.get() != 0) {
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009926 if (!LastLabelStmt)
John Wiegley01296292011-04-08 18:41:53 +00009927 Compound->setLastStmt(LastExpr.take());
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009928 else
John Wiegley01296292011-04-08 18:41:53 +00009929 LastLabelStmt->setSubStmt(LastExpr.take());
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009930 StmtExprMayBindToTemp = true;
9931 }
9932 }
9933 }
Chris Lattner944d3062008-07-26 19:51:01 +00009934 }
Mike Stump4e1f26a2009-02-19 03:04:26 +00009935
Eli Friedmanba961a92009-03-23 00:24:07 +00009936 // FIXME: Check that expression type is complete/non-abstract; statement
9937 // expressions are not lvalues.
Fariborz Jahanian56143ae2010-10-25 23:27:26 +00009938 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc);
9939 if (StmtExprMayBindToTemp)
9940 return MaybeBindToTemporary(ResStmtExpr);
9941 return Owned(ResStmtExpr);
Chris Lattner366727f2007-07-24 16:58:17 +00009942}
Steve Naroff78864672007-08-01 22:05:33 +00009943
John McCalldadc5752010-08-24 06:29:42 +00009944ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
John McCall36226622010-10-12 02:09:17 +00009945 TypeSourceInfo *TInfo,
9946 OffsetOfComponent *CompPtr,
9947 unsigned NumComponents,
9948 SourceLocation RParenLoc) {
Douglas Gregor882211c2010-04-28 22:16:22 +00009949 QualType ArgTy = TInfo->getType();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00009950 bool Dependent = ArgTy->isDependentType();
Abramo Bagnara1108e7b2010-05-20 10:00:11 +00009951 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange();
Douglas Gregor882211c2010-04-28 22:16:22 +00009952
Chris Lattnerf17bd422007-08-30 17:45:32 +00009953 // We must have at least one component that refers to the type, and the first
9954 // one is known to be a field designator. Verify that the ArgTy represents
9955 // a struct/union/class.
Sebastian Redl8d2ccae2009-02-26 14:39:58 +00009956 if (!Dependent && !ArgTy->isRecordType())
Douglas Gregor882211c2010-04-28 22:16:22 +00009957 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
9958 << ArgTy << TypeRange);
9959
9960 // Type must be complete per C99 7.17p3 because a declaring a variable
9961 // with an incomplete type would be ill-formed.
9962 if (!Dependent
9963 && RequireCompleteType(BuiltinLoc, ArgTy,
Douglas Gregor7bfb2d02012-05-04 16:32:21 +00009964 diag::err_offsetof_incomplete_type, TypeRange))
Douglas Gregor882211c2010-04-28 22:16:22 +00009965 return ExprError();
9966
Chris Lattner78502cf2007-08-31 21:49:13 +00009967 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a
9968 // GCC extension, diagnose them.
Eli Friedman988a16b2009-02-27 06:44:11 +00009969 // FIXME: This diagnostic isn't actually visible because the location is in
9970 // a system header!
Chris Lattner78502cf2007-08-31 21:49:13 +00009971 if (NumComponents != 1)
Chris Lattnerf490e152008-11-19 05:27:50 +00009972 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator)
9973 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd);
Douglas Gregor882211c2010-04-28 22:16:22 +00009974
9975 bool DidWarnAboutNonPOD = false;
9976 QualType CurrentType = ArgTy;
9977 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00009978 SmallVector<OffsetOfNode, 4> Comps;
9979 SmallVector<Expr*, 4> Exprs;
Douglas Gregor882211c2010-04-28 22:16:22 +00009980 for (unsigned i = 0; i != NumComponents; ++i) {
9981 const OffsetOfComponent &OC = CompPtr[i];
9982 if (OC.isBrackets) {
9983 // Offset of an array sub-field. TODO: Should we allow vector elements?
9984 if (!CurrentType->isDependentType()) {
9985 const ArrayType *AT = Context.getAsArrayType(CurrentType);
9986 if(!AT)
9987 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
9988 << CurrentType);
9989 CurrentType = AT->getElementType();
9990 } else
9991 CurrentType = Context.DependentTy;
9992
Richard Smith9fcc5c32011-10-17 23:29:39 +00009993 ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
9994 if (IdxRval.isInvalid())
9995 return ExprError();
9996 Expr *Idx = IdxRval.take();
9997
Douglas Gregor882211c2010-04-28 22:16:22 +00009998 // The expression must be an integral expression.
9999 // FIXME: An integral constant expression?
Douglas Gregor882211c2010-04-28 22:16:22 +000010000 if (!Idx->isTypeDependent() && !Idx->isValueDependent() &&
10001 !Idx->getType()->isIntegerType())
10002 return ExprError(Diag(Idx->getLocStart(),
10003 diag::err_typecheck_subscript_not_integer)
10004 << Idx->getSourceRange());
Richard Smitheda612882011-10-17 05:48:07 +000010005
Douglas Gregor882211c2010-04-28 22:16:22 +000010006 // Record this array index.
10007 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd));
Richard Smith9fcc5c32011-10-17 23:29:39 +000010008 Exprs.push_back(Idx);
Douglas Gregor882211c2010-04-28 22:16:22 +000010009 continue;
10010 }
10011
10012 // Offset of a field.
10013 if (CurrentType->isDependentType()) {
10014 // We have the offset of a field, but we can't look into the dependent
10015 // type. Just record the identifier of the field.
10016 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd));
10017 CurrentType = Context.DependentTy;
10018 continue;
10019 }
10020
10021 // We need to have a complete type to look into.
10022 if (RequireCompleteType(OC.LocStart, CurrentType,
10023 diag::err_offsetof_incomplete_type))
10024 return ExprError();
10025
10026 // Look for the designated field.
10027 const RecordType *RC = CurrentType->getAs<RecordType>();
10028 if (!RC)
10029 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type)
10030 << CurrentType);
10031 RecordDecl *RD = RC->getDecl();
10032
10033 // C++ [lib.support.types]p5:
10034 // The macro offsetof accepts a restricted set of type arguments in this
10035 // International Standard. type shall be a POD structure or a POD union
10036 // (clause 9).
Benjamin Kramer9e7876b2012-04-28 11:14:51 +000010037 // C++11 [support.types]p4:
10038 // If type is not a standard-layout class (Clause 9), the results are
10039 // undefined.
Douglas Gregor882211c2010-04-28 22:16:22 +000010040 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
Richard Smith2bf7fdb2013-01-02 11:42:31 +000010041 bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
Benjamin Kramer9e7876b2012-04-28 11:14:51 +000010042 unsigned DiagID =
Richard Smith2bf7fdb2013-01-02 11:42:31 +000010043 LangOpts.CPlusPlus11? diag::warn_offsetof_non_standardlayout_type
Benjamin Kramer9e7876b2012-04-28 11:14:51 +000010044 : diag::warn_offsetof_non_pod_type;
10045
10046 if (!IsSafe && !DidWarnAboutNonPOD &&
Ted Kremenek55ae3192011-02-23 01:51:43 +000010047 DiagRuntimeBehavior(BuiltinLoc, 0,
Benjamin Kramer9e7876b2012-04-28 11:14:51 +000010048 PDiag(DiagID)
Douglas Gregor882211c2010-04-28 22:16:22 +000010049 << SourceRange(CompPtr[0].LocStart, OC.LocEnd)
10050 << CurrentType))
10051 DidWarnAboutNonPOD = true;
10052 }
10053
10054 // Look for the field.
10055 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName);
10056 LookupQualifiedName(R, RD);
10057 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>();
Francois Pichet783dd6e2010-11-21 06:08:52 +000010058 IndirectFieldDecl *IndirectMemberDecl = 0;
10059 if (!MemberDecl) {
Benjamin Kramer39593702010-11-21 14:11:41 +000010060 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>()))
Francois Pichet783dd6e2010-11-21 06:08:52 +000010061 MemberDecl = IndirectMemberDecl->getAnonField();
10062 }
10063
Douglas Gregor882211c2010-04-28 22:16:22 +000010064 if (!MemberDecl)
10065 return ExprError(Diag(BuiltinLoc, diag::err_no_member)
10066 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart,
10067 OC.LocEnd));
10068
Douglas Gregor10982ea2010-04-28 22:36:06 +000010069 // C99 7.17p3:
10070 // (If the specified member is a bit-field, the behavior is undefined.)
10071 //
10072 // We diagnose this as an error.
Richard Smithcaf33902011-10-10 18:28:20 +000010073 if (MemberDecl->isBitField()) {
Douglas Gregor10982ea2010-04-28 22:36:06 +000010074 Diag(OC.LocEnd, diag::err_offsetof_bitfield)
10075 << MemberDecl->getDeclName()
10076 << SourceRange(BuiltinLoc, RParenLoc);
10077 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
10078 return ExprError();
10079 }
Eli Friedman74ef7cf2010-08-05 10:11:36 +000010080
10081 RecordDecl *Parent = MemberDecl->getParent();
Francois Pichet783dd6e2010-11-21 06:08:52 +000010082 if (IndirectMemberDecl)
10083 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext());
Eli Friedman74ef7cf2010-08-05 10:11:36 +000010084
Douglas Gregord1702062010-04-29 00:18:15 +000010085 // If the member was found in a base class, introduce OffsetOfNodes for
10086 // the base class indirections.
David Majnemerff17f832013-10-15 06:28:23 +000010087 CXXBasePaths Paths;
Eli Friedman74ef7cf2010-08-05 10:11:36 +000010088 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) {
David Majnemerff17f832013-10-15 06:28:23 +000010089 if (Paths.getDetectedVirtual()) {
10090 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
10091 << MemberDecl->getDeclName()
10092 << SourceRange(BuiltinLoc, RParenLoc);
10093 return ExprError();
10094 }
10095
Douglas Gregord1702062010-04-29 00:18:15 +000010096 CXXBasePath &Path = Paths.front();
10097 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end();
10098 B != BEnd; ++B)
10099 Comps.push_back(OffsetOfNode(B->Base));
10100 }
Eli Friedman74ef7cf2010-08-05 10:11:36 +000010101
Francois Pichet783dd6e2010-11-21 06:08:52 +000010102 if (IndirectMemberDecl) {
10103 for (IndirectFieldDecl::chain_iterator FI =
10104 IndirectMemberDecl->chain_begin(),
10105 FEnd = IndirectMemberDecl->chain_end(); FI != FEnd; FI++) {
10106 assert(isa<FieldDecl>(*FI));
10107 Comps.push_back(OffsetOfNode(OC.LocStart,
10108 cast<FieldDecl>(*FI), OC.LocEnd));
10109 }
10110 } else
Douglas Gregor882211c2010-04-28 22:16:22 +000010111 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
Francois Pichet783dd6e2010-11-21 06:08:52 +000010112
Douglas Gregor882211c2010-04-28 22:16:22 +000010113 CurrentType = MemberDecl->getType().getNonReferenceType();
10114 }
10115
10116 return Owned(OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc,
Benjamin Kramerc215e762012-08-24 11:54:20 +000010117 TInfo, Comps, Exprs, RParenLoc));
Douglas Gregor882211c2010-04-28 22:16:22 +000010118}
Mike Stump4e1f26a2009-02-19 03:04:26 +000010119
John McCalldadc5752010-08-24 06:29:42 +000010120ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
John McCall36226622010-10-12 02:09:17 +000010121 SourceLocation BuiltinLoc,
10122 SourceLocation TypeLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +000010123 ParsedType ParsedArgTy,
John McCall36226622010-10-12 02:09:17 +000010124 OffsetOfComponent *CompPtr,
10125 unsigned NumComponents,
Richard Trieuba63ce62011-09-09 01:45:06 +000010126 SourceLocation RParenLoc) {
John McCall36226622010-10-12 02:09:17 +000010127
Douglas Gregor882211c2010-04-28 22:16:22 +000010128 TypeSourceInfo *ArgTInfo;
Richard Trieuba63ce62011-09-09 01:45:06 +000010129 QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo);
Douglas Gregor882211c2010-04-28 22:16:22 +000010130 if (ArgTy.isNull())
10131 return ExprError();
10132
Eli Friedman06dcfd92010-08-05 10:15:45 +000010133 if (!ArgTInfo)
10134 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc);
10135
10136 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents,
Richard Trieuba63ce62011-09-09 01:45:06 +000010137 RParenLoc);
Chris Lattnerf17bd422007-08-30 17:45:32 +000010138}
10139
10140
John McCalldadc5752010-08-24 06:29:42 +000010141ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
John McCall36226622010-10-12 02:09:17 +000010142 Expr *CondExpr,
10143 Expr *LHSExpr, Expr *RHSExpr,
10144 SourceLocation RPLoc) {
Steve Naroff9efdabc2007-08-03 21:21:27 +000010145 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
10146
John McCall7decc9e2010-11-18 06:31:45 +000010147 ExprValueKind VK = VK_RValue;
10148 ExprObjectKind OK = OK_Ordinary;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +000010149 QualType resType;
Douglas Gregor56751b52009-09-25 04:25:58 +000010150 bool ValueDependent = false;
Eli Friedman75807f22013-07-20 00:40:58 +000010151 bool CondIsTrue = false;
Douglas Gregor0df91122009-05-19 22:43:30 +000010152 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) {
Sebastian Redl8d2ccae2009-02-26 14:39:58 +000010153 resType = Context.DependentTy;
Douglas Gregor56751b52009-09-25 04:25:58 +000010154 ValueDependent = true;
Sebastian Redl8d2ccae2009-02-26 14:39:58 +000010155 } else {
10156 // The conditional expression is required to be a constant expression.
10157 llvm::APSInt condEval(32);
Douglas Gregore2b37442012-05-04 22:38:52 +000010158 ExprResult CondICE
10159 = VerifyIntegerConstantExpression(CondExpr, &condEval,
10160 diag::err_typecheck_choose_expr_requires_constant, false);
Richard Smithf4c51d92012-02-04 09:53:13 +000010161 if (CondICE.isInvalid())
10162 return ExprError();
10163 CondExpr = CondICE.take();
Eli Friedman75807f22013-07-20 00:40:58 +000010164 CondIsTrue = condEval.getZExtValue();
Steve Naroff9efdabc2007-08-03 21:21:27 +000010165
Sebastian Redl8d2ccae2009-02-26 14:39:58 +000010166 // If the condition is > zero, then the AST type is the same as the LSHExpr.
Eli Friedman75807f22013-07-20 00:40:58 +000010167 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr;
John McCall7decc9e2010-11-18 06:31:45 +000010168
10169 resType = ActiveExpr->getType();
10170 ValueDependent = ActiveExpr->isValueDependent();
10171 VK = ActiveExpr->getValueKind();
10172 OK = ActiveExpr->getObjectKind();
Sebastian Redl8d2ccae2009-02-26 14:39:58 +000010173 }
10174
Sebastian Redl6d4256c2009-03-15 17:47:39 +000010175 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr,
Eli Friedman75807f22013-07-20 00:40:58 +000010176 resType, VK, OK, RPLoc, CondIsTrue,
Douglas Gregor56751b52009-09-25 04:25:58 +000010177 resType->isDependentType(),
10178 ValueDependent));
Steve Naroff9efdabc2007-08-03 21:21:27 +000010179}
10180
Steve Naroffc540d662008-09-03 18:15:37 +000010181//===----------------------------------------------------------------------===//
10182// Clang Extensions.
10183//===----------------------------------------------------------------------===//
10184
10185/// ActOnBlockStart - This callback is invoked when a block literal is started.
Richard Trieuba63ce62011-09-09 01:45:06 +000010186void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) {
Douglas Gregor9a28e842010-03-01 23:15:13 +000010187 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc);
Eli Friedman7e346a82013-07-01 20:22:57 +000010188
Eli Friedman4ef077a2013-09-12 22:36:24 +000010189 if (LangOpts.CPlusPlus) {
Eli Friedman7e346a82013-07-01 20:22:57 +000010190 Decl *ManglingContextDecl;
10191 if (MangleNumberingContext *MCtx =
10192 getCurrentMangleNumberContext(Block->getDeclContext(),
10193 ManglingContextDecl)) {
10194 unsigned ManglingNumber = MCtx->getManglingNumber(Block);
10195 Block->setBlockMangling(ManglingNumber, ManglingContextDecl);
10196 }
10197 }
10198
Richard Trieuba63ce62011-09-09 01:45:06 +000010199 PushBlockScope(CurScope, Block);
Douglas Gregor9a28e842010-03-01 23:15:13 +000010200 CurContext->addDecl(Block);
Richard Trieuba63ce62011-09-09 01:45:06 +000010201 if (CurScope)
10202 PushDeclContext(CurScope, Block);
Fariborz Jahanian1babe772010-07-09 18:44:02 +000010203 else
10204 CurContext = Block;
John McCallf1a3c2a2011-11-11 03:19:12 +000010205
Eli Friedman34b49062012-01-26 03:00:14 +000010206 getCurBlock()->HasImplicitReturnType = true;
10207
John McCallf1a3c2a2011-11-11 03:19:12 +000010208 // Enter a new evaluation context to insulate the block from any
10209 // cleanups from the enclosing full-expression.
10210 PushExpressionEvaluationContext(PotentiallyEvaluated);
Steve Naroff1d95e5a2008-10-10 01:28:17 +000010211}
10212
Douglas Gregor7efd007c2012-06-15 16:59:29 +000010213void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
10214 Scope *CurScope) {
Mike Stumpf70bcf72009-05-07 18:43:07 +000010215 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!");
John McCall3882ace2011-01-05 12:14:39 +000010216 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext);
Douglas Gregor9a28e842010-03-01 23:15:13 +000010217 BlockScopeInfo *CurBlock = getCurBlock();
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000010218
John McCall8cb7bdf2010-06-04 23:28:52 +000010219 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope);
John McCall8cb7bdf2010-06-04 23:28:52 +000010220 QualType T = Sig->getType();
Mike Stump82f071f2009-02-04 22:31:32 +000010221
Douglas Gregor7efd007c2012-06-15 16:59:29 +000010222 // FIXME: We should allow unexpanded parameter packs here, but that would,
10223 // in turn, make the block expression contain unexpanded parameter packs.
10224 if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) {
10225 // Drop the parameters.
10226 FunctionProtoType::ExtProtoInfo EPI;
10227 EPI.HasTrailingReturn = false;
10228 EPI.TypeQuals |= DeclSpec::TQ_const;
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +000010229 T = Context.getFunctionType(Context.DependentTy, None, EPI);
Douglas Gregor7efd007c2012-06-15 16:59:29 +000010230 Sig = Context.getTrivialTypeSourceInfo(T);
10231 }
10232
John McCall3882ace2011-01-05 12:14:39 +000010233 // GetTypeForDeclarator always produces a function type for a block
10234 // literal signature. Furthermore, it is always a FunctionProtoType
10235 // unless the function was written with a typedef.
10236 assert(T->isFunctionType() &&
10237 "GetTypeForDeclarator made a non-function block signature");
10238
10239 // Look for an explicit signature in that function type.
10240 FunctionProtoTypeLoc ExplicitSignature;
10241
10242 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens();
David Blaikie6adc78e2013-02-18 22:06:02 +000010243 if ((ExplicitSignature = tmp.getAs<FunctionProtoTypeLoc>())) {
John McCall3882ace2011-01-05 12:14:39 +000010244
10245 // Check whether that explicit signature was synthesized by
10246 // GetTypeForDeclarator. If so, don't save that as part of the
10247 // written signature.
Abramo Bagnaraf2a79d92011-03-12 11:17:06 +000010248 if (ExplicitSignature.getLocalRangeBegin() ==
10249 ExplicitSignature.getLocalRangeEnd()) {
John McCall3882ace2011-01-05 12:14:39 +000010250 // This would be much cheaper if we stored TypeLocs instead of
10251 // TypeSourceInfos.
10252 TypeLoc Result = ExplicitSignature.getResultLoc();
10253 unsigned Size = Result.getFullDataSize();
10254 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size);
10255 Sig->getTypeLoc().initializeFullCopy(Result, Size);
10256
10257 ExplicitSignature = FunctionProtoTypeLoc();
10258 }
John McCalla3ccba02010-06-04 11:21:44 +000010259 }
Mike Stump11289f42009-09-09 15:08:12 +000010260
John McCall3882ace2011-01-05 12:14:39 +000010261 CurBlock->TheDecl->setSignatureAsWritten(Sig);
10262 CurBlock->FunctionType = T;
10263
10264 const FunctionType *Fn = T->getAs<FunctionType>();
10265 QualType RetTy = Fn->getResultType();
10266 bool isVariadic =
10267 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic());
10268
John McCall8e346702010-06-04 19:02:56 +000010269 CurBlock->TheDecl->setIsVariadic(isVariadic);
Douglas Gregorb92a1562010-02-03 00:27:59 +000010270
John McCalla3ccba02010-06-04 11:21:44 +000010271 // Context.DependentTy is used as a placeholder for a missing block
John McCall8e346702010-06-04 19:02:56 +000010272 // return type. TODO: what should we do with declarators like:
10273 // ^ * { ... }
10274 // If the answer is "apply template argument deduction"....
Fariborz Jahaniandd5eb9d2011-12-03 17:47:53 +000010275 if (RetTy != Context.DependentTy) {
John McCalla3ccba02010-06-04 11:21:44 +000010276 CurBlock->ReturnType = RetTy;
Fariborz Jahaniandd5eb9d2011-12-03 17:47:53 +000010277 CurBlock->TheDecl->setBlockMissingReturnType(false);
Eli Friedman34b49062012-01-26 03:00:14 +000010278 CurBlock->HasImplicitReturnType = false;
Fariborz Jahaniandd5eb9d2011-12-03 17:47:53 +000010279 }
Mike Stump4e1f26a2009-02-19 03:04:26 +000010280
John McCalla3ccba02010-06-04 11:21:44 +000010281 // Push block parameters from the declarator if we had them.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000010282 SmallVector<ParmVarDecl*, 8> Params;
John McCall3882ace2011-01-05 12:14:39 +000010283 if (ExplicitSignature) {
10284 for (unsigned I = 0, E = ExplicitSignature.getNumArgs(); I != E; ++I) {
10285 ParmVarDecl *Param = ExplicitSignature.getArg(I);
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +000010286 if (Param->getIdentifier() == 0 &&
10287 !Param->isImplicit() &&
10288 !Param->isInvalidDecl() &&
David Blaikiebbafb8a2012-03-11 07:00:24 +000010289 !getLangOpts().CPlusPlus)
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +000010290 Diag(Param->getLocation(), diag::err_parameter_name_omitted);
John McCall8e346702010-06-04 19:02:56 +000010291 Params.push_back(Param);
Fariborz Jahanian5ec502e2010-02-12 21:53:14 +000010292 }
John McCalla3ccba02010-06-04 11:21:44 +000010293
10294 // Fake up parameter variables if we have a typedef, like
10295 // ^ fntype { ... }
10296 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
10297 for (FunctionProtoType::arg_type_iterator
10298 I = Fn->arg_type_begin(), E = Fn->arg_type_end(); I != E; ++I) {
10299 ParmVarDecl *Param =
10300 BuildParmVarDeclForTypedef(CurBlock->TheDecl,
Daniel Dunbar62ee6412012-03-09 18:35:03 +000010301 ParamInfo.getLocStart(),
John McCalla3ccba02010-06-04 11:21:44 +000010302 *I);
John McCall8e346702010-06-04 19:02:56 +000010303 Params.push_back(Param);
John McCalla3ccba02010-06-04 11:21:44 +000010304 }
Steve Naroffc540d662008-09-03 18:15:37 +000010305 }
John McCalla3ccba02010-06-04 11:21:44 +000010306
John McCall8e346702010-06-04 19:02:56 +000010307 // Set the parameters on the block decl.
Douglas Gregorb524d902010-11-01 18:37:59 +000010308 if (!Params.empty()) {
David Blaikie9c70e042011-09-21 18:16:56 +000010309 CurBlock->TheDecl->setParams(Params);
Douglas Gregorb524d902010-11-01 18:37:59 +000010310 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(),
10311 CurBlock->TheDecl->param_end(),
10312 /*CheckParameterNames=*/false);
10313 }
10314
John McCalla3ccba02010-06-04 11:21:44 +000010315 // Finally we can process decl attributes.
Douglas Gregor758a8692009-06-17 21:51:59 +000010316 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo);
John McCalldf8b37c2010-03-22 09:20:08 +000010317
Eli Friedman7e346a82013-07-01 20:22:57 +000010318 // Put the parameter variables in scope.
Steve Naroff1d95e5a2008-10-10 01:28:17 +000010319 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(),
John McCallf7b2fb52010-01-22 00:28:27 +000010320 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) {
10321 (*AI)->setOwningFunction(CurBlock->TheDecl);
10322
Steve Naroff1d95e5a2008-10-10 01:28:17 +000010323 // If this has an identifier, add it to the scope stack.
John McCalldf8b37c2010-03-22 09:20:08 +000010324 if ((*AI)->getIdentifier()) {
Argyrios Kyrtzidis1cb0de12010-12-15 18:44:22 +000010325 CheckShadow(CurBlock->TheScope, *AI);
John McCalldf8b37c2010-03-22 09:20:08 +000010326
Steve Naroff1d95e5a2008-10-10 01:28:17 +000010327 PushOnScopeChains(*AI, CurBlock->TheScope);
John McCalldf8b37c2010-03-22 09:20:08 +000010328 }
John McCallf7b2fb52010-01-22 00:28:27 +000010329 }
Steve Naroffc540d662008-09-03 18:15:37 +000010330}
10331
10332/// ActOnBlockError - If there is an error parsing a block, this callback
10333/// is invoked to pop the information about the block from the action impl.
10334void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
John McCallf1a3c2a2011-11-11 03:19:12 +000010335 // Leave the expression-evaluation context.
10336 DiscardCleanupsInEvaluationContext();
10337 PopExpressionEvaluationContext();
10338
Steve Naroffc540d662008-09-03 18:15:37 +000010339 // Pop off CurBlock, handle nested blocks.
Chris Lattner41b86942009-04-21 22:38:46 +000010340 PopDeclContext();
Eli Friedman71c80552012-01-05 03:35:19 +000010341 PopFunctionScopeInfo();
Steve Naroffc540d662008-09-03 18:15:37 +000010342}
10343
10344/// ActOnBlockStmtExpr - This is called when the body of a block statement
10345/// literal was successfully completed. ^(int x){...}
John McCalldadc5752010-08-24 06:29:42 +000010346ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
Chris Lattner60f84492011-02-17 23:58:47 +000010347 Stmt *Body, Scope *CurScope) {
Chris Lattner9eac9312009-03-27 04:18:06 +000010348 // If blocks are disabled, emit an error.
10349 if (!LangOpts.Blocks)
10350 Diag(CaretLoc, diag::err_blocks_disable);
Mike Stump11289f42009-09-09 15:08:12 +000010351
John McCallf1a3c2a2011-11-11 03:19:12 +000010352 // Leave the expression-evaluation context.
John McCall85110b42012-03-08 22:00:17 +000010353 if (hasAnyUnrecoverableErrorsInThisFunction())
10354 DiscardCleanupsInEvaluationContext();
John McCallf1a3c2a2011-11-11 03:19:12 +000010355 assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!");
10356 PopExpressionEvaluationContext();
10357
Douglas Gregor9a28e842010-03-01 23:15:13 +000010358 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back());
Jordan Rosed39e5f12012-07-02 21:19:23 +000010359
10360 if (BSI->HasImplicitReturnType)
10361 deduceClosureReturnType(*BSI);
10362
Steve Naroff1d95e5a2008-10-10 01:28:17 +000010363 PopDeclContext();
10364
Steve Naroffc540d662008-09-03 18:15:37 +000010365 QualType RetTy = Context.VoidTy;
Fariborz Jahanian3fd73102009-06-19 23:37:08 +000010366 if (!BSI->ReturnType.isNull())
10367 RetTy = BSI->ReturnType;
Mike Stump4e1f26a2009-02-19 03:04:26 +000010368
Aaron Ballman9ead1242013-12-19 02:39:40 +000010369 bool NoReturn = BSI->TheDecl->hasAttr<NoReturnAttr>();
Steve Naroffc540d662008-09-03 18:15:37 +000010370 QualType BlockTy;
John McCall8e346702010-06-04 19:02:56 +000010371
John McCallc63de662011-02-02 13:00:07 +000010372 // Set the captured variables on the block.
Eli Friedman20139d32012-01-11 02:36:31 +000010373 // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo!
10374 SmallVector<BlockDecl::Capture, 4> Captures;
10375 for (unsigned i = 0, e = BSI->Captures.size(); i != e; i++) {
10376 CapturingScopeInfo::Capture &Cap = BSI->Captures[i];
10377 if (Cap.isThisCapture())
10378 continue;
Eli Friedman24af8502012-02-03 22:47:37 +000010379 BlockDecl::Capture NewCap(Cap.getVariable(), Cap.isBlockCapture(),
Richard Smithba71c082013-05-16 06:20:58 +000010380 Cap.isNested(), Cap.getInitExpr());
Eli Friedman20139d32012-01-11 02:36:31 +000010381 Captures.push_back(NewCap);
10382 }
10383 BSI->TheDecl->setCaptures(Context, Captures.begin(), Captures.end(),
10384 BSI->CXXThisCaptureIndex != 0);
John McCallc63de662011-02-02 13:00:07 +000010385
John McCall8e346702010-06-04 19:02:56 +000010386 // If the user wrote a function type in some form, try to use that.
10387 if (!BSI->FunctionType.isNull()) {
10388 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>();
10389
10390 FunctionType::ExtInfo Ext = FTy->getExtInfo();
10391 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);
10392
10393 // Turn protoless block types into nullary block types.
10394 if (isa<FunctionNoProtoType>(FTy)) {
John McCalldb40c7f2010-12-14 08:05:40 +000010395 FunctionProtoType::ExtProtoInfo EPI;
10396 EPI.ExtInfo = Ext;
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +000010397 BlockTy = Context.getFunctionType(RetTy, None, EPI);
John McCall8e346702010-06-04 19:02:56 +000010398
10399 // Otherwise, if we don't need to change anything about the function type,
10400 // preserve its sugar structure.
10401 } else if (FTy->getResultType() == RetTy &&
10402 (!NoReturn || FTy->getNoReturnAttr())) {
10403 BlockTy = BSI->FunctionType;
10404
10405 // Otherwise, make the minimal modifications to the function type.
10406 } else {
10407 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
John McCalldb40c7f2010-12-14 08:05:40 +000010408 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
10409 EPI.TypeQuals = 0; // FIXME: silently?
10410 EPI.ExtInfo = Ext;
Reid Kleckner896b32f2013-06-10 20:51:09 +000010411 BlockTy = Context.getFunctionType(RetTy, FPT->getArgTypes(), EPI);
John McCall8e346702010-06-04 19:02:56 +000010412 }
10413
10414 // If we don't have a function type, just build one from nothing.
10415 } else {
John McCalldb40c7f2010-12-14 08:05:40 +000010416 FunctionProtoType::ExtProtoInfo EPI;
John McCall31168b02011-06-15 23:02:42 +000010417 EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn);
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +000010418 BlockTy = Context.getFunctionType(RetTy, None, EPI);
John McCall8e346702010-06-04 19:02:56 +000010419 }
Mike Stump4e1f26a2009-02-19 03:04:26 +000010420
John McCall8e346702010-06-04 19:02:56 +000010421 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(),
10422 BSI->TheDecl->param_end());
Steve Naroffc540d662008-09-03 18:15:37 +000010423 BlockTy = Context.getBlockPointerType(BlockTy);
Mike Stump4e1f26a2009-02-19 03:04:26 +000010424
Chris Lattner45542ea2009-04-19 05:28:12 +000010425 // If needed, diagnose invalid gotos and switches in the block.
John McCall31168b02011-06-15 23:02:42 +000010426 if (getCurFunction()->NeedsScopeChecking() &&
Douglas Gregor5d944db2012-08-17 05:12:08 +000010427 !hasAnyUnrecoverableErrorsInThisFunction() &&
10428 !PP.isCodeCompletionEnabled())
John McCallb268a282010-08-23 23:25:46 +000010429 DiagnoseInvalidJumps(cast<CompoundStmt>(Body));
Mike Stump11289f42009-09-09 15:08:12 +000010430
Chris Lattner60f84492011-02-17 23:58:47 +000010431 BSI->TheDecl->setBody(cast<CompoundStmt>(Body));
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000010432
Jordan Rosed39e5f12012-07-02 21:19:23 +000010433 // Try to apply the named return value optimization. We have to check again
10434 // if we can do this, though, because blocks keep return statements around
10435 // to deduce an implicit return type.
10436 if (getLangOpts().CPlusPlus && RetTy->isRecordType() &&
10437 !BSI->TheDecl->isDependentContext())
10438 computeNRVO(Body, getCurBlock());
Douglas Gregor49695f02011-09-06 20:46:03 +000010439
Benjamin Kramera4fb8362011-07-12 14:11:05 +000010440 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy);
David Blaikie43472b32013-09-03 21:40:15 +000010441 AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
Eli Friedman71c80552012-01-05 03:35:19 +000010442 PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result);
Benjamin Kramera4fb8362011-07-12 14:11:05 +000010443
John McCall28fc7092011-11-10 05:35:25 +000010444 // If the block isn't obviously global, i.e. it captures anything at
John McCalld2393872012-04-13 01:08:17 +000010445 // all, then we need to do a few things in the surrounding context:
John McCall28fc7092011-11-10 05:35:25 +000010446 if (Result->getBlockDecl()->hasCaptures()) {
John McCalld2393872012-04-13 01:08:17 +000010447 // First, this expression has a new cleanup object.
John McCall28fc7092011-11-10 05:35:25 +000010448 ExprCleanupObjects.push_back(Result->getBlockDecl());
10449 ExprNeedsCleanups = true;
John McCalld2393872012-04-13 01:08:17 +000010450
10451 // It also gets a branch-protected scope if any of the captured
10452 // variables needs destruction.
10453 for (BlockDecl::capture_const_iterator
10454 ci = Result->getBlockDecl()->capture_begin(),
10455 ce = Result->getBlockDecl()->capture_end(); ci != ce; ++ci) {
10456 const VarDecl *var = ci->getVariable();
10457 if (var->getType().isDestructedType() != QualType::DK_none) {
10458 getCurFunction()->setHasBranchProtectedScope();
10459 break;
10460 }
10461 }
John McCall28fc7092011-11-10 05:35:25 +000010462 }
Fariborz Jahanian197c68c2012-03-06 18:41:35 +000010463
Douglas Gregor9a28e842010-03-01 23:15:13 +000010464 return Owned(Result);
Steve Naroffc540d662008-09-03 18:15:37 +000010465}
10466
John McCalldadc5752010-08-24 06:29:42 +000010467ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc,
Richard Trieuba63ce62011-09-09 01:45:06 +000010468 Expr *E, ParsedType Ty,
Sebastian Redl6d4256c2009-03-15 17:47:39 +000010469 SourceLocation RPLoc) {
Abramo Bagnara27db2392010-08-10 10:06:15 +000010470 TypeSourceInfo *TInfo;
Richard Trieuba63ce62011-09-09 01:45:06 +000010471 GetTypeFromParser(Ty, &TInfo);
10472 return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
Abramo Bagnara27db2392010-08-10 10:06:15 +000010473}
10474
John McCalldadc5752010-08-24 06:29:42 +000010475ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
John McCall7decc9e2010-11-18 06:31:45 +000010476 Expr *E, TypeSourceInfo *TInfo,
10477 SourceLocation RPLoc) {
Chris Lattner56382aa2009-04-05 15:49:53 +000010478 Expr *OrigExpr = E;
Mike Stump11289f42009-09-09 15:08:12 +000010479
Eli Friedman121ba0c2008-08-09 23:32:40 +000010480 // Get the va_list type
10481 QualType VaListType = Context.getBuiltinVaListType();
Eli Friedmane2cad652009-05-16 12:46:54 +000010482 if (VaListType->isArrayType()) {
10483 // Deal with implicit array decay; for example, on x86-64,
10484 // va_list is an array, but it's supposed to decay to
10485 // a pointer for va_arg.
Eli Friedman121ba0c2008-08-09 23:32:40 +000010486 VaListType = Context.getArrayDecayedType(VaListType);
Eli Friedmane2cad652009-05-16 12:46:54 +000010487 // Make sure the input expression also decays appropriately.
John Wiegley01296292011-04-08 18:41:53 +000010488 ExprResult Result = UsualUnaryConversions(E);
10489 if (Result.isInvalid())
10490 return ExprError();
10491 E = Result.take();
Logan Chien29574892012-10-20 06:11:33 +000010492 } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) {
10493 // If va_list is a record type and we are compiling in C++ mode,
10494 // check the argument using reference binding.
10495 InitializedEntity Entity
10496 = InitializedEntity::InitializeParameter(Context,
10497 Context.getLValueReferenceType(VaListType), false);
10498 ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E);
10499 if (Init.isInvalid())
10500 return ExprError();
10501 E = Init.takeAs<Expr>();
Eli Friedmane2cad652009-05-16 12:46:54 +000010502 } else {
10503 // Otherwise, the va_list argument must be an l-value because
10504 // it is modified by va_arg.
Mike Stump11289f42009-09-09 15:08:12 +000010505 if (!E->isTypeDependent() &&
Douglas Gregorad3150c2009-05-19 23:10:31 +000010506 CheckForModifiableLvalue(E, BuiltinLoc, *this))
Eli Friedmane2cad652009-05-16 12:46:54 +000010507 return ExprError();
10508 }
Eli Friedman121ba0c2008-08-09 23:32:40 +000010509
Douglas Gregorad3150c2009-05-19 23:10:31 +000010510 if (!E->isTypeDependent() &&
10511 !Context.hasSameType(VaListType, E->getType())) {
Sebastian Redl6d4256c2009-03-15 17:47:39 +000010512 return ExprError(Diag(E->getLocStart(),
10513 diag::err_first_argument_to_va_arg_not_of_type_va_list)
Chris Lattner56382aa2009-04-05 15:49:53 +000010514 << OrigExpr->getType() << E->getSourceRange());
Chris Lattner3f5cd772009-04-05 00:59:53 +000010515 }
Mike Stump4e1f26a2009-02-19 03:04:26 +000010516
David Majnemerc75d1a12011-06-14 05:17:32 +000010517 if (!TInfo->getType()->isDependentType()) {
10518 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
Douglas Gregor7bfb2d02012-05-04 16:32:21 +000010519 diag::err_second_parameter_to_va_arg_incomplete,
10520 TInfo->getTypeLoc()))
David Majnemerc75d1a12011-06-14 05:17:32 +000010521 return ExprError();
David Majnemer254a5c02011-06-13 06:37:03 +000010522
David Majnemerc75d1a12011-06-14 05:17:32 +000010523 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
Douglas Gregorae298422012-05-04 17:09:59 +000010524 TInfo->getType(),
10525 diag::err_second_parameter_to_va_arg_abstract,
10526 TInfo->getTypeLoc()))
David Majnemerc75d1a12011-06-14 05:17:32 +000010527 return ExprError();
10528
Douglas Gregor7e1eb932011-07-30 06:45:27 +000010529 if (!TInfo->getType().isPODType(Context)) {
David Majnemerc75d1a12011-06-14 05:17:32 +000010530 Diag(TInfo->getTypeLoc().getBeginLoc(),
Douglas Gregor7e1eb932011-07-30 06:45:27 +000010531 TInfo->getType()->isObjCLifetimeType()
10532 ? diag::warn_second_parameter_to_va_arg_ownership_qualified
10533 : diag::warn_second_parameter_to_va_arg_not_pod)
David Majnemerc75d1a12011-06-14 05:17:32 +000010534 << TInfo->getType()
10535 << TInfo->getTypeLoc().getSourceRange();
Douglas Gregor7e1eb932011-07-30 06:45:27 +000010536 }
Eli Friedman6290ae42011-07-11 21:45:59 +000010537
10538 // Check for va_arg where arguments of the given type will be promoted
10539 // (i.e. this va_arg is guaranteed to have undefined behavior).
10540 QualType PromoteType;
10541 if (TInfo->getType()->isPromotableIntegerType()) {
10542 PromoteType = Context.getPromotedIntegerType(TInfo->getType());
10543 if (Context.typesAreCompatible(PromoteType, TInfo->getType()))
10544 PromoteType = QualType();
10545 }
10546 if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float))
10547 PromoteType = Context.DoubleTy;
10548 if (!PromoteType.isNull())
Ted Kremeneka0461692013-01-08 01:50:40 +000010549 DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E,
10550 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
10551 << TInfo->getType()
10552 << PromoteType
10553 << TInfo->getTypeLoc().getSourceRange());
David Majnemerc75d1a12011-06-14 05:17:32 +000010554 }
Mike Stump4e1f26a2009-02-19 03:04:26 +000010555
Abramo Bagnara27db2392010-08-10 10:06:15 +000010556 QualType T = TInfo->getType().getNonLValueExprType(Context);
10557 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T));
Anders Carlsson7e13ab82007-10-15 20:28:48 +000010558}
10559
John McCalldadc5752010-08-24 06:29:42 +000010560ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
Douglas Gregor3be4b122008-11-29 04:51:27 +000010561 // The type of __null will be int or long, depending on the size of
10562 // pointers on the target.
10563 QualType Ty;
Douglas Gregore8bbc122011-09-02 00:18:52 +000010564 unsigned pw = Context.getTargetInfo().getPointerWidth(0);
10565 if (pw == Context.getTargetInfo().getIntWidth())
Douglas Gregor3be4b122008-11-29 04:51:27 +000010566 Ty = Context.IntTy;
Douglas Gregore8bbc122011-09-02 00:18:52 +000010567 else if (pw == Context.getTargetInfo().getLongWidth())
Douglas Gregor3be4b122008-11-29 04:51:27 +000010568 Ty = Context.LongTy;
Douglas Gregore8bbc122011-09-02 00:18:52 +000010569 else if (pw == Context.getTargetInfo().getLongLongWidth())
NAKAMURA Takumi0d13fd32011-01-19 00:11:41 +000010570 Ty = Context.LongLongTy;
10571 else {
David Blaikie83d382b2011-09-23 05:06:16 +000010572 llvm_unreachable("I don't know size of pointer!");
NAKAMURA Takumi0d13fd32011-01-19 00:11:41 +000010573 }
Douglas Gregor3be4b122008-11-29 04:51:27 +000010574
Sebastian Redl6d4256c2009-03-15 17:47:39 +000010575 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc));
Douglas Gregor3be4b122008-11-29 04:51:27 +000010576}
10577
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010578bool
10579Sema::ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&Exp) {
Fariborz Jahanianbd714e92013-12-17 19:33:43 +000010580 if (!getLangOpts().ObjC1)
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010581 return false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000010582
Anders Carlssonace5d072009-11-10 04:46:30 +000010583 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>();
10584 if (!PT)
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010585 return false;
Anders Carlssonace5d072009-11-10 04:46:30 +000010586
Anders Carlssonace5d072009-11-10 04:46:30 +000010587 if (!PT->isObjCIdType()) {
10588 // Check if the destination is the 'NSString' interface.
10589 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl();
10590 if (!ID || !ID->getIdentifier()->isStr("NSString"))
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010591 return false;
Anders Carlssonace5d072009-11-10 04:46:30 +000010592 }
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010593
John McCallfe96e0b2011-11-06 09:01:30 +000010594 // Ignore any parens, implicit casts (should only be
10595 // array-to-pointer decays), and not-so-opaque values. The last is
10596 // important for making this trigger for property assignments.
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010597 Expr *SrcExpr = Exp->IgnoreParenImpCasts();
John McCallfe96e0b2011-11-06 09:01:30 +000010598 if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr))
10599 if (OV->getSourceExpr())
10600 SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts();
10601
10602 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr);
Douglas Gregorfb65e592011-07-27 05:40:30 +000010603 if (!SL || !SL->isAscii())
Fariborz Jahanian283bf892013-12-18 21:04:43 +000010604 return false;
10605 Diag(SL->getLocStart(), diag::err_missing_atsign_prefix)
10606 << FixItHint::CreateInsertion(SL->getLocStart(), "@");
10607 Exp = BuildObjCStringLiteral(SL->getLocStart(), SL).take();
10608 return true;
Anders Carlssonace5d072009-11-10 04:46:30 +000010609}
10610
Chris Lattner9bad62c2008-01-04 18:04:52 +000010611bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
10612 SourceLocation Loc,
10613 QualType DstType, QualType SrcType,
Douglas Gregor4f4946a2010-04-22 00:20:18 +000010614 Expr *SrcExpr, AssignmentAction Action,
10615 bool *Complained) {
10616 if (Complained)
10617 *Complained = false;
10618
Chris Lattner9bad62c2008-01-04 18:04:52 +000010619 // Decode the result (notice that AST's are still created for extensions).
Douglas Gregor33823722011-06-11 01:09:30 +000010620 bool CheckInferredResultType = false;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010621 bool isInvalid = false;
Eli Friedman381f4312012-02-29 20:59:56 +000010622 unsigned DiagKind = 0;
Douglas Gregora771f462010-03-31 17:46:05 +000010623 FixItHint Hint;
Anna Zaks3b402712011-07-28 19:51:27 +000010624 ConversionFixItGenerator ConvHints;
10625 bool MayHaveConvFixit = false;
Richard Trieucaff2472011-11-23 22:32:32 +000010626 bool MayHaveFunctionDiff = false;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000010627
Chris Lattner9bad62c2008-01-04 18:04:52 +000010628 switch (ConvTy) {
Fariborz Jahanian268fec12012-07-17 18:00:08 +000010629 case Compatible:
Joerg Sonnenberger05bd2da2013-11-19 13:38:38 +000010630 DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr);
10631 return false;
Fariborz Jahanian268fec12012-07-17 18:00:08 +000010632
Chris Lattner940cfeb2008-01-04 18:22:42 +000010633 case PointerToInt:
Chris Lattner9bad62c2008-01-04 18:04:52 +000010634 DiagKind = diag::ext_typecheck_convert_pointer_int;
Anna Zaks3b402712011-07-28 19:51:27 +000010635 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
10636 MayHaveConvFixit = true;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010637 break;
Chris Lattner940cfeb2008-01-04 18:22:42 +000010638 case IntToPointer:
10639 DiagKind = diag::ext_typecheck_convert_int_pointer;
Anna Zaks3b402712011-07-28 19:51:27 +000010640 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
10641 MayHaveConvFixit = true;
Chris Lattner940cfeb2008-01-04 18:22:42 +000010642 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010643 case IncompatiblePointer:
Fariborz Jahanian3a25d0d2013-07-31 23:19:34 +000010644 DiagKind =
10645 (Action == AA_Passing_CFAudited ?
10646 diag::err_arc_typecheck_convert_incompatible_pointer :
10647 diag::ext_typecheck_convert_incompatible_pointer);
Douglas Gregor33823722011-06-11 01:09:30 +000010648 CheckInferredResultType = DstType->isObjCObjectPointerType() &&
10649 SrcType->isObjCObjectPointerType();
Anna Zaks3b402712011-07-28 19:51:27 +000010650 if (Hint.isNull() && !CheckInferredResultType) {
10651 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
10652 }
Fariborz Jahanian3beec202013-04-30 00:30:48 +000010653 else if (CheckInferredResultType) {
10654 SrcType = SrcType.getUnqualifiedType();
10655 DstType = DstType.getUnqualifiedType();
10656 }
Anna Zaks3b402712011-07-28 19:51:27 +000010657 MayHaveConvFixit = true;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010658 break;
Eli Friedman80160bd2009-03-22 23:59:44 +000010659 case IncompatiblePointerSign:
10660 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
10661 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010662 case FunctionVoidPointer:
10663 DiagKind = diag::ext_typecheck_convert_pointer_void_func;
10664 break;
John McCall4fff8f62011-02-01 00:10:29 +000010665 case IncompatiblePointerDiscardsQualifiers: {
John McCall71de91c2011-02-01 23:28:01 +000010666 // Perform array-to-pointer decay if necessary.
10667 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);
10668
John McCall4fff8f62011-02-01 00:10:29 +000010669 Qualifiers lhq = SrcType->getPointeeType().getQualifiers();
10670 Qualifiers rhq = DstType->getPointeeType().getQualifiers();
10671 if (lhq.getAddressSpace() != rhq.getAddressSpace()) {
10672 DiagKind = diag::err_typecheck_incompatible_address_space;
10673 break;
John McCall31168b02011-06-15 23:02:42 +000010674
10675
10676 } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) {
Argyrios Kyrtzidiscff00d92011-06-24 00:08:59 +000010677 DiagKind = diag::err_typecheck_incompatible_ownership;
John McCall31168b02011-06-15 23:02:42 +000010678 break;
John McCall4fff8f62011-02-01 00:10:29 +000010679 }
10680
10681 llvm_unreachable("unknown error case for discarding qualifiers!");
10682 // fallthrough
10683 }
Chris Lattner9bad62c2008-01-04 18:04:52 +000010684 case CompatiblePointerDiscardsQualifiers:
Douglas Gregoraa1e21d2008-09-12 00:47:35 +000010685 // If the qualifiers lost were because we were applying the
10686 // (deprecated) C++ conversion from a string literal to a char*
10687 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME:
10688 // Ideally, this check would be performed in
John McCallaba90822011-01-31 23:13:11 +000010689 // checkPointerTypesForAssignment. However, that would require a
Douglas Gregoraa1e21d2008-09-12 00:47:35 +000010690 // bit of refactoring (so that the second argument is an
10691 // expression, rather than a type), which should be done as part
John McCallaba90822011-01-31 23:13:11 +000010692 // of a larger effort to fix checkPointerTypesForAssignment for
Douglas Gregoraa1e21d2008-09-12 00:47:35 +000010693 // C++ semantics.
David Blaikiebbafb8a2012-03-11 07:00:24 +000010694 if (getLangOpts().CPlusPlus &&
Douglas Gregoraa1e21d2008-09-12 00:47:35 +000010695 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
10696 return false;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010697 DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
10698 break;
Alexis Hunt6f3de502009-11-08 07:46:34 +000010699 case IncompatibleNestedPointerQualifiers:
Fariborz Jahanianb98dade2009-11-09 22:16:37 +000010700 DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
Fariborz Jahaniand7aa9d82009-11-07 20:20:40 +000010701 break;
Steve Naroff081c7422008-09-04 15:10:53 +000010702 case IntToBlockPointer:
10703 DiagKind = diag::err_int_to_block_pointer;
10704 break;
10705 case IncompatibleBlockPointer:
Mike Stumpd79b5a82009-04-21 22:51:42 +000010706 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
Steve Naroff081c7422008-09-04 15:10:53 +000010707 break;
Steve Naroff8afa9892008-10-14 22:18:38 +000010708 case IncompatibleObjCQualifiedId:
Mike Stump4e1f26a2009-02-19 03:04:26 +000010709 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since
Steve Naroff8afa9892008-10-14 22:18:38 +000010710 // it can give a more specific diagnostic.
10711 DiagKind = diag::warn_incompatible_qualified_id;
10712 break;
Anders Carlssondb5a9b62009-01-30 23:17:46 +000010713 case IncompatibleVectors:
10714 DiagKind = diag::warn_incompatible_vectors;
10715 break;
Fariborz Jahanian6f472e82011-07-07 18:55:47 +000010716 case IncompatibleObjCWeakRef:
10717 DiagKind = diag::err_arc_weak_unavailable_assign;
10718 break;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010719 case Incompatible:
10720 DiagKind = diag::err_typecheck_convert_incompatible;
Anna Zaks3b402712011-07-28 19:51:27 +000010721 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
10722 MayHaveConvFixit = true;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010723 isInvalid = true;
Richard Trieucaff2472011-11-23 22:32:32 +000010724 MayHaveFunctionDiff = true;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010725 break;
10726 }
Mike Stump4e1f26a2009-02-19 03:04:26 +000010727
Douglas Gregorc68e1402010-04-09 00:35:39 +000010728 QualType FirstType, SecondType;
10729 switch (Action) {
10730 case AA_Assigning:
10731 case AA_Initializing:
10732 // The destination type comes first.
10733 FirstType = DstType;
10734 SecondType = SrcType;
10735 break;
Alexis Huntc46382e2010-04-28 23:02:27 +000010736
Douglas Gregorc68e1402010-04-09 00:35:39 +000010737 case AA_Returning:
10738 case AA_Passing:
Fariborz Jahanian3a25d0d2013-07-31 23:19:34 +000010739 case AA_Passing_CFAudited:
Douglas Gregorc68e1402010-04-09 00:35:39 +000010740 case AA_Converting:
10741 case AA_Sending:
10742 case AA_Casting:
10743 // The source type comes first.
10744 FirstType = SrcType;
10745 SecondType = DstType;
10746 break;
10747 }
Alexis Huntc46382e2010-04-28 23:02:27 +000010748
Anna Zaks3b402712011-07-28 19:51:27 +000010749 PartialDiagnostic FDiag = PDiag(DiagKind);
Fariborz Jahanian3a25d0d2013-07-31 23:19:34 +000010750 if (Action == AA_Passing_CFAudited)
10751 FDiag << FirstType << SecondType << SrcExpr->getSourceRange();
10752 else
10753 FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange();
Anna Zaks3b402712011-07-28 19:51:27 +000010754
10755 // If we can fix the conversion, suggest the FixIts.
10756 assert(ConvHints.isNull() || Hint.isNull());
10757 if (!ConvHints.isNull()) {
Benjamin Kramer490afa62012-01-14 21:05:10 +000010758 for (std::vector<FixItHint>::iterator HI = ConvHints.Hints.begin(),
10759 HE = ConvHints.Hints.end(); HI != HE; ++HI)
Anna Zaks3b402712011-07-28 19:51:27 +000010760 FDiag << *HI;
10761 } else {
10762 FDiag << Hint;
10763 }
10764 if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
10765
Richard Trieucaff2472011-11-23 22:32:32 +000010766 if (MayHaveFunctionDiff)
10767 HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
10768
Anna Zaks3b402712011-07-28 19:51:27 +000010769 Diag(Loc, FDiag);
10770
Richard Trieucaff2472011-11-23 22:32:32 +000010771 if (SecondType == Context.OverloadTy)
10772 NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
10773 FirstType);
10774
Douglas Gregor33823722011-06-11 01:09:30 +000010775 if (CheckInferredResultType)
10776 EmitRelatedResultTypeNote(SrcExpr);
John McCall5ec7e7d2013-03-19 07:04:25 +000010777
10778 if (Action == AA_Returning && ConvTy == IncompatiblePointer)
10779 EmitRelatedResultTypeNoteForReturn(DstType);
Douglas Gregor33823722011-06-11 01:09:30 +000010780
Douglas Gregor4f4946a2010-04-22 00:20:18 +000010781 if (Complained)
10782 *Complained = true;
Chris Lattner9bad62c2008-01-04 18:04:52 +000010783 return isInvalid;
10784}
Anders Carlssone54e8a12008-11-30 19:50:32 +000010785
Richard Smithf4c51d92012-02-04 09:53:13 +000010786ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
10787 llvm::APSInt *Result) {
Douglas Gregore2b37442012-05-04 22:38:52 +000010788 class SimpleICEDiagnoser : public VerifyICEDiagnoser {
10789 public:
10790 virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
10791 S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus << SR;
10792 }
10793 } Diagnoser;
10794
10795 return VerifyIntegerConstantExpression(E, Result, Diagnoser);
10796}
10797
10798ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
10799 llvm::APSInt *Result,
10800 unsigned DiagID,
10801 bool AllowFold) {
10802 class IDDiagnoser : public VerifyICEDiagnoser {
10803 unsigned DiagID;
10804
10805 public:
10806 IDDiagnoser(unsigned DiagID)
10807 : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { }
10808
10809 virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
10810 S.Diag(Loc, DiagID) << SR;
10811 }
10812 } Diagnoser(DiagID);
10813
10814 return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold);
10815}
10816
10817void Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc,
10818 SourceRange SR) {
10819 S.Diag(Loc, diag::ext_expr_not_ice) << SR << S.LangOpts.CPlusPlus;
Richard Smithf4c51d92012-02-04 09:53:13 +000010820}
10821
Benjamin Kramer33adaae2012-04-18 14:22:41 +000010822ExprResult
10823Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
Douglas Gregore2b37442012-05-04 22:38:52 +000010824 VerifyICEDiagnoser &Diagnoser,
10825 bool AllowFold) {
Daniel Dunbar62ee6412012-03-09 18:35:03 +000010826 SourceLocation DiagLoc = E->getLocStart();
Richard Smithf4c51d92012-02-04 09:53:13 +000010827
Richard Smith2bf7fdb2013-01-02 11:42:31 +000010828 if (getLangOpts().CPlusPlus11) {
Richard Smithf4c51d92012-02-04 09:53:13 +000010829 // C++11 [expr.const]p5:
10830 // If an expression of literal class type is used in a context where an
10831 // integral constant expression is required, then that class type shall
10832 // have a single non-explicit conversion function to an integral or
10833 // unscoped enumeration type
10834 ExprResult Converted;
Richard Smithccc11812013-05-21 19:05:48 +000010835 class CXX11ConvertDiagnoser : public ICEConvertDiagnoser {
10836 public:
10837 CXX11ConvertDiagnoser(bool Silent)
10838 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false,
10839 Silent, true) {}
Douglas Gregore2b37442012-05-04 22:38:52 +000010840
Richard Smithccc11812013-05-21 19:05:48 +000010841 virtual SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
10842 QualType T) {
10843 return S.Diag(Loc, diag::err_ice_not_integral) << T;
10844 }
10845
10846 virtual SemaDiagnosticBuilder diagnoseIncomplete(
10847 Sema &S, SourceLocation Loc, QualType T) {
10848 return S.Diag(Loc, diag::err_ice_incomplete_type) << T;
10849 }
10850
10851 virtual SemaDiagnosticBuilder diagnoseExplicitConv(
10852 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) {
10853 return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
10854 }
10855
10856 virtual SemaDiagnosticBuilder noteExplicitConv(
10857 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) {
10858 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
10859 << ConvTy->isEnumeralType() << ConvTy;
10860 }
10861
10862 virtual SemaDiagnosticBuilder diagnoseAmbiguous(
10863 Sema &S, SourceLocation Loc, QualType T) {
10864 return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
10865 }
10866
10867 virtual SemaDiagnosticBuilder noteAmbiguous(
10868 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) {
10869 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
10870 << ConvTy->isEnumeralType() << ConvTy;
10871 }
10872
10873 virtual SemaDiagnosticBuilder diagnoseConversion(
10874 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) {
10875 llvm_unreachable("conversion functions are permitted");
10876 }
10877 } ConvertDiagnoser(Diagnoser.Suppress);
10878
10879 Converted = PerformContextualImplicitConversion(DiagLoc, E,
10880 ConvertDiagnoser);
Richard Smithf4c51d92012-02-04 09:53:13 +000010881 if (Converted.isInvalid())
10882 return Converted;
10883 E = Converted.take();
10884 if (!E->getType()->isIntegralOrUnscopedEnumerationType())
10885 return ExprError();
10886 } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
10887 // An ICE must be of integral or unscoped enumeration type.
Douglas Gregore2b37442012-05-04 22:38:52 +000010888 if (!Diagnoser.Suppress)
10889 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange());
Richard Smithf4c51d92012-02-04 09:53:13 +000010890 return ExprError();
10891 }
10892
Richard Smith902ca212011-12-14 23:32:26 +000010893 // Circumvent ICE checking in C++11 to avoid evaluating the expression twice
10894 // in the non-ICE case.
Richard Smith2bf7fdb2013-01-02 11:42:31 +000010895 if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) {
Richard Smithf4c51d92012-02-04 09:53:13 +000010896 if (Result)
10897 *Result = E->EvaluateKnownConstInt(Context);
10898 return Owned(E);
Eli Friedmanbb967cc2009-04-25 22:26:58 +000010899 }
10900
Anders Carlssone54e8a12008-11-30 19:50:32 +000010901 Expr::EvalResult EvalResult;
Dmitri Gribenkof8579502013-01-12 19:30:44 +000010902 SmallVector<PartialDiagnosticAt, 8> Notes;
Richard Smith92b1ce02011-12-12 09:28:41 +000010903 EvalResult.Diag = &Notes;
Anders Carlssone54e8a12008-11-30 19:50:32 +000010904
Richard Smith902ca212011-12-14 23:32:26 +000010905 // Try to evaluate the expression, and produce diagnostics explaining why it's
10906 // not a constant expression as a side-effect.
10907 bool Folded = E->EvaluateAsRValue(EvalResult, Context) &&
10908 EvalResult.Val.isInt() && !EvalResult.HasSideEffects;
10909
10910 // In C++11, we can rely on diagnostics being produced for any expression
10911 // which is not a constant expression. If no diagnostics were produced, then
10912 // this is a constant expression.
Richard Smith2bf7fdb2013-01-02 11:42:31 +000010913 if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) {
Richard Smith902ca212011-12-14 23:32:26 +000010914 if (Result)
10915 *Result = EvalResult.Val.getInt();
Richard Smithf4c51d92012-02-04 09:53:13 +000010916 return Owned(E);
10917 }
10918
10919 // If our only note is the usual "invalid subexpression" note, just point
10920 // the caret at its location rather than producing an essentially
10921 // redundant note.
10922 if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
10923 diag::note_invalid_subexpr_in_const_expr) {
10924 DiagLoc = Notes[0].first;
10925 Notes.clear();
Richard Smith902ca212011-12-14 23:32:26 +000010926 }
10927
10928 if (!Folded || !AllowFold) {
Douglas Gregore2b37442012-05-04 22:38:52 +000010929 if (!Diagnoser.Suppress) {
10930 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange());
Richard Smith92b1ce02011-12-12 09:28:41 +000010931 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
10932 Diag(Notes[I].first, Notes[I].second);
Anders Carlssone54e8a12008-11-30 19:50:32 +000010933 }
Mike Stump4e1f26a2009-02-19 03:04:26 +000010934
Richard Smithf4c51d92012-02-04 09:53:13 +000010935 return ExprError();
Anders Carlssone54e8a12008-11-30 19:50:32 +000010936 }
10937
Douglas Gregore2b37442012-05-04 22:38:52 +000010938 Diagnoser.diagnoseFold(*this, DiagLoc, E->getSourceRange());
Richard Smith2ec40612012-01-15 03:51:30 +000010939 for (unsigned I = 0, N = Notes.size(); I != N; ++I)
10940 Diag(Notes[I].first, Notes[I].second);
Mike Stump4e1f26a2009-02-19 03:04:26 +000010941
Anders Carlssone54e8a12008-11-30 19:50:32 +000010942 if (Result)
10943 *Result = EvalResult.Val.getInt();
Richard Smithf4c51d92012-02-04 09:53:13 +000010944 return Owned(E);
Anders Carlssone54e8a12008-11-30 19:50:32 +000010945}
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000010946
Eli Friedman456f0182012-01-20 01:26:23 +000010947namespace {
10948 // Handle the case where we conclude a expression which we speculatively
10949 // considered to be unevaluated is actually evaluated.
10950 class TransformToPE : public TreeTransform<TransformToPE> {
10951 typedef TreeTransform<TransformToPE> BaseTransform;
10952
10953 public:
10954 TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { }
10955
10956 // Make sure we redo semantic analysis
10957 bool AlwaysRebuild() { return true; }
10958
Eli Friedman5f0ca242012-02-06 23:29:57 +000010959 // Make sure we handle LabelStmts correctly.
10960 // FIXME: This does the right thing, but maybe we need a more general
10961 // fix to TreeTransform?
10962 StmtResult TransformLabelStmt(LabelStmt *S) {
10963 S->getDecl()->setStmt(0);
10964 return BaseTransform::TransformLabelStmt(S);
10965 }
10966
Eli Friedman456f0182012-01-20 01:26:23 +000010967 // We need to special-case DeclRefExprs referring to FieldDecls which
10968 // are not part of a member pointer formation; normal TreeTransforming
10969 // doesn't catch this case because of the way we represent them in the AST.
10970 // FIXME: This is a bit ugly; is it really the best way to handle this
10971 // case?
10972 //
10973 // Error on DeclRefExprs referring to FieldDecls.
10974 ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
10975 if (isa<FieldDecl>(E->getDecl()) &&
David Blaikie131fcb42012-08-06 22:47:24 +000010976 !SemaRef.isUnevaluatedContext())
Eli Friedman456f0182012-01-20 01:26:23 +000010977 return SemaRef.Diag(E->getLocation(),
10978 diag::err_invalid_non_static_member_use)
10979 << E->getDecl() << E->getSourceRange();
10980
10981 return BaseTransform::TransformDeclRefExpr(E);
10982 }
10983
10984 // Exception: filter out member pointer formation
10985 ExprResult TransformUnaryOperator(UnaryOperator *E) {
10986 if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
10987 return E;
10988
10989 return BaseTransform::TransformUnaryOperator(E);
10990 }
10991
Douglas Gregor89625492012-02-09 08:14:43 +000010992 ExprResult TransformLambdaExpr(LambdaExpr *E) {
10993 // Lambdas never need to be transformed.
10994 return E;
10995 }
Eli Friedman456f0182012-01-20 01:26:23 +000010996 };
Eli Friedmanfbc0dff2012-01-18 01:05:54 +000010997}
10998
Benjamin Kramerd81108f2012-11-14 15:08:31 +000010999ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
John McCallf413f5e2013-05-03 00:10:13 +000011000 assert(isUnevaluatedContext() &&
Eli Friedmane4f22df2012-02-29 04:03:55 +000011001 "Should only transform unevaluated expressions");
Eli Friedman456f0182012-01-20 01:26:23 +000011002 ExprEvalContexts.back().Context =
11003 ExprEvalContexts[ExprEvalContexts.size()-2].Context;
John McCallf413f5e2013-05-03 00:10:13 +000011004 if (isUnevaluatedContext())
Eli Friedman456f0182012-01-20 01:26:23 +000011005 return E;
11006 return TransformToPE(*this).TransformExpr(E);
Eli Friedmanfbc0dff2012-01-18 01:05:54 +000011007}
11008
Douglas Gregorff790f12009-11-26 00:44:06 +000011009void
Douglas Gregor7fcbd902012-02-21 00:37:24 +000011010Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
Richard Smithfd555f62012-02-22 02:04:18 +000011011 Decl *LambdaContextDecl,
11012 bool IsDecltype) {
Douglas Gregorff790f12009-11-26 00:44:06 +000011013 ExprEvalContexts.push_back(
John McCall31168b02011-06-15 23:02:42 +000011014 ExpressionEvaluationContextRecord(NewContext,
John McCall28fc7092011-11-10 05:35:25 +000011015 ExprCleanupObjects.size(),
Douglas Gregor7fcbd902012-02-21 00:37:24 +000011016 ExprNeedsCleanups,
Richard Smithfd555f62012-02-22 02:04:18 +000011017 LambdaContextDecl,
11018 IsDecltype));
John McCall31168b02011-06-15 23:02:42 +000011019 ExprNeedsCleanups = false;
Eli Friedman3bda6b12012-02-02 23:15:15 +000011020 if (!MaybeODRUseExprs.empty())
11021 std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
Douglas Gregor0b6a6242009-06-22 20:57:11 +000011022}
11023
Eli Friedman15681d62012-09-26 04:34:21 +000011024void
11025Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
11026 ReuseLambdaContextDecl_t,
11027 bool IsDecltype) {
Eli Friedman7e346a82013-07-01 20:22:57 +000011028 Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
11029 PushExpressionEvaluationContext(NewContext, ClosureContextDecl, IsDecltype);
Eli Friedman15681d62012-09-26 04:34:21 +000011030}
11031
Richard Trieucfc491d2011-08-02 04:35:43 +000011032void Sema::PopExpressionEvaluationContext() {
Eli Friedmanfa0df832012-02-02 03:46:19 +000011033 ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
Douglas Gregor0b6a6242009-06-22 20:57:11 +000011034
Douglas Gregor89625492012-02-09 08:14:43 +000011035 if (!Rec.Lambdas.empty()) {
David Majnemer9adc3612013-10-25 09:12:52 +000011036 if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
11037 unsigned D;
11038 if (Rec.isUnevaluated()) {
11039 // C++11 [expr.prim.lambda]p2:
11040 // A lambda-expression shall not appear in an unevaluated operand
11041 // (Clause 5).
11042 D = diag::err_lambda_unevaluated_operand;
11043 } else {
11044 // C++1y [expr.const]p2:
11045 // A conditional-expression e is a core constant expression unless the
11046 // evaluation of e, following the rules of the abstract machine, would
11047 // evaluate [...] a lambda-expression.
11048 D = diag::err_lambda_in_constant_expression;
11049 }
Douglas Gregor89625492012-02-09 08:14:43 +000011050 for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I)
David Majnemer9adc3612013-10-25 09:12:52 +000011051 Diag(Rec.Lambdas[I]->getLocStart(), D);
Douglas Gregor89625492012-02-09 08:14:43 +000011052 } else {
11053 // Mark the capture expressions odr-used. This was deferred
11054 // during lambda expression creation.
11055 for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I) {
11056 LambdaExpr *Lambda = Rec.Lambdas[I];
11057 for (LambdaExpr::capture_init_iterator
11058 C = Lambda->capture_init_begin(),
11059 CEnd = Lambda->capture_init_end();
11060 C != CEnd; ++C) {
11061 MarkDeclarationsReferencedInExpr(*C);
11062 }
11063 }
11064 }
11065 }
11066
Douglas Gregorff790f12009-11-26 00:44:06 +000011067 // When are coming out of an unevaluated context, clear out any
11068 // temporaries that we may have created as part of the evaluation of
11069 // the expression in that context: they aren't relevant because they
11070 // will never be constructed.
John McCallf413f5e2013-05-03 00:10:13 +000011071 if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
John McCall28fc7092011-11-10 05:35:25 +000011072 ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects,
11073 ExprCleanupObjects.end());
John McCall31168b02011-06-15 23:02:42 +000011074 ExprNeedsCleanups = Rec.ParentNeedsCleanups;
Eli Friedman3bda6b12012-02-02 23:15:15 +000011075 CleanupVarDeclMarking();
11076 std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
John McCall31168b02011-06-15 23:02:42 +000011077 // Otherwise, merge the contexts together.
11078 } else {
11079 ExprNeedsCleanups |= Rec.ParentNeedsCleanups;
Eli Friedman3bda6b12012-02-02 23:15:15 +000011080 MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(),
11081 Rec.SavedMaybeODRUseExprs.end());
John McCall31168b02011-06-15 23:02:42 +000011082 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000011083
11084 // Pop the current expression evaluation context off the stack.
11085 ExprEvalContexts.pop_back();
Douglas Gregor0b6a6242009-06-22 20:57:11 +000011086}
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000011087
John McCall31168b02011-06-15 23:02:42 +000011088void Sema::DiscardCleanupsInEvaluationContext() {
John McCall28fc7092011-11-10 05:35:25 +000011089 ExprCleanupObjects.erase(
11090 ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
11091 ExprCleanupObjects.end());
John McCall31168b02011-06-15 23:02:42 +000011092 ExprNeedsCleanups = false;
Eli Friedman3bda6b12012-02-02 23:15:15 +000011093 MaybeODRUseExprs.clear();
John McCall31168b02011-06-15 23:02:42 +000011094}
11095
Eli Friedmane0afc982012-01-21 01:01:51 +000011096ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) {
11097 if (!E->getType()->isVariablyModifiedType())
11098 return E;
Benjamin Kramerd81108f2012-11-14 15:08:31 +000011099 return TransformToPotentiallyEvaluated(E);
Eli Friedmane0afc982012-01-21 01:01:51 +000011100}
11101
Benjamin Kramerbf8da9d2012-02-06 11:13:08 +000011102static bool IsPotentiallyEvaluatedContext(Sema &SemaRef) {
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000011103 // Do not mark anything as "used" within a dependent context; wait for
11104 // an instantiation.
Eli Friedmanfa0df832012-02-02 03:46:19 +000011105 if (SemaRef.CurContext->isDependentContext())
11106 return false;
Mike Stump11289f42009-09-09 15:08:12 +000011107
Eli Friedmanfa0df832012-02-02 03:46:19 +000011108 switch (SemaRef.ExprEvalContexts.back().Context) {
11109 case Sema::Unevaluated:
John McCallf413f5e2013-05-03 00:10:13 +000011110 case Sema::UnevaluatedAbstract:
Douglas Gregor0b6a6242009-06-22 20:57:11 +000011111 // We are in an expression that is not potentially evaluated; do nothing.
Eli Friedman02b58512012-01-21 04:44:06 +000011112 // (Depending on how you read the standard, we actually do need to do
11113 // something here for null pointer constants, but the standard's
11114 // definition of a null pointer constant is completely crazy.)
Eli Friedmanfa0df832012-02-02 03:46:19 +000011115 return false;
Mike Stump11289f42009-09-09 15:08:12 +000011116
Eli Friedmanfa0df832012-02-02 03:46:19 +000011117 case Sema::ConstantEvaluated:
11118 case Sema::PotentiallyEvaluated:
Eli Friedman02b58512012-01-21 04:44:06 +000011119 // We are in a potentially evaluated expression (or a constant-expression
11120 // in C++03); we need to do implicit template instantiation, implicitly
11121 // define class members, and mark most declarations as used.
Eli Friedmanfa0df832012-02-02 03:46:19 +000011122 return true;
Mike Stump11289f42009-09-09 15:08:12 +000011123
Eli Friedmanfa0df832012-02-02 03:46:19 +000011124 case Sema::PotentiallyEvaluatedIfUsed:
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000011125 // Referenced declarations will only be used if the construct in the
11126 // containing expression is used.
Eli Friedmanfa0df832012-02-02 03:46:19 +000011127 return false;
Douglas Gregor0b6a6242009-06-22 20:57:11 +000011128 }
Matt Beaumont-Gay248bc722012-02-02 18:35:35 +000011129 llvm_unreachable("Invalid context");
Eli Friedmanfa0df832012-02-02 03:46:19 +000011130}
11131
11132/// \brief Mark a function referenced, and check whether it is odr-used
11133/// (C++ [basic.def.odr]p2, C99 6.9p3)
11134void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func) {
11135 assert(Func && "No function?");
11136
11137 Func->setReferenced();
11138
Richard Smithe10d3042012-11-07 01:14:25 +000011139 // C++11 [basic.def.odr]p3:
11140 // A function whose name appears as a potentially-evaluated expression is
11141 // odr-used if it is the unique lookup result or the selected member of a
11142 // set of overloaded functions [...].
11143 //
11144 // We (incorrectly) mark overload resolution as an unevaluated context, so we
11145 // can just check that here. Skip the rest of this function if we've already
11146 // marked the function as used.
11147 if (Func->isUsed(false) || !IsPotentiallyEvaluatedContext(*this)) {
11148 // C++11 [temp.inst]p3:
11149 // Unless a function template specialization has been explicitly
11150 // instantiated or explicitly specialized, the function template
11151 // specialization is implicitly instantiated when the specialization is
11152 // referenced in a context that requires a function definition to exist.
11153 //
11154 // We consider constexpr function templates to be referenced in a context
11155 // that requires a definition to exist whenever they are referenced.
11156 //
11157 // FIXME: This instantiates constexpr functions too frequently. If this is
11158 // really an unevaluated context (and we're not just in the definition of a
11159 // function template or overload resolution or other cases which we
11160 // incorrectly consider to be unevaluated contexts), and we're not in a
11161 // subexpression which we actually need to evaluate (for instance, a
11162 // template argument, array bound or an expression in a braced-init-list),
11163 // we are not permitted to instantiate this constexpr function definition.
11164 //
11165 // FIXME: This also implicitly defines special members too frequently. They
11166 // are only supposed to be implicitly defined if they are odr-used, but they
11167 // are not odr-used from constant expressions in unevaluated contexts.
11168 // However, they cannot be referenced if they are deleted, and they are
11169 // deleted whenever the implicit definition of the special member would
11170 // fail.
David Majnemerc85ed7e2013-10-23 21:31:20 +000011171 if (!Func->isConstexpr() || Func->getBody())
Richard Smithe10d3042012-11-07 01:14:25 +000011172 return;
11173 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func);
11174 if (!Func->isImplicitlyInstantiable() && (!MD || MD->isUserProvided()))
11175 return;
11176 }
Mike Stump11289f42009-09-09 15:08:12 +000011177
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000011178 // Note that this declaration has been used.
Eli Friedmanfa0df832012-02-02 03:46:19 +000011179 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011180 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl());
Richard Smith273c4e92012-02-26 07:51:39 +000011181 if (Constructor->isDefaulted() && !Constructor->isDeleted()) {
Sebastian Redl22653ba2011-08-30 19:58:05 +000011182 if (Constructor->isDefaultConstructor()) {
11183 if (Constructor->isTrivial())
11184 return;
Richard Smithab44d5b2013-12-10 08:25:00 +000011185 DefineImplicitDefaultConstructor(Loc, Constructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000011186 } else if (Constructor->isCopyConstructor()) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011187 DefineImplicitCopyConstructor(Loc, Constructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000011188 } else if (Constructor->isMoveConstructor()) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011189 DefineImplicitMoveConstructor(Loc, Constructor);
Sebastian Redl22653ba2011-08-30 19:58:05 +000011190 }
Richard Smithc2bc61b2013-03-18 21:12:30 +000011191 } else if (Constructor->getInheritedConstructor()) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011192 DefineInheritingConstructor(Loc, Constructor);
Fariborz Jahanian477d2422009-06-22 23:34:40 +000011193 }
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000011194
Douglas Gregor88d292c2010-05-13 16:44:06 +000011195 MarkVTableUsed(Loc, Constructor->getParent());
Eli Friedmanfa0df832012-02-02 03:46:19 +000011196 } else if (CXXDestructorDecl *Destructor =
11197 dyn_cast<CXXDestructorDecl>(Func)) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011198 Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
11199 if (Destructor->isDefaulted() && !Destructor->isDeleted())
Fariborz Jahanian24a175b2009-06-26 23:49:16 +000011200 DefineImplicitDestructor(Loc, Destructor);
Douglas Gregor88d292c2010-05-13 16:44:06 +000011201 if (Destructor->isVirtual())
11202 MarkVTableUsed(Loc, Destructor->getParent());
Eli Friedmanfa0df832012-02-02 03:46:19 +000011203 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Func)) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011204 if (MethodDecl->isOverloadedOperator() &&
Fariborz Jahanian41f79272009-06-25 21:45:19 +000011205 MethodDecl->getOverloadedOperator() == OO_Equal) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011206 MethodDecl = cast<CXXMethodDecl>(MethodDecl->getFirstDecl());
11207 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted()) {
Sebastian Redl22653ba2011-08-30 19:58:05 +000011208 if (MethodDecl->isCopyAssignmentOperator())
11209 DefineImplicitCopyAssignment(Loc, MethodDecl);
11210 else
11211 DefineImplicitMoveAssignment(Loc, MethodDecl);
11212 }
Douglas Gregord3b672c2012-02-16 01:06:16 +000011213 } else if (isa<CXXConversionDecl>(MethodDecl) &&
11214 MethodDecl->getParent()->isLambda()) {
Richard Smithab44d5b2013-12-10 08:25:00 +000011215 CXXConversionDecl *Conversion =
11216 cast<CXXConversionDecl>(MethodDecl->getFirstDecl());
Douglas Gregord3b672c2012-02-16 01:06:16 +000011217 if (Conversion->isLambdaToBlockPointerConversion())
11218 DefineImplicitLambdaToBlockPointerConversion(Loc, Conversion);
11219 else
11220 DefineImplicitLambdaToFunctionPointerConversion(Loc, Conversion);
Douglas Gregor88d292c2010-05-13 16:44:06 +000011221 } else if (MethodDecl->isVirtual())
11222 MarkVTableUsed(Loc, MethodDecl->getParent());
Fariborz Jahanian41f79272009-06-25 21:45:19 +000011223 }
John McCall83779672011-02-19 02:53:41 +000011224
Eli Friedmanfa0df832012-02-02 03:46:19 +000011225 // Recursive functions should be marked when used from another function.
11226 // FIXME: Is this really right?
11227 if (CurContext == Func) return;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000011228
Richard Smithd3b5c9082012-07-27 04:22:15 +000011229 // Resolve the exception specification for any function which is
Richard Smithf623c962012-04-17 00:58:00 +000011230 // used: CodeGen will need it.
Richard Smithd3729422012-04-19 00:08:28 +000011231 const FunctionProtoType *FPT = Func->getType()->getAs<FunctionProtoType>();
Richard Smithd3b5c9082012-07-27 04:22:15 +000011232 if (FPT && isUnresolvedExceptionSpec(FPT->getExceptionSpecType()))
11233 ResolveExceptionSpec(Loc, FPT);
Richard Smithf623c962012-04-17 00:58:00 +000011234
Eli Friedmanfa0df832012-02-02 03:46:19 +000011235 // Implicit instantiation of function templates and member functions of
11236 // class templates.
11237 if (Func->isImplicitlyInstantiable()) {
11238 bool AlreadyInstantiated = false;
Richard Smith4a941e22012-02-14 22:25:15 +000011239 SourceLocation PointOfInstantiation = Loc;
Eli Friedmanfa0df832012-02-02 03:46:19 +000011240 if (FunctionTemplateSpecializationInfo *SpecInfo
11241 = Func->getTemplateSpecializationInfo()) {
11242 if (SpecInfo->getPointOfInstantiation().isInvalid())
11243 SpecInfo->setPointOfInstantiation(Loc);
11244 else if (SpecInfo->getTemplateSpecializationKind()
Richard Smith4a941e22012-02-14 22:25:15 +000011245 == TSK_ImplicitInstantiation) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000011246 AlreadyInstantiated = true;
Richard Smith4a941e22012-02-14 22:25:15 +000011247 PointOfInstantiation = SpecInfo->getPointOfInstantiation();
11248 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000011249 } else if (MemberSpecializationInfo *MSInfo
11250 = Func->getMemberSpecializationInfo()) {
11251 if (MSInfo->getPointOfInstantiation().isInvalid())
Douglas Gregor06db9f52009-10-12 20:18:28 +000011252 MSInfo->setPointOfInstantiation(Loc);
Eli Friedmanfa0df832012-02-02 03:46:19 +000011253 else if (MSInfo->getTemplateSpecializationKind()
Richard Smith4a941e22012-02-14 22:25:15 +000011254 == TSK_ImplicitInstantiation) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000011255 AlreadyInstantiated = true;
Richard Smith4a941e22012-02-14 22:25:15 +000011256 PointOfInstantiation = MSInfo->getPointOfInstantiation();
11257 }
Douglas Gregor06db9f52009-10-12 20:18:28 +000011258 }
Mike Stump11289f42009-09-09 15:08:12 +000011259
David Majnemerc85ed7e2013-10-23 21:31:20 +000011260 if (!AlreadyInstantiated || Func->isConstexpr()) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000011261 if (isa<CXXRecordDecl>(Func->getDeclContext()) &&
Faisal Vali18d35982013-06-26 02:34:24 +000011262 cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() &&
11263 ActiveTemplateInstantiations.size())
Richard Smith4a941e22012-02-14 22:25:15 +000011264 PendingLocalImplicitInstantiations.push_back(
11265 std::make_pair(Func, PointOfInstantiation));
David Majnemerc85ed7e2013-10-23 21:31:20 +000011266 else if (Func->isConstexpr())
Eli Friedmanfa0df832012-02-02 03:46:19 +000011267 // Do not defer instantiations of constexpr functions, to avoid the
11268 // expression evaluator needing to call back into Sema if it sees a
11269 // call to such a function.
Richard Smith4a941e22012-02-14 22:25:15 +000011270 InstantiateFunctionDefinition(PointOfInstantiation, Func);
Argyrios Kyrtzidise5dc5b32012-02-10 20:10:44 +000011271 else {
Richard Smith4a941e22012-02-14 22:25:15 +000011272 PendingInstantiations.push_back(std::make_pair(Func,
11273 PointOfInstantiation));
Argyrios Kyrtzidise5dc5b32012-02-10 20:10:44 +000011274 // Notify the consumer that a function was implicitly instantiated.
11275 Consumer.HandleCXXImplicitFunctionInstantiation(Func);
11276 }
John McCall83779672011-02-19 02:53:41 +000011277 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000011278 } else {
11279 // Walk redefinitions, as some of them may be instantiable.
11280 for (FunctionDecl::redecl_iterator i(Func->redecls_begin()),
11281 e(Func->redecls_end()); i != e; ++i) {
11282 if (!i->isUsed(false) && i->isImplicitlyInstantiable())
11283 MarkFunctionReferenced(Loc, *i);
11284 }
Sam Weinigbae69142009-09-11 03:29:30 +000011285 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000011286
11287 // Keep track of used but undefined functions.
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000011288 if (!Func->isDefined()) {
Rafael Espindola0e0d0092013-03-14 03:07:35 +000011289 if (mightHaveNonExternalLinkage(Func))
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +000011290 UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
11291 else if (Func->getMostRecentDecl()->isInlined() &&
11292 (LangOpts.CPlusPlus || !LangOpts.GNUInline) &&
11293 !Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
11294 UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
Eli Friedmanfa0df832012-02-02 03:46:19 +000011295 }
11296
Rafael Espindola0d3da832013-10-19 02:06:23 +000011297 // Normally the most current decl is marked used while processing the use and
Rafael Espindola820fa702013-01-08 19:43:34 +000011298 // any subsequent decls are marked used by decl merging. This fails with
11299 // template instantiation since marking can happen at the end of the file
11300 // and, because of the two phase lookup, this function is called with at
11301 // decl in the middle of a decl chain. We loop to maintain the invariant
11302 // that once a decl is used, all decls after it are also used.
Rafael Espindolaf26d5392013-01-08 19:58:34 +000011303 for (FunctionDecl *F = Func->getMostRecentDecl();; F = F->getPreviousDecl()) {
Eli Friedman276dd182013-09-05 00:02:25 +000011304 F->markUsed(Context);
Rafael Espindola820fa702013-01-08 19:43:34 +000011305 if (F == Func)
11306 break;
Rafael Espindola820fa702013-01-08 19:43:34 +000011307 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000011308}
11309
Eli Friedman9bb33f52012-02-03 02:04:35 +000011310static void
11311diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
11312 VarDecl *var, DeclContext *DC) {
Eli Friedmandd053f62012-02-07 00:15:00 +000011313 DeclContext *VarDC = var->getDeclContext();
11314
Eli Friedman9bb33f52012-02-03 02:04:35 +000011315 // If the parameter still belongs to the translation unit, then
11316 // we're actually just using one parameter in the declaration of
11317 // the next.
11318 if (isa<ParmVarDecl>(var) &&
Eli Friedmandd053f62012-02-07 00:15:00 +000011319 isa<TranslationUnitDecl>(VarDC))
Eli Friedman9bb33f52012-02-03 02:04:35 +000011320 return;
11321
Eli Friedmandd053f62012-02-07 00:15:00 +000011322 // For C code, don't diagnose about capture if we're not actually in code
11323 // right now; it's impossible to write a non-constant expression outside of
11324 // function context, so we'll get other (more useful) diagnostics later.
11325 //
11326 // For C++, things get a bit more nasty... it would be nice to suppress this
11327 // diagnostic for certain cases like using a local variable in an array bound
11328 // for a member of a local class, but the correct predicate is not obvious.
David Blaikiebbafb8a2012-03-11 07:00:24 +000011329 if (!S.getLangOpts().CPlusPlus && !S.CurContext->isFunctionOrMethod())
Eli Friedman9bb33f52012-02-03 02:04:35 +000011330 return;
11331
Eli Friedmandd053f62012-02-07 00:15:00 +000011332 if (isa<CXXMethodDecl>(VarDC) &&
11333 cast<CXXRecordDecl>(VarDC->getParent())->isLambda()) {
11334 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_lambda)
11335 << var->getIdentifier();
11336 } else if (FunctionDecl *fn = dyn_cast<FunctionDecl>(VarDC)) {
11337 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_function)
11338 << var->getIdentifier() << fn->getDeclName();
11339 } else if (isa<BlockDecl>(VarDC)) {
11340 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_block)
11341 << var->getIdentifier();
11342 } else {
11343 // FIXME: Is there any other context where a local variable can be
11344 // declared?
11345 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_context)
11346 << var->getIdentifier();
11347 }
Eli Friedman9bb33f52012-02-03 02:04:35 +000011348
Eli Friedman9bb33f52012-02-03 02:04:35 +000011349 S.Diag(var->getLocation(), diag::note_local_variable_declared_here)
11350 << var->getIdentifier();
Eli Friedmandd053f62012-02-07 00:15:00 +000011351
11352 // FIXME: Add additional diagnostic info about class etc. which prevents
11353 // capture.
Eli Friedman9bb33f52012-02-03 02:04:35 +000011354}
11355
Faisal Valiad090d82013-10-07 05:13:48 +000011356
11357static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, VarDecl *Var,
11358 bool &SubCapturesAreNested,
11359 QualType &CaptureType,
11360 QualType &DeclRefType) {
11361 // Check whether we've already captured it.
11362 if (CSI->CaptureMap.count(Var)) {
11363 // If we found a capture, any subcaptures are nested.
11364 SubCapturesAreNested = true;
11365
11366 // Retrieve the capture type for this variable.
11367 CaptureType = CSI->getCapture(Var).getCaptureType();
11368
11369 // Compute the type of an expression that refers to this variable.
11370 DeclRefType = CaptureType.getNonReferenceType();
11371
11372 const CapturingScopeInfo::Capture &Cap = CSI->getCapture(Var);
11373 if (Cap.isCopyCapture() &&
11374 !(isa<LambdaScopeInfo>(CSI) && cast<LambdaScopeInfo>(CSI)->Mutable))
11375 DeclRefType.addConst();
11376 return true;
11377 }
11378 return false;
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +000011379}
11380
Faisal Valiad090d82013-10-07 05:13:48 +000011381// Only block literals, captured statements, and lambda expressions can
11382// capture; other scopes don't work.
11383static DeclContext *getParentOfCapturingContextOrNull(DeclContext *DC, VarDecl *Var,
11384 SourceLocation Loc,
11385 const bool Diagnose, Sema &S) {
Faisal Valia17d19f2013-11-07 05:17:06 +000011386 if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC) || isLambdaCallOperator(DC))
11387 return getLambdaAwareParentOfDeclContext(DC);
Faisal Valiad090d82013-10-07 05:13:48 +000011388 else {
11389 if (Diagnose)
11390 diagnoseUncapturableValueReference(S, Loc, Var, DC);
11391 }
11392 return 0;
11393}
11394
11395// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
11396// certain types of variables (unnamed, variably modified types etc.)
11397// so check for eligibility.
11398static bool isVariableCapturable(CapturingScopeInfo *CSI, VarDecl *Var,
11399 SourceLocation Loc,
11400 const bool Diagnose, Sema &S) {
11401
11402 bool IsBlock = isa<BlockScopeInfo>(CSI);
11403 bool IsLambda = isa<LambdaScopeInfo>(CSI);
11404
11405 // Lambdas are not allowed to capture unnamed variables
11406 // (e.g. anonymous unions).
11407 // FIXME: The C++11 rule don't actually state this explicitly, but I'm
11408 // assuming that's the intent.
11409 if (IsLambda && !Var->getDeclName()) {
11410 if (Diagnose) {
11411 S.Diag(Loc, diag::err_lambda_capture_anonymous_var);
11412 S.Diag(Var->getLocation(), diag::note_declared_at);
11413 }
11414 return false;
11415 }
11416
11417 // Prohibit variably-modified types; they're difficult to deal with.
11418 if (Var->getType()->isVariablyModifiedType()) {
11419 if (Diagnose) {
11420 if (IsBlock)
11421 S.Diag(Loc, diag::err_ref_vm_type);
11422 else
11423 S.Diag(Loc, diag::err_lambda_capture_vm_type) << Var->getDeclName();
11424 S.Diag(Var->getLocation(), diag::note_previous_decl)
11425 << Var->getDeclName();
11426 }
11427 return false;
11428 }
11429 // Prohibit structs with flexible array members too.
11430 // We cannot capture what is in the tail end of the struct.
11431 if (const RecordType *VTTy = Var->getType()->getAs<RecordType>()) {
11432 if (VTTy->getDecl()->hasFlexibleArrayMember()) {
11433 if (Diagnose) {
11434 if (IsBlock)
11435 S.Diag(Loc, diag::err_ref_flexarray_type);
11436 else
11437 S.Diag(Loc, diag::err_lambda_capture_flexarray_type)
11438 << Var->getDeclName();
11439 S.Diag(Var->getLocation(), diag::note_previous_decl)
11440 << Var->getDeclName();
11441 }
11442 return false;
11443 }
11444 }
11445 const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
11446 // Lambdas and captured statements are not allowed to capture __block
11447 // variables; they don't support the expected semantics.
11448 if (HasBlocksAttr && (IsLambda || isa<CapturedRegionScopeInfo>(CSI))) {
11449 if (Diagnose) {
11450 S.Diag(Loc, diag::err_capture_block_variable)
11451 << Var->getDeclName() << !IsLambda;
11452 S.Diag(Var->getLocation(), diag::note_previous_decl)
11453 << Var->getDeclName();
11454 }
11455 return false;
11456 }
11457
11458 return true;
11459}
11460
11461// Returns true if the capture by block was successful.
11462static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var,
11463 SourceLocation Loc,
11464 const bool BuildAndDiagnose,
11465 QualType &CaptureType,
11466 QualType &DeclRefType,
11467 const bool Nested,
11468 Sema &S) {
11469 Expr *CopyExpr = 0;
11470 bool ByRef = false;
11471
11472 // Blocks are not allowed to capture arrays.
11473 if (CaptureType->isArrayType()) {
11474 if (BuildAndDiagnose) {
11475 S.Diag(Loc, diag::err_ref_array_type);
11476 S.Diag(Var->getLocation(), diag::note_previous_decl)
11477 << Var->getDeclName();
11478 }
11479 return false;
11480 }
11481
11482 // Forbid the block-capture of autoreleasing variables.
11483 if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
11484 if (BuildAndDiagnose) {
11485 S.Diag(Loc, diag::err_arc_autoreleasing_capture)
11486 << /*block*/ 0;
11487 S.Diag(Var->getLocation(), diag::note_previous_decl)
11488 << Var->getDeclName();
11489 }
11490 return false;
11491 }
11492 const bool HasBlocksAttr = Var->hasAttr<BlocksAttr>();
11493 if (HasBlocksAttr || CaptureType->isReferenceType()) {
11494 // Block capture by reference does not change the capture or
11495 // declaration reference types.
11496 ByRef = true;
11497 } else {
11498 // Block capture by copy introduces 'const'.
11499 CaptureType = CaptureType.getNonReferenceType().withConst();
11500 DeclRefType = CaptureType;
11501
11502 if (S.getLangOpts().CPlusPlus && BuildAndDiagnose) {
11503 if (const RecordType *Record = DeclRefType->getAs<RecordType>()) {
11504 // The capture logic needs the destructor, so make sure we mark it.
11505 // Usually this is unnecessary because most local variables have
11506 // their destructors marked at declaration time, but parameters are
11507 // an exception because it's technically only the call site that
11508 // actually requires the destructor.
11509 if (isa<ParmVarDecl>(Var))
11510 S.FinalizeVarWithDestructor(Var, Record);
11511
11512 // Enter a new evaluation context to insulate the copy
11513 // full-expression.
11514 EnterExpressionEvaluationContext scope(S, S.PotentiallyEvaluated);
11515
11516 // According to the blocks spec, the capture of a variable from
11517 // the stack requires a const copy constructor. This is not true
11518 // of the copy/move done to move a __block variable to the heap.
11519 Expr *DeclRef = new (S.Context) DeclRefExpr(Var, Nested,
11520 DeclRefType.withConst(),
11521 VK_LValue, Loc);
11522
11523 ExprResult Result
11524 = S.PerformCopyInitialization(
11525 InitializedEntity::InitializeBlock(Var->getLocation(),
11526 CaptureType, false),
11527 Loc, S.Owned(DeclRef));
11528
11529 // Build a full-expression copy expression if initialization
11530 // succeeded and used a non-trivial constructor. Recover from
11531 // errors by pretending that the copy isn't necessary.
11532 if (!Result.isInvalid() &&
11533 !cast<CXXConstructExpr>(Result.get())->getConstructor()
11534 ->isTrivial()) {
11535 Result = S.MaybeCreateExprWithCleanups(Result);
11536 CopyExpr = Result.take();
11537 }
11538 }
11539 }
11540 }
11541
11542 // Actually capture the variable.
11543 if (BuildAndDiagnose)
11544 BSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc,
11545 SourceLocation(), CaptureType, CopyExpr);
11546
11547 return true;
11548
11549}
11550
11551
11552/// \brief Capture the given variable in the captured region.
11553static bool captureInCapturedRegion(CapturedRegionScopeInfo *RSI,
11554 VarDecl *Var,
11555 SourceLocation Loc,
11556 const bool BuildAndDiagnose,
11557 QualType &CaptureType,
11558 QualType &DeclRefType,
11559 const bool RefersToEnclosingLocal,
11560 Sema &S) {
11561
11562 // By default, capture variables by reference.
11563 bool ByRef = true;
11564 // Using an LValue reference type is consistent with Lambdas (see below).
11565 CaptureType = S.Context.getLValueReferenceType(DeclRefType);
11566 Expr *CopyExpr = 0;
11567 if (BuildAndDiagnose) {
11568 // The current implementation assumes that all variables are captured
11569 // by references. Since there is no capture by copy, no expression evaluation
11570 // will be needed.
11571 //
11572 RecordDecl *RD = RSI->TheRecordDecl;
11573
11574 FieldDecl *Field
11575 = FieldDecl::Create(S.Context, RD, Loc, Loc, 0, CaptureType,
11576 S.Context.getTrivialTypeSourceInfo(CaptureType, Loc),
11577 0, false, ICIS_NoInit);
11578 Field->setImplicit(true);
11579 Field->setAccess(AS_private);
11580 RD->addDecl(Field);
11581
11582 CopyExpr = new (S.Context) DeclRefExpr(Var, RefersToEnclosingLocal,
11583 DeclRefType, VK_LValue, Loc);
11584 Var->setReferenced(true);
11585 Var->markUsed(S.Context);
11586 }
11587
11588 // Actually capture the variable.
11589 if (BuildAndDiagnose)
11590 RSI->addCapture(Var, /*isBlock*/false, ByRef, RefersToEnclosingLocal, Loc,
11591 SourceLocation(), CaptureType, CopyExpr);
11592
11593
11594 return true;
11595}
11596
11597/// \brief Create a field within the lambda class for the variable
11598/// being captured. Handle Array captures.
11599static ExprResult addAsFieldToClosureType(Sema &S,
11600 LambdaScopeInfo *LSI,
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011601 VarDecl *Var, QualType FieldType,
11602 QualType DeclRefType,
Douglas Gregora8182f92012-05-16 17:01:33 +000011603 SourceLocation Loc,
11604 bool RefersToEnclosingLocal) {
Douglas Gregor81495f32012-02-12 18:42:33 +000011605 CXXRecordDecl *Lambda = LSI->Lambda;
Douglas Gregor81495f32012-02-12 18:42:33 +000011606
Douglas Gregord1e3ceb2013-12-18 23:02:36 +000011607 // Make sure that by-copy captures are of a complete type.
11608 if (!DeclRefType->isDependentType() &&
11609 !DeclRefType->isReferenceType() &&
11610 S.RequireCompleteType(Loc, DeclRefType,
11611 diag::err_capture_of_incomplete_type,
11612 Var->getDeclName())) {
11613 return ExprError();
11614 }
11615
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011616 // Build the non-static data member.
11617 FieldDecl *Field
11618 = FieldDecl::Create(S.Context, Lambda, Loc, Loc, 0, FieldType,
11619 S.Context.getTrivialTypeSourceInfo(FieldType, Loc),
Richard Smith2b013182012-06-10 03:12:00 +000011620 0, false, ICIS_NoInit);
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011621 Field->setImplicit(true);
11622 Field->setAccess(AS_private);
Douglas Gregor3d23f7882012-02-09 02:12:34 +000011623 Lambda->addDecl(Field);
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011624
11625 // C++11 [expr.prim.lambda]p21:
11626 // When the lambda-expression is evaluated, the entities that
11627 // are captured by copy are used to direct-initialize each
11628 // corresponding non-static data member of the resulting closure
11629 // object. (For array members, the array elements are
11630 // direct-initialized in increasing subscript order.) These
11631 // initializations are performed in the (unspecified) order in
11632 // which the non-static data members are declared.
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011633
Douglas Gregor89625492012-02-09 08:14:43 +000011634 // Introduce a new evaluation context for the initialization, so
11635 // that temporaries introduced as part of the capture are retained
11636 // to be re-"exported" from the lambda expression itself.
John McCalleaef89b2013-03-22 02:10:40 +000011637 EnterExpressionEvaluationContext scope(S, Sema::PotentiallyEvaluated);
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011638
Douglas Gregorf02455e2012-02-10 09:26:04 +000011639 // C++ [expr.prim.labda]p12:
11640 // An entity captured by a lambda-expression is odr-used (3.2) in
11641 // the scope containing the lambda-expression.
Douglas Gregora8182f92012-05-16 17:01:33 +000011642 Expr *Ref = new (S.Context) DeclRefExpr(Var, RefersToEnclosingLocal,
11643 DeclRefType, VK_LValue, Loc);
Eli Friedman23b1be92012-03-01 21:32:56 +000011644 Var->setReferenced(true);
Eli Friedman276dd182013-09-05 00:02:25 +000011645 Var->markUsed(S.Context);
Douglas Gregor199cec72012-02-09 02:45:47 +000011646
11647 // When the field has array type, create index variables for each
11648 // dimension of the array. We use these index variables to subscript
11649 // the source array, and other clients (e.g., CodeGen) will perform
11650 // the necessary iteration with these index variables.
11651 SmallVector<VarDecl *, 4> IndexVariables;
Douglas Gregor199cec72012-02-09 02:45:47 +000011652 QualType BaseType = FieldType;
11653 QualType SizeType = S.Context.getSizeType();
Douglas Gregor54fcea62012-02-13 16:35:30 +000011654 LSI->ArrayIndexStarts.push_back(LSI->ArrayIndexVars.size());
Douglas Gregor199cec72012-02-09 02:45:47 +000011655 while (const ConstantArrayType *Array
11656 = S.Context.getAsConstantArrayType(BaseType)) {
Douglas Gregor199cec72012-02-09 02:45:47 +000011657 // Create the iteration variable for this array index.
11658 IdentifierInfo *IterationVarName = 0;
11659 {
11660 SmallString<8> Str;
11661 llvm::raw_svector_ostream OS(Str);
11662 OS << "__i" << IndexVariables.size();
11663 IterationVarName = &S.Context.Idents.get(OS.str());
11664 }
11665 VarDecl *IterationVar
11666 = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
11667 IterationVarName, SizeType,
11668 S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
Rafael Espindola6ae7e502013-04-03 19:27:57 +000011669 SC_None);
Douglas Gregor199cec72012-02-09 02:45:47 +000011670 IndexVariables.push_back(IterationVar);
Douglas Gregor54fcea62012-02-13 16:35:30 +000011671 LSI->ArrayIndexVars.push_back(IterationVar);
11672
Douglas Gregor199cec72012-02-09 02:45:47 +000011673 // Create a reference to the iteration variable.
11674 ExprResult IterationVarRef
11675 = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc);
11676 assert(!IterationVarRef.isInvalid() &&
11677 "Reference to invented variable cannot fail!");
11678 IterationVarRef = S.DefaultLvalueConversion(IterationVarRef.take());
11679 assert(!IterationVarRef.isInvalid() &&
11680 "Conversion of invented variable cannot fail!");
11681
11682 // Subscript the array with this iteration variable.
11683 ExprResult Subscript = S.CreateBuiltinArraySubscriptExpr(
11684 Ref, Loc, IterationVarRef.take(), Loc);
11685 if (Subscript.isInvalid()) {
11686 S.CleanupVarDeclMarking();
11687 S.DiscardCleanupsInEvaluationContext();
Douglas Gregor199cec72012-02-09 02:45:47 +000011688 return ExprError();
11689 }
11690
11691 Ref = Subscript.take();
11692 BaseType = Array->getElementType();
11693 }
11694
11695 // Construct the entity that we will be initializing. For an array, this
11696 // will be first element in the array, which may require several levels
11697 // of array-subscript entities.
11698 SmallVector<InitializedEntity, 4> Entities;
11699 Entities.reserve(1 + IndexVariables.size());
Douglas Gregor19666fb2012-02-15 16:57:26 +000011700 Entities.push_back(
Faisal Vali5fb7c3c2013-12-05 01:40:41 +000011701 InitializedEntity::InitializeLambdaCapture(Var->getIdentifier(),
11702 Field->getType(), Loc));
Douglas Gregor199cec72012-02-09 02:45:47 +000011703 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I)
11704 Entities.push_back(InitializedEntity::InitializeElement(S.Context,
11705 0,
11706 Entities.back()));
11707
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011708 InitializationKind InitKind
11709 = InitializationKind::CreateDirect(Loc, Loc, Loc);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +000011710 InitializationSequence Init(S, Entities.back(), InitKind, Ref);
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011711 ExprResult Result(true);
Dmitri Gribenko8f8930f2013-05-03 15:05:50 +000011712 if (!Init.Diagnose(S, Entities.back(), InitKind, Ref))
Benjamin Kramercc4c49d2012-08-23 23:38:35 +000011713 Result = Init.Perform(S, Entities.back(), InitKind, Ref);
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011714
11715 // If this initialization requires any cleanups (e.g., due to a
11716 // default argument to a copy constructor), note that for the
11717 // lambda.
11718 if (S.ExprNeedsCleanups)
11719 LSI->ExprNeedsCleanups = true;
11720
11721 // Exit the expression evaluation context used for the capture.
11722 S.CleanupVarDeclMarking();
11723 S.DiscardCleanupsInEvaluationContext();
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011724 return Result;
Douglas Gregor199cec72012-02-09 02:45:47 +000011725}
Douglas Gregorabecb9c2012-02-09 01:56:40 +000011726
Faisal Valiad090d82013-10-07 05:13:48 +000011727
11728
11729/// \brief Capture the given variable in the lambda.
11730static bool captureInLambda(LambdaScopeInfo *LSI,
11731 VarDecl *Var,
11732 SourceLocation Loc,
11733 const bool BuildAndDiagnose,
11734 QualType &CaptureType,
11735 QualType &DeclRefType,
11736 const bool RefersToEnclosingLocal,
11737 const Sema::TryCaptureKind Kind,
11738 SourceLocation EllipsisLoc,
11739 const bool IsTopScope,
11740 Sema &S) {
11741
11742 // Determine whether we are capturing by reference or by value.
11743 bool ByRef = false;
11744 if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
11745 ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
11746 } else {
11747 ByRef = (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
11748 }
11749
11750 // Compute the type of the field that will capture this variable.
11751 if (ByRef) {
11752 // C++11 [expr.prim.lambda]p15:
11753 // An entity is captured by reference if it is implicitly or
11754 // explicitly captured but not captured by copy. It is
11755 // unspecified whether additional unnamed non-static data
11756 // members are declared in the closure type for entities
11757 // captured by reference.
11758 //
11759 // FIXME: It is not clear whether we want to build an lvalue reference
11760 // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears
11761 // to do the former, while EDG does the latter. Core issue 1249 will
11762 // clarify, but for now we follow GCC because it's a more permissive and
11763 // easily defensible position.
11764 CaptureType = S.Context.getLValueReferenceType(DeclRefType);
11765 } else {
11766 // C++11 [expr.prim.lambda]p14:
11767 // For each entity captured by copy, an unnamed non-static
11768 // data member is declared in the closure type. The
11769 // declaration order of these members is unspecified. The type
11770 // of such a data member is the type of the corresponding
11771 // captured entity if the entity is not a reference to an
11772 // object, or the referenced type otherwise. [Note: If the
11773 // captured entity is a reference to a function, the
11774 // corresponding data member is also a reference to a
11775 // function. - end note ]
11776 if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){
11777 if (!RefType->getPointeeType()->isFunctionType())
11778 CaptureType = RefType->getPointeeType();
11779 }
11780
11781 // Forbid the lambda copy-capture of autoreleasing variables.
11782 if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
11783 if (BuildAndDiagnose) {
11784 S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
11785 S.Diag(Var->getLocation(), diag::note_previous_decl)
11786 << Var->getDeclName();
11787 }
11788 return false;
11789 }
Douglas Gregor71fe0e82013-10-11 04:25:21 +000011790
11791 if (S.RequireNonAbstractType(Loc, CaptureType,
11792 diag::err_capture_of_abstract_type))
11793 return false;
Faisal Valiad090d82013-10-07 05:13:48 +000011794 }
11795
11796 // Capture this variable in the lambda.
11797 Expr *CopyExpr = 0;
11798 if (BuildAndDiagnose) {
11799 ExprResult Result = addAsFieldToClosureType(S, LSI, Var,
11800 CaptureType, DeclRefType, Loc,
11801 RefersToEnclosingLocal);
11802 if (!Result.isInvalid())
11803 CopyExpr = Result.take();
11804 }
11805
11806 // Compute the type of a reference to this captured variable.
11807 if (ByRef)
11808 DeclRefType = CaptureType.getNonReferenceType();
11809 else {
11810 // C++ [expr.prim.lambda]p5:
11811 // The closure type for a lambda-expression has a public inline
11812 // function call operator [...]. This function call operator is
11813 // declared const (9.3.1) if and only if the lambda-expression’s
11814 // parameter-declaration-clause is not followed by mutable.
11815 DeclRefType = CaptureType.getNonReferenceType();
11816 if (!LSI->Mutable && !CaptureType->isReferenceType())
11817 DeclRefType.addConst();
11818 }
11819
11820 // Add the capture.
11821 if (BuildAndDiagnose)
11822 LSI->addCapture(Var, /*IsBlock=*/false, ByRef, RefersToEnclosingLocal,
11823 Loc, EllipsisLoc, CaptureType, CopyExpr);
11824
11825 return true;
11826}
11827
11828
11829bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation ExprLoc,
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011830 TryCaptureKind Kind, SourceLocation EllipsisLoc,
11831 bool BuildAndDiagnose,
11832 QualType &CaptureType,
Faisal Valia17d19f2013-11-07 05:17:06 +000011833 QualType &DeclRefType,
11834 const unsigned *const FunctionScopeIndexToStopAt) {
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011835 bool Nested = false;
Douglas Gregor81495f32012-02-12 18:42:33 +000011836
Eli Friedman24af8502012-02-03 22:47:37 +000011837 DeclContext *DC = CurContext;
Faisal Valia17d19f2013-11-07 05:17:06 +000011838 const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
11839 ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
11840 // We need to sync up the Declaration Context with the
11841 // FunctionScopeIndexToStopAt
11842 if (FunctionScopeIndexToStopAt) {
11843 unsigned FSIndex = FunctionScopes.size() - 1;
11844 while (FSIndex != MaxFunctionScopesIndex) {
11845 DC = getLambdaAwareParentOfDeclContext(DC);
11846 --FSIndex;
11847 }
11848 }
Faisal Valiad090d82013-10-07 05:13:48 +000011849
Faisal Valia17d19f2013-11-07 05:17:06 +000011850
Faisal Valiad090d82013-10-07 05:13:48 +000011851 // If the variable is declared in the current context (and is not an
11852 // init-capture), there is no need to capture it.
Richard Smith75e3f692013-09-28 04:31:26 +000011853 if (!Var->isInitCapture() && Var->getDeclContext() == DC) return true;
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011854 if (!Var->hasLocalStorage()) return true;
Eli Friedman9bb33f52012-02-03 02:04:35 +000011855
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011856 // Walk up the stack to determine whether we can capture the variable,
11857 // performing the "simple" checks that don't depend on type. We stop when
11858 // we've either hit the declared scope of the variable or find an existing
Faisal Valiad090d82013-10-07 05:13:48 +000011859 // capture of that variable. We start from the innermost capturing-entity
11860 // (the DC) and ensure that all intervening capturing-entities
11861 // (blocks/lambdas etc.) between the innermost capturer and the variable`s
11862 // declcontext can either capture the variable or have already captured
11863 // the variable.
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011864 CaptureType = Var->getType();
11865 DeclRefType = CaptureType.getNonReferenceType();
11866 bool Explicit = (Kind != TryCapture_Implicit);
Faisal Valiad090d82013-10-07 05:13:48 +000011867 unsigned FunctionScopesIndex = MaxFunctionScopesIndex;
Eli Friedman9bb33f52012-02-03 02:04:35 +000011868 do {
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +000011869 // Only block literals, captured statements, and lambda expressions can
11870 // capture; other scopes don't work.
Faisal Valiad090d82013-10-07 05:13:48 +000011871 DeclContext *ParentDC = getParentOfCapturingContextOrNull(DC, Var,
11872 ExprLoc,
11873 BuildAndDiagnose,
11874 *this);
11875 if (!ParentDC) return true;
11876
11877 FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
11878 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
Eli Friedman9bb33f52012-02-03 02:04:35 +000011879
Eli Friedman9bb33f52012-02-03 02:04:35 +000011880
Eli Friedman24af8502012-02-03 22:47:37 +000011881 // Check whether we've already captured it.
Faisal Valiad090d82013-10-07 05:13:48 +000011882 if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType,
11883 DeclRefType))
Eli Friedman9bb33f52012-02-03 02:04:35 +000011884 break;
Faisal Valia17d19f2013-11-07 05:17:06 +000011885 // If we are instantiating a generic lambda call operator body,
11886 // we do not want to capture new variables. What was captured
11887 // during either a lambdas transformation or initial parsing
11888 // should be used.
11889 if (isGenericLambdaCallOperatorSpecialization(DC)) {
11890 if (BuildAndDiagnose) {
11891 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
11892 if (LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None) {
11893 Diag(ExprLoc, diag::err_lambda_impcap) << Var->getDeclName();
11894 Diag(Var->getLocation(), diag::note_previous_decl)
11895 << Var->getDeclName();
11896 Diag(LSI->Lambda->getLocStart(), diag::note_lambda_decl);
11897 } else
11898 diagnoseUncapturableValueReference(*this, ExprLoc, Var, DC);
11899 }
11900 return true;
11901 }
Faisal Valiad090d82013-10-07 05:13:48 +000011902 // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
11903 // certain types of variables (unnamed, variably modified types etc.)
11904 // so check for eligibility.
11905 if (!isVariableCapturable(CSI, Var, ExprLoc, BuildAndDiagnose, *this))
11906 return true;
11907
Douglas Gregor81495f32012-02-12 18:42:33 +000011908 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) {
Faisal Valiad090d82013-10-07 05:13:48 +000011909 // No capture-default, and this is not an explicit capture
11910 // so cannot capture this variable.
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011911 if (BuildAndDiagnose) {
Faisal Valiad090d82013-10-07 05:13:48 +000011912 Diag(ExprLoc, diag::err_lambda_impcap) << Var->getDeclName();
Douglas Gregor81495f32012-02-12 18:42:33 +000011913 Diag(Var->getLocation(), diag::note_previous_decl)
11914 << Var->getDeclName();
11915 Diag(cast<LambdaScopeInfo>(CSI)->Lambda->getLocStart(),
11916 diag::note_lambda_decl);
Faisal Valia17d19f2013-11-07 05:17:06 +000011917 // FIXME: If we error out because an outer lambda can not implicitly
11918 // capture a variable that an inner lambda explicitly captures, we
11919 // should have the inner lambda do the explicit capture - because
11920 // it makes for cleaner diagnostics later. This would purely be done
11921 // so that the diagnostic does not misleadingly claim that a variable
11922 // can not be captured by a lambda implicitly even though it is captured
11923 // explicitly. Suggestion:
11924 // - create const bool VariableCaptureWasInitiallyExplicit = Explicit
11925 // at the function head
11926 // - cache the StartingDeclContext - this must be a lambda
11927 // - captureInLambda in the innermost lambda the variable.
Douglas Gregor81495f32012-02-12 18:42:33 +000011928 }
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011929 return true;
Douglas Gregor81495f32012-02-12 18:42:33 +000011930 }
11931
11932 FunctionScopesIndex--;
11933 DC = ParentDC;
11934 Explicit = false;
11935 } while (!Var->getDeclContext()->Equals(DC));
11936
Faisal Valiad090d82013-10-07 05:13:48 +000011937 // Walk back down the scope stack, (e.g. from outer lambda to inner lambda)
11938 // computing the type of the capture at each step, checking type-specific
11939 // requirements, and adding captures if requested.
11940 // If the variable had already been captured previously, we start capturing
11941 // at the lambda nested within that one.
11942 for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011943 ++I) {
11944 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]);
Douglas Gregor812d8f62012-02-18 05:51:20 +000011945
Faisal Valiad090d82013-10-07 05:13:48 +000011946 if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
11947 if (!captureInBlock(BSI, Var, ExprLoc,
11948 BuildAndDiagnose, CaptureType,
11949 DeclRefType, Nested, *this))
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011950 return true;
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011951 Nested = true;
Faisal Valiad090d82013-10-07 05:13:48 +000011952 } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
11953 if (!captureInCapturedRegion(RSI, Var, ExprLoc,
11954 BuildAndDiagnose, CaptureType,
11955 DeclRefType, Nested, *this))
John McCall67cd5e02012-03-30 05:23:48 +000011956 return true;
Faisal Valiad090d82013-10-07 05:13:48 +000011957 Nested = true;
11958 } else {
11959 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
11960 if (!captureInLambda(LSI, Var, ExprLoc,
11961 BuildAndDiagnose, CaptureType,
11962 DeclRefType, Nested, Kind, EllipsisLoc,
11963 /*IsTopScope*/I == N - 1, *this))
11964 return true;
11965 Nested = true;
Eli Friedman9bb33f52012-02-03 02:04:35 +000011966 }
Eli Friedman9bb33f52012-02-03 02:04:35 +000011967 }
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011968 return false;
11969}
11970
11971bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
11972 TryCaptureKind Kind, SourceLocation EllipsisLoc) {
11973 QualType CaptureType;
11974 QualType DeclRefType;
11975 return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
11976 /*BuildAndDiagnose=*/true, CaptureType,
Faisal Valia17d19f2013-11-07 05:17:06 +000011977 DeclRefType, 0);
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011978}
11979
11980QualType Sema::getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc) {
11981 QualType CaptureType;
11982 QualType DeclRefType;
11983
11984 // Determine whether we can capture this variable.
11985 if (tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
Faisal Valia17d19f2013-11-07 05:17:06 +000011986 /*BuildAndDiagnose=*/false, CaptureType,
11987 DeclRefType, 0))
Douglas Gregorfdf598e2012-02-18 09:37:24 +000011988 return QualType();
11989
11990 return DeclRefType;
Eli Friedman9bb33f52012-02-03 02:04:35 +000011991}
11992
Eli Friedman3bda6b12012-02-02 23:15:15 +000011993
Eli Friedman9bb33f52012-02-03 02:04:35 +000011994
Faisal Valia17d19f2013-11-07 05:17:06 +000011995// If either the type of the variable or the initializer is dependent,
11996// return false. Otherwise, determine whether the variable is a constant
11997// expression. Use this if you need to know if a variable that might or
11998// might not be dependent is truly a constant expression.
11999static inline bool IsVariableNonDependentAndAConstantExpression(VarDecl *Var,
12000 ASTContext &Context) {
12001
12002 if (Var->getType()->isDependentType())
12003 return false;
12004 const VarDecl *DefVD = 0;
12005 Var->getAnyInitializer(DefVD);
12006 if (!DefVD)
12007 return false;
12008 EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt();
12009 Expr *Init = cast<Expr>(Eval->Value);
12010 if (Init->isValueDependent())
12011 return false;
12012 return IsVariableAConstantExpression(Var, Context);
Eli Friedman3bda6b12012-02-02 23:15:15 +000012013}
12014
Faisal Valia17d19f2013-11-07 05:17:06 +000012015
Eli Friedman3bda6b12012-02-02 23:15:15 +000012016void Sema::UpdateMarkingForLValueToRValue(Expr *E) {
12017 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
12018 // an object that satisfies the requirements for appearing in a
12019 // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1)
12020 // is immediately applied." This function handles the lvalue-to-rvalue
12021 // conversion part.
12022 MaybeODRUseExprs.erase(E->IgnoreParens());
Faisal Valia17d19f2013-11-07 05:17:06 +000012023
12024 // If we are in a lambda, check if this DeclRefExpr or MemberExpr refers
12025 // to a variable that is a constant expression, and if so, identify it as
12026 // a reference to a variable that does not involve an odr-use of that
12027 // variable.
12028 if (LambdaScopeInfo *LSI = getCurLambda()) {
12029 Expr *SansParensExpr = E->IgnoreParens();
12030 VarDecl *Var = 0;
12031 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(SansParensExpr))
12032 Var = dyn_cast<VarDecl>(DRE->getFoundDecl());
12033 else if (MemberExpr *ME = dyn_cast<MemberExpr>(SansParensExpr))
12034 Var = dyn_cast<VarDecl>(ME->getMemberDecl());
12035
12036 if (Var && IsVariableNonDependentAndAConstantExpression(Var, Context))
12037 LSI->markVariableExprAsNonODRUsed(SansParensExpr);
12038 }
Eli Friedman3bda6b12012-02-02 23:15:15 +000012039}
12040
Eli Friedmanc6237c62012-02-29 03:16:56 +000012041ExprResult Sema::ActOnConstantExpression(ExprResult Res) {
12042 if (!Res.isUsable())
12043 return Res;
12044
12045 // If a constant-expression is a reference to a variable where we delay
12046 // deciding whether it is an odr-use, just assume we will apply the
12047 // lvalue-to-rvalue conversion. In the one case where this doesn't happen
12048 // (a non-type template argument), we have special handling anyway.
12049 UpdateMarkingForLValueToRValue(Res.get());
12050 return Res;
12051}
12052
Eli Friedman3bda6b12012-02-02 23:15:15 +000012053void Sema::CleanupVarDeclMarking() {
12054 for (llvm::SmallPtrSetIterator<Expr*> i = MaybeODRUseExprs.begin(),
12055 e = MaybeODRUseExprs.end();
12056 i != e; ++i) {
12057 VarDecl *Var;
12058 SourceLocation Loc;
John McCall113bee02012-03-10 09:33:50 +000012059 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(*i)) {
Eli Friedman3bda6b12012-02-02 23:15:15 +000012060 Var = cast<VarDecl>(DRE->getDecl());
12061 Loc = DRE->getLocation();
12062 } else if (MemberExpr *ME = dyn_cast<MemberExpr>(*i)) {
12063 Var = cast<VarDecl>(ME->getMemberDecl());
12064 Loc = ME->getMemberLoc();
12065 } else {
12066 llvm_unreachable("Unexpcted expression");
12067 }
12068
Faisal Valia17d19f2013-11-07 05:17:06 +000012069 MarkVarDeclODRUsed(Var, Loc, *this, /*MaxFunctionScopeIndex Pointer*/ 0);
Eli Friedman3bda6b12012-02-02 23:15:15 +000012070 }
12071
12072 MaybeODRUseExprs.clear();
12073}
12074
Faisal Valia17d19f2013-11-07 05:17:06 +000012075
Eli Friedman3bda6b12012-02-02 23:15:15 +000012076static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc,
12077 VarDecl *Var, Expr *E) {
Benjamin Kramercd502b52013-11-07 11:03:53 +000012078 assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E)) &&
12079 "Invalid Expr argument to DoMarkVarDeclReferenced");
Eli Friedmanfa0df832012-02-02 03:46:19 +000012080 Var->setReferenced();
12081
Faisal Valia17d19f2013-11-07 05:17:06 +000012082 // If the context is not PotentiallyEvaluated and not Unevaluated
12083 // (i.e PotentiallyEvaluatedIfUsed) do not bother to consider variables
12084 // in this context for odr-use unless we are within a lambda.
12085 // If we don't know whether the context is potentially evaluated or not
12086 // (for e.g., if we're in a generic lambda), we want to add a potential
12087 // capture and eventually analyze for odr-use.
12088 // We should also be able to analyze certain constructs in a non-generic
12089 // lambda setting for potential odr-use and capture violation:
12090 // template<class T> void foo(T t) {
12091 // auto L = [](int i) { return t; };
12092 // }
12093 //
12094 if (!IsPotentiallyEvaluatedContext(SemaRef)) {
12095
12096 if (SemaRef.isUnevaluatedContext()) return;
12097
12098 const bool refersToEnclosingScope =
12099 (SemaRef.CurContext != Var->getDeclContext() &&
12100 Var->getDeclContext()->isFunctionOrMethod());
12101 if (!refersToEnclosingScope) return;
12102
12103 if (LambdaScopeInfo *const LSI = SemaRef.getCurLambda()) {
12104 // If a variable could potentially be odr-used, defer marking it so
12105 // until we finish analyzing the full expression for any lvalue-to-rvalue
12106 // or discarded value conversions that would obviate odr-use.
12107 // Add it to the list of potential captures that will be analyzed
12108 // later (ActOnFinishFullExpr) for eventual capture and odr-use marking
12109 // unless the variable is a reference that was initialized by a constant
12110 // expression (this will never need to be captured or odr-used).
12111 const bool IsConstantExpr = IsVariableNonDependentAndAConstantExpression(
12112 Var, SemaRef.Context);
12113 assert(E && "Capture variable should be used in an expression.");
12114 if (!IsConstantExpr || !Var->getType()->isReferenceType())
12115 LSI->addPotentialCapture(E->IgnoreParens());
12116 }
12117 return;
12118 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000012119
Larisse Voufo39a1e502013-08-06 01:03:05 +000012120 VarTemplateSpecializationDecl *VarSpec =
12121 dyn_cast<VarTemplateSpecializationDecl>(Var);
Richard Smith8809a0c2013-09-27 20:14:12 +000012122 assert(!isa<VarTemplatePartialSpecializationDecl>(Var) &&
12123 "Can't instantiate a partial template specialization.");
Larisse Voufo39a1e502013-08-06 01:03:05 +000012124
12125 // Implicit instantiation of static data members, static data member
12126 // templates of class templates, and variable template specializations.
12127 // Delay instantiations of variable templates, except for those
12128 // that could be used in a constant expression.
Richard Smith8809a0c2013-09-27 20:14:12 +000012129 TemplateSpecializationKind TSK = Var->getTemplateSpecializationKind();
12130 if (isTemplateInstantiation(TSK)) {
12131 bool TryInstantiating = TSK == TSK_ImplicitInstantiation;
Larisse Voufo39a1e502013-08-06 01:03:05 +000012132
Richard Smith8809a0c2013-09-27 20:14:12 +000012133 if (TryInstantiating && !isa<VarTemplateSpecializationDecl>(Var)) {
12134 if (Var->getPointOfInstantiation().isInvalid()) {
12135 // This is a modification of an existing AST node. Notify listeners.
12136 if (ASTMutationListener *L = SemaRef.getASTMutationListener())
12137 L->StaticDataMemberInstantiated(Var);
12138 } else if (!Var->isUsableInConstantExpressions(SemaRef.Context))
12139 // Don't bother trying to instantiate it again, unless we might need
12140 // its initializer before we get to the end of the TU.
12141 TryInstantiating = false;
Larisse Voufo39a1e502013-08-06 01:03:05 +000012142 }
12143
Richard Smith8809a0c2013-09-27 20:14:12 +000012144 if (Var->getPointOfInstantiation().isInvalid())
12145 Var->setTemplateSpecializationKind(TSK, Loc);
12146
12147 if (TryInstantiating) {
12148 SourceLocation PointOfInstantiation = Var->getPointOfInstantiation();
Larisse Voufo39a1e502013-08-06 01:03:05 +000012149 bool InstantiationDependent = false;
12150 bool IsNonDependent =
12151 VarSpec ? !TemplateSpecializationType::anyDependentTemplateArguments(
12152 VarSpec->getTemplateArgsInfo(), InstantiationDependent)
12153 : true;
12154
12155 // Do not instantiate specializations that are still type-dependent.
12156 if (IsNonDependent) {
12157 if (Var->isUsableInConstantExpressions(SemaRef.Context)) {
12158 // Do not defer instantiations of variables which could be used in a
12159 // constant expression.
12160 SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
12161 } else {
12162 SemaRef.PendingInstantiations
12163 .push_back(std::make_pair(Var, PointOfInstantiation));
12164 }
Richard Smithd3cf2382012-02-15 02:42:50 +000012165 }
Eli Friedmanfa0df832012-02-02 03:46:19 +000012166 }
12167 }
Richard Smith5a1104b2012-10-20 01:38:33 +000012168 // Per C++11 [basic.def.odr], a variable is odr-used "unless it satisfies
12169 // the requirements for appearing in a constant expression (5.19) and, if
12170 // it is an object, the lvalue-to-rvalue conversion (4.1)
Eli Friedman3bda6b12012-02-02 23:15:15 +000012171 // is immediately applied." We check the first part here, and
12172 // Sema::UpdateMarkingForLValueToRValue deals with the second part.
12173 // Note that we use the C++11 definition everywhere because nothing in
Richard Smith5a1104b2012-10-20 01:38:33 +000012174 // C++03 depends on whether we get the C++03 version correct. The second
12175 // part does not apply to references, since they are not objects.
Faisal Valia17d19f2013-11-07 05:17:06 +000012176 if (E && IsVariableAConstantExpression(Var, SemaRef.Context)) {
12177 // A reference initialized by a constant expression can never be
12178 // odr-used, so simply ignore it.
12179 // But a non-reference might get odr-used if it doesn't undergo
12180 // an lvalue-to-rvalue or is discarded, so track it.
Richard Smith5a1104b2012-10-20 01:38:33 +000012181 if (!Var->getType()->isReferenceType())
12182 SemaRef.MaybeODRUseExprs.insert(E);
Faisal Valia17d19f2013-11-07 05:17:06 +000012183 }
12184 else
12185 MarkVarDeclODRUsed(Var, Loc, SemaRef, /*MaxFunctionScopeIndex ptr*/0);
Eli Friedman3bda6b12012-02-02 23:15:15 +000012186}
Eli Friedmanfa0df832012-02-02 03:46:19 +000012187
Eli Friedman3bda6b12012-02-02 23:15:15 +000012188/// \brief Mark a variable referenced, and check whether it is odr-used
12189/// (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be
12190/// used directly for normal expressions referring to VarDecl.
12191void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) {
12192 DoMarkVarDeclReferenced(*this, Loc, Var, 0);
Eli Friedmanfa0df832012-02-02 03:46:19 +000012193}
12194
12195static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc,
Nick Lewycky45b50522013-02-02 00:25:55 +000012196 Decl *D, Expr *E, bool OdrUse) {
Eli Friedman3bda6b12012-02-02 23:15:15 +000012197 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
12198 DoMarkVarDeclReferenced(SemaRef, Loc, Var, E);
12199 return;
12200 }
12201
Nick Lewycky45b50522013-02-02 00:25:55 +000012202 SemaRef.MarkAnyDeclReferenced(Loc, D, OdrUse);
Rafael Espindola49e860b2012-06-26 17:45:31 +000012203
12204 // If this is a call to a method via a cast, also mark the method in the
12205 // derived class used in case codegen can devirtualize the call.
12206 const MemberExpr *ME = dyn_cast<MemberExpr>(E);
12207 if (!ME)
12208 return;
12209 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
12210 if (!MD)
12211 return;
12212 const Expr *Base = ME->getBase();
Rafael Espindolab7f5a9c2012-06-27 18:18:05 +000012213 const CXXRecordDecl *MostDerivedClassDecl = Base->getBestDynamicClassType();
Rafael Espindola49e860b2012-06-26 17:45:31 +000012214 if (!MostDerivedClassDecl)
12215 return;
12216 CXXMethodDecl *DM = MD->getCorrespondingMethodInClass(MostDerivedClassDecl);
Nick Lewyckyb7444cd2013-02-14 00:55:17 +000012217 if (!DM || DM->isPure())
Rafael Espindolaa245edc2012-06-27 17:44:39 +000012218 return;
Nick Lewycky45b50522013-02-02 00:25:55 +000012219 SemaRef.MarkAnyDeclReferenced(Loc, DM, OdrUse);
Douglas Gregord3b672c2012-02-16 01:06:16 +000012220}
Eli Friedmanfa0df832012-02-02 03:46:19 +000012221
Eli Friedmanfa0df832012-02-02 03:46:19 +000012222/// \brief Perform reference-marking and odr-use handling for a DeclRefExpr.
12223void Sema::MarkDeclRefReferenced(DeclRefExpr *E) {
Nick Lewycky45b50522013-02-02 00:25:55 +000012224 // TODO: update this with DR# once a defect report is filed.
12225 // C++11 defect. The address of a pure member should not be an ODR use, even
12226 // if it's a qualified reference.
12227 bool OdrUse = true;
12228 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
Nick Lewycky192542c2013-02-05 06:20:31 +000012229 if (Method->isVirtual())
Nick Lewycky45b50522013-02-02 00:25:55 +000012230 OdrUse = false;
12231 MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse);
Eli Friedmanfa0df832012-02-02 03:46:19 +000012232}
12233
12234/// \brief Perform reference-marking and odr-use handling for a MemberExpr.
12235void Sema::MarkMemberReferenced(MemberExpr *E) {
Nick Lewycky60bd4be2013-01-31 03:15:20 +000012236 // C++11 [basic.def.odr]p2:
Nick Lewycky35d23592013-01-31 01:34:31 +000012237 // A non-overloaded function whose name appears as a potentially-evaluated
12238 // expression or a member of a set of candidate functions, if selected by
12239 // overload resolution when referred to from a potentially-evaluated
12240 // expression, is odr-used, unless it is a pure virtual function and its
12241 // name is not explicitly qualified.
Nick Lewycky45b50522013-02-02 00:25:55 +000012242 bool OdrUse = true;
Nick Lewycky35d23592013-01-31 01:34:31 +000012243 if (!E->hasQualifier()) {
12244 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getMemberDecl()))
12245 if (Method->isPure())
Nick Lewycky45b50522013-02-02 00:25:55 +000012246 OdrUse = false;
Nick Lewycky35d23592013-01-31 01:34:31 +000012247 }
Nick Lewyckya096b142013-02-12 08:08:54 +000012248 SourceLocation Loc = E->getMemberLoc().isValid() ?
12249 E->getMemberLoc() : E->getLocStart();
12250 MarkExprReferenced(*this, Loc, E->getMemberDecl(), E, OdrUse);
Eli Friedmanfa0df832012-02-02 03:46:19 +000012251}
12252
Douglas Gregorf02455e2012-02-10 09:26:04 +000012253/// \brief Perform marking for a reference to an arbitrary declaration. It
Eli Friedmanfa0df832012-02-02 03:46:19 +000012254/// marks the declaration referenced, and performs odr-use checking for functions
12255/// and variables. This method should not be used when building an normal
12256/// expression which refers to a variable.
Nick Lewycky45b50522013-02-02 00:25:55 +000012257void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool OdrUse) {
12258 if (OdrUse) {
12259 if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
12260 MarkVariableReferenced(Loc, VD);
12261 return;
12262 }
12263 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
12264 MarkFunctionReferenced(Loc, FD);
12265 return;
12266 }
12267 }
12268 D->setReferenced();
Douglas Gregorc9c02ed2009-06-19 23:52:42 +000012269}
Anders Carlsson7f84ed92009-10-09 23:51:55 +000012270
Douglas Gregor5597ab42010-05-07 23:12:07 +000012271namespace {
Chandler Carruthaf80f662010-06-09 08:17:30 +000012272 // Mark all of the declarations referenced
Douglas Gregor5597ab42010-05-07 23:12:07 +000012273 // FIXME: Not fully implemented yet! We need to have a better understanding
Chandler Carruthaf80f662010-06-09 08:17:30 +000012274 // of when we're entering
Douglas Gregor5597ab42010-05-07 23:12:07 +000012275 class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> {
12276 Sema &S;
12277 SourceLocation Loc;
Chandler Carruthaf80f662010-06-09 08:17:30 +000012278
Douglas Gregor5597ab42010-05-07 23:12:07 +000012279 public:
12280 typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited;
Chandler Carruthaf80f662010-06-09 08:17:30 +000012281
Douglas Gregor5597ab42010-05-07 23:12:07 +000012282 MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { }
Chandler Carruthaf80f662010-06-09 08:17:30 +000012283
12284 bool TraverseTemplateArgument(const TemplateArgument &Arg);
12285 bool TraverseRecordType(RecordType *T);
Douglas Gregor5597ab42010-05-07 23:12:07 +000012286 };
12287}
12288
Chandler Carruthaf80f662010-06-09 08:17:30 +000012289bool MarkReferencedDecls::TraverseTemplateArgument(
12290 const TemplateArgument &Arg) {
Douglas Gregor5597ab42010-05-07 23:12:07 +000012291 if (Arg.getKind() == TemplateArgument::Declaration) {
Douglas Gregor31f55dc2012-04-06 22:40:38 +000012292 if (Decl *D = Arg.getAsDecl())
Nick Lewycky45b50522013-02-02 00:25:55 +000012293 S.MarkAnyDeclReferenced(Loc, D, true);
Douglas Gregor5597ab42010-05-07 23:12:07 +000012294 }
Chandler Carruthaf80f662010-06-09 08:17:30 +000012295
12296 return Inherited::TraverseTemplateArgument(Arg);
Douglas Gregor5597ab42010-05-07 23:12:07 +000012297}
12298
Chandler Carruthaf80f662010-06-09 08:17:30 +000012299bool MarkReferencedDecls::TraverseRecordType(RecordType *T) {
Douglas Gregor5597ab42010-05-07 23:12:07 +000012300 if (ClassTemplateSpecializationDecl *Spec
12301 = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) {
12302 const TemplateArgumentList &Args = Spec->getTemplateArgs();
Douglas Gregor1ccc8412010-11-07 23:05:16 +000012303 return TraverseTemplateArguments(Args.data(), Args.size());
Douglas Gregor5597ab42010-05-07 23:12:07 +000012304 }
12305
Chandler Carruthc65667c2010-06-10 10:31:57 +000012306 return true;
Douglas Gregor5597ab42010-05-07 23:12:07 +000012307}
12308
12309void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) {
12310 MarkReferencedDecls Marker(*this, Loc);
Chandler Carruthaf80f662010-06-09 08:17:30 +000012311 Marker.TraverseType(Context.getCanonicalType(T));
Douglas Gregor5597ab42010-05-07 23:12:07 +000012312}
12313
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012314namespace {
12315 /// \brief Helper class that marks all of the declarations referenced by
12316 /// potentially-evaluated subexpressions as "referenced".
12317 class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> {
12318 Sema &S;
Douglas Gregor680e9e02012-02-21 19:11:17 +000012319 bool SkipLocalVariables;
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012320
12321 public:
12322 typedef EvaluatedExprVisitor<EvaluatedExprMarker> Inherited;
12323
Douglas Gregor680e9e02012-02-21 19:11:17 +000012324 EvaluatedExprMarker(Sema &S, bool SkipLocalVariables)
12325 : Inherited(S.Context), S(S), SkipLocalVariables(SkipLocalVariables) { }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012326
12327 void VisitDeclRefExpr(DeclRefExpr *E) {
Douglas Gregor680e9e02012-02-21 19:11:17 +000012328 // If we were asked not to visit local variables, don't.
12329 if (SkipLocalVariables) {
12330 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
12331 if (VD->hasLocalStorage())
12332 return;
12333 }
12334
Eli Friedmanfa0df832012-02-02 03:46:19 +000012335 S.MarkDeclRefReferenced(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012336 }
12337
12338 void VisitMemberExpr(MemberExpr *E) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000012339 S.MarkMemberReferenced(E);
Douglas Gregor32b3de52010-09-11 23:32:50 +000012340 Inherited::VisitMemberExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012341 }
12342
John McCall28fc7092011-11-10 05:35:25 +000012343 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000012344 S.MarkFunctionReferenced(E->getLocStart(),
John McCall28fc7092011-11-10 05:35:25 +000012345 const_cast<CXXDestructorDecl*>(E->getTemporary()->getDestructor()));
12346 Visit(E->getSubExpr());
12347 }
12348
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012349 void VisitCXXNewExpr(CXXNewExpr *E) {
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012350 if (E->getOperatorNew())
Eli Friedmanfa0df832012-02-02 03:46:19 +000012351 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorNew());
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012352 if (E->getOperatorDelete())
Eli Friedmanfa0df832012-02-02 03:46:19 +000012353 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete());
Douglas Gregor32b3de52010-09-11 23:32:50 +000012354 Inherited::VisitCXXNewExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012355 }
Sebastian Redl6047f072012-02-16 12:22:20 +000012356
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012357 void VisitCXXDeleteExpr(CXXDeleteExpr *E) {
12358 if (E->getOperatorDelete())
Eli Friedmanfa0df832012-02-02 03:46:19 +000012359 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete());
Douglas Gregor6ed2fee2010-09-14 22:55:20 +000012360 QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType());
12361 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) {
12362 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl());
Eli Friedmanfa0df832012-02-02 03:46:19 +000012363 S.MarkFunctionReferenced(E->getLocStart(),
Douglas Gregor6ed2fee2010-09-14 22:55:20 +000012364 S.LookupDestructor(Record));
12365 }
12366
Douglas Gregor32b3de52010-09-11 23:32:50 +000012367 Inherited::VisitCXXDeleteExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012368 }
12369
12370 void VisitCXXConstructExpr(CXXConstructExpr *E) {
Eli Friedmanfa0df832012-02-02 03:46:19 +000012371 S.MarkFunctionReferenced(E->getLocStart(), E->getConstructor());
Douglas Gregor32b3de52010-09-11 23:32:50 +000012372 Inherited::VisitCXXConstructExpr(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012373 }
12374
Douglas Gregorf0873f42010-10-19 17:17:35 +000012375 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
12376 Visit(E->getExpr());
12377 }
Eli Friedman3bda6b12012-02-02 23:15:15 +000012378
12379 void VisitImplicitCastExpr(ImplicitCastExpr *E) {
12380 Inherited::VisitImplicitCastExpr(E);
12381
12382 if (E->getCastKind() == CK_LValueToRValue)
12383 S.UpdateMarkingForLValueToRValue(E->getSubExpr());
12384 }
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012385 };
12386}
12387
12388/// \brief Mark any declarations that appear within this expression or any
12389/// potentially-evaluated subexpressions as "referenced".
Douglas Gregor680e9e02012-02-21 19:11:17 +000012390///
12391/// \param SkipLocalVariables If true, don't mark local variables as
12392/// 'referenced'.
12393void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
12394 bool SkipLocalVariables) {
12395 EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E);
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012396}
12397
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012398/// \brief Emit a diagnostic that describes an effect on the run-time behavior
12399/// of the program being compiled.
12400///
12401/// This routine emits the given diagnostic when the code currently being
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000012402/// type-checked is "potentially evaluated", meaning that there is a
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012403/// possibility that the code will actually be executable. Code in sizeof()
12404/// expressions, code used only during overload resolution, etc., are not
12405/// potentially evaluated. This routine will suppress such diagnostics or,
12406/// in the absolutely nutty case of potentially potentially evaluated
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000012407/// expressions (C++ typeid), queue the diagnostic to potentially emit it
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012408/// later.
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000012409///
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012410/// This routine should be used for all diagnostics that describe the run-time
12411/// behavior of a program, such as passing a non-POD value through an ellipsis.
12412/// Failure to do so will likely result in spurious diagnostics or failures
12413/// during overload resolution or within sizeof/alignof/typeof/typeid.
Richard Trieuba63ce62011-09-09 01:45:06 +000012414bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012415 const PartialDiagnostic &PD) {
John McCall31168b02011-06-15 23:02:42 +000012416 switch (ExprEvalContexts.back().Context) {
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012417 case Unevaluated:
John McCallf413f5e2013-05-03 00:10:13 +000012418 case UnevaluatedAbstract:
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012419 // The argument will never be evaluated, so don't complain.
12420 break;
Kovarththanan Rajaratnamba2c6522010-03-13 10:17:05 +000012421
Richard Smith764d2fe2011-12-20 02:08:33 +000012422 case ConstantEvaluated:
12423 // Relevant diagnostics should be produced by constant evaluation.
12424 break;
12425
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012426 case PotentiallyEvaluated:
Douglas Gregor8a01b2a2010-09-11 20:24:53 +000012427 case PotentiallyEvaluatedIfUsed:
Richard Trieuba63ce62011-09-09 01:45:06 +000012428 if (Statement && getCurFunctionOrMethodDecl()) {
Ted Kremenek3427fac2011-02-23 01:52:04 +000012429 FunctionScopes.back()->PossiblyUnreachableDiags.
Richard Trieuba63ce62011-09-09 01:45:06 +000012430 push_back(sema::PossiblyUnreachableDiag(PD, Loc, Statement));
Ted Kremenek3427fac2011-02-23 01:52:04 +000012431 }
12432 else
12433 Diag(Loc, PD);
12434
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012435 return true;
Douglas Gregorda8cdbc2009-12-22 01:01:55 +000012436 }
12437
12438 return false;
12439}
12440
Anders Carlsson7f84ed92009-10-09 23:51:55 +000012441bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
12442 CallExpr *CE, FunctionDecl *FD) {
12443 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType())
12444 return false;
12445
Richard Smithfd555f62012-02-22 02:04:18 +000012446 // If we're inside a decltype's expression, don't check for a valid return
12447 // type or construct temporaries until we know whether this is the last call.
12448 if (ExprEvalContexts.back().IsDecltype) {
12449 ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE);
12450 return false;
12451 }
12452
Douglas Gregora6c5abb2012-05-04 16:48:41 +000012453 class CallReturnIncompleteDiagnoser : public TypeDiagnoser {
Douglas Gregor7bfb2d02012-05-04 16:32:21 +000012454 FunctionDecl *FD;
12455 CallExpr *CE;
12456
12457 public:
12458 CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
12459 : FD(FD), CE(CE) { }
12460
12461 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) {
12462 if (!FD) {
12463 S.Diag(Loc, diag::err_call_incomplete_return)
12464 << T << CE->getSourceRange();
12465 return;
12466 }
12467
12468 S.Diag(Loc, diag::err_call_function_incomplete_return)
12469 << CE->getSourceRange() << FD->getDeclName() << T;
12470 S.Diag(FD->getLocation(),
12471 diag::note_function_with_incomplete_return_type_declared_here)
12472 << FD->getDeclName();
12473 }
12474 } Diagnoser(FD, CE);
12475
12476 if (RequireCompleteType(Loc, ReturnType, Diagnoser))
Anders Carlsson7f84ed92009-10-09 23:51:55 +000012477 return true;
12478
12479 return false;
12480}
12481
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012482// Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses
John McCalld5707ab2009-10-12 21:59:07 +000012483// will prevent this condition from triggering, which is what we want.
12484void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
12485 SourceLocation Loc;
12486
John McCall0506e4a2009-11-11 02:41:58 +000012487 unsigned diagnostic = diag::warn_condition_is_assignment;
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012488 bool IsOrAssign = false;
John McCall0506e4a2009-11-11 02:41:58 +000012489
Chandler Carruthf87d6c02011-08-16 22:30:10 +000012490 if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012491 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign)
John McCalld5707ab2009-10-12 21:59:07 +000012492 return;
12493
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012494 IsOrAssign = Op->getOpcode() == BO_OrAssign;
12495
John McCallb0e419e2009-11-12 00:06:05 +000012496 // Greylist some idioms by putting them into a warning subcategory.
12497 if (ObjCMessageExpr *ME
12498 = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
12499 Selector Sel = ME->getSelector();
12500
John McCallb0e419e2009-11-12 00:06:05 +000012501 // self = [<foo> init...]
Jean-Daniel Dupas39655742013-07-17 18:17:14 +000012502 if (isSelfExpr(Op->getLHS()) && ME->getMethodFamily() == OMF_init)
John McCallb0e419e2009-11-12 00:06:05 +000012503 diagnostic = diag::warn_condition_is_idiomatic_assignment;
12504
12505 // <foo> = [<bar> nextObject]
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +000012506 else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject")
John McCallb0e419e2009-11-12 00:06:05 +000012507 diagnostic = diag::warn_condition_is_idiomatic_assignment;
12508 }
John McCall0506e4a2009-11-11 02:41:58 +000012509
John McCalld5707ab2009-10-12 21:59:07 +000012510 Loc = Op->getOperatorLoc();
Chandler Carruthf87d6c02011-08-16 22:30:10 +000012511 } else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012512 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual)
John McCalld5707ab2009-10-12 21:59:07 +000012513 return;
12514
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012515 IsOrAssign = Op->getOperator() == OO_PipeEqual;
John McCalld5707ab2009-10-12 21:59:07 +000012516 Loc = Op->getOperatorLoc();
Fariborz Jahanianf07bcc52012-08-29 17:17:11 +000012517 } else if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E))
12518 return DiagnoseAssignmentAsCondition(POE->getSyntacticForm());
12519 else {
John McCalld5707ab2009-10-12 21:59:07 +000012520 // Not an assignment.
12521 return;
12522 }
12523
Douglas Gregor2bf2d3d2010-04-14 16:09:52 +000012524 Diag(Loc, diagnostic) << E->getSourceRange();
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012525
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012526 SourceLocation Open = E->getLocStart();
Argyrios Kyrtzidise1b97c42011-04-25 23:01:29 +000012527 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd());
12528 Diag(Loc, diag::note_condition_assign_silence)
12529 << FixItHint::CreateInsertion(Open, "(")
12530 << FixItHint::CreateInsertion(Close, ")");
12531
Douglas Gregor2d4f64f2011-01-19 16:50:08 +000012532 if (IsOrAssign)
12533 Diag(Loc, diag::note_condition_or_assign_to_comparison)
12534 << FixItHint::CreateReplacement(Loc, "!=");
12535 else
12536 Diag(Loc, diag::note_condition_assign_to_comparison)
12537 << FixItHint::CreateReplacement(Loc, "==");
John McCalld5707ab2009-10-12 21:59:07 +000012538}
12539
Argyrios Kyrtzidis8b6ec682011-02-01 18:24:22 +000012540/// \brief Redundant parentheses over an equality comparison can indicate
12541/// that the user intended an assignment used as condition.
Richard Trieuba63ce62011-09-09 01:45:06 +000012542void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) {
Argyrios Kyrtzidisf4f82782011-02-01 22:23:56 +000012543 // Don't warn if the parens came from a macro.
Richard Trieuba63ce62011-09-09 01:45:06 +000012544 SourceLocation parenLoc = ParenE->getLocStart();
Argyrios Kyrtzidisf4f82782011-02-01 22:23:56 +000012545 if (parenLoc.isInvalid() || parenLoc.isMacroID())
12546 return;
Argyrios Kyrtzidisba699d62011-03-28 23:52:04 +000012547 // Don't warn for dependent expressions.
Richard Trieuba63ce62011-09-09 01:45:06 +000012548 if (ParenE->isTypeDependent())
Argyrios Kyrtzidisba699d62011-03-28 23:52:04 +000012549 return;
Argyrios Kyrtzidisf4f82782011-02-01 22:23:56 +000012550
Richard Trieuba63ce62011-09-09 01:45:06 +000012551 Expr *E = ParenE->IgnoreParens();
Argyrios Kyrtzidis8b6ec682011-02-01 18:24:22 +000012552
12553 if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E))
Argyrios Kyrtzidis582dd682011-02-01 19:32:59 +000012554 if (opE->getOpcode() == BO_EQ &&
12555 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context)
12556 == Expr::MLV_Valid) {
Argyrios Kyrtzidis8b6ec682011-02-01 18:24:22 +000012557 SourceLocation Loc = opE->getOperatorLoc();
Ted Kremenekc358d9f2011-02-01 22:36:09 +000012558
Ted Kremenekae022092011-02-02 02:20:30 +000012559 Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange();
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012560 SourceRange ParenERange = ParenE->getSourceRange();
Ted Kremenekae022092011-02-02 02:20:30 +000012561 Diag(Loc, diag::note_equality_comparison_silence)
Daniel Dunbar62ee6412012-03-09 18:35:03 +000012562 << FixItHint::CreateRemoval(ParenERange.getBegin())
12563 << FixItHint::CreateRemoval(ParenERange.getEnd());
Argyrios Kyrtzidise1b97c42011-04-25 23:01:29 +000012564 Diag(Loc, diag::note_equality_comparison_to_assign)
12565 << FixItHint::CreateReplacement(Loc, "=");
Argyrios Kyrtzidis8b6ec682011-02-01 18:24:22 +000012566 }
12567}
12568
John Wiegley01296292011-04-08 18:41:53 +000012569ExprResult Sema::CheckBooleanCondition(Expr *E, SourceLocation Loc) {
John McCalld5707ab2009-10-12 21:59:07 +000012570 DiagnoseAssignmentAsCondition(E);
Argyrios Kyrtzidis8b6ec682011-02-01 18:24:22 +000012571 if (ParenExpr *parenE = dyn_cast<ParenExpr>(E))
12572 DiagnoseEqualityWithExtraParens(parenE);
John McCalld5707ab2009-10-12 21:59:07 +000012573
John McCall0009fcc2011-04-26 20:42:42 +000012574 ExprResult result = CheckPlaceholderExpr(E);
12575 if (result.isInvalid()) return ExprError();
12576 E = result.take();
Argyrios Kyrtzidisca766292010-11-01 18:49:26 +000012577
John McCall0009fcc2011-04-26 20:42:42 +000012578 if (!E->isTypeDependent()) {
David Blaikiebbafb8a2012-03-11 07:00:24 +000012579 if (getLangOpts().CPlusPlus)
John McCall34376a62010-12-04 03:47:34 +000012580 return CheckCXXBooleanCondition(E); // C++ 6.4p4
12581
John Wiegley01296292011-04-08 18:41:53 +000012582 ExprResult ERes = DefaultFunctionArrayLvalueConversion(E);
12583 if (ERes.isInvalid())
12584 return ExprError();
12585 E = ERes.take();
John McCall29cb2fd2010-12-04 06:09:13 +000012586
12587 QualType T = E->getType();
John Wiegley01296292011-04-08 18:41:53 +000012588 if (!T->isScalarType()) { // C99 6.8.4.1p1
12589 Diag(Loc, diag::err_typecheck_statement_requires_scalar)
12590 << T << E->getSourceRange();
12591 return ExprError();
12592 }
John McCalld5707ab2009-10-12 21:59:07 +000012593 }
12594
John Wiegley01296292011-04-08 18:41:53 +000012595 return Owned(E);
John McCalld5707ab2009-10-12 21:59:07 +000012596}
Douglas Gregore60e41a2010-05-06 17:25:47 +000012597
John McCalldadc5752010-08-24 06:29:42 +000012598ExprResult Sema::ActOnBooleanCondition(Scope *S, SourceLocation Loc,
Richard Trieuba63ce62011-09-09 01:45:06 +000012599 Expr *SubExpr) {
12600 if (!SubExpr)
Douglas Gregore60e41a2010-05-06 17:25:47 +000012601 return ExprError();
John Wiegley01296292011-04-08 18:41:53 +000012602
Richard Trieuba63ce62011-09-09 01:45:06 +000012603 return CheckBooleanCondition(SubExpr, Loc);
Douglas Gregore60e41a2010-05-06 17:25:47 +000012604}
John McCall36e7fe32010-10-12 00:20:44 +000012605
John McCall31996342011-04-07 08:22:57 +000012606namespace {
John McCall2979fe02011-04-12 00:42:48 +000012607 /// A visitor for rebuilding a call to an __unknown_any expression
12608 /// to have an appropriate type.
12609 struct RebuildUnknownAnyFunction
12610 : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
12611
12612 Sema &S;
12613
12614 RebuildUnknownAnyFunction(Sema &S) : S(S) {}
12615
12616 ExprResult VisitStmt(Stmt *S) {
12617 llvm_unreachable("unexpected statement!");
John McCall2979fe02011-04-12 00:42:48 +000012618 }
12619
Richard Trieu10162ab2011-09-09 03:59:41 +000012620 ExprResult VisitExpr(Expr *E) {
12621 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
12622 << E->getSourceRange();
John McCall2979fe02011-04-12 00:42:48 +000012623 return ExprError();
12624 }
12625
12626 /// Rebuild an expression which simply semantically wraps another
12627 /// expression which it shares the type and value kind of.
Richard Trieu10162ab2011-09-09 03:59:41 +000012628 template <class T> ExprResult rebuildSugarExpr(T *E) {
12629 ExprResult SubResult = Visit(E->getSubExpr());
12630 if (SubResult.isInvalid()) return ExprError();
John McCall2979fe02011-04-12 00:42:48 +000012631
Richard Trieu10162ab2011-09-09 03:59:41 +000012632 Expr *SubExpr = SubResult.take();
12633 E->setSubExpr(SubExpr);
12634 E->setType(SubExpr->getType());
12635 E->setValueKind(SubExpr->getValueKind());
12636 assert(E->getObjectKind() == OK_Ordinary);
12637 return E;
John McCall2979fe02011-04-12 00:42:48 +000012638 }
12639
Richard Trieu10162ab2011-09-09 03:59:41 +000012640 ExprResult VisitParenExpr(ParenExpr *E) {
12641 return rebuildSugarExpr(E);
John McCall2979fe02011-04-12 00:42:48 +000012642 }
12643
Richard Trieu10162ab2011-09-09 03:59:41 +000012644 ExprResult VisitUnaryExtension(UnaryOperator *E) {
12645 return rebuildSugarExpr(E);
John McCall2979fe02011-04-12 00:42:48 +000012646 }
12647
Richard Trieu10162ab2011-09-09 03:59:41 +000012648 ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
12649 ExprResult SubResult = Visit(E->getSubExpr());
12650 if (SubResult.isInvalid()) return ExprError();
John McCall2979fe02011-04-12 00:42:48 +000012651
Richard Trieu10162ab2011-09-09 03:59:41 +000012652 Expr *SubExpr = SubResult.take();
12653 E->setSubExpr(SubExpr);
12654 E->setType(S.Context.getPointerType(SubExpr->getType()));
12655 assert(E->getValueKind() == VK_RValue);
12656 assert(E->getObjectKind() == OK_Ordinary);
12657 return E;
John McCall2979fe02011-04-12 00:42:48 +000012658 }
12659
Richard Trieu10162ab2011-09-09 03:59:41 +000012660 ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
12661 if (!isa<FunctionDecl>(VD)) return VisitExpr(E);
John McCall2979fe02011-04-12 00:42:48 +000012662
Richard Trieu10162ab2011-09-09 03:59:41 +000012663 E->setType(VD->getType());
John McCall2979fe02011-04-12 00:42:48 +000012664
Richard Trieu10162ab2011-09-09 03:59:41 +000012665 assert(E->getValueKind() == VK_RValue);
David Blaikiebbafb8a2012-03-11 07:00:24 +000012666 if (S.getLangOpts().CPlusPlus &&
Richard Trieu10162ab2011-09-09 03:59:41 +000012667 !(isa<CXXMethodDecl>(VD) &&
12668 cast<CXXMethodDecl>(VD)->isInstance()))
12669 E->setValueKind(VK_LValue);
John McCall2979fe02011-04-12 00:42:48 +000012670
Richard Trieu10162ab2011-09-09 03:59:41 +000012671 return E;
John McCall2979fe02011-04-12 00:42:48 +000012672 }
12673
Richard Trieu10162ab2011-09-09 03:59:41 +000012674 ExprResult VisitMemberExpr(MemberExpr *E) {
12675 return resolveDecl(E, E->getMemberDecl());
John McCall2979fe02011-04-12 00:42:48 +000012676 }
12677
Richard Trieu10162ab2011-09-09 03:59:41 +000012678 ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
12679 return resolveDecl(E, E->getDecl());
John McCall2979fe02011-04-12 00:42:48 +000012680 }
12681 };
12682}
12683
12684/// Given a function expression of unknown-any type, try to rebuild it
12685/// to have a function type.
Richard Trieu10162ab2011-09-09 03:59:41 +000012686static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
12687 ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
12688 if (Result.isInvalid()) return ExprError();
12689 return S.DefaultFunctionArrayConversion(Result.take());
John McCall2979fe02011-04-12 00:42:48 +000012690}
12691
12692namespace {
John McCall2d2e8702011-04-11 07:02:50 +000012693 /// A visitor for rebuilding an expression of type __unknown_anytype
12694 /// into one which resolves the type directly on the referring
12695 /// expression. Strict preservation of the original source
12696 /// structure is not a goal.
John McCall31996342011-04-07 08:22:57 +000012697 struct RebuildUnknownAnyExpr
John McCall39439732011-04-09 22:50:59 +000012698 : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
John McCall31996342011-04-07 08:22:57 +000012699
12700 Sema &S;
12701
12702 /// The current destination type.
12703 QualType DestType;
12704
Richard Trieu10162ab2011-09-09 03:59:41 +000012705 RebuildUnknownAnyExpr(Sema &S, QualType CastType)
12706 : S(S), DestType(CastType) {}
John McCall31996342011-04-07 08:22:57 +000012707
John McCall39439732011-04-09 22:50:59 +000012708 ExprResult VisitStmt(Stmt *S) {
John McCall2d2e8702011-04-11 07:02:50 +000012709 llvm_unreachable("unexpected statement!");
John McCall31996342011-04-07 08:22:57 +000012710 }
12711
Richard Trieu10162ab2011-09-09 03:59:41 +000012712 ExprResult VisitExpr(Expr *E) {
12713 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
12714 << E->getSourceRange();
John McCall2d2e8702011-04-11 07:02:50 +000012715 return ExprError();
John McCall31996342011-04-07 08:22:57 +000012716 }
12717
Richard Trieu10162ab2011-09-09 03:59:41 +000012718 ExprResult VisitCallExpr(CallExpr *E);
12719 ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
John McCall2d2e8702011-04-11 07:02:50 +000012720
John McCall39439732011-04-09 22:50:59 +000012721 /// Rebuild an expression which simply semantically wraps another
12722 /// expression which it shares the type and value kind of.
Richard Trieu10162ab2011-09-09 03:59:41 +000012723 template <class T> ExprResult rebuildSugarExpr(T *E) {
12724 ExprResult SubResult = Visit(E->getSubExpr());
12725 if (SubResult.isInvalid()) return ExprError();
12726 Expr *SubExpr = SubResult.take();
12727 E->setSubExpr(SubExpr);
12728 E->setType(SubExpr->getType());
12729 E->setValueKind(SubExpr->getValueKind());
12730 assert(E->getObjectKind() == OK_Ordinary);
12731 return E;
John McCall39439732011-04-09 22:50:59 +000012732 }
John McCall31996342011-04-07 08:22:57 +000012733
Richard Trieu10162ab2011-09-09 03:59:41 +000012734 ExprResult VisitParenExpr(ParenExpr *E) {
12735 return rebuildSugarExpr(E);
John McCall39439732011-04-09 22:50:59 +000012736 }
12737
Richard Trieu10162ab2011-09-09 03:59:41 +000012738 ExprResult VisitUnaryExtension(UnaryOperator *E) {
12739 return rebuildSugarExpr(E);
John McCall39439732011-04-09 22:50:59 +000012740 }
12741
Richard Trieu10162ab2011-09-09 03:59:41 +000012742 ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
12743 const PointerType *Ptr = DestType->getAs<PointerType>();
12744 if (!Ptr) {
12745 S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
12746 << E->getSourceRange();
John McCall2979fe02011-04-12 00:42:48 +000012747 return ExprError();
12748 }
Richard Trieu10162ab2011-09-09 03:59:41 +000012749 assert(E->getValueKind() == VK_RValue);
12750 assert(E->getObjectKind() == OK_Ordinary);
12751 E->setType(DestType);
John McCall2979fe02011-04-12 00:42:48 +000012752
12753 // Build the sub-expression as if it were an object of the pointee type.
Richard Trieu10162ab2011-09-09 03:59:41 +000012754 DestType = Ptr->getPointeeType();
12755 ExprResult SubResult = Visit(E->getSubExpr());
12756 if (SubResult.isInvalid()) return ExprError();
12757 E->setSubExpr(SubResult.take());
12758 return E;
John McCall2979fe02011-04-12 00:42:48 +000012759 }
12760
Richard Trieu10162ab2011-09-09 03:59:41 +000012761 ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
John McCall39439732011-04-09 22:50:59 +000012762
Richard Trieu10162ab2011-09-09 03:59:41 +000012763 ExprResult resolveDecl(Expr *E, ValueDecl *VD);
John McCall39439732011-04-09 22:50:59 +000012764
Richard Trieu10162ab2011-09-09 03:59:41 +000012765 ExprResult VisitMemberExpr(MemberExpr *E) {
12766 return resolveDecl(E, E->getMemberDecl());
John McCall2979fe02011-04-12 00:42:48 +000012767 }
John McCall39439732011-04-09 22:50:59 +000012768
Richard Trieu10162ab2011-09-09 03:59:41 +000012769 ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
12770 return resolveDecl(E, E->getDecl());
John McCall31996342011-04-07 08:22:57 +000012771 }
12772 };
12773}
12774
John McCall2d2e8702011-04-11 07:02:50 +000012775/// Rebuilds a call expression which yielded __unknown_anytype.
Richard Trieu10162ab2011-09-09 03:59:41 +000012776ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
12777 Expr *CalleeExpr = E->getCallee();
John McCall2d2e8702011-04-11 07:02:50 +000012778
12779 enum FnKind {
John McCall4adb38c2011-04-27 00:36:17 +000012780 FK_MemberFunction,
John McCall2d2e8702011-04-11 07:02:50 +000012781 FK_FunctionPointer,
12782 FK_BlockPointer
12783 };
12784
Richard Trieu10162ab2011-09-09 03:59:41 +000012785 FnKind Kind;
12786 QualType CalleeType = CalleeExpr->getType();
12787 if (CalleeType == S.Context.BoundMemberTy) {
12788 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E));
12789 Kind = FK_MemberFunction;
12790 CalleeType = Expr::findBoundMemberType(CalleeExpr);
12791 } else if (const PointerType *Ptr = CalleeType->getAs<PointerType>()) {
12792 CalleeType = Ptr->getPointeeType();
12793 Kind = FK_FunctionPointer;
John McCall2d2e8702011-04-11 07:02:50 +000012794 } else {
Richard Trieu10162ab2011-09-09 03:59:41 +000012795 CalleeType = CalleeType->castAs<BlockPointerType>()->getPointeeType();
12796 Kind = FK_BlockPointer;
John McCall2d2e8702011-04-11 07:02:50 +000012797 }
Richard Trieu10162ab2011-09-09 03:59:41 +000012798 const FunctionType *FnType = CalleeType->castAs<FunctionType>();
John McCall2d2e8702011-04-11 07:02:50 +000012799
12800 // Verify that this is a legal result type of a function.
12801 if (DestType->isArrayType() || DestType->isFunctionType()) {
12802 unsigned diagID = diag::err_func_returning_array_function;
Richard Trieu10162ab2011-09-09 03:59:41 +000012803 if (Kind == FK_BlockPointer)
John McCall2d2e8702011-04-11 07:02:50 +000012804 diagID = diag::err_block_returning_array_function;
12805
Richard Trieu10162ab2011-09-09 03:59:41 +000012806 S.Diag(E->getExprLoc(), diagID)
John McCall2d2e8702011-04-11 07:02:50 +000012807 << DestType->isFunctionType() << DestType;
12808 return ExprError();
12809 }
12810
12811 // Otherwise, go ahead and set DestType as the call's result.
Richard Trieu10162ab2011-09-09 03:59:41 +000012812 E->setType(DestType.getNonLValueExprType(S.Context));
12813 E->setValueKind(Expr::getValueKindForType(DestType));
12814 assert(E->getObjectKind() == OK_Ordinary);
John McCall2d2e8702011-04-11 07:02:50 +000012815
12816 // Rebuild the function type, replacing the result type with DestType.
John McCall611d9b62013-06-27 22:43:24 +000012817 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType);
12818 if (Proto) {
12819 // __unknown_anytype(...) is a special case used by the debugger when
12820 // it has no idea what a function's signature is.
12821 //
12822 // We want to build this call essentially under the K&R
12823 // unprototyped rules, but making a FunctionNoProtoType in C++
12824 // would foul up all sorts of assumptions. However, we cannot
12825 // simply pass all arguments as variadic arguments, nor can we
12826 // portably just call the function under a non-variadic type; see
12827 // the comment on IR-gen's TargetInfo::isNoProtoCallVariadic.
12828 // However, it turns out that in practice it is generally safe to
12829 // call a function declared as "A foo(B,C,D);" under the prototype
12830 // "A foo(B,C,D,...);". The only known exception is with the
12831 // Windows ABI, where any variadic function is implicitly cdecl
12832 // regardless of its normal CC. Therefore we change the parameter
12833 // types to match the types of the arguments.
12834 //
12835 // This is a hack, but it is far superior to moving the
12836 // corresponding target-specific code from IR-gen to Sema/AST.
12837
12838 ArrayRef<QualType> ParamTypes = Proto->getArgTypes();
12839 SmallVector<QualType, 8> ArgTypes;
12840 if (ParamTypes.empty() && Proto->isVariadic()) { // the special case
12841 ArgTypes.reserve(E->getNumArgs());
12842 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
12843 Expr *Arg = E->getArg(i);
12844 QualType ArgType = Arg->getType();
12845 if (E->isLValue()) {
12846 ArgType = S.Context.getLValueReferenceType(ArgType);
12847 } else if (E->isXValue()) {
12848 ArgType = S.Context.getRValueReferenceType(ArgType);
12849 }
12850 ArgTypes.push_back(ArgType);
12851 }
12852 ParamTypes = ArgTypes;
12853 }
12854 DestType = S.Context.getFunctionType(DestType, ParamTypes,
Reid Kleckner896b32f2013-06-10 20:51:09 +000012855 Proto->getExtProtoInfo());
John McCall611d9b62013-06-27 22:43:24 +000012856 } else {
John McCall2d2e8702011-04-11 07:02:50 +000012857 DestType = S.Context.getFunctionNoProtoType(DestType,
Richard Trieu10162ab2011-09-09 03:59:41 +000012858 FnType->getExtInfo());
John McCall611d9b62013-06-27 22:43:24 +000012859 }
John McCall2d2e8702011-04-11 07:02:50 +000012860
12861 // Rebuild the appropriate pointer-to-function type.
Richard Trieu10162ab2011-09-09 03:59:41 +000012862 switch (Kind) {
John McCall4adb38c2011-04-27 00:36:17 +000012863 case FK_MemberFunction:
John McCall2d2e8702011-04-11 07:02:50 +000012864 // Nothing to do.
12865 break;
12866
12867 case FK_FunctionPointer:
12868 DestType = S.Context.getPointerType(DestType);
12869 break;
12870
12871 case FK_BlockPointer:
12872 DestType = S.Context.getBlockPointerType(DestType);
12873 break;
12874 }
12875
12876 // Finally, we can recurse.
Richard Trieu10162ab2011-09-09 03:59:41 +000012877 ExprResult CalleeResult = Visit(CalleeExpr);
12878 if (!CalleeResult.isUsable()) return ExprError();
12879 E->setCallee(CalleeResult.take());
John McCall2d2e8702011-04-11 07:02:50 +000012880
12881 // Bind a temporary if necessary.
Richard Trieu10162ab2011-09-09 03:59:41 +000012882 return S.MaybeBindToTemporary(E);
John McCall2d2e8702011-04-11 07:02:50 +000012883}
12884
Richard Trieu10162ab2011-09-09 03:59:41 +000012885ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {
John McCall2979fe02011-04-12 00:42:48 +000012886 // Verify that this is a legal result type of a call.
12887 if (DestType->isArrayType() || DestType->isFunctionType()) {
Richard Trieu10162ab2011-09-09 03:59:41 +000012888 S.Diag(E->getExprLoc(), diag::err_func_returning_array_function)
John McCall2979fe02011-04-12 00:42:48 +000012889 << DestType->isFunctionType() << DestType;
12890 return ExprError();
John McCall2d2e8702011-04-11 07:02:50 +000012891 }
12892
John McCall3f4138c2011-07-13 17:56:40 +000012893 // Rewrite the method result type if available.
Richard Trieu10162ab2011-09-09 03:59:41 +000012894 if (ObjCMethodDecl *Method = E->getMethodDecl()) {
12895 assert(Method->getResultType() == S.Context.UnknownAnyTy);
12896 Method->setResultType(DestType);
John McCall3f4138c2011-07-13 17:56:40 +000012897 }
John McCall2979fe02011-04-12 00:42:48 +000012898
John McCall2d2e8702011-04-11 07:02:50 +000012899 // Change the type of the message.
Richard Trieu10162ab2011-09-09 03:59:41 +000012900 E->setType(DestType.getNonReferenceType());
12901 E->setValueKind(Expr::getValueKindForType(DestType));
John McCall2d2e8702011-04-11 07:02:50 +000012902
Richard Trieu10162ab2011-09-09 03:59:41 +000012903 return S.MaybeBindToTemporary(E);
John McCall2d2e8702011-04-11 07:02:50 +000012904}
12905
Richard Trieu10162ab2011-09-09 03:59:41 +000012906ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
John McCall2979fe02011-04-12 00:42:48 +000012907 // The only case we should ever see here is a function-to-pointer decay.
Sean Callanan2db103c2012-03-06 23:12:57 +000012908 if (E->getCastKind() == CK_FunctionToPointerDecay) {
Sean Callanan12495112012-03-06 21:34:12 +000012909 assert(E->getValueKind() == VK_RValue);
12910 assert(E->getObjectKind() == OK_Ordinary);
12911
12912 E->setType(DestType);
12913
12914 // Rebuild the sub-expression as the pointee (function) type.
12915 DestType = DestType->castAs<PointerType>()->getPointeeType();
12916
12917 ExprResult Result = Visit(E->getSubExpr());
12918 if (!Result.isUsable()) return ExprError();
12919
12920 E->setSubExpr(Result.take());
12921 return S.Owned(E);
Sean Callanan2db103c2012-03-06 23:12:57 +000012922 } else if (E->getCastKind() == CK_LValueToRValue) {
Sean Callanan12495112012-03-06 21:34:12 +000012923 assert(E->getValueKind() == VK_RValue);
12924 assert(E->getObjectKind() == OK_Ordinary);
John McCall2d2e8702011-04-11 07:02:50 +000012925
Sean Callanan12495112012-03-06 21:34:12 +000012926 assert(isa<BlockPointerType>(E->getType()));
John McCall2979fe02011-04-12 00:42:48 +000012927
Sean Callanan12495112012-03-06 21:34:12 +000012928 E->setType(DestType);
John McCall2d2e8702011-04-11 07:02:50 +000012929
Sean Callanan12495112012-03-06 21:34:12 +000012930 // The sub-expression has to be a lvalue reference, so rebuild it as such.
12931 DestType = S.Context.getLValueReferenceType(DestType);
John McCall2d2e8702011-04-11 07:02:50 +000012932
Sean Callanan12495112012-03-06 21:34:12 +000012933 ExprResult Result = Visit(E->getSubExpr());
12934 if (!Result.isUsable()) return ExprError();
12935
12936 E->setSubExpr(Result.take());
12937 return S.Owned(E);
Sean Callanan2db103c2012-03-06 23:12:57 +000012938 } else {
Sean Callanan12495112012-03-06 21:34:12 +000012939 llvm_unreachable("Unhandled cast type!");
12940 }
John McCall2d2e8702011-04-11 07:02:50 +000012941}
12942
Richard Trieu10162ab2011-09-09 03:59:41 +000012943ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
12944 ExprValueKind ValueKind = VK_LValue;
12945 QualType Type = DestType;
John McCall2d2e8702011-04-11 07:02:50 +000012946
12947 // We know how to make this work for certain kinds of decls:
12948
12949 // - functions
Richard Trieu10162ab2011-09-09 03:59:41 +000012950 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {
12951 if (const PointerType *Ptr = Type->getAs<PointerType>()) {
12952 DestType = Ptr->getPointeeType();
12953 ExprResult Result = resolveDecl(E, VD);
12954 if (Result.isInvalid()) return ExprError();
12955 return S.ImpCastExprToType(Result.take(), Type,
John McCall9a877fe2011-08-10 04:12:23 +000012956 CK_FunctionToPointerDecay, VK_RValue);
12957 }
12958
Richard Trieu10162ab2011-09-09 03:59:41 +000012959 if (!Type->isFunctionType()) {
12960 S.Diag(E->getExprLoc(), diag::err_unknown_any_function)
12961 << VD << E->getSourceRange();
John McCall9a877fe2011-08-10 04:12:23 +000012962 return ExprError();
12963 }
John McCall2d2e8702011-04-11 07:02:50 +000012964
Richard Trieu10162ab2011-09-09 03:59:41 +000012965 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
12966 if (MD->isInstance()) {
12967 ValueKind = VK_RValue;
12968 Type = S.Context.BoundMemberTy;
John McCall4adb38c2011-04-27 00:36:17 +000012969 }
12970
John McCall2d2e8702011-04-11 07:02:50 +000012971 // Function references aren't l-values in C.
David Blaikiebbafb8a2012-03-11 07:00:24 +000012972 if (!S.getLangOpts().CPlusPlus)
Richard Trieu10162ab2011-09-09 03:59:41 +000012973 ValueKind = VK_RValue;
John McCall2d2e8702011-04-11 07:02:50 +000012974
12975 // - variables
Richard Trieu10162ab2011-09-09 03:59:41 +000012976 } else if (isa<VarDecl>(VD)) {
12977 if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {
12978 Type = RefTy->getPointeeType();
12979 } else if (Type->isFunctionType()) {
12980 S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type)
12981 << VD << E->getSourceRange();
John McCall2979fe02011-04-12 00:42:48 +000012982 return ExprError();
John McCall2d2e8702011-04-11 07:02:50 +000012983 }
12984
12985 // - nothing else
12986 } else {
Richard Trieu10162ab2011-09-09 03:59:41 +000012987 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl)
12988 << VD << E->getSourceRange();
John McCall2d2e8702011-04-11 07:02:50 +000012989 return ExprError();
12990 }
12991
John McCall611d9b62013-06-27 22:43:24 +000012992 // Modifying the declaration like this is friendly to IR-gen but
12993 // also really dangerous.
Richard Trieu10162ab2011-09-09 03:59:41 +000012994 VD->setType(DestType);
12995 E->setType(Type);
12996 E->setValueKind(ValueKind);
12997 return S.Owned(E);
John McCall2d2e8702011-04-11 07:02:50 +000012998}
12999
John McCall31996342011-04-07 08:22:57 +000013000/// Check a cast of an unknown-any type. We intentionally only
13001/// trigger this for C-style casts.
Richard Trieuba63ce62011-09-09 01:45:06 +000013002ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
13003 Expr *CastExpr, CastKind &CastKind,
13004 ExprValueKind &VK, CXXCastPath &Path) {
John McCall31996342011-04-07 08:22:57 +000013005 // Rewrite the casted expression from scratch.
Richard Trieuba63ce62011-09-09 01:45:06 +000013006 ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
John McCall39439732011-04-09 22:50:59 +000013007 if (!result.isUsable()) return ExprError();
John McCall31996342011-04-07 08:22:57 +000013008
Richard Trieuba63ce62011-09-09 01:45:06 +000013009 CastExpr = result.take();
13010 VK = CastExpr->getValueKind();
13011 CastKind = CK_NoOp;
John McCall39439732011-04-09 22:50:59 +000013012
Richard Trieuba63ce62011-09-09 01:45:06 +000013013 return CastExpr;
John McCall31996342011-04-07 08:22:57 +000013014}
13015
Douglas Gregord8fb1e32011-12-01 01:37:36 +000013016ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) {
13017 return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
13018}
13019
John McCallcc5788c2013-03-04 07:34:02 +000013020ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc,
13021 Expr *arg, QualType &paramType) {
13022 // If the syntactic form of the argument is not an explicit cast of
13023 // any sort, just do default argument promotion.
13024 ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
13025 if (!castArg) {
13026 ExprResult result = DefaultArgumentPromotion(arg);
13027 if (result.isInvalid()) return ExprError();
13028 paramType = result.get()->getType();
13029 return result;
John McCallea0a39e2012-11-14 00:49:39 +000013030 }
13031
John McCallcc5788c2013-03-04 07:34:02 +000013032 // Otherwise, use the type that was written in the explicit cast.
13033 assert(!arg->hasPlaceholderType());
13034 paramType = castArg->getTypeAsWritten();
13035
13036 // Copy-initialize a parameter of that type.
13037 InitializedEntity entity =
13038 InitializedEntity::InitializeParameter(Context, paramType,
13039 /*consumed*/ false);
13040 return PerformCopyInitialization(entity, callLoc, Owned(arg));
John McCallea0a39e2012-11-14 00:49:39 +000013041}
13042
Richard Trieuba63ce62011-09-09 01:45:06 +000013043static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
13044 Expr *orig = E;
John McCall2d2e8702011-04-11 07:02:50 +000013045 unsigned diagID = diag::err_uncasted_use_of_unknown_any;
John McCall31996342011-04-07 08:22:57 +000013046 while (true) {
Richard Trieuba63ce62011-09-09 01:45:06 +000013047 E = E->IgnoreParenImpCasts();
13048 if (CallExpr *call = dyn_cast<CallExpr>(E)) {
13049 E = call->getCallee();
John McCall2d2e8702011-04-11 07:02:50 +000013050 diagID = diag::err_uncasted_call_of_unknown_any;
13051 } else {
John McCall31996342011-04-07 08:22:57 +000013052 break;
John McCall2d2e8702011-04-11 07:02:50 +000013053 }
John McCall31996342011-04-07 08:22:57 +000013054 }
13055
John McCall2d2e8702011-04-11 07:02:50 +000013056 SourceLocation loc;
13057 NamedDecl *d;
Richard Trieuba63ce62011-09-09 01:45:06 +000013058 if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {
John McCall2d2e8702011-04-11 07:02:50 +000013059 loc = ref->getLocation();
13060 d = ref->getDecl();
Richard Trieuba63ce62011-09-09 01:45:06 +000013061 } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
John McCall2d2e8702011-04-11 07:02:50 +000013062 loc = mem->getMemberLoc();
13063 d = mem->getMemberDecl();
Richard Trieuba63ce62011-09-09 01:45:06 +000013064 } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {
John McCall2d2e8702011-04-11 07:02:50 +000013065 diagID = diag::err_uncasted_call_of_unknown_any;
Argyrios Kyrtzidisa6011e22011-10-03 06:36:51 +000013066 loc = msg->getSelectorStartLoc();
John McCall2d2e8702011-04-11 07:02:50 +000013067 d = msg->getMethodDecl();
John McCallfa6f5d62011-08-31 20:57:36 +000013068 if (!d) {
13069 S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
13070 << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
13071 << orig->getSourceRange();
13072 return ExprError();
13073 }
John McCall2d2e8702011-04-11 07:02:50 +000013074 } else {
Richard Trieuba63ce62011-09-09 01:45:06 +000013075 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
13076 << E->getSourceRange();
John McCall2d2e8702011-04-11 07:02:50 +000013077 return ExprError();
13078 }
13079
13080 S.Diag(loc, diagID) << d << orig->getSourceRange();
John McCall31996342011-04-07 08:22:57 +000013081
13082 // Never recoverable.
13083 return ExprError();
13084}
13085
John McCall36e7fe32010-10-12 00:20:44 +000013086/// Check for operands with placeholder types and complain if found.
13087/// Returns true if there was an error and no recovery was possible.
John McCall3aef3d82011-04-10 19:13:55 +000013088ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
John McCall4124c492011-10-17 18:40:02 +000013089 const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
13090 if (!placeholderType) return Owned(E);
13091
13092 switch (placeholderType->getKind()) {
John McCall36e7fe32010-10-12 00:20:44 +000013093
John McCall31996342011-04-07 08:22:57 +000013094 // Overloaded expressions.
John McCall4124c492011-10-17 18:40:02 +000013095 case BuiltinType::Overload: {
John McCall50a2c2c2011-10-11 23:14:30 +000013096 // Try to resolve a single function template specialization.
13097 // This is obligatory.
13098 ExprResult result = Owned(E);
13099 if (ResolveAndFixSingleFunctionTemplateSpecialization(result, false)) {
13100 return result;
13101
13102 // If that failed, try to recover with a call.
13103 } else {
13104 tryToRecoverWithCall(result, PDiag(diag::err_ovl_unresolvable),
13105 /*complain*/ true);
13106 return result;
13107 }
13108 }
John McCall31996342011-04-07 08:22:57 +000013109
John McCall0009fcc2011-04-26 20:42:42 +000013110 // Bound member functions.
John McCall4124c492011-10-17 18:40:02 +000013111 case BuiltinType::BoundMember: {
John McCall50a2c2c2011-10-11 23:14:30 +000013112 ExprResult result = Owned(E);
13113 tryToRecoverWithCall(result, PDiag(diag::err_bound_member_function),
13114 /*complain*/ true);
13115 return result;
John McCall4124c492011-10-17 18:40:02 +000013116 }
13117
13118 // ARC unbridged casts.
13119 case BuiltinType::ARCUnbridgedCast: {
13120 Expr *realCast = stripARCUnbridgedCast(E);
13121 diagnoseARCUnbridgedCast(realCast);
13122 return Owned(realCast);
13123 }
John McCall0009fcc2011-04-26 20:42:42 +000013124
John McCall31996342011-04-07 08:22:57 +000013125 // Expressions of unknown type.
John McCall4124c492011-10-17 18:40:02 +000013126 case BuiltinType::UnknownAny:
John McCall31996342011-04-07 08:22:57 +000013127 return diagnoseUnknownAnyExpr(*this, E);
13128
John McCall526ab472011-10-25 17:37:35 +000013129 // Pseudo-objects.
13130 case BuiltinType::PseudoObject:
13131 return checkPseudoObjectRValue(E);
13132
Eli Friedman34866c72012-08-31 00:14:07 +000013133 case BuiltinType::BuiltinFn:
13134 Diag(E->getLocStart(), diag::err_builtin_fn_use);
13135 return ExprError();
13136
John McCalle314e272011-10-18 21:02:43 +000013137 // Everything else should be impossible.
13138#define BUILTIN_TYPE(Id, SingletonId) \
13139 case BuiltinType::Id:
13140#define PLACEHOLDER_TYPE(Id, SingletonId)
13141#include "clang/AST/BuiltinTypes.def"
John McCall4124c492011-10-17 18:40:02 +000013142 break;
13143 }
13144
13145 llvm_unreachable("invalid placeholder type!");
John McCall36e7fe32010-10-12 00:20:44 +000013146}
Richard Trieu2c850c02011-04-21 21:44:26 +000013147
Richard Trieuba63ce62011-09-09 01:45:06 +000013148bool Sema::CheckCaseExpression(Expr *E) {
13149 if (E->isTypeDependent())
Richard Trieu2c850c02011-04-21 21:44:26 +000013150 return true;
Richard Trieuba63ce62011-09-09 01:45:06 +000013151 if (E->isValueDependent() || E->isIntegerConstantExpr(Context))
13152 return E->getType()->isIntegralOrEnumerationType();
Richard Trieu2c850c02011-04-21 21:44:26 +000013153 return false;
13154}
Ted Kremeneke65b0862012-03-06 20:05:56 +000013155
13156/// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
13157ExprResult
13158Sema::ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
13159 assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&
13160 "Unknown Objective-C Boolean value!");
Fariborz Jahanianf2578572012-08-30 18:49:41 +000013161 QualType BoolT = Context.ObjCBuiltinBoolTy;
13162 if (!Context.getBOOLDecl()) {
Fariborz Jahanianeab17302012-10-16 17:08:11 +000013163 LookupResult Result(*this, &Context.Idents.get("BOOL"), OpLoc,
Fariborz Jahanianf2578572012-08-30 18:49:41 +000013164 Sema::LookupOrdinaryName);
Fariborz Jahanian379e5362012-10-16 16:21:20 +000013165 if (LookupName(Result, getCurScope()) && Result.isSingleResult()) {
Fariborz Jahanianf2578572012-08-30 18:49:41 +000013166 NamedDecl *ND = Result.getFoundDecl();
13167 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(ND))
13168 Context.setBOOLDecl(TD);
13169 }
13170 }
13171 if (Context.getBOOLDecl())
13172 BoolT = Context.getBOOLType();
Ted Kremeneke65b0862012-03-06 20:05:56 +000013173 return Owned(new (Context) ObjCBoolLiteralExpr(Kind == tok::kw___objc_yes,
Fariborz Jahanianf2578572012-08-30 18:49:41 +000013174 BoolT, OpLoc));
Ted Kremeneke65b0862012-03-06 20:05:56 +000013175}