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