ExprObjC.cpp revision 296417 
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
18using namespace clang;
19
20ObjCArrayLiteral::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
38ObjCArrayLiteral *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
46ObjCArrayLiteral *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
53ObjCDictionaryLiteral::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
88ObjCDictionaryLiteral *
89ObjCDictionaryLiteral::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
98ObjCDictionaryLiteral *
99ObjCDictionaryLiteral::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
107QualType 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
117ObjCMessageExpr::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
139ObjCMessageExpr::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
157ObjCMessageExpr::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
175void 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
200ObjCMessageExpr *
201ObjCMessageExpr::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
220ObjCMessageExpr *
221ObjCMessageExpr::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
239ObjCMessageExpr *
240ObjCMessageExpr::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
258ObjCMessageExpr *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
265ObjCMessageExpr *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
277ObjCMessageExpr *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
284void 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
290SourceRange 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
306Selector ObjCMessageExpr::getSelector() const {
307  if (HasMethod)
308    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
309        ->getSelector();
310  return Selector(SelectorOrMethod);
311}
312
313QualType 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
327ObjCInterfaceDecl *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
339Stmt::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
349StringRef 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}
361