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