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