1 //===- DeclObjC.cpp - ObjC Declaration AST Node Implementation ------------===//
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 // This file implements the Objective-C related Decl classes.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/DeclObjC.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTMutationListener.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclBase.h"
19 #include "clang/AST/Stmt.h"
20 #include "clang/AST/Type.h"
21 #include "clang/AST/TypeLoc.h"
22 #include "clang/Basic/IdentifierTable.h"
23 #include "clang/Basic/LLVM.h"
24 #include "clang/Basic/LangOptions.h"
25 #include "clang/Basic/SourceLocation.h"
26 #include "llvm/ADT/None.h"
27 #include "llvm/ADT/SmallString.h"
28 #include "llvm/ADT/SmallVector.h"
29 #include "llvm/Support/Casting.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include <algorithm>
33 #include <cassert>
34 #include <cstdint>
35 #include <cstring>
36 #include <utility>
37
38 using namespace clang;
39
40 //===----------------------------------------------------------------------===//
41 // ObjCListBase
42 //===----------------------------------------------------------------------===//
43
set(void * const * InList,unsigned Elts,ASTContext & Ctx)44 void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
45 List = nullptr;
46 if (Elts == 0) return; // Setting to an empty list is a noop.
47
48 List = new (Ctx) void*[Elts];
49 NumElts = Elts;
50 memcpy(List, InList, sizeof(void*)*Elts);
51 }
52
set(ObjCProtocolDecl * const * InList,unsigned Elts,const SourceLocation * Locs,ASTContext & Ctx)53 void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
54 const SourceLocation *Locs, ASTContext &Ctx) {
55 if (Elts == 0)
56 return;
57
58 Locations = new (Ctx) SourceLocation[Elts];
59 memcpy(Locations, Locs, sizeof(SourceLocation) * Elts);
60 set(InList, Elts, Ctx);
61 }
62
63 //===----------------------------------------------------------------------===//
64 // ObjCInterfaceDecl
65 //===----------------------------------------------------------------------===//
66
ObjCContainerDecl(Kind DK,DeclContext * DC,IdentifierInfo * Id,SourceLocation nameLoc,SourceLocation atStartLoc)67 ObjCContainerDecl::ObjCContainerDecl(Kind DK, DeclContext *DC,
68 IdentifierInfo *Id, SourceLocation nameLoc,
69 SourceLocation atStartLoc)
70 : NamedDecl(DK, DC, nameLoc, Id), DeclContext(DK) {
71 setAtStartLoc(atStartLoc);
72 }
73
anchor()74 void ObjCContainerDecl::anchor() {}
75
76 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
77 ///
78 ObjCIvarDecl *
getIvarDecl(IdentifierInfo * Id) const79 ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
80 lookup_result R = lookup(Id);
81 for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end();
82 Ivar != IvarEnd; ++Ivar) {
83 if (auto *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
84 return ivar;
85 }
86 return nullptr;
87 }
88
89 // Get the local instance/class method declared in this interface.
90 ObjCMethodDecl *
getMethod(Selector Sel,bool isInstance,bool AllowHidden) const91 ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
92 bool AllowHidden) const {
93 // If this context is a hidden protocol definition, don't find any
94 // methods there.
95 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
96 if (const ObjCProtocolDecl *Def = Proto->getDefinition())
97 if (!Def->isUnconditionallyVisible() && !AllowHidden)
98 return nullptr;
99 }
100
101 // Since instance & class methods can have the same name, the loop below
102 // ensures we get the correct method.
103 //
104 // @interface Whatever
105 // - (int) class_method;
106 // + (float) class_method;
107 // @end
108 lookup_result R = lookup(Sel);
109 for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
110 Meth != MethEnd; ++Meth) {
111 auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
112 if (MD && MD->isInstanceMethod() == isInstance)
113 return MD;
114 }
115 return nullptr;
116 }
117
118 /// This routine returns 'true' if a user declared setter method was
119 /// found in the class, its protocols, its super classes or categories.
120 /// It also returns 'true' if one of its categories has declared a 'readwrite'
121 /// property. This is because, user must provide a setter method for the
122 /// category's 'readwrite' property.
HasUserDeclaredSetterMethod(const ObjCPropertyDecl * Property) const123 bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
124 const ObjCPropertyDecl *Property) const {
125 Selector Sel = Property->getSetterName();
126 lookup_result R = lookup(Sel);
127 for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
128 Meth != MethEnd; ++Meth) {
129 auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
130 if (MD && MD->isInstanceMethod() && !MD->isImplicit())
131 return true;
132 }
133
134 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
135 // Also look into categories, including class extensions, looking
136 // for a user declared instance method.
137 for (const auto *Cat : ID->visible_categories()) {
138 if (ObjCMethodDecl *MD = Cat->getInstanceMethod(Sel))
139 if (!MD->isImplicit())
140 return true;
141 if (Cat->IsClassExtension())
142 continue;
143 // Also search through the categories looking for a 'readwrite'
144 // declaration of this property. If one found, presumably a setter will
145 // be provided (properties declared in categories will not get
146 // auto-synthesized).
147 for (const auto *P : Cat->properties())
148 if (P->getIdentifier() == Property->getIdentifier()) {
149 if (P->getPropertyAttributes() &
150 ObjCPropertyAttribute::kind_readwrite)
151 return true;
152 break;
153 }
154 }
155
156 // Also look into protocols, for a user declared instance method.
157 for (const auto *Proto : ID->all_referenced_protocols())
158 if (Proto->HasUserDeclaredSetterMethod(Property))
159 return true;
160
161 // And in its super class.
162 ObjCInterfaceDecl *OSC = ID->getSuperClass();
163 while (OSC) {
164 if (OSC->HasUserDeclaredSetterMethod(Property))
165 return true;
166 OSC = OSC->getSuperClass();
167 }
168 }
169 if (const auto *PD = dyn_cast<ObjCProtocolDecl>(this))
170 for (const auto *PI : PD->protocols())
171 if (PI->HasUserDeclaredSetterMethod(Property))
172 return true;
173 return false;
174 }
175
176 ObjCPropertyDecl *
findPropertyDecl(const DeclContext * DC,const IdentifierInfo * propertyID,ObjCPropertyQueryKind queryKind)177 ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
178 const IdentifierInfo *propertyID,
179 ObjCPropertyQueryKind queryKind) {
180 // If this context is a hidden protocol definition, don't find any
181 // property.
182 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
183 if (const ObjCProtocolDecl *Def = Proto->getDefinition())
184 if (!Def->isUnconditionallyVisible())
185 return nullptr;
186 }
187
188 // If context is class, then lookup property in its visible extensions.
189 // This comes before property is looked up in primary class.
190 if (auto *IDecl = dyn_cast<ObjCInterfaceDecl>(DC)) {
191 for (const auto *Ext : IDecl->visible_extensions())
192 if (ObjCPropertyDecl *PD = ObjCPropertyDecl::findPropertyDecl(Ext,
193 propertyID,
194 queryKind))
195 return PD;
196 }
197
198 DeclContext::lookup_result R = DC->lookup(propertyID);
199 ObjCPropertyDecl *classProp = nullptr;
200 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
201 ++I)
202 if (auto *PD = dyn_cast<ObjCPropertyDecl>(*I)) {
203 // If queryKind is unknown, we return the instance property if one
204 // exists; otherwise we return the class property.
205 if ((queryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown &&
206 !PD->isClassProperty()) ||
207 (queryKind == ObjCPropertyQueryKind::OBJC_PR_query_class &&
208 PD->isClassProperty()) ||
209 (queryKind == ObjCPropertyQueryKind::OBJC_PR_query_instance &&
210 !PD->isClassProperty()))
211 return PD;
212
213 if (PD->isClassProperty())
214 classProp = PD;
215 }
216
217 if (queryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown)
218 // We can't find the instance property, return the class property.
219 return classProp;
220
221 return nullptr;
222 }
223
224 IdentifierInfo *
getDefaultSynthIvarName(ASTContext & Ctx) const225 ObjCPropertyDecl::getDefaultSynthIvarName(ASTContext &Ctx) const {
226 SmallString<128> ivarName;
227 {
228 llvm::raw_svector_ostream os(ivarName);
229 os << '_' << getIdentifier()->getName();
230 }
231 return &Ctx.Idents.get(ivarName.str());
232 }
233
234 /// FindPropertyDeclaration - Finds declaration of the property given its name
235 /// in 'PropertyId' and returns it. It returns 0, if not found.
FindPropertyDeclaration(const IdentifierInfo * PropertyId,ObjCPropertyQueryKind QueryKind) const236 ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
237 const IdentifierInfo *PropertyId,
238 ObjCPropertyQueryKind QueryKind) const {
239 // Don't find properties within hidden protocol definitions.
240 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
241 if (const ObjCProtocolDecl *Def = Proto->getDefinition())
242 if (!Def->isUnconditionallyVisible())
243 return nullptr;
244 }
245
246 // Search the extensions of a class first; they override what's in
247 // the class itself.
248 if (const auto *ClassDecl = dyn_cast<ObjCInterfaceDecl>(this)) {
249 for (const auto *Ext : ClassDecl->visible_extensions()) {
250 if (auto *P = Ext->FindPropertyDeclaration(PropertyId, QueryKind))
251 return P;
252 }
253 }
254
255 if (ObjCPropertyDecl *PD =
256 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
257 QueryKind))
258 return PD;
259
260 switch (getKind()) {
261 default:
262 break;
263 case Decl::ObjCProtocol: {
264 const auto *PID = cast<ObjCProtocolDecl>(this);
265 for (const auto *I : PID->protocols())
266 if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
267 QueryKind))
268 return P;
269 break;
270 }
271 case Decl::ObjCInterface: {
272 const auto *OID = cast<ObjCInterfaceDecl>(this);
273 // Look through categories (but not extensions; they were handled above).
274 for (const auto *Cat : OID->visible_categories()) {
275 if (!Cat->IsClassExtension())
276 if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(
277 PropertyId, QueryKind))
278 return P;
279 }
280
281 // Look through protocols.
282 for (const auto *I : OID->all_referenced_protocols())
283 if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
284 QueryKind))
285 return P;
286
287 // Finally, check the super class.
288 if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
289 return superClass->FindPropertyDeclaration(PropertyId, QueryKind);
290 break;
291 }
292 case Decl::ObjCCategory: {
293 const auto *OCD = cast<ObjCCategoryDecl>(this);
294 // Look through protocols.
295 if (!OCD->IsClassExtension())
296 for (const auto *I : OCD->protocols())
297 if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
298 QueryKind))
299 return P;
300 break;
301 }
302 }
303 return nullptr;
304 }
305
anchor()306 void ObjCInterfaceDecl::anchor() {}
307
getTypeParamList() const308 ObjCTypeParamList *ObjCInterfaceDecl::getTypeParamList() const {
309 // If this particular declaration has a type parameter list, return it.
310 if (ObjCTypeParamList *written = getTypeParamListAsWritten())
311 return written;
312
313 // If there is a definition, return its type parameter list.
314 if (const ObjCInterfaceDecl *def = getDefinition())
315 return def->getTypeParamListAsWritten();
316
317 // Otherwise, look at previous declarations to determine whether any
318 // of them has a type parameter list, skipping over those
319 // declarations that do not.
320 for (const ObjCInterfaceDecl *decl = getMostRecentDecl(); decl;
321 decl = decl->getPreviousDecl()) {
322 if (ObjCTypeParamList *written = decl->getTypeParamListAsWritten())
323 return written;
324 }
325
326 return nullptr;
327 }
328
setTypeParamList(ObjCTypeParamList * TPL)329 void ObjCInterfaceDecl::setTypeParamList(ObjCTypeParamList *TPL) {
330 TypeParamList = TPL;
331 if (!TPL)
332 return;
333 // Set the declaration context of each of the type parameters.
334 for (auto *typeParam : *TypeParamList)
335 typeParam->setDeclContext(this);
336 }
337
getSuperClass() const338 ObjCInterfaceDecl *ObjCInterfaceDecl::getSuperClass() const {
339 // FIXME: Should make sure no callers ever do this.
340 if (!hasDefinition())
341 return nullptr;
342
343 if (data().ExternallyCompleted)
344 LoadExternalDefinition();
345
346 if (const ObjCObjectType *superType = getSuperClassType()) {
347 if (ObjCInterfaceDecl *superDecl = superType->getInterface()) {
348 if (ObjCInterfaceDecl *superDef = superDecl->getDefinition())
349 return superDef;
350
351 return superDecl;
352 }
353 }
354
355 return nullptr;
356 }
357
getSuperClassLoc() const358 SourceLocation ObjCInterfaceDecl::getSuperClassLoc() const {
359 if (TypeSourceInfo *superTInfo = getSuperClassTInfo())
360 return superTInfo->getTypeLoc().getBeginLoc();
361
362 return SourceLocation();
363 }
364
365 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
366 /// with name 'PropertyId' in the primary class; including those in protocols
367 /// (direct or indirect) used by the primary class.
368 ObjCPropertyDecl *
FindPropertyVisibleInPrimaryClass(IdentifierInfo * PropertyId,ObjCPropertyQueryKind QueryKind) const369 ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
370 IdentifierInfo *PropertyId,
371 ObjCPropertyQueryKind QueryKind) const {
372 // FIXME: Should make sure no callers ever do this.
373 if (!hasDefinition())
374 return nullptr;
375
376 if (data().ExternallyCompleted)
377 LoadExternalDefinition();
378
379 if (ObjCPropertyDecl *PD =
380 ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
381 QueryKind))
382 return PD;
383
384 // Look through protocols.
385 for (const auto *I : all_referenced_protocols())
386 if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
387 QueryKind))
388 return P;
389
390 return nullptr;
391 }
392
collectPropertiesToImplement(PropertyMap & PM,PropertyDeclOrder & PO) const393 void ObjCInterfaceDecl::collectPropertiesToImplement(PropertyMap &PM,
394 PropertyDeclOrder &PO) const {
395 for (auto *Prop : properties()) {
396 PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
397 PO.push_back(Prop);
398 }
399 for (const auto *Ext : known_extensions()) {
400 const ObjCCategoryDecl *ClassExt = Ext;
401 for (auto *Prop : ClassExt->properties()) {
402 PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
403 PO.push_back(Prop);
404 }
405 }
406 for (const auto *PI : all_referenced_protocols())
407 PI->collectPropertiesToImplement(PM, PO);
408 // Note, the properties declared only in class extensions are still copied
409 // into the main @interface's property list, and therefore we don't
410 // explicitly, have to search class extension properties.
411 }
412
isArcWeakrefUnavailable() const413 bool ObjCInterfaceDecl::isArcWeakrefUnavailable() const {
414 const ObjCInterfaceDecl *Class = this;
415 while (Class) {
416 if (Class->hasAttr<ArcWeakrefUnavailableAttr>())
417 return true;
418 Class = Class->getSuperClass();
419 }
420 return false;
421 }
422
isObjCRequiresPropertyDefs() const423 const ObjCInterfaceDecl *ObjCInterfaceDecl::isObjCRequiresPropertyDefs() const {
424 const ObjCInterfaceDecl *Class = this;
425 while (Class) {
426 if (Class->hasAttr<ObjCRequiresPropertyDefsAttr>())
427 return Class;
428 Class = Class->getSuperClass();
429 }
430 return nullptr;
431 }
432
mergeClassExtensionProtocolList(ObjCProtocolDecl * const * ExtList,unsigned ExtNum,ASTContext & C)433 void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
434 ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
435 ASTContext &C) {
436 if (data().ExternallyCompleted)
437 LoadExternalDefinition();
438
439 if (data().AllReferencedProtocols.empty() &&
440 data().ReferencedProtocols.empty()) {
441 data().AllReferencedProtocols.set(ExtList, ExtNum, C);
442 return;
443 }
444
445 // Check for duplicate protocol in class's protocol list.
446 // This is O(n*m). But it is extremely rare and number of protocols in
447 // class or its extension are very few.
448 SmallVector<ObjCProtocolDecl *, 8> ProtocolRefs;
449 for (unsigned i = 0; i < ExtNum; i++) {
450 bool protocolExists = false;
451 ObjCProtocolDecl *ProtoInExtension = ExtList[i];
452 for (auto *Proto : all_referenced_protocols()) {
453 if (C.ProtocolCompatibleWithProtocol(ProtoInExtension, Proto)) {
454 protocolExists = true;
455 break;
456 }
457 }
458 // Do we want to warn on a protocol in extension class which
459 // already exist in the class? Probably not.
460 if (!protocolExists)
461 ProtocolRefs.push_back(ProtoInExtension);
462 }
463
464 if (ProtocolRefs.empty())
465 return;
466
467 // Merge ProtocolRefs into class's protocol list;
468 ProtocolRefs.append(all_referenced_protocol_begin(),
469 all_referenced_protocol_end());
470
471 data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),C);
472 }
473
474 const ObjCInterfaceDecl *
findInterfaceWithDesignatedInitializers() const475 ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers() const {
476 const ObjCInterfaceDecl *IFace = this;
477 while (IFace) {
478 if (IFace->hasDesignatedInitializers())
479 return IFace;
480 if (!IFace->inheritsDesignatedInitializers())
481 break;
482 IFace = IFace->getSuperClass();
483 }
484 return nullptr;
485 }
486
isIntroducingInitializers(const ObjCInterfaceDecl * D)487 static bool isIntroducingInitializers(const ObjCInterfaceDecl *D) {
488 for (const auto *MD : D->instance_methods()) {
489 if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
490 return true;
491 }
492 for (const auto *Ext : D->visible_extensions()) {
493 for (const auto *MD : Ext->instance_methods()) {
494 if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
495 return true;
496 }
497 }
498 if (const auto *ImplD = D->getImplementation()) {
499 for (const auto *MD : ImplD->instance_methods()) {
500 if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
501 return true;
502 }
503 }
504 return false;
505 }
506
inheritsDesignatedInitializers() const507 bool ObjCInterfaceDecl::inheritsDesignatedInitializers() const {
508 switch (data().InheritedDesignatedInitializers) {
509 case DefinitionData::IDI_Inherited:
510 return true;
511 case DefinitionData::IDI_NotInherited:
512 return false;
513 case DefinitionData::IDI_Unknown:
514 // If the class introduced initializers we conservatively assume that we
515 // don't know if any of them is a designated initializer to avoid possible
516 // misleading warnings.
517 if (isIntroducingInitializers(this)) {
518 data().InheritedDesignatedInitializers = DefinitionData::IDI_NotInherited;
519 } else {
520 if (auto SuperD = getSuperClass()) {
521 data().InheritedDesignatedInitializers =
522 SuperD->declaresOrInheritsDesignatedInitializers() ?
523 DefinitionData::IDI_Inherited :
524 DefinitionData::IDI_NotInherited;
525 } else {
526 data().InheritedDesignatedInitializers =
527 DefinitionData::IDI_NotInherited;
528 }
529 }
530 assert(data().InheritedDesignatedInitializers
531 != DefinitionData::IDI_Unknown);
532 return data().InheritedDesignatedInitializers ==
533 DefinitionData::IDI_Inherited;
534 }
535
536 llvm_unreachable("unexpected InheritedDesignatedInitializers value");
537 }
538
getDesignatedInitializers(llvm::SmallVectorImpl<const ObjCMethodDecl * > & Methods) const539 void ObjCInterfaceDecl::getDesignatedInitializers(
540 llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const {
541 // Check for a complete definition and recover if not so.
542 if (!isThisDeclarationADefinition())
543 return;
544 if (data().ExternallyCompleted)
545 LoadExternalDefinition();
546
547 const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
548 if (!IFace)
549 return;
550
551 for (const auto *MD : IFace->instance_methods())
552 if (MD->isThisDeclarationADesignatedInitializer())
553 Methods.push_back(MD);
554 for (const auto *Ext : IFace->visible_extensions()) {
555 for (const auto *MD : Ext->instance_methods())
556 if (MD->isThisDeclarationADesignatedInitializer())
557 Methods.push_back(MD);
558 }
559 }
560
isDesignatedInitializer(Selector Sel,const ObjCMethodDecl ** InitMethod) const561 bool ObjCInterfaceDecl::isDesignatedInitializer(Selector Sel,
562 const ObjCMethodDecl **InitMethod) const {
563 bool HasCompleteDef = isThisDeclarationADefinition();
564 // During deserialization the data record for the ObjCInterfaceDecl could
565 // be made invariant by reusing the canonical decl. Take this into account
566 // when checking for the complete definition.
567 if (!HasCompleteDef && getCanonicalDecl()->hasDefinition() &&
568 getCanonicalDecl()->getDefinition() == getDefinition())
569 HasCompleteDef = true;
570
571 // Check for a complete definition and recover if not so.
572 if (!HasCompleteDef)
573 return false;
574
575 if (data().ExternallyCompleted)
576 LoadExternalDefinition();
577
578 const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
579 if (!IFace)
580 return false;
581
582 if (const ObjCMethodDecl *MD = IFace->getInstanceMethod(Sel)) {
583 if (MD->isThisDeclarationADesignatedInitializer()) {
584 if (InitMethod)
585 *InitMethod = MD;
586 return true;
587 }
588 }
589 for (const auto *Ext : IFace->visible_extensions()) {
590 if (const ObjCMethodDecl *MD = Ext->getInstanceMethod(Sel)) {
591 if (MD->isThisDeclarationADesignatedInitializer()) {
592 if (InitMethod)
593 *InitMethod = MD;
594 return true;
595 }
596 }
597 }
598 return false;
599 }
600
allocateDefinitionData()601 void ObjCInterfaceDecl::allocateDefinitionData() {
602 assert(!hasDefinition() && "ObjC class already has a definition");
603 Data.setPointer(new (getASTContext()) DefinitionData());
604 Data.getPointer()->Definition = this;
605
606 // Make the type point at the definition, now that we have one.
607 if (TypeForDecl)
608 cast<ObjCInterfaceType>(TypeForDecl)->Decl = this;
609 }
610
startDefinition()611 void ObjCInterfaceDecl::startDefinition() {
612 allocateDefinitionData();
613
614 // Update all of the declarations with a pointer to the definition.
615 for (auto *RD : redecls()) {
616 if (RD != this)
617 RD->Data = Data;
618 }
619 }
620
lookupInstanceVariable(IdentifierInfo * ID,ObjCInterfaceDecl * & clsDeclared)621 ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
622 ObjCInterfaceDecl *&clsDeclared) {
623 // FIXME: Should make sure no callers ever do this.
624 if (!hasDefinition())
625 return nullptr;
626
627 if (data().ExternallyCompleted)
628 LoadExternalDefinition();
629
630 ObjCInterfaceDecl* ClassDecl = this;
631 while (ClassDecl != nullptr) {
632 if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
633 clsDeclared = ClassDecl;
634 return I;
635 }
636
637 for (const auto *Ext : ClassDecl->visible_extensions()) {
638 if (ObjCIvarDecl *I = Ext->getIvarDecl(ID)) {
639 clsDeclared = ClassDecl;
640 return I;
641 }
642 }
643
644 ClassDecl = ClassDecl->getSuperClass();
645 }
646 return nullptr;
647 }
648
649 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
650 /// class whose name is passed as argument. If it is not one of the super classes
651 /// the it returns NULL.
lookupInheritedClass(const IdentifierInfo * ICName)652 ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
653 const IdentifierInfo*ICName) {
654 // FIXME: Should make sure no callers ever do this.
655 if (!hasDefinition())
656 return nullptr;
657
658 if (data().ExternallyCompleted)
659 LoadExternalDefinition();
660
661 ObjCInterfaceDecl* ClassDecl = this;
662 while (ClassDecl != nullptr) {
663 if (ClassDecl->getIdentifier() == ICName)
664 return ClassDecl;
665 ClassDecl = ClassDecl->getSuperClass();
666 }
667 return nullptr;
668 }
669
670 ObjCProtocolDecl *
lookupNestedProtocol(IdentifierInfo * Name)671 ObjCInterfaceDecl::lookupNestedProtocol(IdentifierInfo *Name) {
672 for (auto *P : all_referenced_protocols())
673 if (P->lookupProtocolNamed(Name))
674 return P;
675 ObjCInterfaceDecl *SuperClass = getSuperClass();
676 return SuperClass ? SuperClass->lookupNestedProtocol(Name) : nullptr;
677 }
678
679 /// lookupMethod - This method returns an instance/class method by looking in
680 /// the class, its categories, and its super classes (using a linear search).
681 /// When argument category "C" is specified, any implicit method found
682 /// in this category is ignored.
lookupMethod(Selector Sel,bool isInstance,bool shallowCategoryLookup,bool followSuper,const ObjCCategoryDecl * C) const683 ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
684 bool isInstance,
685 bool shallowCategoryLookup,
686 bool followSuper,
687 const ObjCCategoryDecl *C) const
688 {
689 // FIXME: Should make sure no callers ever do this.
690 if (!hasDefinition())
691 return nullptr;
692
693 const ObjCInterfaceDecl* ClassDecl = this;
694 ObjCMethodDecl *MethodDecl = nullptr;
695
696 if (data().ExternallyCompleted)
697 LoadExternalDefinition();
698
699 while (ClassDecl) {
700 // 1. Look through primary class.
701 if ((MethodDecl = ClassDecl->getMethod(Sel, isInstance)))
702 return MethodDecl;
703
704 // 2. Didn't find one yet - now look through categories.
705 for (const auto *Cat : ClassDecl->visible_categories())
706 if ((MethodDecl = Cat->getMethod(Sel, isInstance)))
707 if (C != Cat || !MethodDecl->isImplicit())
708 return MethodDecl;
709
710 // 3. Didn't find one yet - look through primary class's protocols.
711 for (const auto *I : ClassDecl->protocols())
712 if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
713 return MethodDecl;
714
715 // 4. Didn't find one yet - now look through categories' protocols
716 if (!shallowCategoryLookup)
717 for (const auto *Cat : ClassDecl->visible_categories()) {
718 // Didn't find one yet - look through protocols.
719 const ObjCList<ObjCProtocolDecl> &Protocols =
720 Cat->getReferencedProtocols();
721 for (auto *Protocol : Protocols)
722 if ((MethodDecl = Protocol->lookupMethod(Sel, isInstance)))
723 if (C != Cat || !MethodDecl->isImplicit())
724 return MethodDecl;
725 }
726
727
728 if (!followSuper)
729 return nullptr;
730
731 // 5. Get to the super class (if any).
732 ClassDecl = ClassDecl->getSuperClass();
733 }
734 return nullptr;
735 }
736
737 // Will search "local" class/category implementations for a method decl.
738 // If failed, then we search in class's root for an instance method.
739 // Returns 0 if no method is found.
lookupPrivateMethod(const Selector & Sel,bool Instance) const740 ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
741 const Selector &Sel,
742 bool Instance) const {
743 // FIXME: Should make sure no callers ever do this.
744 if (!hasDefinition())
745 return nullptr;
746
747 if (data().ExternallyCompleted)
748 LoadExternalDefinition();
749
750 ObjCMethodDecl *Method = nullptr;
751 if (ObjCImplementationDecl *ImpDecl = getImplementation())
752 Method = Instance ? ImpDecl->getInstanceMethod(Sel)
753 : ImpDecl->getClassMethod(Sel);
754
755 // Look through local category implementations associated with the class.
756 if (!Method)
757 Method = getCategoryMethod(Sel, Instance);
758
759 // Before we give up, check if the selector is an instance method.
760 // But only in the root. This matches gcc's behavior and what the
761 // runtime expects.
762 if (!Instance && !Method && !getSuperClass()) {
763 Method = lookupInstanceMethod(Sel);
764 // Look through local category implementations associated
765 // with the root class.
766 if (!Method)
767 Method = lookupPrivateMethod(Sel, true);
768 }
769
770 if (!Method && getSuperClass())
771 return getSuperClass()->lookupPrivateMethod(Sel, Instance);
772 return Method;
773 }
774
775 //===----------------------------------------------------------------------===//
776 // ObjCMethodDecl
777 //===----------------------------------------------------------------------===//
778
ObjCMethodDecl(SourceLocation beginLoc,SourceLocation endLoc,Selector SelInfo,QualType T,TypeSourceInfo * ReturnTInfo,DeclContext * contextDecl,bool isInstance,bool isVariadic,bool isPropertyAccessor,bool isSynthesizedAccessorStub,bool isImplicitlyDeclared,bool isDefined,ImplementationControl impControl,bool HasRelatedResultType)779 ObjCMethodDecl::ObjCMethodDecl(
780 SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo,
781 QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl,
782 bool isInstance, bool isVariadic, bool isPropertyAccessor,
783 bool isSynthesizedAccessorStub, bool isImplicitlyDeclared, bool isDefined,
784 ImplementationControl impControl, bool HasRelatedResultType)
785 : NamedDecl(ObjCMethod, contextDecl, beginLoc, SelInfo),
786 DeclContext(ObjCMethod), MethodDeclType(T), ReturnTInfo(ReturnTInfo),
787 DeclEndLoc(endLoc) {
788
789 // Initialized the bits stored in DeclContext.
790 ObjCMethodDeclBits.Family =
791 static_cast<ObjCMethodFamily>(InvalidObjCMethodFamily);
792 setInstanceMethod(isInstance);
793 setVariadic(isVariadic);
794 setPropertyAccessor(isPropertyAccessor);
795 setSynthesizedAccessorStub(isSynthesizedAccessorStub);
796 setDefined(isDefined);
797 setIsRedeclaration(false);
798 setHasRedeclaration(false);
799 setDeclImplementation(impControl);
800 setObjCDeclQualifier(OBJC_TQ_None);
801 setRelatedResultType(HasRelatedResultType);
802 setSelLocsKind(SelLoc_StandardNoSpace);
803 setOverriding(false);
804 setHasSkippedBody(false);
805
806 setImplicit(isImplicitlyDeclared);
807 }
808
Create(ASTContext & C,SourceLocation beginLoc,SourceLocation endLoc,Selector SelInfo,QualType T,TypeSourceInfo * ReturnTInfo,DeclContext * contextDecl,bool isInstance,bool isVariadic,bool isPropertyAccessor,bool isSynthesizedAccessorStub,bool isImplicitlyDeclared,bool isDefined,ImplementationControl impControl,bool HasRelatedResultType)809 ObjCMethodDecl *ObjCMethodDecl::Create(
810 ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc,
811 Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo,
812 DeclContext *contextDecl, bool isInstance, bool isVariadic,
813 bool isPropertyAccessor, bool isSynthesizedAccessorStub,
814 bool isImplicitlyDeclared, bool isDefined, ImplementationControl impControl,
815 bool HasRelatedResultType) {
816 return new (C, contextDecl) ObjCMethodDecl(
817 beginLoc, endLoc, SelInfo, T, ReturnTInfo, contextDecl, isInstance,
818 isVariadic, isPropertyAccessor, isSynthesizedAccessorStub,
819 isImplicitlyDeclared, isDefined, impControl, HasRelatedResultType);
820 }
821
CreateDeserialized(ASTContext & C,unsigned ID)822 ObjCMethodDecl *ObjCMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
823 return new (C, ID) ObjCMethodDecl(SourceLocation(), SourceLocation(),
824 Selector(), QualType(), nullptr, nullptr);
825 }
826
isDirectMethod() const827 bool ObjCMethodDecl::isDirectMethod() const {
828 return hasAttr<ObjCDirectAttr>();
829 }
830
isThisDeclarationADesignatedInitializer() const831 bool ObjCMethodDecl::isThisDeclarationADesignatedInitializer() const {
832 return getMethodFamily() == OMF_init &&
833 hasAttr<ObjCDesignatedInitializerAttr>();
834 }
835
definedInNSObject(const ASTContext & Ctx) const836 bool ObjCMethodDecl::definedInNSObject(const ASTContext &Ctx) const {
837 if (const auto *PD = dyn_cast<const ObjCProtocolDecl>(getDeclContext()))
838 return PD->getIdentifier() == Ctx.getNSObjectName();
839 if (const auto *ID = dyn_cast<const ObjCInterfaceDecl>(getDeclContext()))
840 return ID->getIdentifier() == Ctx.getNSObjectName();
841 return false;
842 }
843
isDesignatedInitializerForTheInterface(const ObjCMethodDecl ** InitMethod) const844 bool ObjCMethodDecl::isDesignatedInitializerForTheInterface(
845 const ObjCMethodDecl **InitMethod) const {
846 if (getMethodFamily() != OMF_init)
847 return false;
848 const DeclContext *DC = getDeclContext();
849 if (isa<ObjCProtocolDecl>(DC))
850 return false;
851 if (const ObjCInterfaceDecl *ID = getClassInterface())
852 return ID->isDesignatedInitializer(getSelector(), InitMethod);
853 return false;
854 }
855
getBody() const856 Stmt *ObjCMethodDecl::getBody() const {
857 return Body.get(getASTContext().getExternalSource());
858 }
859
setAsRedeclaration(const ObjCMethodDecl * PrevMethod)860 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
861 assert(PrevMethod);
862 getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
863 setIsRedeclaration(true);
864 PrevMethod->setHasRedeclaration(true);
865 }
866
setParamsAndSelLocs(ASTContext & C,ArrayRef<ParmVarDecl * > Params,ArrayRef<SourceLocation> SelLocs)867 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
868 ArrayRef<ParmVarDecl*> Params,
869 ArrayRef<SourceLocation> SelLocs) {
870 ParamsAndSelLocs = nullptr;
871 NumParams = Params.size();
872 if (Params.empty() && SelLocs.empty())
873 return;
874
875 static_assert(alignof(ParmVarDecl *) >= alignof(SourceLocation),
876 "Alignment not sufficient for SourceLocation");
877
878 unsigned Size = sizeof(ParmVarDecl *) * NumParams +
879 sizeof(SourceLocation) * SelLocs.size();
880 ParamsAndSelLocs = C.Allocate(Size);
881 std::copy(Params.begin(), Params.end(), getParams());
882 std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
883 }
884
getSelectorLocs(SmallVectorImpl<SourceLocation> & SelLocs) const885 void ObjCMethodDecl::getSelectorLocs(
886 SmallVectorImpl<SourceLocation> &SelLocs) const {
887 for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
888 SelLocs.push_back(getSelectorLoc(i));
889 }
890
setMethodParams(ASTContext & C,ArrayRef<ParmVarDecl * > Params,ArrayRef<SourceLocation> SelLocs)891 void ObjCMethodDecl::setMethodParams(ASTContext &C,
892 ArrayRef<ParmVarDecl*> Params,
893 ArrayRef<SourceLocation> SelLocs) {
894 assert((!SelLocs.empty() || isImplicit()) &&
895 "No selector locs for non-implicit method");
896 if (isImplicit())
897 return setParamsAndSelLocs(C, Params, llvm::None);
898
899 setSelLocsKind(hasStandardSelectorLocs(getSelector(), SelLocs, Params,
900 DeclEndLoc));
901 if (getSelLocsKind() != SelLoc_NonStandard)
902 return setParamsAndSelLocs(C, Params, llvm::None);
903
904 setParamsAndSelLocs(C, Params, SelLocs);
905 }
906
907 /// A definition will return its interface declaration.
908 /// An interface declaration will return its definition.
909 /// Otherwise it will return itself.
getNextRedeclarationImpl()910 ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() {
911 ASTContext &Ctx = getASTContext();
912 ObjCMethodDecl *Redecl = nullptr;
913 if (hasRedeclaration())
914 Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
915 if (Redecl)
916 return Redecl;
917
918 auto *CtxD = cast<Decl>(getDeclContext());
919
920 if (!CtxD->isInvalidDecl()) {
921 if (auto *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
922 if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
923 if (!ImplD->isInvalidDecl())
924 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
925
926 } else if (auto *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
927 if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
928 if (!ImplD->isInvalidDecl())
929 Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
930
931 } else if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
932 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
933 if (!IFD->isInvalidDecl())
934 Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
935
936 } else if (auto *CImplD = dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
937 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
938 if (!CatD->isInvalidDecl())
939 Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
940 }
941 }
942
943 // Ensure that the discovered method redeclaration has a valid declaration
944 // context. Used to prevent infinite loops when iterating redeclarations in
945 // a partially invalid AST.
946 if (Redecl && cast<Decl>(Redecl->getDeclContext())->isInvalidDecl())
947 Redecl = nullptr;
948
949 if (!Redecl && isRedeclaration()) {
950 // This is the last redeclaration, go back to the first method.
951 return cast<ObjCContainerDecl>(CtxD)->getMethod(getSelector(),
952 isInstanceMethod());
953 }
954
955 return Redecl ? Redecl : this;
956 }
957
getCanonicalDecl()958 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
959 auto *CtxD = cast<Decl>(getDeclContext());
960 const auto &Sel = getSelector();
961
962 if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
963 if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) {
964 // When the container is the ObjCImplementationDecl (the primary
965 // @implementation), then the canonical Decl is either in
966 // the class Interface, or in any of its extension.
967 //
968 // So when we don't find it in the ObjCInterfaceDecl,
969 // sift through extensions too.
970 if (ObjCMethodDecl *MD = IFD->getMethod(Sel, isInstanceMethod()))
971 return MD;
972 for (auto *Ext : IFD->known_extensions())
973 if (ObjCMethodDecl *MD = Ext->getMethod(Sel, isInstanceMethod()))
974 return MD;
975 }
976 } else if (auto *CImplD = dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
977 if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
978 if (ObjCMethodDecl *MD = CatD->getMethod(Sel, isInstanceMethod()))
979 return MD;
980 }
981
982 if (isRedeclaration()) {
983 // It is possible that we have not done deserializing the ObjCMethod yet.
984 ObjCMethodDecl *MD =
985 cast<ObjCContainerDecl>(CtxD)->getMethod(Sel, isInstanceMethod());
986 return MD ? MD : this;
987 }
988
989 return this;
990 }
991
getEndLoc() const992 SourceLocation ObjCMethodDecl::getEndLoc() const {
993 if (Stmt *Body = getBody())
994 return Body->getEndLoc();
995 return DeclEndLoc;
996 }
997
getMethodFamily() const998 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
999 auto family = static_cast<ObjCMethodFamily>(ObjCMethodDeclBits.Family);
1000 if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
1001 return family;
1002
1003 // Check for an explicit attribute.
1004 if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
1005 // The unfortunate necessity of mapping between enums here is due
1006 // to the attributes framework.
1007 switch (attr->getFamily()) {
1008 case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
1009 case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
1010 case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
1011 case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
1012 case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
1013 case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
1014 }
1015 ObjCMethodDeclBits.Family = family;
1016 return family;
1017 }
1018
1019 family = getSelector().getMethodFamily();
1020 switch (family) {
1021 case OMF_None: break;
1022
1023 // init only has a conventional meaning for an instance method, and
1024 // it has to return an object.
1025 case OMF_init:
1026 if (!isInstanceMethod() || !getReturnType()->isObjCObjectPointerType())
1027 family = OMF_None;
1028 break;
1029
1030 // alloc/copy/new have a conventional meaning for both class and
1031 // instance methods, but they require an object return.
1032 case OMF_alloc:
1033 case OMF_copy:
1034 case OMF_mutableCopy:
1035 case OMF_new:
1036 if (!getReturnType()->isObjCObjectPointerType())
1037 family = OMF_None;
1038 break;
1039
1040 // These selectors have a conventional meaning only for instance methods.
1041 case OMF_dealloc:
1042 case OMF_finalize:
1043 case OMF_retain:
1044 case OMF_release:
1045 case OMF_autorelease:
1046 case OMF_retainCount:
1047 case OMF_self:
1048 if (!isInstanceMethod())
1049 family = OMF_None;
1050 break;
1051
1052 case OMF_initialize:
1053 if (isInstanceMethod() || !getReturnType()->isVoidType())
1054 family = OMF_None;
1055 break;
1056
1057 case OMF_performSelector:
1058 if (!isInstanceMethod() || !getReturnType()->isObjCIdType())
1059 family = OMF_None;
1060 else {
1061 unsigned noParams = param_size();
1062 if (noParams < 1 || noParams > 3)
1063 family = OMF_None;
1064 else {
1065 ObjCMethodDecl::param_type_iterator it = param_type_begin();
1066 QualType ArgT = (*it);
1067 if (!ArgT->isObjCSelType()) {
1068 family = OMF_None;
1069 break;
1070 }
1071 while (--noParams) {
1072 it++;
1073 ArgT = (*it);
1074 if (!ArgT->isObjCIdType()) {
1075 family = OMF_None;
1076 break;
1077 }
1078 }
1079 }
1080 }
1081 break;
1082
1083 }
1084
1085 // Cache the result.
1086 ObjCMethodDeclBits.Family = family;
1087 return family;
1088 }
1089
getSelfType(ASTContext & Context,const ObjCInterfaceDecl * OID,bool & selfIsPseudoStrong,bool & selfIsConsumed) const1090 QualType ObjCMethodDecl::getSelfType(ASTContext &Context,
1091 const ObjCInterfaceDecl *OID,
1092 bool &selfIsPseudoStrong,
1093 bool &selfIsConsumed) const {
1094 QualType selfTy;
1095 selfIsPseudoStrong = false;
1096 selfIsConsumed = false;
1097 if (isInstanceMethod()) {
1098 // There may be no interface context due to error in declaration
1099 // of the interface (which has been reported). Recover gracefully.
1100 if (OID) {
1101 selfTy = Context.getObjCInterfaceType(OID);
1102 selfTy = Context.getObjCObjectPointerType(selfTy);
1103 } else {
1104 selfTy = Context.getObjCIdType();
1105 }
1106 } else // we have a factory method.
1107 selfTy = Context.getObjCClassType();
1108
1109 if (Context.getLangOpts().ObjCAutoRefCount) {
1110 if (isInstanceMethod()) {
1111 selfIsConsumed = hasAttr<NSConsumesSelfAttr>();
1112
1113 // 'self' is always __strong. It's actually pseudo-strong except
1114 // in init methods (or methods labeled ns_consumes_self), though.
1115 Qualifiers qs;
1116 qs.setObjCLifetime(Qualifiers::OCL_Strong);
1117 selfTy = Context.getQualifiedType(selfTy, qs);
1118
1119 // In addition, 'self' is const unless this is an init method.
1120 if (getMethodFamily() != OMF_init && !selfIsConsumed) {
1121 selfTy = selfTy.withConst();
1122 selfIsPseudoStrong = true;
1123 }
1124 }
1125 else {
1126 assert(isClassMethod());
1127 // 'self' is always const in class methods.
1128 selfTy = selfTy.withConst();
1129 selfIsPseudoStrong = true;
1130 }
1131 }
1132 return selfTy;
1133 }
1134
createImplicitParams(ASTContext & Context,const ObjCInterfaceDecl * OID)1135 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
1136 const ObjCInterfaceDecl *OID) {
1137 bool selfIsPseudoStrong, selfIsConsumed;
1138 QualType selfTy =
1139 getSelfType(Context, OID, selfIsPseudoStrong, selfIsConsumed);
1140 auto *Self = ImplicitParamDecl::Create(Context, this, SourceLocation(),
1141 &Context.Idents.get("self"), selfTy,
1142 ImplicitParamDecl::ObjCSelf);
1143 setSelfDecl(Self);
1144
1145 if (selfIsConsumed)
1146 Self->addAttr(NSConsumedAttr::CreateImplicit(Context));
1147
1148 if (selfIsPseudoStrong)
1149 Self->setARCPseudoStrong(true);
1150
1151 setCmdDecl(ImplicitParamDecl::Create(
1152 Context, this, SourceLocation(), &Context.Idents.get("_cmd"),
1153 Context.getObjCSelType(), ImplicitParamDecl::ObjCCmd));
1154 }
1155
getClassInterface()1156 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
1157 if (auto *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
1158 return ID;
1159 if (auto *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
1160 return CD->getClassInterface();
1161 if (auto *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
1162 return IMD->getClassInterface();
1163 if (isa<ObjCProtocolDecl>(getDeclContext()))
1164 return nullptr;
1165 llvm_unreachable("unknown method context");
1166 }
1167
getReturnTypeSourceRange() const1168 SourceRange ObjCMethodDecl::getReturnTypeSourceRange() const {
1169 const auto *TSI = getReturnTypeSourceInfo();
1170 if (TSI)
1171 return TSI->getTypeLoc().getSourceRange();
1172 return SourceRange();
1173 }
1174
getSendResultType() const1175 QualType ObjCMethodDecl::getSendResultType() const {
1176 ASTContext &Ctx = getASTContext();
1177 return getReturnType().getNonLValueExprType(Ctx)
1178 .substObjCTypeArgs(Ctx, {}, ObjCSubstitutionContext::Result);
1179 }
1180
getSendResultType(QualType receiverType) const1181 QualType ObjCMethodDecl::getSendResultType(QualType receiverType) const {
1182 // FIXME: Handle related result types here.
1183
1184 return getReturnType().getNonLValueExprType(getASTContext())
1185 .substObjCMemberType(receiverType, getDeclContext(),
1186 ObjCSubstitutionContext::Result);
1187 }
1188
CollectOverriddenMethodsRecurse(const ObjCContainerDecl * Container,const ObjCMethodDecl * Method,SmallVectorImpl<const ObjCMethodDecl * > & Methods,bool MovedToSuper)1189 static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
1190 const ObjCMethodDecl *Method,
1191 SmallVectorImpl<const ObjCMethodDecl *> &Methods,
1192 bool MovedToSuper) {
1193 if (!Container)
1194 return;
1195
1196 // In categories look for overridden methods from protocols. A method from
1197 // category is not "overridden" since it is considered as the "same" method
1198 // (same USR) as the one from the interface.
1199 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
1200 // Check whether we have a matching method at this category but only if we
1201 // are at the super class level.
1202 if (MovedToSuper)
1203 if (ObjCMethodDecl *
1204 Overridden = Container->getMethod(Method->getSelector(),
1205 Method->isInstanceMethod(),
1206 /*AllowHidden=*/true))
1207 if (Method != Overridden) {
1208 // We found an override at this category; there is no need to look
1209 // into its protocols.
1210 Methods.push_back(Overridden);
1211 return;
1212 }
1213
1214 for (const auto *P : Category->protocols())
1215 CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
1216 return;
1217 }
1218
1219 // Check whether we have a matching method at this level.
1220 if (const ObjCMethodDecl *
1221 Overridden = Container->getMethod(Method->getSelector(),
1222 Method->isInstanceMethod(),
1223 /*AllowHidden=*/true))
1224 if (Method != Overridden) {
1225 // We found an override at this level; there is no need to look
1226 // into other protocols or categories.
1227 Methods.push_back(Overridden);
1228 return;
1229 }
1230
1231 if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
1232 for (const auto *P : Protocol->protocols())
1233 CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
1234 }
1235
1236 if (const auto *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
1237 for (const auto *P : Interface->protocols())
1238 CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
1239
1240 for (const auto *Cat : Interface->known_categories())
1241 CollectOverriddenMethodsRecurse(Cat, Method, Methods, MovedToSuper);
1242
1243 if (const ObjCInterfaceDecl *Super = Interface->getSuperClass())
1244 return CollectOverriddenMethodsRecurse(Super, Method, Methods,
1245 /*MovedToSuper=*/true);
1246 }
1247 }
1248
CollectOverriddenMethods(const ObjCContainerDecl * Container,const ObjCMethodDecl * Method,SmallVectorImpl<const ObjCMethodDecl * > & Methods)1249 static inline void CollectOverriddenMethods(const ObjCContainerDecl *Container,
1250 const ObjCMethodDecl *Method,
1251 SmallVectorImpl<const ObjCMethodDecl *> &Methods) {
1252 CollectOverriddenMethodsRecurse(Container, Method, Methods,
1253 /*MovedToSuper=*/false);
1254 }
1255
collectOverriddenMethodsSlow(const ObjCMethodDecl * Method,SmallVectorImpl<const ObjCMethodDecl * > & overridden)1256 static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
1257 SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
1258 assert(Method->isOverriding());
1259
1260 if (const auto *ProtD =
1261 dyn_cast<ObjCProtocolDecl>(Method->getDeclContext())) {
1262 CollectOverriddenMethods(ProtD, Method, overridden);
1263
1264 } else if (const auto *IMD =
1265 dyn_cast<ObjCImplDecl>(Method->getDeclContext())) {
1266 const ObjCInterfaceDecl *ID = IMD->getClassInterface();
1267 if (!ID)
1268 return;
1269 // Start searching for overridden methods using the method from the
1270 // interface as starting point.
1271 if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
1272 Method->isInstanceMethod(),
1273 /*AllowHidden=*/true))
1274 Method = IFaceMeth;
1275 CollectOverriddenMethods(ID, Method, overridden);
1276
1277 } else if (const auto *CatD =
1278 dyn_cast<ObjCCategoryDecl>(Method->getDeclContext())) {
1279 const ObjCInterfaceDecl *ID = CatD->getClassInterface();
1280 if (!ID)
1281 return;
1282 // Start searching for overridden methods using the method from the
1283 // interface as starting point.
1284 if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
1285 Method->isInstanceMethod(),
1286 /*AllowHidden=*/true))
1287 Method = IFaceMeth;
1288 CollectOverriddenMethods(ID, Method, overridden);
1289
1290 } else {
1291 CollectOverriddenMethods(
1292 dyn_cast_or_null<ObjCContainerDecl>(Method->getDeclContext()),
1293 Method, overridden);
1294 }
1295 }
1296
getOverriddenMethods(SmallVectorImpl<const ObjCMethodDecl * > & Overridden) const1297 void ObjCMethodDecl::getOverriddenMethods(
1298 SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const {
1299 const ObjCMethodDecl *Method = this;
1300
1301 if (Method->isRedeclaration()) {
1302 Method = cast<ObjCContainerDecl>(Method->getDeclContext())->
1303 getMethod(Method->getSelector(), Method->isInstanceMethod());
1304 }
1305
1306 if (Method->isOverriding()) {
1307 collectOverriddenMethodsSlow(Method, Overridden);
1308 assert(!Overridden.empty() &&
1309 "ObjCMethodDecl's overriding bit is not as expected");
1310 }
1311 }
1312
1313 const ObjCPropertyDecl *
findPropertyDecl(bool CheckOverrides) const1314 ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
1315 Selector Sel = getSelector();
1316 unsigned NumArgs = Sel.getNumArgs();
1317 if (NumArgs > 1)
1318 return nullptr;
1319
1320 if (isPropertyAccessor()) {
1321 const auto *Container = cast<ObjCContainerDecl>(getParent());
1322 // For accessor stubs, go back to the interface.
1323 if (auto *ImplDecl = dyn_cast<ObjCImplDecl>(Container))
1324 if (isSynthesizedAccessorStub())
1325 Container = ImplDecl->getClassInterface();
1326
1327 bool IsGetter = (NumArgs == 0);
1328 bool IsInstance = isInstanceMethod();
1329
1330 /// Local function that attempts to find a matching property within the
1331 /// given Objective-C container.
1332 auto findMatchingProperty =
1333 [&](const ObjCContainerDecl *Container) -> const ObjCPropertyDecl * {
1334 if (IsInstance) {
1335 for (const auto *I : Container->instance_properties()) {
1336 Selector NextSel = IsGetter ? I->getGetterName()
1337 : I->getSetterName();
1338 if (NextSel == Sel)
1339 return I;
1340 }
1341 } else {
1342 for (const auto *I : Container->class_properties()) {
1343 Selector NextSel = IsGetter ? I->getGetterName()
1344 : I->getSetterName();
1345 if (NextSel == Sel)
1346 return I;
1347 }
1348 }
1349
1350 return nullptr;
1351 };
1352
1353 // Look in the container we were given.
1354 if (const auto *Found = findMatchingProperty(Container))
1355 return Found;
1356
1357 // If we're in a category or extension, look in the main class.
1358 const ObjCInterfaceDecl *ClassDecl = nullptr;
1359 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
1360 ClassDecl = Category->getClassInterface();
1361 if (const auto *Found = findMatchingProperty(ClassDecl))
1362 return Found;
1363 } else {
1364 // Determine whether the container is a class.
1365 ClassDecl = cast<ObjCInterfaceDecl>(Container);
1366 }
1367 assert(ClassDecl && "Failed to find main class");
1368
1369 // If we have a class, check its visible extensions.
1370 for (const auto *Ext : ClassDecl->visible_extensions()) {
1371 if (Ext == Container)
1372 continue;
1373 if (const auto *Found = findMatchingProperty(Ext))
1374 return Found;
1375 }
1376
1377 assert(isSynthesizedAccessorStub() && "expected an accessor stub");
1378
1379 for (const auto *Cat : ClassDecl->known_categories()) {
1380 if (Cat == Container)
1381 continue;
1382 if (const auto *Found = findMatchingProperty(Cat))
1383 return Found;
1384 }
1385
1386 llvm_unreachable("Marked as a property accessor but no property found!");
1387 }
1388
1389 if (!CheckOverrides)
1390 return nullptr;
1391
1392 using OverridesTy = SmallVector<const ObjCMethodDecl *, 8>;
1393
1394 OverridesTy Overrides;
1395 getOverriddenMethods(Overrides);
1396 for (const auto *Override : Overrides)
1397 if (const ObjCPropertyDecl *Prop = Override->findPropertyDecl(false))
1398 return Prop;
1399
1400 return nullptr;
1401 }
1402
1403 //===----------------------------------------------------------------------===//
1404 // ObjCTypeParamDecl
1405 //===----------------------------------------------------------------------===//
1406
anchor()1407 void ObjCTypeParamDecl::anchor() {}
1408
Create(ASTContext & ctx,DeclContext * dc,ObjCTypeParamVariance variance,SourceLocation varianceLoc,unsigned index,SourceLocation nameLoc,IdentifierInfo * name,SourceLocation colonLoc,TypeSourceInfo * boundInfo)1409 ObjCTypeParamDecl *ObjCTypeParamDecl::Create(ASTContext &ctx, DeclContext *dc,
1410 ObjCTypeParamVariance variance,
1411 SourceLocation varianceLoc,
1412 unsigned index,
1413 SourceLocation nameLoc,
1414 IdentifierInfo *name,
1415 SourceLocation colonLoc,
1416 TypeSourceInfo *boundInfo) {
1417 auto *TPDecl =
1418 new (ctx, dc) ObjCTypeParamDecl(ctx, dc, variance, varianceLoc, index,
1419 nameLoc, name, colonLoc, boundInfo);
1420 QualType TPType = ctx.getObjCTypeParamType(TPDecl, {});
1421 TPDecl->setTypeForDecl(TPType.getTypePtr());
1422 return TPDecl;
1423 }
1424
CreateDeserialized(ASTContext & ctx,unsigned ID)1425 ObjCTypeParamDecl *ObjCTypeParamDecl::CreateDeserialized(ASTContext &ctx,
1426 unsigned ID) {
1427 return new (ctx, ID) ObjCTypeParamDecl(ctx, nullptr,
1428 ObjCTypeParamVariance::Invariant,
1429 SourceLocation(), 0, SourceLocation(),
1430 nullptr, SourceLocation(), nullptr);
1431 }
1432
getSourceRange() const1433 SourceRange ObjCTypeParamDecl::getSourceRange() const {
1434 SourceLocation startLoc = VarianceLoc;
1435 if (startLoc.isInvalid())
1436 startLoc = getLocation();
1437
1438 if (hasExplicitBound()) {
1439 return SourceRange(startLoc,
1440 getTypeSourceInfo()->getTypeLoc().getEndLoc());
1441 }
1442
1443 return SourceRange(startLoc);
1444 }
1445
1446 //===----------------------------------------------------------------------===//
1447 // ObjCTypeParamList
1448 //===----------------------------------------------------------------------===//
ObjCTypeParamList(SourceLocation lAngleLoc,ArrayRef<ObjCTypeParamDecl * > typeParams,SourceLocation rAngleLoc)1449 ObjCTypeParamList::ObjCTypeParamList(SourceLocation lAngleLoc,
1450 ArrayRef<ObjCTypeParamDecl *> typeParams,
1451 SourceLocation rAngleLoc)
1452 : NumParams(typeParams.size()) {
1453 Brackets.Begin = lAngleLoc.getRawEncoding();
1454 Brackets.End = rAngleLoc.getRawEncoding();
1455 std::copy(typeParams.begin(), typeParams.end(), begin());
1456 }
1457
create(ASTContext & ctx,SourceLocation lAngleLoc,ArrayRef<ObjCTypeParamDecl * > typeParams,SourceLocation rAngleLoc)1458 ObjCTypeParamList *ObjCTypeParamList::create(
1459 ASTContext &ctx,
1460 SourceLocation lAngleLoc,
1461 ArrayRef<ObjCTypeParamDecl *> typeParams,
1462 SourceLocation rAngleLoc) {
1463 void *mem =
1464 ctx.Allocate(totalSizeToAlloc<ObjCTypeParamDecl *>(typeParams.size()),
1465 alignof(ObjCTypeParamList));
1466 return new (mem) ObjCTypeParamList(lAngleLoc, typeParams, rAngleLoc);
1467 }
1468
gatherDefaultTypeArgs(SmallVectorImpl<QualType> & typeArgs) const1469 void ObjCTypeParamList::gatherDefaultTypeArgs(
1470 SmallVectorImpl<QualType> &typeArgs) const {
1471 typeArgs.reserve(size());
1472 for (auto typeParam : *this)
1473 typeArgs.push_back(typeParam->getUnderlyingType());
1474 }
1475
1476 //===----------------------------------------------------------------------===//
1477 // ObjCInterfaceDecl
1478 //===----------------------------------------------------------------------===//
1479
Create(const ASTContext & C,DeclContext * DC,SourceLocation atLoc,IdentifierInfo * Id,ObjCTypeParamList * typeParamList,ObjCInterfaceDecl * PrevDecl,SourceLocation ClassLoc,bool isInternal)1480 ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
1481 DeclContext *DC,
1482 SourceLocation atLoc,
1483 IdentifierInfo *Id,
1484 ObjCTypeParamList *typeParamList,
1485 ObjCInterfaceDecl *PrevDecl,
1486 SourceLocation ClassLoc,
1487 bool isInternal){
1488 auto *Result = new (C, DC)
1489 ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
1490 isInternal);
1491 Result->Data.setInt(!C.getLangOpts().Modules);
1492 C.getObjCInterfaceType(Result, PrevDecl);
1493 return Result;
1494 }
1495
CreateDeserialized(const ASTContext & C,unsigned ID)1496 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
1497 unsigned ID) {
1498 auto *Result = new (C, ID)
1499 ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr,
1500 SourceLocation(), nullptr, false);
1501 Result->Data.setInt(!C.getLangOpts().Modules);
1502 return Result;
1503 }
1504
ObjCInterfaceDecl(const ASTContext & C,DeclContext * DC,SourceLocation AtLoc,IdentifierInfo * Id,ObjCTypeParamList * typeParamList,SourceLocation CLoc,ObjCInterfaceDecl * PrevDecl,bool IsInternal)1505 ObjCInterfaceDecl::ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC,
1506 SourceLocation AtLoc, IdentifierInfo *Id,
1507 ObjCTypeParamList *typeParamList,
1508 SourceLocation CLoc,
1509 ObjCInterfaceDecl *PrevDecl,
1510 bool IsInternal)
1511 : ObjCContainerDecl(ObjCInterface, DC, Id, CLoc, AtLoc),
1512 redeclarable_base(C) {
1513 setPreviousDecl(PrevDecl);
1514
1515 // Copy the 'data' pointer over.
1516 if (PrevDecl)
1517 Data = PrevDecl->Data;
1518
1519 setImplicit(IsInternal);
1520
1521 setTypeParamList(typeParamList);
1522 }
1523
LoadExternalDefinition() const1524 void ObjCInterfaceDecl::LoadExternalDefinition() const {
1525 assert(data().ExternallyCompleted && "Class is not externally completed");
1526 data().ExternallyCompleted = false;
1527 getASTContext().getExternalSource()->CompleteType(
1528 const_cast<ObjCInterfaceDecl *>(this));
1529 }
1530
setExternallyCompleted()1531 void ObjCInterfaceDecl::setExternallyCompleted() {
1532 assert(getASTContext().getExternalSource() &&
1533 "Class can't be externally completed without an external source");
1534 assert(hasDefinition() &&
1535 "Forward declarations can't be externally completed");
1536 data().ExternallyCompleted = true;
1537 }
1538
setHasDesignatedInitializers()1539 void ObjCInterfaceDecl::setHasDesignatedInitializers() {
1540 // Check for a complete definition and recover if not so.
1541 if (!isThisDeclarationADefinition())
1542 return;
1543 data().HasDesignatedInitializers = true;
1544 }
1545
hasDesignatedInitializers() const1546 bool ObjCInterfaceDecl::hasDesignatedInitializers() const {
1547 // Check for a complete definition and recover if not so.
1548 if (!isThisDeclarationADefinition())
1549 return false;
1550 if (data().ExternallyCompleted)
1551 LoadExternalDefinition();
1552
1553 return data().HasDesignatedInitializers;
1554 }
1555
1556 StringRef
getObjCRuntimeNameAsString() const1557 ObjCInterfaceDecl::getObjCRuntimeNameAsString() const {
1558 if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
1559 return ObjCRTName->getMetadataName();
1560
1561 return getName();
1562 }
1563
1564 StringRef
getObjCRuntimeNameAsString() const1565 ObjCImplementationDecl::getObjCRuntimeNameAsString() const {
1566 if (ObjCInterfaceDecl *ID =
1567 const_cast<ObjCImplementationDecl*>(this)->getClassInterface())
1568 return ID->getObjCRuntimeNameAsString();
1569
1570 return getName();
1571 }
1572
getImplementation() const1573 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
1574 if (const ObjCInterfaceDecl *Def = getDefinition()) {
1575 if (data().ExternallyCompleted)
1576 LoadExternalDefinition();
1577
1578 return getASTContext().getObjCImplementation(
1579 const_cast<ObjCInterfaceDecl*>(Def));
1580 }
1581
1582 // FIXME: Should make sure no callers ever do this.
1583 return nullptr;
1584 }
1585
setImplementation(ObjCImplementationDecl * ImplD)1586 void ObjCInterfaceDecl::setImplementation(ObjCImplementationDecl *ImplD) {
1587 getASTContext().setObjCImplementation(getDefinition(), ImplD);
1588 }
1589
1590 namespace {
1591
1592 struct SynthesizeIvarChunk {
1593 uint64_t Size;
1594 ObjCIvarDecl *Ivar;
1595
SynthesizeIvarChunk__anon5de0dcd90211::SynthesizeIvarChunk1596 SynthesizeIvarChunk(uint64_t size, ObjCIvarDecl *ivar)
1597 : Size(size), Ivar(ivar) {}
1598 };
1599
operator <(const SynthesizeIvarChunk & LHS,const SynthesizeIvarChunk & RHS)1600 bool operator<(const SynthesizeIvarChunk & LHS,
1601 const SynthesizeIvarChunk &RHS) {
1602 return LHS.Size < RHS.Size;
1603 }
1604
1605 } // namespace
1606
1607 /// all_declared_ivar_begin - return first ivar declared in this class,
1608 /// its extensions and its implementation. Lazily build the list on first
1609 /// access.
1610 ///
1611 /// Caveat: The list returned by this method reflects the current
1612 /// state of the parser. The cache will be updated for every ivar
1613 /// added by an extension or the implementation when they are
1614 /// encountered.
1615 /// See also ObjCIvarDecl::Create().
all_declared_ivar_begin()1616 ObjCIvarDecl *ObjCInterfaceDecl::all_declared_ivar_begin() {
1617 // FIXME: Should make sure no callers ever do this.
1618 if (!hasDefinition())
1619 return nullptr;
1620
1621 ObjCIvarDecl *curIvar = nullptr;
1622 if (!data().IvarList) {
1623 if (!ivar_empty()) {
1624 ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
1625 data().IvarList = *I; ++I;
1626 for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
1627 curIvar->setNextIvar(*I);
1628 }
1629
1630 for (const auto *Ext : known_extensions()) {
1631 if (!Ext->ivar_empty()) {
1632 ObjCCategoryDecl::ivar_iterator
1633 I = Ext->ivar_begin(),
1634 E = Ext->ivar_end();
1635 if (!data().IvarList) {
1636 data().IvarList = *I; ++I;
1637 curIvar = data().IvarList;
1638 }
1639 for ( ;I != E; curIvar = *I, ++I)
1640 curIvar->setNextIvar(*I);
1641 }
1642 }
1643 data().IvarListMissingImplementation = true;
1644 }
1645
1646 // cached and complete!
1647 if (!data().IvarListMissingImplementation)
1648 return data().IvarList;
1649
1650 if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
1651 data().IvarListMissingImplementation = false;
1652 if (!ImplDecl->ivar_empty()) {
1653 SmallVector<SynthesizeIvarChunk, 16> layout;
1654 for (auto *IV : ImplDecl->ivars()) {
1655 if (IV->getSynthesize() && !IV->isInvalidDecl()) {
1656 layout.push_back(SynthesizeIvarChunk(
1657 IV->getASTContext().getTypeSize(IV->getType()), IV));
1658 continue;
1659 }
1660 if (!data().IvarList)
1661 data().IvarList = IV;
1662 else
1663 curIvar->setNextIvar(IV);
1664 curIvar = IV;
1665 }
1666
1667 if (!layout.empty()) {
1668 // Order synthesized ivars by their size.
1669 llvm::stable_sort(layout);
1670 unsigned Ix = 0, EIx = layout.size();
1671 if (!data().IvarList) {
1672 data().IvarList = layout[0].Ivar; Ix++;
1673 curIvar = data().IvarList;
1674 }
1675 for ( ; Ix != EIx; curIvar = layout[Ix].Ivar, Ix++)
1676 curIvar->setNextIvar(layout[Ix].Ivar);
1677 }
1678 }
1679 }
1680 return data().IvarList;
1681 }
1682
1683 /// FindCategoryDeclaration - Finds category declaration in the list of
1684 /// categories for this class and returns it. Name of the category is passed
1685 /// in 'CategoryId'. If category not found, return 0;
1686 ///
1687 ObjCCategoryDecl *
FindCategoryDeclaration(IdentifierInfo * CategoryId) const1688 ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
1689 // FIXME: Should make sure no callers ever do this.
1690 if (!hasDefinition())
1691 return nullptr;
1692
1693 if (data().ExternallyCompleted)
1694 LoadExternalDefinition();
1695
1696 for (auto *Cat : visible_categories())
1697 if (Cat->getIdentifier() == CategoryId)
1698 return Cat;
1699
1700 return nullptr;
1701 }
1702
1703 ObjCMethodDecl *
getCategoryInstanceMethod(Selector Sel) const1704 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
1705 for (const auto *Cat : visible_categories()) {
1706 if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
1707 if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
1708 return MD;
1709 }
1710
1711 return nullptr;
1712 }
1713
getCategoryClassMethod(Selector Sel) const1714 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
1715 for (const auto *Cat : visible_categories()) {
1716 if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
1717 if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
1718 return MD;
1719 }
1720
1721 return nullptr;
1722 }
1723
1724 /// ClassImplementsProtocol - Checks that 'lProto' protocol
1725 /// has been implemented in IDecl class, its super class or categories (if
1726 /// lookupCategory is true).
ClassImplementsProtocol(ObjCProtocolDecl * lProto,bool lookupCategory,bool RHSIsQualifiedID)1727 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
1728 bool lookupCategory,
1729 bool RHSIsQualifiedID) {
1730 if (!hasDefinition())
1731 return false;
1732
1733 ObjCInterfaceDecl *IDecl = this;
1734 // 1st, look up the class.
1735 for (auto *PI : IDecl->protocols()){
1736 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
1737 return true;
1738 // This is dubious and is added to be compatible with gcc. In gcc, it is
1739 // also allowed assigning a protocol-qualified 'id' type to a LHS object
1740 // when protocol in qualified LHS is in list of protocols in the rhs 'id'
1741 // object. This IMO, should be a bug.
1742 // FIXME: Treat this as an extension, and flag this as an error when GCC
1743 // extensions are not enabled.
1744 if (RHSIsQualifiedID &&
1745 getASTContext().ProtocolCompatibleWithProtocol(PI, lProto))
1746 return true;
1747 }
1748
1749 // 2nd, look up the category.
1750 if (lookupCategory)
1751 for (const auto *Cat : visible_categories()) {
1752 for (auto *PI : Cat->protocols())
1753 if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
1754 return true;
1755 }
1756
1757 // 3rd, look up the super class(s)
1758 if (IDecl->getSuperClass())
1759 return
1760 IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
1761 RHSIsQualifiedID);
1762
1763 return false;
1764 }
1765
1766 //===----------------------------------------------------------------------===//
1767 // ObjCIvarDecl
1768 //===----------------------------------------------------------------------===//
1769
anchor()1770 void ObjCIvarDecl::anchor() {}
1771
Create(ASTContext & C,ObjCContainerDecl * DC,SourceLocation StartLoc,SourceLocation IdLoc,IdentifierInfo * Id,QualType T,TypeSourceInfo * TInfo,AccessControl ac,Expr * BW,bool synthesized)1772 ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
1773 SourceLocation StartLoc,
1774 SourceLocation IdLoc, IdentifierInfo *Id,
1775 QualType T, TypeSourceInfo *TInfo,
1776 AccessControl ac, Expr *BW,
1777 bool synthesized) {
1778 if (DC) {
1779 // Ivar's can only appear in interfaces, implementations (via synthesized
1780 // properties), and class extensions (via direct declaration, or synthesized
1781 // properties).
1782 //
1783 // FIXME: This should really be asserting this:
1784 // (isa<ObjCCategoryDecl>(DC) &&
1785 // cast<ObjCCategoryDecl>(DC)->IsClassExtension()))
1786 // but unfortunately we sometimes place ivars into non-class extension
1787 // categories on error. This breaks an AST invariant, and should not be
1788 // fixed.
1789 assert((isa<ObjCInterfaceDecl>(DC) || isa<ObjCImplementationDecl>(DC) ||
1790 isa<ObjCCategoryDecl>(DC)) &&
1791 "Invalid ivar decl context!");
1792 // Once a new ivar is created in any of class/class-extension/implementation
1793 // decl contexts, the previously built IvarList must be rebuilt.
1794 auto *ID = dyn_cast<ObjCInterfaceDecl>(DC);
1795 if (!ID) {
1796 if (auto *IM = dyn_cast<ObjCImplementationDecl>(DC))
1797 ID = IM->getClassInterface();
1798 else
1799 ID = cast<ObjCCategoryDecl>(DC)->getClassInterface();
1800 }
1801 ID->setIvarList(nullptr);
1802 }
1803
1804 return new (C, DC) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo, ac, BW,
1805 synthesized);
1806 }
1807
CreateDeserialized(ASTContext & C,unsigned ID)1808 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1809 return new (C, ID) ObjCIvarDecl(nullptr, SourceLocation(), SourceLocation(),
1810 nullptr, QualType(), nullptr,
1811 ObjCIvarDecl::None, nullptr, false);
1812 }
1813
getContainingInterface() const1814 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
1815 const auto *DC = cast<ObjCContainerDecl>(getDeclContext());
1816
1817 switch (DC->getKind()) {
1818 default:
1819 case ObjCCategoryImpl:
1820 case ObjCProtocol:
1821 llvm_unreachable("invalid ivar container!");
1822
1823 // Ivars can only appear in class extension categories.
1824 case ObjCCategory: {
1825 const auto *CD = cast<ObjCCategoryDecl>(DC);
1826 assert(CD->IsClassExtension() && "invalid container for ivar!");
1827 return CD->getClassInterface();
1828 }
1829
1830 case ObjCImplementation:
1831 return cast<ObjCImplementationDecl>(DC)->getClassInterface();
1832
1833 case ObjCInterface:
1834 return cast<ObjCInterfaceDecl>(DC);
1835 }
1836 }
1837
getUsageType(QualType objectType) const1838 QualType ObjCIvarDecl::getUsageType(QualType objectType) const {
1839 return getType().substObjCMemberType(objectType, getDeclContext(),
1840 ObjCSubstitutionContext::Property);
1841 }
1842
1843 //===----------------------------------------------------------------------===//
1844 // ObjCAtDefsFieldDecl
1845 //===----------------------------------------------------------------------===//
1846
anchor()1847 void ObjCAtDefsFieldDecl::anchor() {}
1848
1849 ObjCAtDefsFieldDecl
Create(ASTContext & C,DeclContext * DC,SourceLocation StartLoc,SourceLocation IdLoc,IdentifierInfo * Id,QualType T,Expr * BW)1850 *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
1851 SourceLocation StartLoc, SourceLocation IdLoc,
1852 IdentifierInfo *Id, QualType T, Expr *BW) {
1853 return new (C, DC) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
1854 }
1855
CreateDeserialized(ASTContext & C,unsigned ID)1856 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
1857 unsigned ID) {
1858 return new (C, ID) ObjCAtDefsFieldDecl(nullptr, SourceLocation(),
1859 SourceLocation(), nullptr, QualType(),
1860 nullptr);
1861 }
1862
1863 //===----------------------------------------------------------------------===//
1864 // ObjCProtocolDecl
1865 //===----------------------------------------------------------------------===//
1866
anchor()1867 void ObjCProtocolDecl::anchor() {}
1868
ObjCProtocolDecl(ASTContext & C,DeclContext * DC,IdentifierInfo * Id,SourceLocation nameLoc,SourceLocation atStartLoc,ObjCProtocolDecl * PrevDecl)1869 ObjCProtocolDecl::ObjCProtocolDecl(ASTContext &C, DeclContext *DC,
1870 IdentifierInfo *Id, SourceLocation nameLoc,
1871 SourceLocation atStartLoc,
1872 ObjCProtocolDecl *PrevDecl)
1873 : ObjCContainerDecl(ObjCProtocol, DC, Id, nameLoc, atStartLoc),
1874 redeclarable_base(C) {
1875 setPreviousDecl(PrevDecl);
1876 if (PrevDecl)
1877 Data = PrevDecl->Data;
1878 }
1879
Create(ASTContext & C,DeclContext * DC,IdentifierInfo * Id,SourceLocation nameLoc,SourceLocation atStartLoc,ObjCProtocolDecl * PrevDecl)1880 ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
1881 IdentifierInfo *Id,
1882 SourceLocation nameLoc,
1883 SourceLocation atStartLoc,
1884 ObjCProtocolDecl *PrevDecl) {
1885 auto *Result =
1886 new (C, DC) ObjCProtocolDecl(C, DC, Id, nameLoc, atStartLoc, PrevDecl);
1887 Result->Data.setInt(!C.getLangOpts().Modules);
1888 return Result;
1889 }
1890
CreateDeserialized(ASTContext & C,unsigned ID)1891 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
1892 unsigned ID) {
1893 ObjCProtocolDecl *Result =
1894 new (C, ID) ObjCProtocolDecl(C, nullptr, nullptr, SourceLocation(),
1895 SourceLocation(), nullptr);
1896 Result->Data.setInt(!C.getLangOpts().Modules);
1897 return Result;
1898 }
1899
lookupProtocolNamed(IdentifierInfo * Name)1900 ObjCProtocolDecl *ObjCProtocolDecl::lookupProtocolNamed(IdentifierInfo *Name) {
1901 ObjCProtocolDecl *PDecl = this;
1902
1903 if (Name == getIdentifier())
1904 return PDecl;
1905
1906 for (auto *I : protocols())
1907 if ((PDecl = I->lookupProtocolNamed(Name)))
1908 return PDecl;
1909
1910 return nullptr;
1911 }
1912
1913 // lookupMethod - Lookup a instance/class method in the protocol and protocols
1914 // it inherited.
lookupMethod(Selector Sel,bool isInstance) const1915 ObjCMethodDecl *ObjCProtocolDecl::lookupMethod(Selector Sel,
1916 bool isInstance) const {
1917 ObjCMethodDecl *MethodDecl = nullptr;
1918
1919 // If there is no definition or the definition is hidden, we don't find
1920 // anything.
1921 const ObjCProtocolDecl *Def = getDefinition();
1922 if (!Def || !Def->isUnconditionallyVisible())
1923 return nullptr;
1924
1925 if ((MethodDecl = getMethod(Sel, isInstance)))
1926 return MethodDecl;
1927
1928 for (const auto *I : protocols())
1929 if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
1930 return MethodDecl;
1931 return nullptr;
1932 }
1933
allocateDefinitionData()1934 void ObjCProtocolDecl::allocateDefinitionData() {
1935 assert(!Data.getPointer() && "Protocol already has a definition!");
1936 Data.setPointer(new (getASTContext()) DefinitionData);
1937 Data.getPointer()->Definition = this;
1938 }
1939
startDefinition()1940 void ObjCProtocolDecl::startDefinition() {
1941 allocateDefinitionData();
1942
1943 // Update all of the declarations with a pointer to the definition.
1944 for (auto *RD : redecls())
1945 RD->Data = this->Data;
1946 }
1947
collectPropertiesToImplement(PropertyMap & PM,PropertyDeclOrder & PO) const1948 void ObjCProtocolDecl::collectPropertiesToImplement(PropertyMap &PM,
1949 PropertyDeclOrder &PO) const {
1950 if (const ObjCProtocolDecl *PDecl = getDefinition()) {
1951 for (auto *Prop : PDecl->properties()) {
1952 // Insert into PM if not there already.
1953 PM.insert(std::make_pair(
1954 std::make_pair(Prop->getIdentifier(), Prop->isClassProperty()),
1955 Prop));
1956 PO.push_back(Prop);
1957 }
1958 // Scan through protocol's protocols.
1959 for (const auto *PI : PDecl->protocols())
1960 PI->collectPropertiesToImplement(PM, PO);
1961 }
1962 }
1963
collectInheritedProtocolProperties(const ObjCPropertyDecl * Property,ProtocolPropertySet & PS,PropertyDeclOrder & PO) const1964 void ObjCProtocolDecl::collectInheritedProtocolProperties(
1965 const ObjCPropertyDecl *Property, ProtocolPropertySet &PS,
1966 PropertyDeclOrder &PO) const {
1967 if (const ObjCProtocolDecl *PDecl = getDefinition()) {
1968 if (!PS.insert(PDecl).second)
1969 return;
1970 for (auto *Prop : PDecl->properties()) {
1971 if (Prop == Property)
1972 continue;
1973 if (Prop->getIdentifier() == Property->getIdentifier()) {
1974 PO.push_back(Prop);
1975 return;
1976 }
1977 }
1978 // Scan through protocol's protocols which did not have a matching property.
1979 for (const auto *PI : PDecl->protocols())
1980 PI->collectInheritedProtocolProperties(Property, PS, PO);
1981 }
1982 }
1983
1984 StringRef
getObjCRuntimeNameAsString() const1985 ObjCProtocolDecl::getObjCRuntimeNameAsString() const {
1986 if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
1987 return ObjCRTName->getMetadataName();
1988
1989 return getName();
1990 }
1991
1992 //===----------------------------------------------------------------------===//
1993 // ObjCCategoryDecl
1994 //===----------------------------------------------------------------------===//
1995
anchor()1996 void ObjCCategoryDecl::anchor() {}
1997
ObjCCategoryDecl(DeclContext * DC,SourceLocation AtLoc,SourceLocation ClassNameLoc,SourceLocation CategoryNameLoc,IdentifierInfo * Id,ObjCInterfaceDecl * IDecl,ObjCTypeParamList * typeParamList,SourceLocation IvarLBraceLoc,SourceLocation IvarRBraceLoc)1998 ObjCCategoryDecl::ObjCCategoryDecl(DeclContext *DC, SourceLocation AtLoc,
1999 SourceLocation ClassNameLoc,
2000 SourceLocation CategoryNameLoc,
2001 IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
2002 ObjCTypeParamList *typeParamList,
2003 SourceLocation IvarLBraceLoc,
2004 SourceLocation IvarRBraceLoc)
2005 : ObjCContainerDecl(ObjCCategory, DC, Id, ClassNameLoc, AtLoc),
2006 ClassInterface(IDecl), CategoryNameLoc(CategoryNameLoc),
2007 IvarLBraceLoc(IvarLBraceLoc), IvarRBraceLoc(IvarRBraceLoc) {
2008 setTypeParamList(typeParamList);
2009 }
2010
Create(ASTContext & C,DeclContext * DC,SourceLocation AtLoc,SourceLocation ClassNameLoc,SourceLocation CategoryNameLoc,IdentifierInfo * Id,ObjCInterfaceDecl * IDecl,ObjCTypeParamList * typeParamList,SourceLocation IvarLBraceLoc,SourceLocation IvarRBraceLoc)2011 ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
2012 SourceLocation AtLoc,
2013 SourceLocation ClassNameLoc,
2014 SourceLocation CategoryNameLoc,
2015 IdentifierInfo *Id,
2016 ObjCInterfaceDecl *IDecl,
2017 ObjCTypeParamList *typeParamList,
2018 SourceLocation IvarLBraceLoc,
2019 SourceLocation IvarRBraceLoc) {
2020 auto *CatDecl =
2021 new (C, DC) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id,
2022 IDecl, typeParamList, IvarLBraceLoc,
2023 IvarRBraceLoc);
2024 if (IDecl) {
2025 // Link this category into its class's category list.
2026 CatDecl->NextClassCategory = IDecl->getCategoryListRaw();
2027 if (IDecl->hasDefinition()) {
2028 IDecl->setCategoryListRaw(CatDecl);
2029 if (ASTMutationListener *L = C.getASTMutationListener())
2030 L->AddedObjCCategoryToInterface(CatDecl, IDecl);
2031 }
2032 }
2033
2034 return CatDecl;
2035 }
2036
CreateDeserialized(ASTContext & C,unsigned ID)2037 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
2038 unsigned ID) {
2039 return new (C, ID) ObjCCategoryDecl(nullptr, SourceLocation(),
2040 SourceLocation(), SourceLocation(),
2041 nullptr, nullptr, nullptr);
2042 }
2043
getImplementation() const2044 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
2045 return getASTContext().getObjCImplementation(
2046 const_cast<ObjCCategoryDecl*>(this));
2047 }
2048
setImplementation(ObjCCategoryImplDecl * ImplD)2049 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
2050 getASTContext().setObjCImplementation(this, ImplD);
2051 }
2052
setTypeParamList(ObjCTypeParamList * TPL)2053 void ObjCCategoryDecl::setTypeParamList(ObjCTypeParamList *TPL) {
2054 TypeParamList = TPL;
2055 if (!TPL)
2056 return;
2057 // Set the declaration context of each of the type parameters.
2058 for (auto *typeParam : *TypeParamList)
2059 typeParam->setDeclContext(this);
2060 }
2061
2062 //===----------------------------------------------------------------------===//
2063 // ObjCCategoryImplDecl
2064 //===----------------------------------------------------------------------===//
2065
anchor()2066 void ObjCCategoryImplDecl::anchor() {}
2067
2068 ObjCCategoryImplDecl *
Create(ASTContext & C,DeclContext * DC,IdentifierInfo * Id,ObjCInterfaceDecl * ClassInterface,SourceLocation nameLoc,SourceLocation atStartLoc,SourceLocation CategoryNameLoc)2069 ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
2070 IdentifierInfo *Id,
2071 ObjCInterfaceDecl *ClassInterface,
2072 SourceLocation nameLoc,
2073 SourceLocation atStartLoc,
2074 SourceLocation CategoryNameLoc) {
2075 if (ClassInterface && ClassInterface->hasDefinition())
2076 ClassInterface = ClassInterface->getDefinition();
2077 return new (C, DC) ObjCCategoryImplDecl(DC, Id, ClassInterface, nameLoc,
2078 atStartLoc, CategoryNameLoc);
2079 }
2080
CreateDeserialized(ASTContext & C,unsigned ID)2081 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C,
2082 unsigned ID) {
2083 return new (C, ID) ObjCCategoryImplDecl(nullptr, nullptr, nullptr,
2084 SourceLocation(), SourceLocation(),
2085 SourceLocation());
2086 }
2087
getCategoryDecl() const2088 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
2089 // The class interface might be NULL if we are working with invalid code.
2090 if (const ObjCInterfaceDecl *ID = getClassInterface())
2091 return ID->FindCategoryDeclaration(getIdentifier());
2092 return nullptr;
2093 }
2094
anchor()2095 void ObjCImplDecl::anchor() {}
2096
addPropertyImplementation(ObjCPropertyImplDecl * property)2097 void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
2098 // FIXME: The context should be correct before we get here.
2099 property->setLexicalDeclContext(this);
2100 addDecl(property);
2101 }
2102
setClassInterface(ObjCInterfaceDecl * IFace)2103 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
2104 ASTContext &Ctx = getASTContext();
2105
2106 if (auto *ImplD = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
2107 if (IFace)
2108 Ctx.setObjCImplementation(IFace, ImplD);
2109
2110 } else if (auto *ImplD = dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
2111 if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
2112 Ctx.setObjCImplementation(CD, ImplD);
2113 }
2114
2115 ClassInterface = IFace;
2116 }
2117
2118 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
2119 /// properties implemented in this \@implementation block and returns
2120 /// the implemented property that uses it.
2121 ObjCPropertyImplDecl *ObjCImplDecl::
FindPropertyImplIvarDecl(IdentifierInfo * ivarId) const2122 FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
2123 for (auto *PID : property_impls())
2124 if (PID->getPropertyIvarDecl() &&
2125 PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
2126 return PID;
2127 return nullptr;
2128 }
2129
2130 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
2131 /// added to the list of those properties \@synthesized/\@dynamic in this
2132 /// category \@implementation block.
2133 ObjCPropertyImplDecl *ObjCImplDecl::
FindPropertyImplDecl(IdentifierInfo * Id,ObjCPropertyQueryKind QueryKind) const2134 FindPropertyImplDecl(IdentifierInfo *Id,
2135 ObjCPropertyQueryKind QueryKind) const {
2136 ObjCPropertyImplDecl *ClassPropImpl = nullptr;
2137 for (auto *PID : property_impls())
2138 // If queryKind is unknown, we return the instance property if one
2139 // exists; otherwise we return the class property.
2140 if (PID->getPropertyDecl()->getIdentifier() == Id) {
2141 if ((QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown &&
2142 !PID->getPropertyDecl()->isClassProperty()) ||
2143 (QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_class &&
2144 PID->getPropertyDecl()->isClassProperty()) ||
2145 (QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_instance &&
2146 !PID->getPropertyDecl()->isClassProperty()))
2147 return PID;
2148
2149 if (PID->getPropertyDecl()->isClassProperty())
2150 ClassPropImpl = PID;
2151 }
2152
2153 if (QueryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown)
2154 // We can't find the instance property, return the class property.
2155 return ClassPropImpl;
2156
2157 return nullptr;
2158 }
2159
operator <<(raw_ostream & OS,const ObjCCategoryImplDecl & CID)2160 raw_ostream &clang::operator<<(raw_ostream &OS,
2161 const ObjCCategoryImplDecl &CID) {
2162 OS << CID.getName();
2163 return OS;
2164 }
2165
2166 //===----------------------------------------------------------------------===//
2167 // ObjCImplementationDecl
2168 //===----------------------------------------------------------------------===//
2169
anchor()2170 void ObjCImplementationDecl::anchor() {}
2171
2172 ObjCImplementationDecl *
Create(ASTContext & C,DeclContext * DC,ObjCInterfaceDecl * ClassInterface,ObjCInterfaceDecl * SuperDecl,SourceLocation nameLoc,SourceLocation atStartLoc,SourceLocation superLoc,SourceLocation IvarLBraceLoc,SourceLocation IvarRBraceLoc)2173 ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
2174 ObjCInterfaceDecl *ClassInterface,
2175 ObjCInterfaceDecl *SuperDecl,
2176 SourceLocation nameLoc,
2177 SourceLocation atStartLoc,
2178 SourceLocation superLoc,
2179 SourceLocation IvarLBraceLoc,
2180 SourceLocation IvarRBraceLoc) {
2181 if (ClassInterface && ClassInterface->hasDefinition())
2182 ClassInterface = ClassInterface->getDefinition();
2183 return new (C, DC) ObjCImplementationDecl(DC, ClassInterface, SuperDecl,
2184 nameLoc, atStartLoc, superLoc,
2185 IvarLBraceLoc, IvarRBraceLoc);
2186 }
2187
2188 ObjCImplementationDecl *
CreateDeserialized(ASTContext & C,unsigned ID)2189 ObjCImplementationDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2190 return new (C, ID) ObjCImplementationDecl(nullptr, nullptr, nullptr,
2191 SourceLocation(), SourceLocation());
2192 }
2193
setIvarInitializers(ASTContext & C,CXXCtorInitializer ** initializers,unsigned numInitializers)2194 void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
2195 CXXCtorInitializer ** initializers,
2196 unsigned numInitializers) {
2197 if (numInitializers > 0) {
2198 NumIvarInitializers = numInitializers;
2199 auto **ivarInitializers = new (C) CXXCtorInitializer*[NumIvarInitializers];
2200 memcpy(ivarInitializers, initializers,
2201 numInitializers * sizeof(CXXCtorInitializer*));
2202 IvarInitializers = ivarInitializers;
2203 }
2204 }
2205
2206 ObjCImplementationDecl::init_const_iterator
init_begin() const2207 ObjCImplementationDecl::init_begin() const {
2208 return IvarInitializers.get(getASTContext().getExternalSource());
2209 }
2210
operator <<(raw_ostream & OS,const ObjCImplementationDecl & ID)2211 raw_ostream &clang::operator<<(raw_ostream &OS,
2212 const ObjCImplementationDecl &ID) {
2213 OS << ID.getName();
2214 return OS;
2215 }
2216
2217 //===----------------------------------------------------------------------===//
2218 // ObjCCompatibleAliasDecl
2219 //===----------------------------------------------------------------------===//
2220
anchor()2221 void ObjCCompatibleAliasDecl::anchor() {}
2222
2223 ObjCCompatibleAliasDecl *
Create(ASTContext & C,DeclContext * DC,SourceLocation L,IdentifierInfo * Id,ObjCInterfaceDecl * AliasedClass)2224 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
2225 SourceLocation L,
2226 IdentifierInfo *Id,
2227 ObjCInterfaceDecl* AliasedClass) {
2228 return new (C, DC) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
2229 }
2230
2231 ObjCCompatibleAliasDecl *
CreateDeserialized(ASTContext & C,unsigned ID)2232 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2233 return new (C, ID) ObjCCompatibleAliasDecl(nullptr, SourceLocation(),
2234 nullptr, nullptr);
2235 }
2236
2237 //===----------------------------------------------------------------------===//
2238 // ObjCPropertyDecl
2239 //===----------------------------------------------------------------------===//
2240
anchor()2241 void ObjCPropertyDecl::anchor() {}
2242
Create(ASTContext & C,DeclContext * DC,SourceLocation L,IdentifierInfo * Id,SourceLocation AtLoc,SourceLocation LParenLoc,QualType T,TypeSourceInfo * TSI,PropertyControl propControl)2243 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
2244 SourceLocation L,
2245 IdentifierInfo *Id,
2246 SourceLocation AtLoc,
2247 SourceLocation LParenLoc,
2248 QualType T,
2249 TypeSourceInfo *TSI,
2250 PropertyControl propControl) {
2251 return new (C, DC) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T, TSI,
2252 propControl);
2253 }
2254
CreateDeserialized(ASTContext & C,unsigned ID)2255 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
2256 unsigned ID) {
2257 return new (C, ID) ObjCPropertyDecl(nullptr, SourceLocation(), nullptr,
2258 SourceLocation(), SourceLocation(),
2259 QualType(), nullptr, None);
2260 }
2261
getUsageType(QualType objectType) const2262 QualType ObjCPropertyDecl::getUsageType(QualType objectType) const {
2263 return DeclType.substObjCMemberType(objectType, getDeclContext(),
2264 ObjCSubstitutionContext::Property);
2265 }
2266
2267 //===----------------------------------------------------------------------===//
2268 // ObjCPropertyImplDecl
2269 //===----------------------------------------------------------------------===//
2270
Create(ASTContext & C,DeclContext * DC,SourceLocation atLoc,SourceLocation L,ObjCPropertyDecl * property,Kind PK,ObjCIvarDecl * ivar,SourceLocation ivarLoc)2271 ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
2272 DeclContext *DC,
2273 SourceLocation atLoc,
2274 SourceLocation L,
2275 ObjCPropertyDecl *property,
2276 Kind PK,
2277 ObjCIvarDecl *ivar,
2278 SourceLocation ivarLoc) {
2279 return new (C, DC) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
2280 ivarLoc);
2281 }
2282
CreateDeserialized(ASTContext & C,unsigned ID)2283 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C,
2284 unsigned ID) {
2285 return new (C, ID) ObjCPropertyImplDecl(nullptr, SourceLocation(),
2286 SourceLocation(), nullptr, Dynamic,
2287 nullptr, SourceLocation());
2288 }
2289
getSourceRange() const2290 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
2291 SourceLocation EndLoc = getLocation();
2292 if (IvarLoc.isValid())
2293 EndLoc = IvarLoc;
2294
2295 return SourceRange(AtLoc, EndLoc);
2296 }
2297