Bug Summary

File:tools/clang/lib/AST/DeclObjC.cpp
Warning:line 1616, column 11
Called C++ object pointer is null

Annotated Source Code

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