blob: 9463b6cc731c2b5230880182db44b71508f22adc [file] [log] [blame]
Eli Friedman56d29372008-06-07 16:52:53 +00001//===--- DeclBase.cpp - 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 Decl and DeclContext classes.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/DeclBase.h"
Douglas Gregor64650af2009-02-02 23:39:07 +000015#include "clang/AST/Decl.h"
Douglas Gregorc2ee10d2009-04-07 17:20:56 +000016#include "clang/AST/DeclContextInternals.h"
Argyrios Kyrtzidisd3bb44f2008-06-09 21:05:31 +000017#include "clang/AST/DeclCXX.h"
John McCall92b7f702010-03-11 07:50:04 +000018#include "clang/AST/DeclFriend.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000019#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
John McCall0c01d182010-03-24 05:22:00 +000021#include "clang/AST/DependentDiagnostic.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000022#include "clang/AST/ExternalASTSource.h"
Eli Friedman56d29372008-06-07 16:52:53 +000023#include "clang/AST/ASTContext.h"
Douglas Gregor44b43212008-12-11 16:49:14 +000024#include "clang/AST/Type.h"
Sebastian Redld3a413d2009-04-26 20:35:05 +000025#include "clang/AST/Stmt.h"
26#include "clang/AST/StmtCXX.h"
Eli Friedman56d29372008-06-07 16:52:53 +000027#include "llvm/ADT/DenseMap.h"
Chris Lattner49f28ca2009-03-05 08:00:35 +000028#include "llvm/Support/raw_ostream.h"
Douglas Gregor6ed40e32008-12-23 21:05:05 +000029#include <algorithm>
Chris Lattner3daed522009-03-02 22:20:04 +000030#include <cstdio>
Douglas Gregor3fc749d2008-12-23 00:26:44 +000031#include <vector>
Eli Friedman56d29372008-06-07 16:52:53 +000032using namespace clang;
33
34//===----------------------------------------------------------------------===//
35// Statistics
36//===----------------------------------------------------------------------===//
37
Sean Hunt9a555912010-05-30 07:21:58 +000038#define DECL(DERIVED, BASE) static int n##DERIVED##s = 0;
39#define ABSTRACT_DECL(DECL)
40#include "clang/AST/DeclNodes.inc"
Eli Friedman56d29372008-06-07 16:52:53 +000041
42static bool StatSwitch = false;
43
Eli Friedman56d29372008-06-07 16:52:53 +000044const char *Decl::getDeclKindName() const {
45 switch (DeclKind) {
Sean Hunt9a555912010-05-30 07:21:58 +000046 default: assert(0 && "Declaration not in DeclNodes.inc!");
47#define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;
48#define ABSTRACT_DECL(DECL)
49#include "clang/AST/DeclNodes.inc"
Eli Friedman56d29372008-06-07 16:52:53 +000050 }
51}
52
Douglas Gregor42738572010-03-05 00:26:45 +000053void Decl::setInvalidDecl(bool Invalid) {
54 InvalidDecl = Invalid;
55 if (Invalid) {
56 // Defensive maneuver for ill-formed code: we're likely not to make it to
57 // a point where we set the access specifier, so default it to "public"
58 // to avoid triggering asserts elsewhere in the front end.
59 setAccess(AS_public);
60 }
61}
62
Steve Naroff0a473932009-01-20 19:53:53 +000063const char *DeclContext::getDeclKindName() const {
64 switch (DeclKind) {
Sean Hunt9a555912010-05-30 07:21:58 +000065 default: assert(0 && "Declaration context not in DeclNodes.inc!");
66#define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;
67#define ABSTRACT_DECL(DECL)
68#include "clang/AST/DeclNodes.inc"
Steve Naroff0a473932009-01-20 19:53:53 +000069 }
70}
71
Eli Friedman56d29372008-06-07 16:52:53 +000072bool Decl::CollectingStats(bool Enable) {
Kovarththanan Rajaratnam2024f4d2009-11-29 14:54:35 +000073 if (Enable) StatSwitch = true;
Eli Friedman56d29372008-06-07 16:52:53 +000074 return StatSwitch;
75}
76
77void Decl::PrintStats() {
78 fprintf(stderr, "*** Decl Stats:\n");
Mike Stump1eb44332009-09-09 15:08:12 +000079
Douglas Gregor64650af2009-02-02 23:39:07 +000080 int totalDecls = 0;
Sean Hunt9a555912010-05-30 07:21:58 +000081#define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s;
82#define ABSTRACT_DECL(DECL)
83#include "clang/AST/DeclNodes.inc"
Douglas Gregor64650af2009-02-02 23:39:07 +000084 fprintf(stderr, " %d decls total.\n", totalDecls);
Mike Stump1eb44332009-09-09 15:08:12 +000085
Douglas Gregor64650af2009-02-02 23:39:07 +000086 int totalBytes = 0;
Sean Hunt9a555912010-05-30 07:21:58 +000087#define DECL(DERIVED, BASE) \
88 if (n##DERIVED##s > 0) { \
89 totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \
90 fprintf(stderr, " %d " #DERIVED " decls, %d each (%d bytes)\n", \
91 n##DERIVED##s, (int)sizeof(DERIVED##Decl), \
92 (int)(n##DERIVED##s * sizeof(DERIVED##Decl))); \
Douglas Gregor64650af2009-02-02 23:39:07 +000093 }
Sean Hunt9a555912010-05-30 07:21:58 +000094#define ABSTRACT_DECL(DECL)
95#include "clang/AST/DeclNodes.inc"
Mike Stump1eb44332009-09-09 15:08:12 +000096
Douglas Gregor64650af2009-02-02 23:39:07 +000097 fprintf(stderr, "Total bytes = %d\n", totalBytes);
Eli Friedman56d29372008-06-07 16:52:53 +000098}
99
Sean Hunt9a555912010-05-30 07:21:58 +0000100void Decl::add(Kind k) {
Eli Friedman56d29372008-06-07 16:52:53 +0000101 switch (k) {
Sean Hunt9a555912010-05-30 07:21:58 +0000102 default: assert(0 && "Declaration not in DeclNodes.inc!");
103#define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;
104#define ABSTRACT_DECL(DECL)
105#include "clang/AST/DeclNodes.inc"
Eli Friedman56d29372008-06-07 16:52:53 +0000106 }
107}
108
Anders Carlsson67e33202009-06-13 00:08:58 +0000109bool Decl::isTemplateParameterPack() const {
110 if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this))
111 return TTP->isParameterPack();
Mike Stump1eb44332009-09-09 15:08:12 +0000112
Anders Carlsson67e33202009-06-13 00:08:58 +0000113 return false;
114}
115
Douglas Gregore53060f2009-06-25 22:08:12 +0000116bool Decl::isFunctionOrFunctionTemplate() const {
John McCall9488ea12009-11-17 05:59:44 +0000117 if (const UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(this))
Anders Carlsson58badb72009-06-26 05:26:50 +0000118 return UD->getTargetDecl()->isFunctionOrFunctionTemplate();
Mike Stump1eb44332009-09-09 15:08:12 +0000119
Douglas Gregore53060f2009-06-25 22:08:12 +0000120 return isa<FunctionDecl>(this) || isa<FunctionTemplateDecl>(this);
121}
122
Douglas Gregor79c22782010-01-16 20:21:20 +0000123bool Decl::isDefinedOutsideFunctionOrMethod() const {
124 for (const DeclContext *DC = getDeclContext();
125 DC && !DC->isTranslationUnit();
126 DC = DC->getParent())
127 if (DC->isFunctionOrMethod())
128 return false;
129
130 return true;
131}
132
133
Eli Friedman56d29372008-06-07 16:52:53 +0000134//===----------------------------------------------------------------------===//
Chris Lattner49f28ca2009-03-05 08:00:35 +0000135// PrettyStackTraceDecl Implementation
136//===----------------------------------------------------------------------===//
Mike Stump1eb44332009-09-09 15:08:12 +0000137
Chris Lattner49f28ca2009-03-05 08:00:35 +0000138void PrettyStackTraceDecl::print(llvm::raw_ostream &OS) const {
139 SourceLocation TheLoc = Loc;
140 if (TheLoc.isInvalid() && TheDecl)
141 TheLoc = TheDecl->getLocation();
Mike Stump1eb44332009-09-09 15:08:12 +0000142
Chris Lattner49f28ca2009-03-05 08:00:35 +0000143 if (TheLoc.isValid()) {
144 TheLoc.print(OS, SM);
145 OS << ": ";
146 }
147
148 OS << Message;
149
Daniel Dunbarc5236562009-11-21 09:05:59 +0000150 if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl))
Chris Lattner49f28ca2009-03-05 08:00:35 +0000151 OS << " '" << DN->getQualifiedNameAsString() << '\'';
152 OS << '\n';
153}
Mike Stump1eb44332009-09-09 15:08:12 +0000154
Chris Lattner49f28ca2009-03-05 08:00:35 +0000155//===----------------------------------------------------------------------===//
Eli Friedman56d29372008-06-07 16:52:53 +0000156// Decl Implementation
157//===----------------------------------------------------------------------===//
158
Chris Lattner769dbdf2009-03-27 20:18:19 +0000159// Out-of-line virtual method providing a home for Decl.
Douglas Gregorff331c12010-07-25 18:17:45 +0000160Decl::~Decl() { }
Chris Lattner769dbdf2009-03-27 20:18:19 +0000161
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000162void Decl::setDeclContext(DeclContext *DC) {
163 if (isOutOfSemaDC())
164 delete getMultipleDC();
Mike Stump1eb44332009-09-09 15:08:12 +0000165
Chris Lattneree219fd2009-03-29 06:06:59 +0000166 DeclCtx = DC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000167}
168
169void Decl::setLexicalDeclContext(DeclContext *DC) {
170 if (DC == getLexicalDeclContext())
171 return;
172
173 if (isInSemaDC()) {
Ted Kremenek94a39002009-12-01 00:07:10 +0000174 MultipleDC *MDC = new (getASTContext()) MultipleDC();
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000175 MDC->SemanticDC = getDeclContext();
176 MDC->LexicalDC = DC;
Chris Lattneree219fd2009-03-29 06:06:59 +0000177 DeclCtx = MDC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000178 } else {
179 getMultipleDC()->LexicalDC = DC;
180 }
181}
182
John McCall9aeed322009-10-01 00:25:31 +0000183bool Decl::isInAnonymousNamespace() const {
184 const DeclContext *DC = getDeclContext();
185 do {
186 if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
187 if (ND->isAnonymousNamespace())
188 return true;
189 } while ((DC = DC->getParent()));
190
191 return false;
192}
193
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000194TranslationUnitDecl *Decl::getTranslationUnitDecl() {
Argyrios Kyrtzidis9b346692009-06-30 02:34:53 +0000195 if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this))
196 return TUD;
197
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000198 DeclContext *DC = getDeclContext();
199 assert(DC && "This decl is not contained in a translation unit!");
Mike Stump1eb44332009-09-09 15:08:12 +0000200
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000201 while (!DC->isTranslationUnit()) {
202 DC = DC->getParent();
203 assert(DC && "This decl is not contained in a translation unit!");
204 }
Mike Stump1eb44332009-09-09 15:08:12 +0000205
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000206 return cast<TranslationUnitDecl>(DC);
207}
208
209ASTContext &Decl::getASTContext() const {
Mike Stump1eb44332009-09-09 15:08:12 +0000210 return getTranslationUnitDecl()->getASTContext();
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000211}
212
Douglas Gregorc070cc62010-06-17 23:14:26 +0000213bool Decl::isUsed(bool CheckUsedAttr) const {
Tanya Lattner12ead492010-02-17 02:17:21 +0000214 if (Used)
215 return true;
216
217 // Check for used attribute.
Douglas Gregorc070cc62010-06-17 23:14:26 +0000218 if (CheckUsedAttr && hasAttr<UsedAttr>())
Tanya Lattner12ead492010-02-17 02:17:21 +0000219 return true;
220
221 // Check redeclarations for used attribute.
222 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) {
Douglas Gregorc070cc62010-06-17 23:14:26 +0000223 if ((CheckUsedAttr && I->hasAttr<UsedAttr>()) || I->Used)
Tanya Lattner12ead492010-02-17 02:17:21 +0000224 return true;
225 }
226
227 return false;
228}
229
230
Chris Lattner769dbdf2009-03-27 20:18:19 +0000231unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
232 switch (DeclKind) {
John McCall9488ea12009-11-17 05:59:44 +0000233 case Function:
234 case CXXMethod:
235 case CXXConstructor:
236 case CXXDestructor:
237 case CXXConversion:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000238 case EnumConstant:
239 case Var:
240 case ImplicitParam:
241 case ParmVar:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000242 case NonTypeTemplateParm:
243 case ObjCMethod:
Daniel Dunbar00b40d32010-04-23 13:07:39 +0000244 case ObjCProperty:
Daniel Dunbar00b40d32010-04-23 13:07:39 +0000245 return IDNS_Ordinary;
John McCalld04efc92010-04-23 02:41:41 +0000246
John McCall0d6b1642010-04-23 18:46:30 +0000247 case ObjCCompatibleAlias:
248 case ObjCInterface:
249 return IDNS_Ordinary | IDNS_Type;
250
251 case Typedef:
252 case UnresolvedUsingTypename:
253 case TemplateTypeParm:
254 return IDNS_Ordinary | IDNS_Type;
255
John McCall9488ea12009-11-17 05:59:44 +0000256 case UsingShadow:
257 return 0; // we'll actually overwrite this later
258
John McCall7ba107a2009-11-18 02:36:19 +0000259 case UnresolvedUsingValue:
John McCall7ba107a2009-11-18 02:36:19 +0000260 return IDNS_Ordinary | IDNS_Using;
John McCall9488ea12009-11-17 05:59:44 +0000261
262 case Using:
263 return IDNS_Using;
264
Chris Lattner769dbdf2009-03-27 20:18:19 +0000265 case ObjCProtocol:
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000266 return IDNS_ObjCProtocol;
Mike Stump1eb44332009-09-09 15:08:12 +0000267
Chris Lattner769dbdf2009-03-27 20:18:19 +0000268 case Field:
269 case ObjCAtDefsField:
270 case ObjCIvar:
271 return IDNS_Member;
Mike Stump1eb44332009-09-09 15:08:12 +0000272
Chris Lattner769dbdf2009-03-27 20:18:19 +0000273 case Record:
274 case CXXRecord:
275 case Enum:
John McCall0d6b1642010-04-23 18:46:30 +0000276 return IDNS_Tag | IDNS_Type;
Mike Stump1eb44332009-09-09 15:08:12 +0000277
Chris Lattner769dbdf2009-03-27 20:18:19 +0000278 case Namespace:
John McCall0d6b1642010-04-23 18:46:30 +0000279 case NamespaceAlias:
280 return IDNS_Namespace;
281
Chris Lattner769dbdf2009-03-27 20:18:19 +0000282 case FunctionTemplate:
John McCall0d6b1642010-04-23 18:46:30 +0000283 return IDNS_Ordinary;
284
Chris Lattner769dbdf2009-03-27 20:18:19 +0000285 case ClassTemplate:
286 case TemplateTemplateParm:
John McCall0d6b1642010-04-23 18:46:30 +0000287 return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
Mike Stump1eb44332009-09-09 15:08:12 +0000288
Chris Lattner769dbdf2009-03-27 20:18:19 +0000289 // Never have names.
John McCall02cace72009-08-28 07:59:38 +0000290 case Friend:
John McCalldd4a3b02009-09-16 22:47:08 +0000291 case FriendTemplate:
Abramo Bagnara6206d532010-06-05 05:09:32 +0000292 case AccessSpec:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000293 case LinkageSpec:
294 case FileScopeAsm:
295 case StaticAssert:
296 case ObjCClass:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000297 case ObjCPropertyImpl:
298 case ObjCForwardProtocol:
299 case Block:
300 case TranslationUnit:
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000301
Chris Lattner769dbdf2009-03-27 20:18:19 +0000302 case UsingDirective:
303 case ClassTemplateSpecialization:
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000304 case ClassTemplatePartialSpecialization:
Douglas Gregorbd4187b2010-04-22 23:19:50 +0000305 case ObjCImplementation:
306 case ObjCCategory:
307 case ObjCCategoryImpl:
308 // Never looked up by name.
Chris Lattner769dbdf2009-03-27 20:18:19 +0000309 return 0;
310 }
John McCall9488ea12009-11-17 05:59:44 +0000311
312 return 0;
Eli Friedman56d29372008-06-07 16:52:53 +0000313}
314
Sean Huntcf807c42010-08-18 23:23:40 +0000315void Decl::setAttrs(const AttrVec &attrs) {
Argyrios Kyrtzidis1715bf52010-06-11 23:09:25 +0000316 assert(!HasAttrs && "Decl already contains attrs.");
317
Sean Huntcf807c42010-08-18 23:23:40 +0000318 AttrVec &AttrBlank = getASTContext().getDeclAttrs(this);
319 assert(AttrBlank.empty() && "HasAttrs was wrong?");
Argyrios Kyrtzidis1715bf52010-06-11 23:09:25 +0000320
321 AttrBlank = attrs;
322 HasAttrs = true;
323}
324
Sean Huntcf807c42010-08-18 23:23:40 +0000325void Decl::dropAttrs() {
Eli Friedman56d29372008-06-07 16:52:53 +0000326 if (!HasAttrs) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000327
Eli Friedman56d29372008-06-07 16:52:53 +0000328 HasAttrs = false;
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000329 getASTContext().eraseDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000330}
331
Sean Huntcf807c42010-08-18 23:23:40 +0000332const AttrVec &Decl::getAttrs() const {
333 assert(HasAttrs && "No attrs to get!");
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000334 return getASTContext().getDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000335}
336
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000337void Decl::swapAttrs(Decl *RHS) {
Eli Friedman56d29372008-06-07 16:52:53 +0000338 bool HasLHSAttr = this->HasAttrs;
339 bool HasRHSAttr = RHS->HasAttrs;
Mike Stump1eb44332009-09-09 15:08:12 +0000340
Eli Friedman56d29372008-06-07 16:52:53 +0000341 // Usually, neither decl has attrs, nothing to do.
342 if (!HasLHSAttr && !HasRHSAttr) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000343
Eli Friedman56d29372008-06-07 16:52:53 +0000344 // If 'this' has no attrs, swap the other way.
345 if (!HasLHSAttr)
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000346 return RHS->swapAttrs(this);
Mike Stump1eb44332009-09-09 15:08:12 +0000347
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000348 ASTContext &Context = getASTContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000349
Eli Friedman56d29372008-06-07 16:52:53 +0000350 // Handle the case when both decls have attrs.
351 if (HasRHSAttr) {
Douglas Gregor68584ed2009-06-18 16:11:24 +0000352 std::swap(Context.getDeclAttrs(this), Context.getDeclAttrs(RHS));
Eli Friedman56d29372008-06-07 16:52:53 +0000353 return;
354 }
Mike Stump1eb44332009-09-09 15:08:12 +0000355
Eli Friedman56d29372008-06-07 16:52:53 +0000356 // Otherwise, LHS has an attr and RHS doesn't.
Douglas Gregor68584ed2009-06-18 16:11:24 +0000357 Context.getDeclAttrs(RHS) = Context.getDeclAttrs(this);
358 Context.eraseDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000359 this->HasAttrs = false;
360 RHS->HasAttrs = true;
361}
362
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000363Decl *Decl::castFromDeclContext (const DeclContext *D) {
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000364 Decl::Kind DK = D->getDeclKind();
365 switch(DK) {
Sean Hunt9a555912010-05-30 07:21:58 +0000366#define DECL(NAME, BASE)
367#define DECL_CONTEXT(NAME) \
368 case Decl::NAME: \
369 return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
370#define DECL_CONTEXT_BASE(NAME)
371#include "clang/AST/DeclNodes.inc"
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000372 default:
Sean Hunt9a555912010-05-30 07:21:58 +0000373#define DECL(NAME, BASE)
374#define DECL_CONTEXT_BASE(NAME) \
375 if (DK >= first##NAME && DK <= last##NAME) \
376 return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
377#include "clang/AST/DeclNodes.inc"
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000378 assert(false && "a decl that inherits DeclContext isn't handled");
379 return 0;
380 }
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000381}
382
383DeclContext *Decl::castToDeclContext(const Decl *D) {
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000384 Decl::Kind DK = D->getKind();
385 switch(DK) {
Sean Hunt9a555912010-05-30 07:21:58 +0000386#define DECL(NAME, BASE)
387#define DECL_CONTEXT(NAME) \
388 case Decl::NAME: \
389 return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
390#define DECL_CONTEXT_BASE(NAME)
391#include "clang/AST/DeclNodes.inc"
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000392 default:
Sean Hunt9a555912010-05-30 07:21:58 +0000393#define DECL(NAME, BASE)
394#define DECL_CONTEXT_BASE(NAME) \
395 if (DK >= first##NAME && DK <= last##NAME) \
396 return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
397#include "clang/AST/DeclNodes.inc"
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000398 assert(false && "a decl that inherits DeclContext isn't handled");
399 return 0;
400 }
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000401}
402
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +0000403SourceLocation Decl::getBodyRBrace() const {
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +0000404 // Special handling of FunctionDecl to avoid de-serializing the body from PCH.
405 // FunctionDecl stores EndRangeLoc for this purpose.
406 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
407 const FunctionDecl *Definition;
408 if (FD->hasBody(Definition))
409 return Definition->getSourceRange().getEnd();
410 return SourceLocation();
411 }
412
Argyrios Kyrtzidis6717ef42010-07-07 11:31:27 +0000413 if (Stmt *Body = getBody())
414 return Body->getSourceRange().getEnd();
415
416 return SourceLocation();
Sebastian Redld3a413d2009-04-26 20:35:05 +0000417}
418
Anders Carlsson1329c272009-03-25 23:38:06 +0000419#ifndef NDEBUG
420void Decl::CheckAccessDeclContext() const {
Argyrios Kyrtzidis04aed0e2010-07-02 11:55:44 +0000421 // FIXME: Disable this until rdar://8146294 "access specifier for inner class
422 // templates is not set or checked" is fixed.
423 return;
John McCall46460a62010-01-20 21:53:11 +0000424 // Suppress this check if any of the following hold:
425 // 1. this is the translation unit (and thus has no parent)
426 // 2. this is a template parameter (and thus doesn't belong to its context)
Argyrios Kyrtzidis04aed0e2010-07-02 11:55:44 +0000427 // 3. the context is not a record
428 // 4. it's invalid
Anders Carlsson35eda442009-08-29 20:47:47 +0000429 if (isa<TranslationUnitDecl>(this) ||
Argyrios Kyrtzidis04aed0e2010-07-02 11:55:44 +0000430 isa<TemplateTypeParmDecl>(this) ||
Douglas Gregorfdd8ab12010-02-22 17:53:38 +0000431 !isa<CXXRecordDecl>(getDeclContext()) ||
432 isInvalidDecl())
Anders Carlsson35eda442009-08-29 20:47:47 +0000433 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000434
435 assert(Access != AS_none &&
Anders Carlsson1329c272009-03-25 23:38:06 +0000436 "Access specifier is AS_none inside a record decl");
437}
438
439#endif
440
Eli Friedman56d29372008-06-07 16:52:53 +0000441//===----------------------------------------------------------------------===//
442// DeclContext Implementation
443//===----------------------------------------------------------------------===//
444
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000445bool DeclContext::classof(const Decl *D) {
446 switch (D->getKind()) {
Sean Hunt9a555912010-05-30 07:21:58 +0000447#define DECL(NAME, BASE)
448#define DECL_CONTEXT(NAME) case Decl::NAME:
449#define DECL_CONTEXT_BASE(NAME)
450#include "clang/AST/DeclNodes.inc"
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000451 return true;
452 default:
Sean Hunt9a555912010-05-30 07:21:58 +0000453#define DECL(NAME, BASE)
454#define DECL_CONTEXT_BASE(NAME) \
455 if (D->getKind() >= Decl::first##NAME && \
456 D->getKind() <= Decl::last##NAME) \
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000457 return true;
Sean Hunt9a555912010-05-30 07:21:58 +0000458#include "clang/AST/DeclNodes.inc"
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000459 return false;
460 }
461}
462
Douglas Gregora2da7802010-07-25 18:38:02 +0000463DeclContext::~DeclContext() { }
Douglas Gregor44b43212008-12-11 16:49:14 +0000464
Douglas Gregore942bbe2009-09-10 16:57:35 +0000465/// \brief Find the parent context of this context that will be
466/// used for unqualified name lookup.
467///
468/// Generally, the parent lookup context is the semantic context. However, for
469/// a friend function the parent lookup context is the lexical context, which
470/// is the class in which the friend is declared.
471DeclContext *DeclContext::getLookupParent() {
472 // FIXME: Find a better way to identify friends
473 if (isa<FunctionDecl>(this))
474 if (getParent()->getLookupContext()->isFileContext() &&
475 getLexicalParent()->getLookupContext()->isRecord())
476 return getLexicalParent();
477
478 return getParent();
479}
480
Douglas Gregorbc221632009-05-28 16:34:51 +0000481bool DeclContext::isDependentContext() const {
482 if (isFileContext())
483 return false;
484
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000485 if (isa<ClassTemplatePartialSpecializationDecl>(this))
486 return true;
487
Douglas Gregorbc221632009-05-28 16:34:51 +0000488 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this))
489 if (Record->getDescribedClassTemplate())
490 return true;
491
John McCall0c01d182010-03-24 05:22:00 +0000492 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) {
Douglas Gregorbc221632009-05-28 16:34:51 +0000493 if (Function->getDescribedFunctionTemplate())
494 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000495
John McCall0c01d182010-03-24 05:22:00 +0000496 // Friend function declarations are dependent if their *lexical*
497 // context is dependent.
498 if (cast<Decl>(this)->getFriendObjectKind())
499 return getLexicalParent()->isDependentContext();
500 }
501
Douglas Gregorbc221632009-05-28 16:34:51 +0000502 return getParent() && getParent()->isDependentContext();
503}
504
Douglas Gregor074149e2009-01-05 19:45:36 +0000505bool DeclContext::isTransparentContext() const {
506 if (DeclKind == Decl::Enum)
507 return true; // FIXME: Check for C++0x scoped enums
508 else if (DeclKind == Decl::LinkageSpec)
509 return true;
Sean Hunt9a555912010-05-30 07:21:58 +0000510 else if (DeclKind >= Decl::firstRecord && DeclKind <= Decl::lastRecord)
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000511 return cast<RecordDecl>(this)->isAnonymousStructOrUnion();
Douglas Gregor074149e2009-01-05 19:45:36 +0000512 else if (DeclKind == Decl::Namespace)
513 return false; // FIXME: Check for C++0x inline namespaces
514
515 return false;
516}
517
Douglas Gregor6dd38da2009-08-27 06:03:53 +0000518bool DeclContext::Encloses(DeclContext *DC) {
519 if (getPrimaryContext() != this)
520 return getPrimaryContext()->Encloses(DC);
Mike Stump1eb44332009-09-09 15:08:12 +0000521
Douglas Gregor6dd38da2009-08-27 06:03:53 +0000522 for (; DC; DC = DC->getParent())
523 if (DC->getPrimaryContext() == this)
524 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000525 return false;
Douglas Gregor6dd38da2009-08-27 06:03:53 +0000526}
527
Steve Naroff0701bbb2009-01-08 17:28:14 +0000528DeclContext *DeclContext::getPrimaryContext() {
Douglas Gregor44b43212008-12-11 16:49:14 +0000529 switch (DeclKind) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000530 case Decl::TranslationUnit:
Douglas Gregor074149e2009-01-05 19:45:36 +0000531 case Decl::LinkageSpec:
Mike Stump1eb44332009-09-09 15:08:12 +0000532 case Decl::Block:
Douglas Gregor44b43212008-12-11 16:49:14 +0000533 // There is only one DeclContext for these entities.
534 return this;
535
536 case Decl::Namespace:
537 // The original namespace is our primary context.
538 return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
539
Douglas Gregor44b43212008-12-11 16:49:14 +0000540 case Decl::ObjCMethod:
541 return this;
542
543 case Decl::ObjCInterface:
Steve Naroff0701bbb2009-01-08 17:28:14 +0000544 case Decl::ObjCProtocol:
545 case Decl::ObjCCategory:
Douglas Gregor44b43212008-12-11 16:49:14 +0000546 // FIXME: Can Objective-C interfaces be forward-declared?
547 return this;
548
Steve Naroff0701bbb2009-01-08 17:28:14 +0000549 case Decl::ObjCImplementation:
550 case Decl::ObjCCategoryImpl:
551 return this;
552
Douglas Gregor44b43212008-12-11 16:49:14 +0000553 default:
Sean Hunt9a555912010-05-30 07:21:58 +0000554 if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) {
Douglas Gregorcc636682009-02-17 23:15:12 +0000555 // If this is a tag type that has a definition or is currently
556 // being defined, that definition is our primary context.
John McCall3cb0ebd2010-03-10 03:28:59 +0000557 TagDecl *Tag = cast<TagDecl>(this);
558 assert(isa<TagType>(Tag->TypeForDecl) ||
559 isa<InjectedClassNameType>(Tag->TypeForDecl));
560
561 if (TagDecl *Def = Tag->getDefinition())
562 return Def;
563
564 if (!isa<InjectedClassNameType>(Tag->TypeForDecl)) {
565 const TagType *TagTy = cast<TagType>(Tag->TypeForDecl);
566 if (TagTy->isBeingDefined())
567 // FIXME: is it necessarily being defined in the decl
568 // that owns the type?
569 return TagTy->getDecl();
570 }
571
572 return Tag;
Douglas Gregorcc636682009-02-17 23:15:12 +0000573 }
574
Sean Hunt9a555912010-05-30 07:21:58 +0000575 assert(DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction &&
Douglas Gregor44b43212008-12-11 16:49:14 +0000576 "Unknown DeclContext kind");
577 return this;
578 }
579}
580
581DeclContext *DeclContext::getNextContext() {
582 switch (DeclKind) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000583 case Decl::Namespace:
584 // Return the next namespace
585 return static_cast<NamespaceDecl*>(this)->getNextNamespace();
586
587 default:
Douglas Gregor44b43212008-12-11 16:49:14 +0000588 return 0;
589 }
590}
591
Douglas Gregor2cf26342009-04-09 22:27:44 +0000592/// \brief Load the declarations within this lexical storage from an
593/// external source.
Mike Stump1eb44332009-09-09 15:08:12 +0000594void
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000595DeclContext::LoadLexicalDeclsFromExternalStorage() const {
596 ExternalASTSource *Source = getParentASTContext().getExternalSource();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000597 assert(hasExternalLexicalStorage() && Source && "No external storage?");
598
Argyrios Kyrtzidis0dbbc042010-07-30 10:03:23 +0000599 // Notify that we have a DeclContext that is initializing.
600 ExternalASTSource::Deserializing ADeclContext(Source);
601
John McCall76bd1f32010-06-01 09:23:16 +0000602 llvm::SmallVector<Decl*, 64> Decls;
603 if (Source->FindExternalLexicalDecls(this, Decls))
Douglas Gregor2cf26342009-04-09 22:27:44 +0000604 return;
605
606 // There is no longer any lexical storage in this context
607 ExternalLexicalStorage = false;
608
609 if (Decls.empty())
610 return;
611
612 // Resolve all of the declaration IDs into declarations, building up
613 // a chain of declarations via the Decl::NextDeclInContext field.
614 Decl *FirstNewDecl = 0;
615 Decl *PrevDecl = 0;
616 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
John McCall76bd1f32010-06-01 09:23:16 +0000617 Decl *D = Decls[I];
Douglas Gregor2cf26342009-04-09 22:27:44 +0000618 if (PrevDecl)
619 PrevDecl->NextDeclInContext = D;
620 else
621 FirstNewDecl = D;
622
623 PrevDecl = D;
624 }
625
626 // Splice the newly-read declarations into the beginning of the list
627 // of declarations.
628 PrevDecl->NextDeclInContext = FirstDecl;
629 FirstDecl = FirstNewDecl;
630 if (!LastDecl)
631 LastDecl = PrevDecl;
632}
633
John McCall76bd1f32010-06-01 09:23:16 +0000634DeclContext::lookup_result
635ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC,
636 DeclarationName Name) {
637 ASTContext &Context = DC->getParentASTContext();
638 StoredDeclsMap *Map;
639 if (!(Map = DC->LookupPtr))
640 Map = DC->CreateStoredDeclsMap(Context);
Douglas Gregor2cf26342009-04-09 22:27:44 +0000641
John McCall76bd1f32010-06-01 09:23:16 +0000642 StoredDeclsList &List = (*Map)[Name];
643 assert(List.isNull());
644 (void) List;
Douglas Gregor2cf26342009-04-09 22:27:44 +0000645
John McCall76bd1f32010-06-01 09:23:16 +0000646 return DeclContext::lookup_result();
647}
Douglas Gregor2cf26342009-04-09 22:27:44 +0000648
John McCall76bd1f32010-06-01 09:23:16 +0000649DeclContext::lookup_result
650ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC,
John McCall76bd1f32010-06-01 09:23:16 +0000651 DeclarationName Name,
652 llvm::SmallVectorImpl<NamedDecl*> &Decls) {
653 ASTContext &Context = DC->getParentASTContext();;
654
655 StoredDeclsMap *Map;
656 if (!(Map = DC->LookupPtr))
657 Map = DC->CreateStoredDeclsMap(Context);
658
659 StoredDeclsList &List = (*Map)[Name];
660 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
661 if (List.isNull())
662 List.setOnlyValue(Decls[I]);
663 else
664 List.AddSubsequentDecl(Decls[I]);
665 }
666
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000667 return List.getLookupResult();
John McCall76bd1f32010-06-01 09:23:16 +0000668}
669
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000670void ExternalASTSource::MaterializeVisibleDeclsForName(const DeclContext *DC,
671 DeclarationName Name,
672 llvm::SmallVectorImpl<NamedDecl*> &Decls) {
673 assert(DC->LookupPtr);
674 StoredDeclsMap &Map = *DC->LookupPtr;
675
676 // If there's an entry in the table the visible decls for this name have
677 // already been deserialized.
678 if (Map.find(Name) == Map.end()) {
679 StoredDeclsList &List = Map[Name];
680 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
681 if (List.isNull())
682 List.setOnlyValue(Decls[I]);
683 else
684 List.AddSubsequentDecl(Decls[I]);
685 }
686 }
687}
688
Sebastian Redl681d7232010-07-27 00:17:23 +0000689DeclContext::decl_iterator DeclContext::noload_decls_begin() const {
690 return decl_iterator(FirstDecl);
691}
692
693DeclContext::decl_iterator DeclContext::noload_decls_end() const {
694 return decl_iterator();
695}
696
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000697DeclContext::decl_iterator DeclContext::decls_begin() const {
Douglas Gregor2cf26342009-04-09 22:27:44 +0000698 if (hasExternalLexicalStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000699 LoadLexicalDeclsFromExternalStorage();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000700
701 // FIXME: Check whether we need to load some declarations from
702 // external storage.
Mike Stump1eb44332009-09-09 15:08:12 +0000703 return decl_iterator(FirstDecl);
Douglas Gregor6ab35242009-04-09 21:40:53 +0000704}
705
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000706DeclContext::decl_iterator DeclContext::decls_end() const {
Douglas Gregor2cf26342009-04-09 22:27:44 +0000707 if (hasExternalLexicalStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000708 LoadLexicalDeclsFromExternalStorage();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000709
Mike Stump1eb44332009-09-09 15:08:12 +0000710 return decl_iterator();
Douglas Gregor6ab35242009-04-09 21:40:53 +0000711}
712
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000713bool DeclContext::decls_empty() const {
Douglas Gregor8038d512009-04-10 17:25:41 +0000714 if (hasExternalLexicalStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000715 LoadLexicalDeclsFromExternalStorage();
Douglas Gregor8038d512009-04-10 17:25:41 +0000716
717 return !FirstDecl;
718}
719
John McCall9f54ad42009-12-10 09:41:52 +0000720void DeclContext::removeDecl(Decl *D) {
721 assert(D->getLexicalDeclContext() == this &&
722 "decl being removed from non-lexical context");
723 assert((D->NextDeclInContext || D == LastDecl) &&
724 "decl is not in decls list");
725
726 // Remove D from the decl chain. This is O(n) but hopefully rare.
727 if (D == FirstDecl) {
728 if (D == LastDecl)
729 FirstDecl = LastDecl = 0;
730 else
731 FirstDecl = D->NextDeclInContext;
732 } else {
733 for (Decl *I = FirstDecl; true; I = I->NextDeclInContext) {
734 assert(I && "decl not found in linked list");
735 if (I->NextDeclInContext == D) {
736 I->NextDeclInContext = D->NextDeclInContext;
737 if (D == LastDecl) LastDecl = I;
738 break;
739 }
740 }
741 }
742
743 // Mark that D is no longer in the decl chain.
744 D->NextDeclInContext = 0;
745
746 // Remove D from the lookup table if necessary.
747 if (isa<NamedDecl>(D)) {
748 NamedDecl *ND = cast<NamedDecl>(D);
749
John McCall0c01d182010-03-24 05:22:00 +0000750 StoredDeclsMap *Map = getPrimaryContext()->LookupPtr;
751 if (!Map) return;
John McCall9f54ad42009-12-10 09:41:52 +0000752
John McCall9f54ad42009-12-10 09:41:52 +0000753 StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName());
754 assert(Pos != Map->end() && "no lookup entry for decl");
755 Pos->second.remove(ND);
756 }
757}
758
John McCall3f9a8a62009-08-11 06:59:38 +0000759void DeclContext::addHiddenDecl(Decl *D) {
Chris Lattner7f0be132009-02-20 00:56:18 +0000760 assert(D->getLexicalDeclContext() == this &&
761 "Decl inserted into wrong lexical context");
Mike Stump1eb44332009-09-09 15:08:12 +0000762 assert(!D->getNextDeclInContext() && D != LastDecl &&
Douglas Gregor6037fcb2009-01-09 19:42:16 +0000763 "Decl already inserted into a DeclContext");
764
765 if (FirstDecl) {
Chris Lattner244a67d2009-03-28 06:04:26 +0000766 LastDecl->NextDeclInContext = D;
Douglas Gregor6037fcb2009-01-09 19:42:16 +0000767 LastDecl = D;
768 } else {
769 FirstDecl = LastDecl = D;
770 }
John McCall3f9a8a62009-08-11 06:59:38 +0000771}
772
773void DeclContext::addDecl(Decl *D) {
774 addHiddenDecl(D);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000775
776 if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000777 ND->getDeclContext()->makeDeclVisibleInContext(ND);
Douglas Gregor44b43212008-12-11 16:49:14 +0000778}
779
Douglas Gregor074149e2009-01-05 19:45:36 +0000780/// buildLookup - Build the lookup data structure with all of the
781/// declarations in DCtx (and any other contexts linked to it or
782/// transparent contexts nested within it).
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000783void DeclContext::buildLookup(DeclContext *DCtx) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000784 for (; DCtx; DCtx = DCtx->getNextContext()) {
Mike Stump1eb44332009-09-09 15:08:12 +0000785 for (decl_iterator D = DCtx->decls_begin(),
786 DEnd = DCtx->decls_end();
Douglas Gregor4f3b8f82009-01-06 07:17:58 +0000787 D != DEnd; ++D) {
John McCall3f9a8a62009-08-11 06:59:38 +0000788 // Insert this declaration into the lookup structure, but only
789 // if it's semantically in its decl context. During non-lazy
790 // lookup building, this is implicitly enforced by addDecl.
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000791 if (NamedDecl *ND = dyn_cast<NamedDecl>(*D))
John McCall3f9a8a62009-08-11 06:59:38 +0000792 if (D->getDeclContext() == DCtx)
793 makeDeclVisibleInContextImpl(ND);
Douglas Gregor074149e2009-01-05 19:45:36 +0000794
Ted Kremenekc32b1d82009-11-17 22:58:30 +0000795 // Insert any forward-declared Objective-C interfaces into the lookup
796 // data structure.
797 if (ObjCClassDecl *Class = dyn_cast<ObjCClassDecl>(*D))
798 for (ObjCClassDecl::iterator I = Class->begin(), IEnd = Class->end();
799 I != IEnd; ++I)
Ted Kremenek321c22f2009-11-18 00:28:11 +0000800 makeDeclVisibleInContextImpl(I->getInterface());
Ted Kremenekc32b1d82009-11-17 22:58:30 +0000801
Douglas Gregor074149e2009-01-05 19:45:36 +0000802 // If this declaration is itself a transparent declaration context,
803 // add its members (recursively).
804 if (DeclContext *InnerCtx = dyn_cast<DeclContext>(*D))
805 if (InnerCtx->isTransparentContext())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000806 buildLookup(InnerCtx->getPrimaryContext());
Douglas Gregor074149e2009-01-05 19:45:36 +0000807 }
808 }
809}
810
Mike Stump1eb44332009-09-09 15:08:12 +0000811DeclContext::lookup_result
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000812DeclContext::lookup(DeclarationName Name) {
Steve Naroff0701bbb2009-01-08 17:28:14 +0000813 DeclContext *PrimaryContext = getPrimaryContext();
Douglas Gregor44b43212008-12-11 16:49:14 +0000814 if (PrimaryContext != this)
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000815 return PrimaryContext->lookup(Name);
Douglas Gregor44b43212008-12-11 16:49:14 +0000816
John McCall76bd1f32010-06-01 09:23:16 +0000817 if (hasExternalVisibleStorage()) {
818 // Check to see if we've already cached the lookup results.
819 if (LookupPtr) {
820 StoredDeclsMap::iterator I = LookupPtr->find(Name);
821 if (I != LookupPtr->end())
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000822 return I->second.getLookupResult();
John McCall76bd1f32010-06-01 09:23:16 +0000823 }
824
825 ExternalASTSource *Source = getParentASTContext().getExternalSource();
826 return Source->FindExternalVisibleDeclsByName(this, Name);
827 }
Douglas Gregor2cf26342009-04-09 22:27:44 +0000828
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000829 /// If there is no lookup data structure, build one now by walking
Douglas Gregor44b43212008-12-11 16:49:14 +0000830 /// all of the linked DeclContexts (in declaration order!) and
831 /// inserting their values.
Douglas Gregorc36c5402009-04-09 17:29:08 +0000832 if (!LookupPtr) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000833 buildLookup(this);
Douglas Gregor44b43212008-12-11 16:49:14 +0000834
Douglas Gregorc36c5402009-04-09 17:29:08 +0000835 if (!LookupPtr)
Douglas Gregora5fdd9c2010-05-11 06:18:17 +0000836 return lookup_result(lookup_iterator(0), lookup_iterator(0));
Douglas Gregorc36c5402009-04-09 17:29:08 +0000837 }
Douglas Gregor44b43212008-12-11 16:49:14 +0000838
John McCall0c01d182010-03-24 05:22:00 +0000839 StoredDeclsMap::iterator Pos = LookupPtr->find(Name);
840 if (Pos == LookupPtr->end())
Douglas Gregora5fdd9c2010-05-11 06:18:17 +0000841 return lookup_result(lookup_iterator(0), lookup_iterator(0));
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000842 return Pos->second.getLookupResult();
Douglas Gregor44b43212008-12-11 16:49:14 +0000843}
844
Mike Stump1eb44332009-09-09 15:08:12 +0000845DeclContext::lookup_const_result
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000846DeclContext::lookup(DeclarationName Name) const {
847 return const_cast<DeclContext*>(this)->lookup(Name);
Douglas Gregor44b43212008-12-11 16:49:14 +0000848}
849
Chris Lattner0cf2b192009-03-27 19:19:59 +0000850DeclContext *DeclContext::getLookupContext() {
851 DeclContext *Ctx = this;
Douglas Gregor72de6672009-01-08 20:45:30 +0000852 // Skip through transparent contexts.
Douglas Gregorce356072009-01-06 23:51:29 +0000853 while (Ctx->isTransparentContext())
854 Ctx = Ctx->getParent();
855 return Ctx;
856}
857
Douglas Gregor88b70942009-02-25 22:02:03 +0000858DeclContext *DeclContext::getEnclosingNamespaceContext() {
859 DeclContext *Ctx = this;
860 // Skip through non-namespace, non-translation-unit contexts.
Sebastian Redl51a8a372010-08-31 00:36:23 +0000861 while (!Ctx->isFileContext())
Douglas Gregor88b70942009-02-25 22:02:03 +0000862 Ctx = Ctx->getParent();
863 return Ctx->getPrimaryContext();
864}
865
John McCallab88d972009-08-31 22:39:49 +0000866void DeclContext::makeDeclVisibleInContext(NamedDecl *D, bool Recoverable) {
Douglas Gregorcc636682009-02-17 23:15:12 +0000867 // FIXME: This feels like a hack. Should DeclarationName support
868 // template-ids, or is there a better way to keep specializations
869 // from being visible?
870 if (isa<ClassTemplateSpecializationDecl>(D))
871 return;
Eli Friedman6bc20132009-12-08 05:40:03 +0000872 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
873 if (FD->isFunctionTemplateSpecialization())
874 return;
Douglas Gregorcc636682009-02-17 23:15:12 +0000875
Steve Naroff0701bbb2009-01-08 17:28:14 +0000876 DeclContext *PrimaryContext = getPrimaryContext();
Douglas Gregor44b43212008-12-11 16:49:14 +0000877 if (PrimaryContext != this) {
John McCallab88d972009-08-31 22:39:49 +0000878 PrimaryContext->makeDeclVisibleInContext(D, Recoverable);
Douglas Gregor44b43212008-12-11 16:49:14 +0000879 return;
880 }
881
882 // If we already have a lookup data structure, perform the insertion
Argyrios Kyrtzidis5586b012010-07-04 21:44:25 +0000883 // into it. If we haven't deserialized externally stored decls, deserialize
884 // them so we can add the decl. Otherwise, be lazy and don't build that
885 // structure until someone asks for it.
886 if (LookupPtr || !Recoverable || hasExternalVisibleStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000887 makeDeclVisibleInContextImpl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +0000888
Douglas Gregor074149e2009-01-05 19:45:36 +0000889 // If we are a transparent context, insert into our parent context,
890 // too. This operation is recursive.
891 if (isTransparentContext())
John McCallab88d972009-08-31 22:39:49 +0000892 getParent()->makeDeclVisibleInContext(D, Recoverable);
Douglas Gregor44b43212008-12-11 16:49:14 +0000893}
894
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000895void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000896 // Skip unnamed declarations.
897 if (!D->getDeclName())
898 return;
899
Douglas Gregorcc636682009-02-17 23:15:12 +0000900 // FIXME: This feels like a hack. Should DeclarationName support
901 // template-ids, or is there a better way to keep specializations
902 // from being visible?
903 if (isa<ClassTemplateSpecializationDecl>(D))
904 return;
905
Argyrios Kyrtzidis5586b012010-07-04 21:44:25 +0000906 ASTContext *C = 0;
907 if (!LookupPtr) {
908 C = &getParentASTContext();
909 CreateStoredDeclsMap(*C);
910 }
911
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000912 // If there is an external AST source, load any declarations it knows about
913 // with this declaration's name.
914 // If the lookup table contains an entry about this name it means that we
915 // have already checked the external source.
916 if (ExternalASTSource *Source = getParentASTContext().getExternalSource())
917 if (hasExternalVisibleStorage() &&
918 LookupPtr->find(D->getDeclName()) == LookupPtr->end())
919 Source->FindExternalVisibleDeclsByName(this, D->getDeclName());
920
Douglas Gregor44b43212008-12-11 16:49:14 +0000921 // Insert this declaration into the map.
John McCall0c01d182010-03-24 05:22:00 +0000922 StoredDeclsList &DeclNameEntries = (*LookupPtr)[D->getDeclName()];
Chris Lattner67762a32009-02-20 01:44:05 +0000923 if (DeclNameEntries.isNull()) {
924 DeclNameEntries.setOnlyValue(D);
Chris Lattnerbd6c8002009-02-19 07:00:44 +0000925 return;
Douglas Gregor44b43212008-12-11 16:49:14 +0000926 }
Chris Lattner91942502009-02-20 00:55:03 +0000927
Chris Lattnerbdc3d002009-02-20 01:10:07 +0000928 // If it is possible that this is a redeclaration, check to see if there is
929 // already a decl for which declarationReplaces returns true. If there is
930 // one, just replace it and return.
Argyrios Kyrtzidis074dcc82010-08-20 16:04:35 +0000931 if (DeclNameEntries.HandleRedeclaration(D))
Chris Lattner67762a32009-02-20 01:44:05 +0000932 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000933
Chris Lattnerbd6c8002009-02-19 07:00:44 +0000934 // Put this declaration into the appropriate slot.
Chris Lattner67762a32009-02-20 01:44:05 +0000935 DeclNameEntries.AddSubsequentDecl(D);
Douglas Gregor44b43212008-12-11 16:49:14 +0000936}
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000937
Argyrios Kyrtzidisa60786b2010-08-20 23:35:55 +0000938void DeclContext::MaterializeVisibleDeclsFromExternalStorage() {
939 ExternalASTSource *Source = getParentASTContext().getExternalSource();
940 assert(hasExternalVisibleStorage() && Source && "No external storage?");
941
942 if (!LookupPtr)
943 CreateStoredDeclsMap(getParentASTContext());
944 Source->MaterializeVisibleDecls(this);
945}
946
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000947/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
948/// this context.
Mike Stump1eb44332009-09-09 15:08:12 +0000949DeclContext::udir_iterator_range
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000950DeclContext::getUsingDirectives() const {
951 lookup_const_result Result = lookup(UsingDirectiveDecl::getName());
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000952 return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.first),
953 reinterpret_cast<udir_iterator>(Result.second));
954}
Douglas Gregor2cf26342009-04-09 22:27:44 +0000955
Ted Kremenek3478eb62010-02-11 07:12:28 +0000956//===----------------------------------------------------------------------===//
957// Creation and Destruction of StoredDeclsMaps. //
958//===----------------------------------------------------------------------===//
959
John McCall0c01d182010-03-24 05:22:00 +0000960StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const {
961 assert(!LookupPtr && "context already has a decls map");
962 assert(getPrimaryContext() == this &&
963 "creating decls map on non-primary context");
964
965 StoredDeclsMap *M;
966 bool Dependent = isDependentContext();
967 if (Dependent)
968 M = new DependentStoredDeclsMap();
969 else
970 M = new StoredDeclsMap();
971 M->Previous = C.LastSDM;
972 C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);
973 LookupPtr = M;
Ted Kremenek3478eb62010-02-11 07:12:28 +0000974 return M;
975}
976
977void ASTContext::ReleaseDeclContextMaps() {
John McCall0c01d182010-03-24 05:22:00 +0000978 // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap
979 // pointer because the subclass doesn't add anything that needs to
980 // be deleted.
John McCall0c01d182010-03-24 05:22:00 +0000981 StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt());
982}
983
984void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) {
985 while (Map) {
986 // Advance the iteration before we invalidate memory.
987 llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;
988
989 if (Dependent)
990 delete static_cast<DependentStoredDeclsMap*>(Map);
991 else
992 delete Map;
993
994 Map = Next.getPointer();
995 Dependent = Next.getInt();
996 }
997}
998
John McCall0c01d182010-03-24 05:22:00 +0000999DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
1000 DeclContext *Parent,
1001 const PartialDiagnostic &PDiag) {
1002 assert(Parent->isDependentContext()
1003 && "cannot iterate dependent diagnostics of non-dependent context");
1004 Parent = Parent->getPrimaryContext();
1005 if (!Parent->LookupPtr)
1006 Parent->CreateStoredDeclsMap(C);
1007
1008 DependentStoredDeclsMap *Map
1009 = static_cast<DependentStoredDeclsMap*>(Parent->LookupPtr);
1010
Douglas Gregorb8365182010-03-29 23:56:53 +00001011 // Allocate the copy of the PartialDiagnostic via the ASTContext's
Douglas Gregorfe6b2d42010-03-29 23:34:08 +00001012 // BumpPtrAllocator, rather than the ASTContext itself.
Douglas Gregorb8365182010-03-29 23:56:53 +00001013 PartialDiagnostic::Storage *DiagStorage = 0;
1014 if (PDiag.hasStorage())
1015 DiagStorage = new (C) PartialDiagnostic::Storage;
1016
1017 DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
John McCall0c01d182010-03-24 05:22:00 +00001018
1019 // TODO: Maybe we shouldn't reverse the order during insertion.
1020 DD->NextDiagnostic = Map->FirstDiagnostic;
1021 Map->FirstDiagnostic = DD;
1022
1023 return DD;
Ted Kremenek3478eb62010-02-11 07:12:28 +00001024}