clang  10.0.0svn
NSAPI.cpp
Go to the documentation of this file.
1 //===--- NSAPI.cpp - NSFoundation APIs ------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/AST/NSAPI.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/AST/DeclObjC.h"
12 #include "clang/AST/Expr.h"
13 #include "llvm/ADT/StringSwitch.h"
14 
15 using namespace clang;
16 
18  : Ctx(ctx), ClassIds(), BOOLId(nullptr), NSIntegerId(nullptr),
19  NSUIntegerId(nullptr), NSASCIIStringEncodingId(nullptr),
20  NSUTF8StringEncodingId(nullptr) {}
21 
23  static const char *ClassName[NumClassIds] = {
24  "NSObject",
25  "NSString",
26  "NSArray",
27  "NSMutableArray",
28  "NSDictionary",
29  "NSMutableDictionary",
30  "NSNumber",
31  "NSMutableSet",
32  "NSMutableOrderedSet",
33  "NSValue"
34  };
35 
36  if (!ClassIds[K])
37  return (ClassIds[K] = &Ctx.Idents.get(ClassName[K]));
38 
39  return ClassIds[K];
40 }
41 
43  if (NSStringSelectors[MK].isNull()) {
44  Selector Sel;
45  switch (MK) {
47  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("stringWithString"));
48  break;
50  Sel = Ctx.Selectors.getUnarySelector(
51  &Ctx.Idents.get("stringWithUTF8String"));
52  break;
54  Sel = Ctx.Selectors.getUnarySelector(
55  &Ctx.Idents.get("initWithUTF8String"));
56  break;
58  IdentifierInfo *KeyIdents[] = {
59  &Ctx.Idents.get("stringWithCString"),
60  &Ctx.Idents.get("encoding")
61  };
62  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
63  break;
64  }
66  Sel= Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("stringWithCString"));
67  break;
69  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("initWithString"));
70  break;
71  }
72  return (NSStringSelectors[MK] = Sel);
73  }
74 
75  return NSStringSelectors[MK];
76 }
77 
79  if (NSArraySelectors[MK].isNull()) {
80  Selector Sel;
81  switch (MK) {
82  case NSArr_array:
83  Sel = Ctx.Selectors.getNullarySelector(&Ctx.Idents.get("array"));
84  break;
86  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithArray"));
87  break;
89  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithObject"));
90  break;
92  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithObjects"));
93  break;
95  IdentifierInfo *KeyIdents[] = {
96  &Ctx.Idents.get("arrayWithObjects"),
97  &Ctx.Idents.get("count")
98  };
99  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
100  break;
101  }
102  case NSArr_initWithArray:
103  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("initWithArray"));
104  break;
106  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("initWithObjects"));
107  break;
108  case NSArr_objectAtIndex:
109  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("objectAtIndex"));
110  break;
112  IdentifierInfo *KeyIdents[] = {
113  &Ctx.Idents.get("replaceObjectAtIndex"),
114  &Ctx.Idents.get("withObject")
115  };
116  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
117  break;
118  }
120  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("addObject"));
121  break;
123  IdentifierInfo *KeyIdents[] = {
124  &Ctx.Idents.get("insertObject"),
125  &Ctx.Idents.get("atIndex")
126  };
127  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
128  break;
129  }
131  IdentifierInfo *KeyIdents[] = {
132  &Ctx.Idents.get("setObject"),
133  &Ctx.Idents.get("atIndexedSubscript")
134  };
135  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
136  break;
137  }
138  }
139  return (NSArraySelectors[MK] = Sel);
140  }
141 
142  return NSArraySelectors[MK];
143 }
144 
146  for (unsigned i = 0; i != NumNSArrayMethods; ++i) {
148  if (Sel == getNSArraySelector(MK))
149  return MK;
150  }
151 
152  return None;
153 }
154 
156  NSDictionaryMethodKind MK) const {
157  if (NSDictionarySelectors[MK].isNull()) {
158  Selector Sel;
159  switch (MK) {
160  case NSDict_dictionary:
161  Sel = Ctx.Selectors.getNullarySelector(&Ctx.Idents.get("dictionary"));
162  break;
164  Sel = Ctx.Selectors.getUnarySelector(
165  &Ctx.Idents.get("dictionaryWithDictionary"));
166  break;
168  IdentifierInfo *KeyIdents[] = {
169  &Ctx.Idents.get("dictionaryWithObject"),
170  &Ctx.Idents.get("forKey")
171  };
172  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
173  break;
174  }
176  IdentifierInfo *KeyIdents[] = {
177  &Ctx.Idents.get("dictionaryWithObjects"),
178  &Ctx.Idents.get("forKeys")
179  };
180  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
181  break;
182  }
184  IdentifierInfo *KeyIdents[] = {
185  &Ctx.Idents.get("dictionaryWithObjects"),
186  &Ctx.Idents.get("forKeys"),
187  &Ctx.Idents.get("count")
188  };
189  Sel = Ctx.Selectors.getSelector(3, KeyIdents);
190  break;
191  }
193  Sel = Ctx.Selectors.getUnarySelector(
194  &Ctx.Idents.get("dictionaryWithObjectsAndKeys"));
195  break;
197  Sel = Ctx.Selectors.getUnarySelector(
198  &Ctx.Idents.get("initWithDictionary"));
199  break;
201  Sel = Ctx.Selectors.getUnarySelector(
202  &Ctx.Idents.get("initWithObjectsAndKeys"));
203  break;
205  IdentifierInfo *KeyIdents[] = {
206  &Ctx.Idents.get("initWithObjects"),
207  &Ctx.Idents.get("forKeys")
208  };
209  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
210  break;
211  }
212  case NSDict_objectForKey:
213  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("objectForKey"));
214  break;
216  IdentifierInfo *KeyIdents[] = {
217  &Ctx.Idents.get("setObject"),
218  &Ctx.Idents.get("forKey")
219  };
220  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
221  break;
222  }
224  IdentifierInfo *KeyIdents[] = {
225  &Ctx.Idents.get("setObject"),
226  &Ctx.Idents.get("forKeyedSubscript")
227  };
228  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
229  break;
230  }
232  IdentifierInfo *KeyIdents[] = {
233  &Ctx.Idents.get("setValue"),
234  &Ctx.Idents.get("forKey")
235  };
236  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
237  break;
238  }
239  }
240  return (NSDictionarySelectors[MK] = Sel);
241  }
242 
243  return NSDictionarySelectors[MK];
244 }
245 
248  for (unsigned i = 0; i != NumNSDictionaryMethods; ++i) {
250  if (Sel == getNSDictionarySelector(MK))
251  return MK;
252  }
253 
254  return None;
255 }
256 
258  if (NSSetSelectors[MK].isNull()) {
259  Selector Sel;
260  switch (MK) {
262  Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("addObject"));
263  break;
265  IdentifierInfo *KeyIdents[] = {
266  &Ctx.Idents.get("insertObject"),
267  &Ctx.Idents.get("atIndex")
268  };
269  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
270  break;
271  }
273  IdentifierInfo *KeyIdents[] = {
274  &Ctx.Idents.get("setObject"),
275  &Ctx.Idents.get("atIndex")
276  };
277  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
278  break;
279  }
281  IdentifierInfo *KeyIdents[] = {
282  &Ctx.Idents.get("setObject"),
283  &Ctx.Idents.get("atIndexedSubscript")
284  };
285  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
286  break;
287  }
289  IdentifierInfo *KeyIdents[] = {
290  &Ctx.Idents.get("replaceObjectAtIndex"),
291  &Ctx.Idents.get("withObject")
292  };
293  Sel = Ctx.Selectors.getSelector(2, KeyIdents);
294  break;
295  }
296  }
297  return (NSSetSelectors[MK] = Sel);
298  }
299 
300  return NSSetSelectors[MK];
301 }
302 
305  for (unsigned i = 0; i != NumNSSetMethods; ++i) {
307  if (Sel == getNSSetSelector(MK))
308  return MK;
309  }
310 
311  return None;
312 }
313 
315  bool Instance) const {
316  static const char *ClassSelectorName[NumNSNumberLiteralMethods] = {
317  "numberWithChar",
318  "numberWithUnsignedChar",
319  "numberWithShort",
320  "numberWithUnsignedShort",
321  "numberWithInt",
322  "numberWithUnsignedInt",
323  "numberWithLong",
324  "numberWithUnsignedLong",
325  "numberWithLongLong",
326  "numberWithUnsignedLongLong",
327  "numberWithFloat",
328  "numberWithDouble",
329  "numberWithBool",
330  "numberWithInteger",
331  "numberWithUnsignedInteger"
332  };
333  static const char *InstanceSelectorName[NumNSNumberLiteralMethods] = {
334  "initWithChar",
335  "initWithUnsignedChar",
336  "initWithShort",
337  "initWithUnsignedShort",
338  "initWithInt",
339  "initWithUnsignedInt",
340  "initWithLong",
341  "initWithUnsignedLong",
342  "initWithLongLong",
343  "initWithUnsignedLongLong",
344  "initWithFloat",
345  "initWithDouble",
346  "initWithBool",
347  "initWithInteger",
348  "initWithUnsignedInteger"
349  };
350 
351  Selector *Sels;
352  const char **Names;
353  if (Instance) {
354  Sels = NSNumberInstanceSelectors;
355  Names = InstanceSelectorName;
356  } else {
357  Sels = NSNumberClassSelectors;
358  Names = ClassSelectorName;
359  }
360 
361  if (Sels[MK].isNull())
362  Sels[MK] = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get(Names[MK]));
363  return Sels[MK];
364 }
365 
368  for (unsigned i = 0; i != NumNSNumberLiteralMethods; ++i) {
370  if (isNSNumberLiteralSelector(MK, Sel))
371  return MK;
372  }
373 
374  return None;
375 }
376 
379  const BuiltinType *BT = T->getAs<BuiltinType>();
380  if (!BT)
381  return None;
382 
383  const TypedefType *TDT = T->getAs<TypedefType>();
384  if (TDT) {
385  QualType TDTTy = QualType(TDT, 0);
386  if (isObjCBOOLType(TDTTy))
388  if (isObjCNSIntegerType(TDTTy))
390  if (isObjCNSUIntegerType(TDTTy))
392  }
393 
394  switch (BT->getKind()) {
395  case BuiltinType::Char_S:
396  case BuiltinType::SChar:
398  case BuiltinType::Char_U:
399  case BuiltinType::UChar:
401  case BuiltinType::Short:
403  case BuiltinType::UShort:
405  case BuiltinType::Int:
406  return NSAPI::NSNumberWithInt;
407  case BuiltinType::UInt:
409  case BuiltinType::Long:
411  case BuiltinType::ULong:
413  case BuiltinType::LongLong:
415  case BuiltinType::ULongLong:
417  case BuiltinType::Float:
419  case BuiltinType::Double:
421  case BuiltinType::Bool:
423 
424  case BuiltinType::Void:
425  case BuiltinType::WChar_U:
426  case BuiltinType::WChar_S:
427  case BuiltinType::Char8:
428  case BuiltinType::Char16:
429  case BuiltinType::Char32:
430  case BuiltinType::Int128:
431  case BuiltinType::LongDouble:
432  case BuiltinType::ShortAccum:
433  case BuiltinType::Accum:
434  case BuiltinType::LongAccum:
435  case BuiltinType::UShortAccum:
436  case BuiltinType::UAccum:
437  case BuiltinType::ULongAccum:
438  case BuiltinType::ShortFract:
439  case BuiltinType::Fract:
440  case BuiltinType::LongFract:
441  case BuiltinType::UShortFract:
442  case BuiltinType::UFract:
443  case BuiltinType::ULongFract:
444  case BuiltinType::SatShortAccum:
445  case BuiltinType::SatAccum:
446  case BuiltinType::SatLongAccum:
447  case BuiltinType::SatUShortAccum:
448  case BuiltinType::SatUAccum:
449  case BuiltinType::SatULongAccum:
450  case BuiltinType::SatShortFract:
451  case BuiltinType::SatFract:
452  case BuiltinType::SatLongFract:
453  case BuiltinType::SatUShortFract:
454  case BuiltinType::SatUFract:
455  case BuiltinType::SatULongFract:
456  case BuiltinType::UInt128:
457  case BuiltinType::Float16:
458  case BuiltinType::Float128:
459  case BuiltinType::NullPtr:
460  case BuiltinType::ObjCClass:
461  case BuiltinType::ObjCId:
462  case BuiltinType::ObjCSel:
463 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
464  case BuiltinType::Id:
465 #include "clang/Basic/OpenCLImageTypes.def"
466 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
467  case BuiltinType::Id:
468 #include "clang/Basic/OpenCLExtensionTypes.def"
469  case BuiltinType::OCLSampler:
470  case BuiltinType::OCLEvent:
471  case BuiltinType::OCLClkEvent:
472  case BuiltinType::OCLQueue:
473  case BuiltinType::OCLReserveID:
474 #define SVE_TYPE(Name, Id, SingletonId) \
475  case BuiltinType::Id:
476 #include "clang/Basic/AArch64SVEACLETypes.def"
477  case BuiltinType::BoundMember:
478  case BuiltinType::Dependent:
479  case BuiltinType::Overload:
480  case BuiltinType::UnknownAny:
481  case BuiltinType::ARCUnbridgedCast:
482  case BuiltinType::Half:
483  case BuiltinType::PseudoObject:
484  case BuiltinType::BuiltinFn:
485  case BuiltinType::OMPArraySection:
486  break;
487  }
488 
489  return None;
490 }
491 
492 /// Returns true if \param T is a typedef of "BOOL" in objective-c.
494  return isObjCTypedef(T, "BOOL", BOOLId);
495 }
496 /// Returns true if \param T is a typedef of "NSInteger" in objective-c.
498  return isObjCTypedef(T, "NSInteger", NSIntegerId);
499 }
500 /// Returns true if \param T is a typedef of "NSUInteger" in objective-c.
502  return isObjCTypedef(T, "NSUInteger", NSUIntegerId);
503 }
504 
505 StringRef NSAPI::GetNSIntegralKind(QualType T) const {
506  if (!Ctx.getLangOpts().ObjC || T.isNull())
507  return StringRef();
508 
509  while (const TypedefType *TDT = T->getAs<TypedefType>()) {
510  StringRef NSIntegralResust =
511  llvm::StringSwitch<StringRef>(
512  TDT->getDecl()->getDeclName().getAsIdentifierInfo()->getName())
513  .Case("int8_t", "int8_t")
514  .Case("int16_t", "int16_t")
515  .Case("int32_t", "int32_t")
516  .Case("NSInteger", "NSInteger")
517  .Case("int64_t", "int64_t")
518  .Case("uint8_t", "uint8_t")
519  .Case("uint16_t", "uint16_t")
520  .Case("uint32_t", "uint32_t")
521  .Case("NSUInteger", "NSUInteger")
522  .Case("uint64_t", "uint64_t")
523  .Default(StringRef());
524  if (!NSIntegralResust.empty())
525  return NSIntegralResust;
526  T = TDT->desugar();
527  }
528  return StringRef();
529 }
530 
531 bool NSAPI::isMacroDefined(StringRef Id) const {
532  // FIXME: Check whether the relevant module macros are visible.
533  return Ctx.Idents.get(Id).hasMacroDefinition();
534 }
535 
537  NSClassIdKindKind NSClassKind) const {
538  if (!InterfaceDecl) {
539  return false;
540  }
541 
542  IdentifierInfo *NSClassID = getNSClassId(NSClassKind);
543 
544  bool IsSubclass = false;
545  do {
546  IsSubclass = NSClassID == InterfaceDecl->getIdentifier();
547 
548  if (IsSubclass) {
549  break;
550  }
551  } while ((InterfaceDecl = InterfaceDecl->getSuperClass()));
552 
553  return IsSubclass;
554 }
555 
556 bool NSAPI::isObjCTypedef(QualType T,
557  StringRef name, IdentifierInfo *&II) const {
558  if (!Ctx.getLangOpts().ObjC)
559  return false;
560  if (T.isNull())
561  return false;
562 
563  if (!II)
564  II = &Ctx.Idents.get(name);
565 
566  while (const TypedefType *TDT = T->getAs<TypedefType>()) {
567  if (TDT->getDecl()->getDeclName().getAsIdentifierInfo() == II)
568  return true;
569  T = TDT->desugar();
570  }
571 
572  return false;
573 }
574 
575 bool NSAPI::isObjCEnumerator(const Expr *E,
576  StringRef name, IdentifierInfo *&II) const {
577  if (!Ctx.getLangOpts().ObjC)
578  return false;
579  if (!E)
580  return false;
581 
582  if (!II)
583  II = &Ctx.Idents.get(name);
584 
585  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
586  if (const EnumConstantDecl *
587  EnumD = dyn_cast_or_null<EnumConstantDecl>(DRE->getDecl()))
588  return EnumD->getIdentifier() == II;
589 
590  return false;
591 }
592 
593 Selector NSAPI::getOrInitSelector(ArrayRef<StringRef> Ids,
594  Selector &Sel) const {
595  if (Sel.isNull()) {
598  I = Ids.begin(), E = Ids.end(); I != E; ++I)
599  Idents.push_back(&Ctx.Idents.get(*I));
600  Sel = Ctx.Selectors.getSelector(Idents.size(), Idents.data());
601  }
602  return Sel;
603 }
604 
605 Selector NSAPI::getOrInitNullarySelector(StringRef Id, Selector &Sel) const {
606  if (Sel.isNull()) {
607  IdentifierInfo *Ident = &Ctx.Idents.get(Id);
608  Sel = Ctx.Selectors.getSelector(0, &Ident);
609  }
610  return Sel;
611 }
Optional< NSNumberLiteralMethodKind > getNSNumberFactoryMethodKind(QualType T) const
Determine the appropriate NSNumber factory method kind for a literal of the given type...
Definition: NSAPI.cpp:378
Defines the clang::ASTContext interface.
Smart pointer class that efficiently represents Objective-C method names.
A (possibly-)qualified type.
Definition: Type.h:643
Kind getKind() const
Definition: Type.h:2466
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2855
Optional< NSDictionaryMethodKind > getNSDictionaryMethodKind(Selector Sel)
Return NSDictionaryMethodKind if Sel is such a selector.
Definition: NSAPI.cpp:247
NSNumberLiteralMethodKind
Enumerates the NSNumber methods used to generate literals.
Definition: NSAPI.h:174
NSDictionaryMethodKind
Enumerates the NSDictionary/NSMutableDictionary methods used to generate literals and to apply some c...
Definition: NSAPI.h:96
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6858
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Selector getUnarySelector(IdentifierInfo *ID)
One of these records is kept for each identifier that is lexed.
Optional< NSSetMethodKind > getNSSetMethodKind(Selector Sel)
Return NSSetMethodKind if Sel is such a selector.
Definition: NSAPI.cpp:304
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
Selector getNSStringSelector(NSStringMethodKind MK) const
The Objective-C NSString selectors.
Definition: NSAPI.cpp:42
Selector getNSNumberLiteralSelector(NSNumberLiteralMethodKind MK, bool Instance) const
The Objective-C NSNumber selectors used to create NSNumber literals.
Definition: NSAPI.cpp:314
IdentifierTable & Idents
Definition: ASTContext.h:579
Optional< NSNumberLiteralMethodKind > getNSNumberLiteralMethodKind(Selector Sel) const
Return NSNumberLiteralMethodKind if Sel is such a selector.
Definition: NSAPI.cpp:367
Selector getNullarySelector(IdentifierInfo *ID)
static const unsigned NumClassIds
Definition: NSAPI.h:41
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:191
NSSetMethodKind
Enumerates the NSMutableSet/NSOrderedSet methods used to apply some checks.
Definition: NSAPI.h:121
NSAPI(ASTContext &Ctx)
Definition: NSAPI.cpp:17
Represents an ObjC class declaration.
Definition: DeclObjC.h:1171
static const unsigned NumNSSetMethods
Definition: NSAPI.h:128
NSClassIdKindKind
Definition: NSAPI.h:29
NSArrayMethodKind
Enumerates the NSArray/NSMutableArray methods used to generate literals and to apply some checks...
Definition: NSAPI.h:72
This represents one expression.
Definition: Expr.h:108
Selector getNSArraySelector(NSArrayMethodKind MK) const
The Objective-C NSArray selectors.
Definition: NSAPI.cpp:78
int Id
Definition: ASTDiff.cpp:190
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
StringRef GetNSIntegralKind(QualType T) const
Returns one of NSIntegral typedef names if.
Definition: NSAPI.cpp:505
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
SelectorTable & Selectors
Definition: ASTContext.h:580
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
bool isObjCBOOLType(QualType T) const
Returns true if.
Definition: NSAPI.cpp:493
bool isObjCNSUIntegerType(QualType T) const
Returns true if.
Definition: NSAPI.cpp:501
Selector getNSSetSelector(NSSetMethodKind MK) const
The Objective-C NSSet selectors.
Definition: NSAPI.cpp:257
bool isObjCNSIntegerType(QualType T) const
Returns true if.
Definition: NSAPI.cpp:497
bool isSubclassOfNSClass(ObjCInterfaceDecl *InterfaceDecl, NSClassIdKindKind NSClassKind) const
Returns true if InterfaceDecl is subclass of NSClassKind.
Definition: NSAPI.cpp:536
NSStringMethodKind
Definition: NSAPI.h:43
IdentifierInfo * getNSClassId(NSClassIdKindKind K) const
Definition: NSAPI.cpp:22
Dataflow Directional Tag Classes.
bool isMacroDefined(StringRef Id) const
Returns true if Id is currently defined as a macro.
Definition: NSAPI.cpp:531
bool isNSNumberLiteralSelector(NSNumberLiteralMethodKind MK, Selector Sel) const
Definition: NSAPI.h:199
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2966
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
static const unsigned NumNSArrayMethods
Definition: NSAPI.h:86
Selector getNSDictionarySelector(NSDictionaryMethodKind MK) const
The Objective-C NSDictionary selectors.
Definition: NSAPI.cpp:155
static const unsigned NumNSDictionaryMethods
Definition: NSAPI.h:111
bool isNull() const
Determine whether this is the empty selector.
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2436
Optional< NSArrayMethodKind > getNSArrayMethodKind(Selector Sel)
Return NSArrayMethodKind if Sel is such a selector.
Definition: NSAPI.cpp:145
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1146
bool hasMacroDefinition() const
Return true if this identifier is #defined to some other value.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:723