blob: 763998e852ed88361886ad0924b0994bf8e6cd5c [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"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000018#include "clang/AST/DeclObjC.h"
19#include "clang/AST/DeclTemplate.h"
Eli Friedman56d29372008-06-07 16:52:53 +000020#include "clang/AST/ASTContext.h"
Douglas Gregor44b43212008-12-11 16:49:14 +000021#include "clang/AST/Type.h"
Eli Friedman56d29372008-06-07 16:52:53 +000022#include "llvm/ADT/DenseMap.h"
Chris Lattner49f28ca2009-03-05 08:00:35 +000023#include "llvm/Support/raw_ostream.h"
Douglas Gregor6ed40e32008-12-23 21:05:05 +000024#include <algorithm>
Chris Lattner3daed522009-03-02 22:20:04 +000025#include <cstdio>
Douglas Gregor3fc749d2008-12-23 00:26:44 +000026#include <vector>
Eli Friedman56d29372008-06-07 16:52:53 +000027using namespace clang;
28
29//===----------------------------------------------------------------------===//
30// Statistics
31//===----------------------------------------------------------------------===//
32
Douglas Gregor64650af2009-02-02 23:39:07 +000033#define DECL(Derived, Base) static int n##Derived##s = 0;
34#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000035
36static bool StatSwitch = false;
37
38// This keeps track of all decl attributes. Since so few decls have attrs, we
39// keep them in a hash map instead of wasting space in the Decl class.
40typedef llvm::DenseMap<const Decl*, Attr*> DeclAttrMapTy;
41
42static DeclAttrMapTy *DeclAttrs = 0;
43
44const char *Decl::getDeclKindName() const {
45 switch (DeclKind) {
Douglas Gregor64650af2009-02-02 23:39:07 +000046 default: assert(0 && "Declaration not in DeclNodes.def!");
47#define DECL(Derived, Base) case Derived: return #Derived;
48#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000049 }
50}
51
Steve Naroff0a473932009-01-20 19:53:53 +000052const char *DeclContext::getDeclKindName() const {
53 switch (DeclKind) {
Douglas Gregor64650af2009-02-02 23:39:07 +000054 default: assert(0 && "Declaration context not in DeclNodes.def!");
Argyrios Kyrtzidis1ad4dd72009-02-16 14:28:33 +000055#define DECL(Derived, Base) case Decl::Derived: return #Derived;
Douglas Gregor64650af2009-02-02 23:39:07 +000056#include "clang/AST/DeclNodes.def"
Steve Naroff0a473932009-01-20 19:53:53 +000057 }
58}
59
Eli Friedman56d29372008-06-07 16:52:53 +000060bool Decl::CollectingStats(bool Enable) {
61 if (Enable)
62 StatSwitch = true;
63 return StatSwitch;
64}
65
66void Decl::PrintStats() {
67 fprintf(stderr, "*** Decl Stats:\n");
Eli Friedman56d29372008-06-07 16:52:53 +000068
Douglas Gregor64650af2009-02-02 23:39:07 +000069 int totalDecls = 0;
70#define DECL(Derived, Base) totalDecls += n##Derived##s;
71#include "clang/AST/DeclNodes.def"
72 fprintf(stderr, " %d decls total.\n", totalDecls);
73
74 int totalBytes = 0;
75#define DECL(Derived, Base) \
76 if (n##Derived##s > 0) { \
77 totalBytes += (int)(n##Derived##s * sizeof(Derived##Decl)); \
78 fprintf(stderr, " %d " #Derived " decls, %d each (%d bytes)\n", \
79 n##Derived##s, (int)sizeof(Derived##Decl), \
80 (int)(n##Derived##s * sizeof(Derived##Decl))); \
81 }
82#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000083
Douglas Gregor64650af2009-02-02 23:39:07 +000084 fprintf(stderr, "Total bytes = %d\n", totalBytes);
Eli Friedman56d29372008-06-07 16:52:53 +000085}
86
87void Decl::addDeclKind(Kind k) {
88 switch (k) {
Douglas Gregor64650af2009-02-02 23:39:07 +000089 default: assert(0 && "Declaration not in DeclNodes.def!");
90#define DECL(Derived, Base) case Derived: ++n##Derived##s; break;
91#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000092 }
93}
94
95//===----------------------------------------------------------------------===//
Chris Lattner49f28ca2009-03-05 08:00:35 +000096// PrettyStackTraceDecl Implementation
97//===----------------------------------------------------------------------===//
98
99void PrettyStackTraceDecl::print(llvm::raw_ostream &OS) const {
100 SourceLocation TheLoc = Loc;
101 if (TheLoc.isInvalid() && TheDecl)
102 TheLoc = TheDecl->getLocation();
103
104 if (TheLoc.isValid()) {
105 TheLoc.print(OS, SM);
106 OS << ": ";
107 }
108
109 OS << Message;
110
111 if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl))
112 OS << " '" << DN->getQualifiedNameAsString() << '\'';
113 OS << '\n';
114}
115
116//===----------------------------------------------------------------------===//
Eli Friedman56d29372008-06-07 16:52:53 +0000117// Decl Implementation
118//===----------------------------------------------------------------------===//
119
Chris Lattner769dbdf2009-03-27 20:18:19 +0000120// Out-of-line virtual method providing a home for Decl.
121Decl::~Decl() {
122 if (isOutOfSemaDC())
123 delete getMultipleDC();
124
125 assert(!HasAttrs && "attributes should have been freed by Destroy");
126}
127
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000128void Decl::setDeclContext(DeclContext *DC) {
129 if (isOutOfSemaDC())
130 delete getMultipleDC();
131
Chris Lattneree219fd2009-03-29 06:06:59 +0000132 DeclCtx = DC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000133}
134
135void Decl::setLexicalDeclContext(DeclContext *DC) {
136 if (DC == getLexicalDeclContext())
137 return;
138
139 if (isInSemaDC()) {
140 MultipleDC *MDC = new MultipleDC();
141 MDC->SemanticDC = getDeclContext();
142 MDC->LexicalDC = DC;
Chris Lattneree219fd2009-03-29 06:06:59 +0000143 DeclCtx = MDC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000144 } else {
145 getMultipleDC()->LexicalDC = DC;
146 }
147}
148
Chris Lattner769dbdf2009-03-27 20:18:19 +0000149unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
150 switch (DeclKind) {
151 default:
152 if (DeclKind >= FunctionFirst && DeclKind <= FunctionLast)
153 return IDNS_Ordinary;
154 assert(0 && "Unknown decl kind!");
155 case OverloadedFunction:
156 case Typedef:
157 case EnumConstant:
158 case Var:
159 case ImplicitParam:
160 case ParmVar:
161 case OriginalParmVar:
162 case NonTypeTemplateParm:
163 case ObjCMethod:
164 case ObjCContainer:
165 case ObjCCategory:
166 case ObjCInterface:
167 case ObjCCategoryImpl:
168 case ObjCProperty:
169 case ObjCCompatibleAlias:
170 return IDNS_Ordinary;
171
172 case ObjCProtocol:
173 return IDNS_Protocol;
174
175 case Field:
176 case ObjCAtDefsField:
177 case ObjCIvar:
178 return IDNS_Member;
179
180 case Record:
181 case CXXRecord:
182 case Enum:
183 case TemplateTypeParm:
184 return IDNS_Tag;
185
186 case Namespace:
187 case Template:
188 case FunctionTemplate:
189 case ClassTemplate:
190 case TemplateTemplateParm:
Anders Carlssonfaf0e872009-03-28 23:02:53 +0000191 case NamespaceAlias:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000192 return IDNS_Tag | IDNS_Ordinary;
193
194 // Never have names.
195 case LinkageSpec:
196 case FileScopeAsm:
197 case StaticAssert:
198 case ObjCClass:
199 case ObjCImplementation:
200 case ObjCPropertyImpl:
201 case ObjCForwardProtocol:
202 case Block:
203 case TranslationUnit:
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000204
Chris Lattner769dbdf2009-03-27 20:18:19 +0000205 // Aren't looked up?
206 case UsingDirective:
207 case ClassTemplateSpecialization:
208 return 0;
209 }
Eli Friedman56d29372008-06-07 16:52:53 +0000210}
211
212void Decl::addAttr(Attr *NewAttr) {
213 if (!DeclAttrs)
214 DeclAttrs = new DeclAttrMapTy();
215
216 Attr *&ExistingAttr = (*DeclAttrs)[this];
217
218 NewAttr->setNext(ExistingAttr);
219 ExistingAttr = NewAttr;
220
221 HasAttrs = true;
222}
223
224void Decl::invalidateAttrs() {
225 if (!HasAttrs) return;
226
227 HasAttrs = false;
228 (*DeclAttrs)[this] = 0;
229 DeclAttrs->erase(this);
230
231 if (DeclAttrs->empty()) {
232 delete DeclAttrs;
233 DeclAttrs = 0;
234 }
235}
236
Chris Lattner81abbdd2009-03-21 06:27:31 +0000237const Attr *Decl::getAttrsImpl() const {
238 assert(HasAttrs && "getAttrs() should verify this!");
Eli Friedman56d29372008-06-07 16:52:53 +0000239 return (*DeclAttrs)[this];
240}
241
242void Decl::swapAttrs(Decl *RHS) {
243 bool HasLHSAttr = this->HasAttrs;
244 bool HasRHSAttr = RHS->HasAttrs;
245
246 // Usually, neither decl has attrs, nothing to do.
247 if (!HasLHSAttr && !HasRHSAttr) return;
248
249 // If 'this' has no attrs, swap the other way.
250 if (!HasLHSAttr)
251 return RHS->swapAttrs(this);
252
253 // Handle the case when both decls have attrs.
254 if (HasRHSAttr) {
255 std::swap((*DeclAttrs)[this], (*DeclAttrs)[RHS]);
256 return;
257 }
258
259 // Otherwise, LHS has an attr and RHS doesn't.
260 (*DeclAttrs)[RHS] = (*DeclAttrs)[this];
261 (*DeclAttrs).erase(this);
262 this->HasAttrs = false;
263 RHS->HasAttrs = true;
264}
265
266
Chris Lattnercc581472009-03-04 06:05:19 +0000267void Decl::Destroy(ASTContext &C) {
268 // Free attributes for this decl.
269 if (HasAttrs) {
270 DeclAttrMapTy::iterator it = DeclAttrs->find(this);
271 assert(it != DeclAttrs->end() && "No attrs found but HasAttrs is true!");
272
273 // release attributes.
274 it->second->Destroy(C);
275 invalidateAttrs();
276 HasAttrs = false;
277 }
278
Douglas Gregora0fc55f2009-01-13 19:47:12 +0000279#if 0
Douglas Gregor00ad0ef2009-01-20 04:25:11 +0000280 // FIXME: Once ownership is fully understood, we can enable this code
281 if (DeclContext *DC = dyn_cast<DeclContext>(this))
282 DC->decls_begin()->Destroy(C);
Eli Friedman56d29372008-06-07 16:52:53 +0000283
Chris Lattner244a67d2009-03-28 06:04:26 +0000284 // Observe the unrolled recursion. By setting N->NextDeclInContext = 0x0
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000285 // within the loop, only the Destroy method for the first Decl
286 // will deallocate all of the Decls in a chain.
287
Chris Lattner244a67d2009-03-28 06:04:26 +0000288 Decl* N = getNextDeclInContext();
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000289
290 while (N) {
Chris Lattner244a67d2009-03-28 06:04:26 +0000291 Decl* Tmp = N->getNextDeclInContext();
292 N->NextDeclInContext = 0;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000293 N->Destroy(C);
294 N = Tmp;
Eli Friedman56d29372008-06-07 16:52:53 +0000295 }
Douglas Gregora0fc55f2009-01-13 19:47:12 +0000296
Eli Friedman56d29372008-06-07 16:52:53 +0000297 this->~Decl();
Steve Naroff3e970492009-01-27 21:25:57 +0000298 C.Deallocate((void *)this);
Douglas Gregor00ad0ef2009-01-20 04:25:11 +0000299#endif
Eli Friedman56d29372008-06-07 16:52:53 +0000300}
301
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000302Decl *Decl::castFromDeclContext (const DeclContext *D) {
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000303 Decl::Kind DK = D->getDeclKind();
304 switch(DK) {
305#define DECL_CONTEXT(Name) \
306 case Decl::Name: \
307 return static_cast<Name##Decl*>(const_cast<DeclContext*>(D));
308#define DECL_CONTEXT_BASE(Name)
309#include "clang/AST/DeclNodes.def"
310 default:
311#define DECL_CONTEXT_BASE(Name) \
312 if (DK >= Decl::Name##First && DK <= Decl::Name##Last) \
313 return static_cast<Name##Decl*>(const_cast<DeclContext*>(D));
314#include "clang/AST/DeclNodes.def"
315 assert(false && "a decl that inherits DeclContext isn't handled");
316 return 0;
317 }
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000318}
319
320DeclContext *Decl::castToDeclContext(const Decl *D) {
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000321 Decl::Kind DK = D->getKind();
322 switch(DK) {
323#define DECL_CONTEXT(Name) \
324 case Decl::Name: \
325 return static_cast<Name##Decl*>(const_cast<Decl*>(D));
326#define DECL_CONTEXT_BASE(Name)
327#include "clang/AST/DeclNodes.def"
328 default:
329#define DECL_CONTEXT_BASE(Name) \
330 if (DK >= Decl::Name##First && DK <= Decl::Name##Last) \
331 return static_cast<Name##Decl*>(const_cast<Decl*>(D));
332#include "clang/AST/DeclNodes.def"
333 assert(false && "a decl that inherits DeclContext isn't handled");
334 return 0;
335 }
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000336}
337
Anders Carlsson1329c272009-03-25 23:38:06 +0000338#ifndef NDEBUG
339void Decl::CheckAccessDeclContext() const {
Douglas Gregor5c27f2b2009-04-07 20:58:25 +0000340 assert((Access != AS_none || isa<TranslationUnitDecl>(this) ||
341 !isa<CXXRecordDecl>(getDeclContext())) &&
Anders Carlsson1329c272009-03-25 23:38:06 +0000342 "Access specifier is AS_none inside a record decl");
343}
344
345#endif
346
Eli Friedman56d29372008-06-07 16:52:53 +0000347//===----------------------------------------------------------------------===//
348// DeclContext Implementation
349//===----------------------------------------------------------------------===//
350
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000351bool DeclContext::classof(const Decl *D) {
352 switch (D->getKind()) {
353#define DECL_CONTEXT(Name) case Decl::Name:
354#define DECL_CONTEXT_BASE(Name)
355#include "clang/AST/DeclNodes.def"
356 return true;
357 default:
358#define DECL_CONTEXT_BASE(Name) \
359 if (D->getKind() >= Decl::Name##First && \
360 D->getKind() <= Decl::Name##Last) \
361 return true;
362#include "clang/AST/DeclNodes.def"
363 return false;
364 }
365}
366
Douglas Gregor44b43212008-12-11 16:49:14 +0000367DeclContext::~DeclContext() {
Douglas Gregorc36c5402009-04-09 17:29:08 +0000368 delete static_cast<StoredDeclsMap*>(LookupPtr);
Douglas Gregor44b43212008-12-11 16:49:14 +0000369}
370
371void DeclContext::DestroyDecls(ASTContext &C) {
Douglas Gregor6ab35242009-04-09 21:40:53 +0000372 for (decl_iterator D = decls_begin(C); D != decls_end(C); )
Douglas Gregor00ad0ef2009-01-20 04:25:11 +0000373 (*D++)->Destroy(C);
Douglas Gregor44b43212008-12-11 16:49:14 +0000374}
375
Douglas Gregor074149e2009-01-05 19:45:36 +0000376bool DeclContext::isTransparentContext() const {
377 if (DeclKind == Decl::Enum)
378 return true; // FIXME: Check for C++0x scoped enums
379 else if (DeclKind == Decl::LinkageSpec)
380 return true;
Douglas Gregor65100792009-02-26 00:02:51 +0000381 else if (DeclKind >= Decl::RecordFirst && DeclKind <= Decl::RecordLast)
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000382 return cast<RecordDecl>(this)->isAnonymousStructOrUnion();
Douglas Gregor074149e2009-01-05 19:45:36 +0000383 else if (DeclKind == Decl::Namespace)
384 return false; // FIXME: Check for C++0x inline namespaces
385
386 return false;
387}
388
Steve Naroff0701bbb2009-01-08 17:28:14 +0000389DeclContext *DeclContext::getPrimaryContext() {
Douglas Gregor44b43212008-12-11 16:49:14 +0000390 switch (DeclKind) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000391 case Decl::TranslationUnit:
Douglas Gregor074149e2009-01-05 19:45:36 +0000392 case Decl::LinkageSpec:
393 case Decl::Block:
Douglas Gregor44b43212008-12-11 16:49:14 +0000394 // There is only one DeclContext for these entities.
395 return this;
396
397 case Decl::Namespace:
398 // The original namespace is our primary context.
399 return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
400
Douglas Gregor44b43212008-12-11 16:49:14 +0000401 case Decl::ObjCMethod:
402 return this;
403
404 case Decl::ObjCInterface:
Steve Naroff0701bbb2009-01-08 17:28:14 +0000405 case Decl::ObjCProtocol:
406 case Decl::ObjCCategory:
Douglas Gregor44b43212008-12-11 16:49:14 +0000407 // FIXME: Can Objective-C interfaces be forward-declared?
408 return this;
409
Steve Naroff0701bbb2009-01-08 17:28:14 +0000410 case Decl::ObjCImplementation:
411 case Decl::ObjCCategoryImpl:
412 return this;
413
Douglas Gregor44b43212008-12-11 16:49:14 +0000414 default:
Douglas Gregorcc636682009-02-17 23:15:12 +0000415 if (DeclKind >= Decl::TagFirst && DeclKind <= Decl::TagLast) {
416 // If this is a tag type that has a definition or is currently
417 // being defined, that definition is our primary context.
Chris Lattner244a67d2009-03-28 06:04:26 +0000418 if (const TagType *TagT =cast<TagDecl>(this)->TypeForDecl->getAsTagType())
Douglas Gregorcc636682009-02-17 23:15:12 +0000419 if (TagT->isBeingDefined() ||
420 (TagT->getDecl() && TagT->getDecl()->isDefinition()))
421 return TagT->getDecl();
422 return this;
423 }
424
Douglas Gregor44b43212008-12-11 16:49:14 +0000425 assert(DeclKind >= Decl::FunctionFirst && DeclKind <= Decl::FunctionLast &&
426 "Unknown DeclContext kind");
427 return this;
428 }
429}
430
431DeclContext *DeclContext::getNextContext() {
432 switch (DeclKind) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000433 case Decl::Namespace:
434 // Return the next namespace
435 return static_cast<NamespaceDecl*>(this)->getNextNamespace();
436
437 default:
Douglas Gregor44b43212008-12-11 16:49:14 +0000438 return 0;
439 }
440}
441
Douglas Gregor6ab35242009-04-09 21:40:53 +0000442DeclContext::decl_iterator DeclContext::decls_begin(ASTContext &Context) const {
443 return decl_iterator(FirstDecl);
444}
445
446DeclContext::decl_iterator DeclContext::decls_end(ASTContext &Context) const {
447 return decl_iterator();
448}
449
450void DeclContext::addDecl(ASTContext &Context, Decl *D) {
Chris Lattner7f0be132009-02-20 00:56:18 +0000451 assert(D->getLexicalDeclContext() == this &&
452 "Decl inserted into wrong lexical context");
Chris Lattner244a67d2009-03-28 06:04:26 +0000453 assert(!D->getNextDeclInContext() && D != LastDecl &&
Douglas Gregor6037fcb2009-01-09 19:42:16 +0000454 "Decl already inserted into a DeclContext");
455
456 if (FirstDecl) {
Chris Lattner244a67d2009-03-28 06:04:26 +0000457 LastDecl->NextDeclInContext = D;
Douglas Gregor6037fcb2009-01-09 19:42:16 +0000458 LastDecl = D;
459 } else {
460 FirstDecl = LastDecl = D;
461 }
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000462
463 if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
Douglas Gregor6ab35242009-04-09 21:40:53 +0000464 ND->getDeclContext()->makeDeclVisibleInContext(Context, ND);
Douglas Gregor44b43212008-12-11 16:49:14 +0000465}
466
Douglas Gregor074149e2009-01-05 19:45:36 +0000467/// buildLookup - Build the lookup data structure with all of the
468/// declarations in DCtx (and any other contexts linked to it or
469/// transparent contexts nested within it).
Douglas Gregor6ab35242009-04-09 21:40:53 +0000470void DeclContext::buildLookup(ASTContext &Context, DeclContext *DCtx) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000471 for (; DCtx; DCtx = DCtx->getNextContext()) {
Douglas Gregor6ab35242009-04-09 21:40:53 +0000472 for (decl_iterator D = DCtx->decls_begin(Context),
473 DEnd = DCtx->decls_end(Context);
Douglas Gregor4f3b8f82009-01-06 07:17:58 +0000474 D != DEnd; ++D) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000475 // Insert this declaration into the lookup structure
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000476 if (NamedDecl *ND = dyn_cast<NamedDecl>(*D))
Douglas Gregor6ab35242009-04-09 21:40:53 +0000477 makeDeclVisibleInContextImpl(Context, ND);
Douglas Gregor074149e2009-01-05 19:45:36 +0000478
479 // If this declaration is itself a transparent declaration context,
480 // add its members (recursively).
481 if (DeclContext *InnerCtx = dyn_cast<DeclContext>(*D))
482 if (InnerCtx->isTransparentContext())
Douglas Gregor6ab35242009-04-09 21:40:53 +0000483 buildLookup(Context, InnerCtx->getPrimaryContext());
Douglas Gregor074149e2009-01-05 19:45:36 +0000484 }
485 }
486}
487
Douglas Gregor44b43212008-12-11 16:49:14 +0000488DeclContext::lookup_result
Douglas Gregor6ab35242009-04-09 21:40:53 +0000489DeclContext::lookup(ASTContext &Context, DeclarationName Name) {
Steve Naroff0701bbb2009-01-08 17:28:14 +0000490 DeclContext *PrimaryContext = getPrimaryContext();
Douglas Gregor44b43212008-12-11 16:49:14 +0000491 if (PrimaryContext != this)
Douglas Gregor6ab35242009-04-09 21:40:53 +0000492 return PrimaryContext->lookup(Context, Name);
Douglas Gregor44b43212008-12-11 16:49:14 +0000493
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000494 /// If there is no lookup data structure, build one now by walking
Douglas Gregor44b43212008-12-11 16:49:14 +0000495 /// all of the linked DeclContexts (in declaration order!) and
496 /// inserting their values.
Douglas Gregorc36c5402009-04-09 17:29:08 +0000497 if (!LookupPtr) {
Douglas Gregor6ab35242009-04-09 21:40:53 +0000498 buildLookup(Context, this);
Douglas Gregor44b43212008-12-11 16:49:14 +0000499
Douglas Gregorc36c5402009-04-09 17:29:08 +0000500 if (!LookupPtr)
Chris Lattner91942502009-02-20 00:55:03 +0000501 return lookup_result(0, 0);
Douglas Gregorc36c5402009-04-09 17:29:08 +0000502 }
Douglas Gregor44b43212008-12-11 16:49:14 +0000503
Douglas Gregorc36c5402009-04-09 17:29:08 +0000504 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(LookupPtr);
505 StoredDeclsMap::iterator Pos = Map->find(Name);
506 if (Pos == Map->end())
507 return lookup_result(0, 0);
Douglas Gregor6ab35242009-04-09 21:40:53 +0000508 return Pos->second.getLookupResult(Context);
Douglas Gregor44b43212008-12-11 16:49:14 +0000509}
510
511DeclContext::lookup_const_result
Douglas Gregor6ab35242009-04-09 21:40:53 +0000512DeclContext::lookup(ASTContext &Context, DeclarationName Name) const {
513 return const_cast<DeclContext*>(this)->lookup(Context, Name);
Douglas Gregor44b43212008-12-11 16:49:14 +0000514}
515
Chris Lattner0cf2b192009-03-27 19:19:59 +0000516DeclContext *DeclContext::getLookupContext() {
517 DeclContext *Ctx = this;
Douglas Gregor72de6672009-01-08 20:45:30 +0000518 // Skip through transparent contexts.
Douglas Gregorce356072009-01-06 23:51:29 +0000519 while (Ctx->isTransparentContext())
520 Ctx = Ctx->getParent();
521 return Ctx;
522}
523
Douglas Gregor88b70942009-02-25 22:02:03 +0000524DeclContext *DeclContext::getEnclosingNamespaceContext() {
525 DeclContext *Ctx = this;
526 // Skip through non-namespace, non-translation-unit contexts.
527 while (!Ctx->isFileContext() || Ctx->isTransparentContext())
528 Ctx = Ctx->getParent();
529 return Ctx->getPrimaryContext();
530}
531
Douglas Gregor6ab35242009-04-09 21:40:53 +0000532void DeclContext::makeDeclVisibleInContext(ASTContext &Context, NamedDecl *D) {
Douglas Gregorcc636682009-02-17 23:15:12 +0000533 // FIXME: This feels like a hack. Should DeclarationName support
534 // template-ids, or is there a better way to keep specializations
535 // from being visible?
536 if (isa<ClassTemplateSpecializationDecl>(D))
537 return;
538
Steve Naroff0701bbb2009-01-08 17:28:14 +0000539 DeclContext *PrimaryContext = getPrimaryContext();
Douglas Gregor44b43212008-12-11 16:49:14 +0000540 if (PrimaryContext != this) {
Douglas Gregor6ab35242009-04-09 21:40:53 +0000541 PrimaryContext->makeDeclVisibleInContext(Context, D);
Douglas Gregor44b43212008-12-11 16:49:14 +0000542 return;
543 }
544
545 // If we already have a lookup data structure, perform the insertion
546 // into it. Otherwise, be lazy and don't build that structure until
547 // someone asks for it.
Douglas Gregorc36c5402009-04-09 17:29:08 +0000548 if (LookupPtr)
Douglas Gregor6ab35242009-04-09 21:40:53 +0000549 makeDeclVisibleInContextImpl(Context, D);
Douglas Gregor074149e2009-01-05 19:45:36 +0000550
Douglas Gregor074149e2009-01-05 19:45:36 +0000551 // If we are a transparent context, insert into our parent context,
552 // too. This operation is recursive.
553 if (isTransparentContext())
Douglas Gregor6ab35242009-04-09 21:40:53 +0000554 getParent()->makeDeclVisibleInContext(Context, D);
Douglas Gregor44b43212008-12-11 16:49:14 +0000555}
556
Douglas Gregor6ab35242009-04-09 21:40:53 +0000557void DeclContext::makeDeclVisibleInContextImpl(ASTContext &Context,
558 NamedDecl *D) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000559 // Skip unnamed declarations.
560 if (!D->getDeclName())
561 return;
562
Douglas Gregorcc636682009-02-17 23:15:12 +0000563 // FIXME: This feels like a hack. Should DeclarationName support
564 // template-ids, or is there a better way to keep specializations
565 // from being visible?
566 if (isa<ClassTemplateSpecializationDecl>(D))
567 return;
568
Douglas Gregorc36c5402009-04-09 17:29:08 +0000569 if (!LookupPtr)
570 LookupPtr = new StoredDeclsMap;
Douglas Gregor44b43212008-12-11 16:49:14 +0000571
572 // Insert this declaration into the map.
Douglas Gregorc36c5402009-04-09 17:29:08 +0000573 StoredDeclsMap &Map = *static_cast<StoredDeclsMap*>(LookupPtr);
Chris Lattner67762a32009-02-20 01:44:05 +0000574 StoredDeclsList &DeclNameEntries = Map[D->getDeclName()];
575 if (DeclNameEntries.isNull()) {
576 DeclNameEntries.setOnlyValue(D);
Chris Lattnerbd6c8002009-02-19 07:00:44 +0000577 return;
Douglas Gregor44b43212008-12-11 16:49:14 +0000578 }
Chris Lattner91942502009-02-20 00:55:03 +0000579
Chris Lattnerbdc3d002009-02-20 01:10:07 +0000580 // If it is possible that this is a redeclaration, check to see if there is
581 // already a decl for which declarationReplaces returns true. If there is
582 // one, just replace it and return.
Douglas Gregor6ab35242009-04-09 21:40:53 +0000583 if (DeclNameEntries.HandleRedeclaration(Context, D))
Chris Lattner67762a32009-02-20 01:44:05 +0000584 return;
Chris Lattner91942502009-02-20 00:55:03 +0000585
Chris Lattnerbd6c8002009-02-19 07:00:44 +0000586 // Put this declaration into the appropriate slot.
Chris Lattner67762a32009-02-20 01:44:05 +0000587 DeclNameEntries.AddSubsequentDecl(D);
Douglas Gregor44b43212008-12-11 16:49:14 +0000588}
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000589
590/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
591/// this context.
Douglas Gregor6ab35242009-04-09 21:40:53 +0000592DeclContext::udir_iterator_range
593DeclContext::getUsingDirectives(ASTContext &Context) const {
594 lookup_const_result Result = lookup(Context, UsingDirectiveDecl::getName());
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000595 return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.first),
596 reinterpret_cast<udir_iterator>(Result.second));
597}