0b6bfcd6006bdc709ee7ad69522f96dcc1047dc8
[lldb.git] / clang / lib / AST / ExprObjC.cpp
1 //===--- ExprObjC.cpp - (ObjC) Expression AST Node Implementation ---------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the subclesses of Expr class declared in ExprObjC.h
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/ExprObjC.h"
15
16 #include "clang/AST/ASTContext.h"
17
18 using namespace clang;
19
20 ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, QualType T,
21                                    ObjCMethodDecl *Method, SourceRange SR)
22     : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
23            false, false),
24       NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) {
25   Expr **SaveElements = getElements();
26   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
27     if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent())
28       ExprBits.ValueDependent = true;
29     if (Elements[I]->isInstantiationDependent())
30       ExprBits.InstantiationDependent = true;
31     if (Elements[I]->containsUnexpandedParameterPack())
32       ExprBits.ContainsUnexpandedParameterPack = true;
33
34     SaveElements[I] = Elements[I];
35   }
36 }
37
38 ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C,
39                                            ArrayRef<Expr *> Elements,
40                                            QualType T, ObjCMethodDecl *Method,
41                                            SourceRange SR) {
42   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Elements.size()));
43   return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR);
44 }
45
46 ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(const ASTContext &C,
47                                                 unsigned NumElements) {
48
49   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumElements));
50   return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements);
51 }
52
53 ObjCDictionaryLiteral::ObjCDictionaryLiteral(ArrayRef<ObjCDictionaryElement> VK,
54                                              bool HasPackExpansions, QualType T,
55                                              ObjCMethodDecl *method,
56                                              SourceRange SR)
57     : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
58            false, false),
59       NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
60       DictWithObjectsMethod(method) {
61   KeyValuePair *KeyValues = getTrailingObjects<KeyValuePair>();
62   ExpansionData *Expansions = getTrailingObjects<ExpansionData>();
63   for (unsigned I = 0; I < NumElements; I++) {
64     if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() ||
65         VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent())
66       ExprBits.ValueDependent = true;
67     if (VK[I].Key->isInstantiationDependent() ||
68         VK[I].Value->isInstantiationDependent())
69       ExprBits.InstantiationDependent = true;
70     if (VK[I].EllipsisLoc.isInvalid() &&
71         (VK[I].Key->containsUnexpandedParameterPack() ||
72          VK[I].Value->containsUnexpandedParameterPack()))
73       ExprBits.ContainsUnexpandedParameterPack = true;
74
75     KeyValues[I].Key = VK[I].Key;
76     KeyValues[I].Value = VK[I].Value;
77     if (Expansions) {
78       Expansions[I].EllipsisLoc = VK[I].EllipsisLoc;
79       if (VK[I].NumExpansions)
80         Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1;
81       else
82         Expansions[I].NumExpansionsPlusOne = 0;
83     }
84   }
85 }
86
87 ObjCDictionaryLiteral *
88 ObjCDictionaryLiteral::Create(const ASTContext &C,
89                               ArrayRef<ObjCDictionaryElement> VK,
90                               bool HasPackExpansions, QualType T,
91                               ObjCMethodDecl *method, SourceRange SR) {
92   void *Mem = C.Allocate(totalSizeToAlloc<KeyValuePair, ExpansionData>(
93       VK.size(), HasPackExpansions ? VK.size() : 0));
94   return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR);
95 }
96
97 ObjCDictionaryLiteral *
98 ObjCDictionaryLiteral::CreateEmpty(const ASTContext &C, unsigned NumElements,
99                                    bool HasPackExpansions) {
100   void *Mem = C.Allocate(totalSizeToAlloc<KeyValuePair, ExpansionData>(
101       NumElements, HasPackExpansions ? NumElements : 0));
102   return new (Mem)
103       ObjCDictionaryLiteral(EmptyShell(), NumElements, HasPackExpansions);
104 }
105
106 QualType ObjCPropertyRefExpr::getReceiverType(const ASTContext &ctx) const {
107   if (isClassReceiver())
108     return ctx.getObjCInterfaceType(getClassReceiver());
109
110   if (isSuperReceiver())
111     return getSuperReceiverType();
112
113   return getBase()->getType();
114 }
115
116 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
117                                  SourceLocation LBracLoc,
118                                  SourceLocation SuperLoc, bool IsInstanceSuper,
119                                  QualType SuperType, Selector Sel,
120                                  ArrayRef<SourceLocation> SelLocs,
121                                  SelectorLocationsKind SelLocsK,
122                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
123                                  SourceLocation RBracLoc, bool isImplicit)
124     : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
125            /*TypeDependent=*/false, /*ValueDependent=*/false,
126            /*InstantiationDependent=*/false,
127            /*ContainsUnexpandedParameterPack=*/false),
128       SelectorOrMethod(
129           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
130       Kind(IsInstanceSuper ? SuperInstance : SuperClass),
131       HasMethod(Method != nullptr), IsDelegateInitCall(false),
132       IsImplicit(isImplicit), SuperLoc(SuperLoc), LBracLoc(LBracLoc),
133       RBracLoc(RBracLoc) {
134   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
135   setReceiverPointer(SuperType.getAsOpaquePtr());
136 }
137
138 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
139                                  SourceLocation LBracLoc,
140                                  TypeSourceInfo *Receiver, Selector Sel,
141                                  ArrayRef<SourceLocation> SelLocs,
142                                  SelectorLocationsKind SelLocsK,
143                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
144                                  SourceLocation RBracLoc, bool isImplicit)
145     : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
146            T->isDependentType(), T->isInstantiationDependentType(),
147            T->containsUnexpandedParameterPack()),
148       SelectorOrMethod(
149           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
150       Kind(Class), HasMethod(Method != nullptr), IsDelegateInitCall(false),
151       IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) {
152   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
153   setReceiverPointer(Receiver);
154 }
155
156 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
157                                  SourceLocation LBracLoc, Expr *Receiver,
158                                  Selector Sel, ArrayRef<SourceLocation> SelLocs,
159                                  SelectorLocationsKind SelLocsK,
160                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
161                                  SourceLocation RBracLoc, bool isImplicit)
162     : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
163            Receiver->isTypeDependent(), Receiver->isTypeDependent(),
164            Receiver->isInstantiationDependent(),
165            Receiver->containsUnexpandedParameterPack()),
166       SelectorOrMethod(
167           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
168       Kind(Instance), HasMethod(Method != nullptr), IsDelegateInitCall(false),
169       IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) {
170   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
171   setReceiverPointer(Receiver);
172 }
173
174 void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args,
175                                          ArrayRef<SourceLocation> SelLocs,
176                                          SelectorLocationsKind SelLocsK) {
177   setNumArgs(Args.size());
178   Expr **MyArgs = getArgs();
179   for (unsigned I = 0; I != Args.size(); ++I) {
180     if (Args[I]->isTypeDependent())
181       ExprBits.TypeDependent = true;
182     if (Args[I]->isValueDependent())
183       ExprBits.ValueDependent = true;
184     if (Args[I]->isInstantiationDependent())
185       ExprBits.InstantiationDependent = true;
186     if (Args[I]->containsUnexpandedParameterPack())
187       ExprBits.ContainsUnexpandedParameterPack = true;
188
189     MyArgs[I] = Args[I];
190   }
191
192   SelLocsKind = SelLocsK;
193   if (!isImplicit()) {
194     if (SelLocsK == SelLoc_NonStandard)
195       std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
196   }
197 }
198
199 ObjCMessageExpr *
200 ObjCMessageExpr::Create(const ASTContext &Context, QualType T, ExprValueKind VK,
201                         SourceLocation LBracLoc, SourceLocation SuperLoc,
202                         bool IsInstanceSuper, QualType SuperType, Selector Sel,
203                         ArrayRef<SourceLocation> SelLocs,
204                         ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
205                         SourceLocation RBracLoc, bool isImplicit) {
206   assert((!SelLocs.empty() || isImplicit) &&
207          "No selector locs for non-implicit message");
208   ObjCMessageExpr *Mem;
209   SelectorLocationsKind SelLocsK = SelectorLocationsKind();
210   if (isImplicit)
211     Mem = alloc(Context, Args.size(), 0);
212   else
213     Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
214   return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper,
215                                    SuperType, Sel, SelLocs, SelLocsK, Method,
216                                    Args, RBracLoc, isImplicit);
217 }
218
219 ObjCMessageExpr *
220 ObjCMessageExpr::Create(const ASTContext &Context, QualType T, ExprValueKind VK,
221                         SourceLocation LBracLoc, TypeSourceInfo *Receiver,
222                         Selector Sel, ArrayRef<SourceLocation> SelLocs,
223                         ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
224                         SourceLocation RBracLoc, bool isImplicit) {
225   assert((!SelLocs.empty() || isImplicit) &&
226          "No selector locs for non-implicit message");
227   ObjCMessageExpr *Mem;
228   SelectorLocationsKind SelLocsK = SelectorLocationsKind();
229   if (isImplicit)
230     Mem = alloc(Context, Args.size(), 0);
231   else
232     Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
233   return new (Mem)
234       ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, SelLocs, SelLocsK, Method,
235                       Args, RBracLoc, isImplicit);
236 }
237
238 ObjCMessageExpr *
239 ObjCMessageExpr::Create(const ASTContext &Context, QualType T, ExprValueKind VK,
240                         SourceLocation LBracLoc, Expr *Receiver, Selector Sel,
241                         ArrayRef<SourceLocation> SelLocs,
242                         ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
243                         SourceLocation RBracLoc, bool isImplicit) {
244   assert((!SelLocs.empty() || isImplicit) &&
245          "No selector locs for non-implicit message");
246   ObjCMessageExpr *Mem;
247   SelectorLocationsKind SelLocsK = SelectorLocationsKind();
248   if (isImplicit)
249     Mem = alloc(Context, Args.size(), 0);
250   else
251     Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
252   return new (Mem)
253       ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, SelLocs, SelLocsK, Method,
254                       Args, RBracLoc, isImplicit);
255 }
256
257 ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(const ASTContext &Context,
258                                               unsigned NumArgs,
259                                               unsigned NumStoredSelLocs) {
260   ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs);
261   return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
262 }
263
264 ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C,
265                                         ArrayRef<Expr *> Args,
266                                         SourceLocation RBraceLoc,
267                                         ArrayRef<SourceLocation> SelLocs,
268                                         Selector Sel,
269                                         SelectorLocationsKind &SelLocsK) {
270   SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc);
271   unsigned NumStoredSelLocs =
272       (SelLocsK == SelLoc_NonStandard) ? SelLocs.size() : 0;
273   return alloc(C, Args.size(), NumStoredSelLocs);
274 }
275
276 ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, unsigned NumArgs,
277                                         unsigned NumStoredSelLocs) {
278   return (ObjCMessageExpr *)C.Allocate(
279       totalSizeToAlloc<void *, SourceLocation>(NumArgs + 1, NumStoredSelLocs),
280       llvm::AlignOf<ObjCMessageExpr>::Alignment);
281 }
282
283 void ObjCMessageExpr::getSelectorLocs(
284     SmallVectorImpl<SourceLocation> &SelLocs) const {
285   for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
286     SelLocs.push_back(getSelectorLoc(i));
287 }
288
289 SourceRange ObjCMessageExpr::getReceiverRange() const {
290   switch (getReceiverKind()) {
291   case Instance:
292     return getInstanceReceiver()->getSourceRange();
293
294   case Class:
295     return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange();
296
297   case SuperInstance:
298   case SuperClass:
299     return getSuperLoc();
300   }
301
302   llvm_unreachable("Invalid ReceiverKind!");
303 }
304
305 Selector ObjCMessageExpr::getSelector() const {
306   if (HasMethod)
307     return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
308         ->getSelector();
309   return Selector(SelectorOrMethod);
310 }
311
312 QualType ObjCMessageExpr::getReceiverType() const {
313   switch (getReceiverKind()) {
314   case Instance:
315     return getInstanceReceiver()->getType();
316   case Class:
317     return getClassReceiver();
318   case SuperInstance:
319   case SuperClass:
320     return getSuperType();
321   }
322
323   llvm_unreachable("unexpected receiver kind");
324 }
325
326 ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
327   QualType T = getReceiverType();
328
329   if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
330     return Ptr->getInterfaceDecl();
331
332   if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>())
333     return Ty->getInterface();
334
335   return nullptr;
336 }
337
338 Stmt::child_range ObjCMessageExpr::children() {
339   Stmt **begin;
340   if (getReceiverKind() == Instance)
341     begin = reinterpret_cast<Stmt **>(getTrailingObjects<void *>());
342   else
343     begin = reinterpret_cast<Stmt **>(getArgs());
344   return child_range(begin,
345                      reinterpret_cast<Stmt **>(getArgs() + getNumArgs()));
346 }
347
348 StringRef ObjCBridgedCastExpr::getBridgeKindName() const {
349   switch (getBridgeKind()) {
350   case OBC_Bridge:
351     return "__bridge";
352   case OBC_BridgeTransfer:
353     return "__bridge_transfer";
354   case OBC_BridgeRetained:
355     return "__bridge_retained";
356   }
357
358   llvm_unreachable("Invalid BridgeKind!");
359 }