DeclObjC.cpp source code [clang_source_code/lib/AST/DeclObjC.cpp]

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