xref: /llvm-project-15.0.7/clang/lib/AST/NSAPI.cpp (revision fa1b602e) 
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 
17 NSAPI::NSAPI(ASTContext &ctx)
18   : Ctx(ctx), ClassIds(), BOOLId(nullptr), NSIntegerId(nullptr),
19     NSUIntegerId(nullptr), NSASCIIStringEncodingId(nullptr),
20     NSUTF8StringEncodingId(nullptr) {}
21 
22 IdentifierInfo *NSAPI::getNSClassId(NSClassIdKindKind K) const {
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 
42 Selector NSAPI::getNSStringSelector(NSStringMethodKind MK) const {
43   if (NSStringSelectors[MK].isNull()) {
44     Selector Sel;
45     switch (MK) {
46     case NSStr_stringWithString:
47       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("stringWithString"));
48       break;
49     case NSStr_stringWithUTF8String:
50       Sel = Ctx.Selectors.getUnarySelector(
51                                        &Ctx.Idents.get("stringWithUTF8String"));
52       break;
53     case NSStr_initWithUTF8String:
54       Sel = Ctx.Selectors.getUnarySelector(
55                                        &Ctx.Idents.get("initWithUTF8String"));
56       break;
57     case NSStr_stringWithCStringEncoding: {
58       IdentifierInfo *KeyIdents[] = {
59         &Ctx.Idents.get("stringWithCString"),
60         &Ctx.Idents.get("encoding")
61       };
62       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
63       break;
64     }
65     case NSStr_stringWithCString:
66       Sel= Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("stringWithCString"));
67       break;
68     case NSStr_initWithString:
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 
78 Selector NSAPI::getNSArraySelector(NSArrayMethodKind MK) const {
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;
85     case NSArr_arrayWithArray:
86       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithArray"));
87       break;
88     case NSArr_arrayWithObject:
89       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithObject"));
90       break;
91     case NSArr_arrayWithObjects:
92       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithObjects"));
93       break;
94     case NSArr_arrayWithObjectsCount: {
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;
105     case NSArr_initWithObjects:
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;
111     case NSMutableArr_replaceObjectAtIndex: {
112       IdentifierInfo *KeyIdents[] = {
113         &Ctx.Idents.get("replaceObjectAtIndex"),
114         &Ctx.Idents.get("withObject")
115       };
116       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
117       break;
118     }
119     case NSMutableArr_addObject:
120       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("addObject"));
121       break;
122     case NSMutableArr_insertObjectAtIndex: {
123       IdentifierInfo *KeyIdents[] = {
124         &Ctx.Idents.get("insertObject"),
125         &Ctx.Idents.get("atIndex")
126       };
127       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
128       break;
129     }
130     case NSMutableArr_setObjectAtIndexedSubscript: {
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 
145 Optional<NSAPI::NSArrayMethodKind> NSAPI::getNSArrayMethodKind(Selector Sel) {
146   for (unsigned i = 0; i != NumNSArrayMethods; ++i) {
147     NSArrayMethodKind MK = NSArrayMethodKind(i);
148     if (Sel == getNSArraySelector(MK))
149       return MK;
150   }
151 
152   return None;
153 }
154 
155 Selector NSAPI::getNSDictionarySelector(
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;
163     case NSDict_dictionaryWithDictionary:
164       Sel = Ctx.Selectors.getUnarySelector(
165                                    &Ctx.Idents.get("dictionaryWithDictionary"));
166       break;
167     case NSDict_dictionaryWithObjectForKey: {
168       IdentifierInfo *KeyIdents[] = {
169         &Ctx.Idents.get("dictionaryWithObject"),
170         &Ctx.Idents.get("forKey")
171       };
172       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
173       break;
174     }
175     case NSDict_dictionaryWithObjectsForKeys: {
176       IdentifierInfo *KeyIdents[] = {
177         &Ctx.Idents.get("dictionaryWithObjects"),
178         &Ctx.Idents.get("forKeys")
179       };
180       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
181       break;
182     }
183     case NSDict_dictionaryWithObjectsForKeysCount: {
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     }
192     case NSDict_dictionaryWithObjectsAndKeys:
193       Sel = Ctx.Selectors.getUnarySelector(
194                                &Ctx.Idents.get("dictionaryWithObjectsAndKeys"));
195       break;
196     case NSDict_initWithDictionary:
197       Sel = Ctx.Selectors.getUnarySelector(
198                                          &Ctx.Idents.get("initWithDictionary"));
199       break;
200     case NSDict_initWithObjectsAndKeys:
201       Sel = Ctx.Selectors.getUnarySelector(
202                                      &Ctx.Idents.get("initWithObjectsAndKeys"));
203       break;
204     case NSDict_initWithObjectsForKeys: {
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;
215     case NSMutableDict_setObjectForKey: {
216       IdentifierInfo *KeyIdents[] = {
217         &Ctx.Idents.get("setObject"),
218         &Ctx.Idents.get("forKey")
219       };
220       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
221       break;
222     }
223     case NSMutableDict_setObjectForKeyedSubscript: {
224       IdentifierInfo *KeyIdents[] = {
225         &Ctx.Idents.get("setObject"),
226         &Ctx.Idents.get("forKeyedSubscript")
227       };
228       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
229       break;
230     }
231     case NSMutableDict_setValueForKey: {
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 
246 Optional<NSAPI::NSDictionaryMethodKind>
247 NSAPI::getNSDictionaryMethodKind(Selector Sel) {
248   for (unsigned i = 0; i != NumNSDictionaryMethods; ++i) {
249     NSDictionaryMethodKind MK = NSDictionaryMethodKind(i);
250     if (Sel == getNSDictionarySelector(MK))
251       return MK;
252   }
253 
254   return None;
255 }
256 
257 Selector NSAPI::getNSSetSelector(NSSetMethodKind MK) const {
258   if (NSSetSelectors[MK].isNull()) {
259     Selector Sel;
260     switch (MK) {
261     case NSMutableSet_addObject:
262       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("addObject"));
263       break;
264     case NSOrderedSet_insertObjectAtIndex: {
265       IdentifierInfo *KeyIdents[] = {
266         &Ctx.Idents.get("insertObject"),
267         &Ctx.Idents.get("atIndex")
268       };
269       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
270       break;
271     }
272     case NSOrderedSet_setObjectAtIndex: {
273       IdentifierInfo *KeyIdents[] = {
274         &Ctx.Idents.get("setObject"),
275         &Ctx.Idents.get("atIndex")
276       };
277       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
278       break;
279     }
280     case NSOrderedSet_setObjectAtIndexedSubscript: {
281       IdentifierInfo *KeyIdents[] = {
282         &Ctx.Idents.get("setObject"),
283         &Ctx.Idents.get("atIndexedSubscript")
284       };
285       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
286       break;
287     }
288     case NSOrderedSet_replaceObjectAtIndexWithObject: {
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 
303 Optional<NSAPI::NSSetMethodKind>
304 NSAPI::getNSSetMethodKind(Selector Sel) {
305   for (unsigned i = 0; i != NumNSSetMethods; ++i) {
306     NSSetMethodKind MK = NSSetMethodKind(i);
307     if (Sel == getNSSetSelector(MK))
308       return MK;
309   }
310 
311   return None;
312 }
313 
314 Selector NSAPI::getNSNumberLiteralSelector(NSNumberLiteralMethodKind MK,
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 
366 Optional<NSAPI::NSNumberLiteralMethodKind>
367 NSAPI::getNSNumberLiteralMethodKind(Selector Sel) const {
368   for (unsigned i = 0; i != NumNSNumberLiteralMethods; ++i) {
369     NSNumberLiteralMethodKind MK = NSNumberLiteralMethodKind(i);
370     if (isNSNumberLiteralSelector(MK, Sel))
371       return MK;
372   }
373 
374   return None;
375 }
376 
377 Optional<NSAPI::NSNumberLiteralMethodKind>
378 NSAPI::getNSNumberFactoryMethodKind(QualType T) const {
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))
387       return NSAPI::NSNumberWithBool;
388     if (isObjCNSIntegerType(TDTTy))
389       return NSAPI::NSNumberWithInteger;
390     if (isObjCNSUIntegerType(TDTTy))
391       return NSAPI::NSNumberWithUnsignedInteger;
392   }
393 
394   switch (BT->getKind()) {
395   case BuiltinType::Char_S:
396   case BuiltinType::SChar:
397     return NSAPI::NSNumberWithChar;
398   case BuiltinType::Char_U:
399   case BuiltinType::UChar:
400     return NSAPI::NSNumberWithUnsignedChar;
401   case BuiltinType::Short:
402     return NSAPI::NSNumberWithShort;
403   case BuiltinType::UShort:
404     return NSAPI::NSNumberWithUnsignedShort;
405   case BuiltinType::Int:
406     return NSAPI::NSNumberWithInt;
407   case BuiltinType::UInt:
408     return NSAPI::NSNumberWithUnsignedInt;
409   case BuiltinType::Long:
410     return NSAPI::NSNumberWithLong;
411   case BuiltinType::ULong:
412     return NSAPI::NSNumberWithUnsignedLong;
413   case BuiltinType::LongLong:
414     return NSAPI::NSNumberWithLongLong;
415   case BuiltinType::ULongLong:
416     return NSAPI::NSNumberWithUnsignedLongLong;
417   case BuiltinType::Float:
418     return NSAPI::NSNumberWithFloat;
419   case BuiltinType::Double:
420     return NSAPI::NSNumberWithDouble;
421   case BuiltinType::Bool:
422     return NSAPI::NSNumberWithBool;
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   case BuiltinType::OMPArrayShaping:
487     break;
488   }
489 
490   return None;
491 }
492 
493 /// Returns true if \param T is a typedef of "BOOL" in objective-c.
494 bool NSAPI::isObjCBOOLType(QualType T) const {
495   return isObjCTypedef(T, "BOOL", BOOLId);
496 }
497 /// Returns true if \param T is a typedef of "NSInteger" in objective-c.
498 bool NSAPI::isObjCNSIntegerType(QualType T) const {
499   return isObjCTypedef(T, "NSInteger", NSIntegerId);
500 }
501 /// Returns true if \param T is a typedef of "NSUInteger" in objective-c.
502 bool NSAPI::isObjCNSUIntegerType(QualType T) const {
503   return isObjCTypedef(T, "NSUInteger", NSUIntegerId);
504 }
505 
506 StringRef NSAPI::GetNSIntegralKind(QualType T) const {
507   if (!Ctx.getLangOpts().ObjC || T.isNull())
508     return StringRef();
509 
510   while (const TypedefType *TDT = T->getAs<TypedefType>()) {
511     StringRef NSIntegralResust =
512       llvm::StringSwitch<StringRef>(
513         TDT->getDecl()->getDeclName().getAsIdentifierInfo()->getName())
514     .Case("int8_t", "int8_t")
515     .Case("int16_t", "int16_t")
516     .Case("int32_t", "int32_t")
517     .Case("NSInteger", "NSInteger")
518     .Case("int64_t", "int64_t")
519     .Case("uint8_t", "uint8_t")
520     .Case("uint16_t", "uint16_t")
521     .Case("uint32_t", "uint32_t")
522     .Case("NSUInteger", "NSUInteger")
523     .Case("uint64_t", "uint64_t")
524     .Default(StringRef());
525     if (!NSIntegralResust.empty())
526       return NSIntegralResust;
527     T = TDT->desugar();
528   }
529   return StringRef();
530 }
531 
532 bool NSAPI::isMacroDefined(StringRef Id) const {
533   // FIXME: Check whether the relevant module macros are visible.
534   return Ctx.Idents.get(Id).hasMacroDefinition();
535 }
536 
537 bool NSAPI::isSubclassOfNSClass(ObjCInterfaceDecl *InterfaceDecl,
538                                 NSClassIdKindKind NSClassKind) const {
539   if (!InterfaceDecl) {
540     return false;
541   }
542 
543   IdentifierInfo *NSClassID = getNSClassId(NSClassKind);
544 
545   bool IsSubclass = false;
546   do {
547     IsSubclass = NSClassID == InterfaceDecl->getIdentifier();
548 
549     if (IsSubclass) {
550       break;
551     }
552   } while ((InterfaceDecl = InterfaceDecl->getSuperClass()));
553 
554   return IsSubclass;
555 }
556 
557 bool NSAPI::isObjCTypedef(QualType T,
558                           StringRef name, IdentifierInfo *&II) const {
559   if (!Ctx.getLangOpts().ObjC)
560     return false;
561   if (T.isNull())
562     return false;
563 
564   if (!II)
565     II = &Ctx.Idents.get(name);
566 
567   while (const TypedefType *TDT = T->getAs<TypedefType>()) {
568     if (TDT->getDecl()->getDeclName().getAsIdentifierInfo() == II)
569       return true;
570     T = TDT->desugar();
571   }
572 
573   return false;
574 }
575 
576 bool NSAPI::isObjCEnumerator(const Expr *E,
577                              StringRef name, IdentifierInfo *&II) const {
578   if (!Ctx.getLangOpts().ObjC)
579     return false;
580   if (!E)
581     return false;
582 
583   if (!II)
584     II = &Ctx.Idents.get(name);
585 
586   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
587     if (const EnumConstantDecl *
588           EnumD = dyn_cast_or_null<EnumConstantDecl>(DRE->getDecl()))
589       return EnumD->getIdentifier() == II;
590 
591   return false;
592 }
593 
594 Selector NSAPI::getOrInitSelector(ArrayRef<StringRef> Ids,
595                                   Selector &Sel) const {
596   if (Sel.isNull()) {
597     SmallVector<IdentifierInfo *, 4> Idents;
598     for (ArrayRef<StringRef>::const_iterator
599            I = Ids.begin(), E = Ids.end(); I != E; ++I)
600       Idents.push_back(&Ctx.Idents.get(*I));
601     Sel = Ctx.Selectors.getSelector(Idents.size(), Idents.data());
602   }
603   return Sel;
604 }
605 
606 Selector NSAPI::getOrInitNullarySelector(StringRef Id, Selector &Sel) const {
607   if (Sel.isNull()) {
608     IdentifierInfo *Ident = &Ctx.Idents.get(Id);
609     Sel = Ctx.Selectors.getSelector(0, &Ident);
610   }
611   return Sel;
612 }
613