blob: 5f639d807dc3b729b46d4a3f491adc1a17a590ec [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"
Douglas Gregor2cf26342009-04-09 22:27:44 +000020#include "clang/AST/ExternalASTSource.h"
Eli Friedman56d29372008-06-07 16:52:53 +000021#include "clang/AST/ASTContext.h"
Douglas Gregor44b43212008-12-11 16:49:14 +000022#include "clang/AST/Type.h"
Sebastian Redld3a413d2009-04-26 20:35:05 +000023#include "clang/AST/Stmt.h"
24#include "clang/AST/StmtCXX.h"
Eli Friedman56d29372008-06-07 16:52:53 +000025#include "llvm/ADT/DenseMap.h"
Chris Lattner49f28ca2009-03-05 08:00:35 +000026#include "llvm/Support/raw_ostream.h"
Douglas Gregor6ed40e32008-12-23 21:05:05 +000027#include <algorithm>
Chris Lattner3daed522009-03-02 22:20:04 +000028#include <cstdio>
Douglas Gregor3fc749d2008-12-23 00:26:44 +000029#include <vector>
Eli Friedman56d29372008-06-07 16:52:53 +000030using namespace clang;
31
32//===----------------------------------------------------------------------===//
33// Statistics
34//===----------------------------------------------------------------------===//
35
Douglas Gregor64650af2009-02-02 23:39:07 +000036#define DECL(Derived, Base) static int n##Derived##s = 0;
37#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000038
39static bool StatSwitch = false;
40
Eli Friedman56d29372008-06-07 16:52:53 +000041const char *Decl::getDeclKindName() const {
42 switch (DeclKind) {
Douglas Gregor64650af2009-02-02 23:39:07 +000043 default: assert(0 && "Declaration not in DeclNodes.def!");
44#define DECL(Derived, Base) case Derived: return #Derived;
45#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000046 }
47}
48
Steve Naroff0a473932009-01-20 19:53:53 +000049const char *DeclContext::getDeclKindName() const {
50 switch (DeclKind) {
Douglas Gregor64650af2009-02-02 23:39:07 +000051 default: assert(0 && "Declaration context not in DeclNodes.def!");
Argyrios Kyrtzidis1ad4dd72009-02-16 14:28:33 +000052#define DECL(Derived, Base) case Decl::Derived: return #Derived;
Douglas Gregor64650af2009-02-02 23:39:07 +000053#include "clang/AST/DeclNodes.def"
Steve Naroff0a473932009-01-20 19:53:53 +000054 }
55}
56
Eli Friedman56d29372008-06-07 16:52:53 +000057bool Decl::CollectingStats(bool Enable) {
58 if (Enable)
59 StatSwitch = true;
60 return StatSwitch;
61}
62
63void Decl::PrintStats() {
64 fprintf(stderr, "*** Decl Stats:\n");
Mike Stump1eb44332009-09-09 15:08:12 +000065
Douglas Gregor64650af2009-02-02 23:39:07 +000066 int totalDecls = 0;
67#define DECL(Derived, Base) totalDecls += n##Derived##s;
68#include "clang/AST/DeclNodes.def"
69 fprintf(stderr, " %d decls total.\n", totalDecls);
Mike Stump1eb44332009-09-09 15:08:12 +000070
Douglas Gregor64650af2009-02-02 23:39:07 +000071 int totalBytes = 0;
72#define DECL(Derived, Base) \
73 if (n##Derived##s > 0) { \
74 totalBytes += (int)(n##Derived##s * sizeof(Derived##Decl)); \
75 fprintf(stderr, " %d " #Derived " decls, %d each (%d bytes)\n", \
76 n##Derived##s, (int)sizeof(Derived##Decl), \
77 (int)(n##Derived##s * sizeof(Derived##Decl))); \
78 }
79#include "clang/AST/DeclNodes.def"
Mike Stump1eb44332009-09-09 15:08:12 +000080
Douglas Gregor64650af2009-02-02 23:39:07 +000081 fprintf(stderr, "Total bytes = %d\n", totalBytes);
Eli Friedman56d29372008-06-07 16:52:53 +000082}
83
84void Decl::addDeclKind(Kind k) {
85 switch (k) {
Douglas Gregor64650af2009-02-02 23:39:07 +000086 default: assert(0 && "Declaration not in DeclNodes.def!");
87#define DECL(Derived, Base) case Derived: ++n##Derived##s; break;
88#include "clang/AST/DeclNodes.def"
Eli Friedman56d29372008-06-07 16:52:53 +000089 }
90}
91
Anders Carlsson67e33202009-06-13 00:08:58 +000092bool Decl::isTemplateParameterPack() const {
93 if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this))
94 return TTP->isParameterPack();
Mike Stump1eb44332009-09-09 15:08:12 +000095
Anders Carlsson67e33202009-06-13 00:08:58 +000096 return false;
97}
98
Douglas Gregore53060f2009-06-25 22:08:12 +000099bool Decl::isFunctionOrFunctionTemplate() const {
Anders Carlsson58badb72009-06-26 05:26:50 +0000100 if (const UsingDecl *UD = dyn_cast<UsingDecl>(this))
101 return UD->getTargetDecl()->isFunctionOrFunctionTemplate();
Mike Stump1eb44332009-09-09 15:08:12 +0000102
Douglas Gregore53060f2009-06-25 22:08:12 +0000103 return isa<FunctionDecl>(this) || isa<FunctionTemplateDecl>(this);
104}
105
Eli Friedman56d29372008-06-07 16:52:53 +0000106//===----------------------------------------------------------------------===//
Chris Lattner49f28ca2009-03-05 08:00:35 +0000107// PrettyStackTraceDecl Implementation
108//===----------------------------------------------------------------------===//
Mike Stump1eb44332009-09-09 15:08:12 +0000109
Chris Lattner49f28ca2009-03-05 08:00:35 +0000110void PrettyStackTraceDecl::print(llvm::raw_ostream &OS) const {
111 SourceLocation TheLoc = Loc;
112 if (TheLoc.isInvalid() && TheDecl)
113 TheLoc = TheDecl->getLocation();
Mike Stump1eb44332009-09-09 15:08:12 +0000114
Chris Lattner49f28ca2009-03-05 08:00:35 +0000115 if (TheLoc.isValid()) {
116 TheLoc.print(OS, SM);
117 OS << ": ";
118 }
119
120 OS << Message;
121
122 if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl))
123 OS << " '" << DN->getQualifiedNameAsString() << '\'';
124 OS << '\n';
125}
Mike Stump1eb44332009-09-09 15:08:12 +0000126
Chris Lattner49f28ca2009-03-05 08:00:35 +0000127//===----------------------------------------------------------------------===//
Eli Friedman56d29372008-06-07 16:52:53 +0000128// Decl Implementation
129//===----------------------------------------------------------------------===//
130
Chris Lattner769dbdf2009-03-27 20:18:19 +0000131// Out-of-line virtual method providing a home for Decl.
132Decl::~Decl() {
133 if (isOutOfSemaDC())
134 delete getMultipleDC();
Mike Stump1eb44332009-09-09 15:08:12 +0000135
Chris Lattner769dbdf2009-03-27 20:18:19 +0000136 assert(!HasAttrs && "attributes should have been freed by Destroy");
137}
138
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000139void Decl::setDeclContext(DeclContext *DC) {
140 if (isOutOfSemaDC())
141 delete getMultipleDC();
Mike Stump1eb44332009-09-09 15:08:12 +0000142
Chris Lattneree219fd2009-03-29 06:06:59 +0000143 DeclCtx = DC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000144}
145
146void Decl::setLexicalDeclContext(DeclContext *DC) {
147 if (DC == getLexicalDeclContext())
148 return;
149
150 if (isInSemaDC()) {
151 MultipleDC *MDC = new MultipleDC();
152 MDC->SemanticDC = getDeclContext();
153 MDC->LexicalDC = DC;
Chris Lattneree219fd2009-03-29 06:06:59 +0000154 DeclCtx = MDC;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000155 } else {
156 getMultipleDC()->LexicalDC = DC;
157 }
158}
159
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000160TranslationUnitDecl *Decl::getTranslationUnitDecl() {
Argyrios Kyrtzidis9b346692009-06-30 02:34:53 +0000161 if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this))
162 return TUD;
163
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000164 DeclContext *DC = getDeclContext();
165 assert(DC && "This decl is not contained in a translation unit!");
Mike Stump1eb44332009-09-09 15:08:12 +0000166
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000167 while (!DC->isTranslationUnit()) {
168 DC = DC->getParent();
169 assert(DC && "This decl is not contained in a translation unit!");
170 }
Mike Stump1eb44332009-09-09 15:08:12 +0000171
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000172 return cast<TranslationUnitDecl>(DC);
173}
174
175ASTContext &Decl::getASTContext() const {
Mike Stump1eb44332009-09-09 15:08:12 +0000176 return getTranslationUnitDecl()->getASTContext();
Argyrios Kyrtzidis3708b3d2009-06-29 17:38:40 +0000177}
178
Chris Lattner769dbdf2009-03-27 20:18:19 +0000179unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
180 switch (DeclKind) {
Mike Stump1eb44332009-09-09 15:08:12 +0000181 default:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000182 if (DeclKind >= FunctionFirst && DeclKind <= FunctionLast)
183 return IDNS_Ordinary;
184 assert(0 && "Unknown decl kind!");
185 case OverloadedFunction:
186 case Typedef:
187 case EnumConstant:
188 case Var:
189 case ImplicitParam:
190 case ParmVar:
191 case OriginalParmVar:
192 case NonTypeTemplateParm:
Douglas Gregor9cfbe482009-06-20 00:51:54 +0000193 case Using:
Anders Carlsson665b49c2009-08-28 05:30:28 +0000194 case UnresolvedUsing:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000195 case ObjCMethod:
196 case ObjCContainer:
197 case ObjCCategory:
198 case ObjCInterface:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000199 case ObjCProperty:
200 case ObjCCompatibleAlias:
201 return IDNS_Ordinary;
John McCall3f9a8a62009-08-11 06:59:38 +0000202
Chris Lattner769dbdf2009-03-27 20:18:19 +0000203 case ObjCProtocol:
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000204 return IDNS_ObjCProtocol;
Mike Stump1eb44332009-09-09 15:08:12 +0000205
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000206 case ObjCImplementation:
207 return IDNS_ObjCImplementation;
208
209 case ObjCCategoryImpl:
210 return IDNS_ObjCCategoryImpl;
211
Chris Lattner769dbdf2009-03-27 20:18:19 +0000212 case Field:
213 case ObjCAtDefsField:
214 case ObjCIvar:
215 return IDNS_Member;
Mike Stump1eb44332009-09-09 15:08:12 +0000216
Chris Lattner769dbdf2009-03-27 20:18:19 +0000217 case Record:
218 case CXXRecord:
219 case Enum:
220 case TemplateTypeParm:
221 return IDNS_Tag;
Mike Stump1eb44332009-09-09 15:08:12 +0000222
Chris Lattner769dbdf2009-03-27 20:18:19 +0000223 case Namespace:
224 case Template:
225 case FunctionTemplate:
226 case ClassTemplate:
227 case TemplateTemplateParm:
Anders Carlssonfaf0e872009-03-28 23:02:53 +0000228 case NamespaceAlias:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000229 return IDNS_Tag | IDNS_Ordinary;
Mike Stump1eb44332009-09-09 15:08:12 +0000230
Chris Lattner769dbdf2009-03-27 20:18:19 +0000231 // Never have names.
John McCall02cace72009-08-28 07:59:38 +0000232 case Friend:
John McCalldd4a3b02009-09-16 22:47:08 +0000233 case FriendTemplate:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000234 case LinkageSpec:
235 case FileScopeAsm:
236 case StaticAssert:
237 case ObjCClass:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000238 case ObjCPropertyImpl:
239 case ObjCForwardProtocol:
240 case Block:
241 case TranslationUnit:
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000242
Chris Lattner769dbdf2009-03-27 20:18:19 +0000243 // Aren't looked up?
244 case UsingDirective:
245 case ClassTemplateSpecialization:
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000246 case ClassTemplatePartialSpecialization:
Chris Lattner769dbdf2009-03-27 20:18:19 +0000247 return 0;
248 }
Eli Friedman56d29372008-06-07 16:52:53 +0000249}
250
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000251void Decl::addAttr(Attr *NewAttr) {
252 Attr *&ExistingAttr = getASTContext().getDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000253
254 NewAttr->setNext(ExistingAttr);
255 ExistingAttr = NewAttr;
Mike Stump1eb44332009-09-09 15:08:12 +0000256
Eli Friedman56d29372008-06-07 16:52:53 +0000257 HasAttrs = true;
258}
259
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000260void Decl::invalidateAttrs() {
Eli Friedman56d29372008-06-07 16:52:53 +0000261 if (!HasAttrs) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000262
Eli Friedman56d29372008-06-07 16:52:53 +0000263 HasAttrs = false;
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000264 getASTContext().eraseDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000265}
266
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000267const Attr *Decl::getAttrsImpl() const {
Mike Stump1eb44332009-09-09 15:08:12 +0000268 assert(HasAttrs && "getAttrs() should verify this!");
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000269 return getASTContext().getDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000270}
271
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000272void Decl::swapAttrs(Decl *RHS) {
Eli Friedman56d29372008-06-07 16:52:53 +0000273 bool HasLHSAttr = this->HasAttrs;
274 bool HasRHSAttr = RHS->HasAttrs;
Mike Stump1eb44332009-09-09 15:08:12 +0000275
Eli Friedman56d29372008-06-07 16:52:53 +0000276 // Usually, neither decl has attrs, nothing to do.
277 if (!HasLHSAttr && !HasRHSAttr) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000278
Eli Friedman56d29372008-06-07 16:52:53 +0000279 // If 'this' has no attrs, swap the other way.
280 if (!HasLHSAttr)
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000281 return RHS->swapAttrs(this);
Mike Stump1eb44332009-09-09 15:08:12 +0000282
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000283 ASTContext &Context = getASTContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000284
Eli Friedman56d29372008-06-07 16:52:53 +0000285 // Handle the case when both decls have attrs.
286 if (HasRHSAttr) {
Douglas Gregor68584ed2009-06-18 16:11:24 +0000287 std::swap(Context.getDeclAttrs(this), Context.getDeclAttrs(RHS));
Eli Friedman56d29372008-06-07 16:52:53 +0000288 return;
289 }
Mike Stump1eb44332009-09-09 15:08:12 +0000290
Eli Friedman56d29372008-06-07 16:52:53 +0000291 // Otherwise, LHS has an attr and RHS doesn't.
Douglas Gregor68584ed2009-06-18 16:11:24 +0000292 Context.getDeclAttrs(RHS) = Context.getDeclAttrs(this);
293 Context.eraseDeclAttrs(this);
Eli Friedman56d29372008-06-07 16:52:53 +0000294 this->HasAttrs = false;
295 RHS->HasAttrs = true;
296}
297
298
Chris Lattnercc581472009-03-04 06:05:19 +0000299void Decl::Destroy(ASTContext &C) {
300 // Free attributes for this decl.
301 if (HasAttrs) {
Douglas Gregor68584ed2009-06-18 16:11:24 +0000302 C.getDeclAttrs(this)->Destroy(C);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000303 invalidateAttrs();
Chris Lattnercc581472009-03-04 06:05:19 +0000304 HasAttrs = false;
305 }
Mike Stump1eb44332009-09-09 15:08:12 +0000306
Douglas Gregora0fc55f2009-01-13 19:47:12 +0000307#if 0
Douglas Gregor00ad0ef2009-01-20 04:25:11 +0000308 // FIXME: Once ownership is fully understood, we can enable this code
309 if (DeclContext *DC = dyn_cast<DeclContext>(this))
310 DC->decls_begin()->Destroy(C);
Eli Friedman56d29372008-06-07 16:52:53 +0000311
Chris Lattner244a67d2009-03-28 06:04:26 +0000312 // Observe the unrolled recursion. By setting N->NextDeclInContext = 0x0
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000313 // within the loop, only the Destroy method for the first Decl
314 // will deallocate all of the Decls in a chain.
Mike Stump1eb44332009-09-09 15:08:12 +0000315
Chris Lattner244a67d2009-03-28 06:04:26 +0000316 Decl* N = getNextDeclInContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000317
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000318 while (N) {
Chris Lattner244a67d2009-03-28 06:04:26 +0000319 Decl* Tmp = N->getNextDeclInContext();
320 N->NextDeclInContext = 0;
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000321 N->Destroy(C);
322 N = Tmp;
Mike Stump1eb44332009-09-09 15:08:12 +0000323 }
Douglas Gregora0fc55f2009-01-13 19:47:12 +0000324
Eli Friedman56d29372008-06-07 16:52:53 +0000325 this->~Decl();
Steve Naroff3e970492009-01-27 21:25:57 +0000326 C.Deallocate((void *)this);
Douglas Gregor00ad0ef2009-01-20 04:25:11 +0000327#endif
Eli Friedman56d29372008-06-07 16:52:53 +0000328}
329
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000330Decl *Decl::castFromDeclContext (const DeclContext *D) {
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000331 Decl::Kind DK = D->getDeclKind();
332 switch(DK) {
333#define DECL_CONTEXT(Name) \
334 case Decl::Name: \
335 return static_cast<Name##Decl*>(const_cast<DeclContext*>(D));
336#define DECL_CONTEXT_BASE(Name)
337#include "clang/AST/DeclNodes.def"
338 default:
339#define DECL_CONTEXT_BASE(Name) \
340 if (DK >= Decl::Name##First && DK <= Decl::Name##Last) \
341 return static_cast<Name##Decl*>(const_cast<DeclContext*>(D));
342#include "clang/AST/DeclNodes.def"
343 assert(false && "a decl that inherits DeclContext isn't handled");
344 return 0;
345 }
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000346}
347
348DeclContext *Decl::castToDeclContext(const Decl *D) {
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000349 Decl::Kind DK = D->getKind();
350 switch(DK) {
351#define DECL_CONTEXT(Name) \
352 case Decl::Name: \
353 return static_cast<Name##Decl*>(const_cast<Decl*>(D));
354#define DECL_CONTEXT_BASE(Name)
355#include "clang/AST/DeclNodes.def"
356 default:
357#define DECL_CONTEXT_BASE(Name) \
358 if (DK >= Decl::Name##First && DK <= Decl::Name##Last) \
359 return static_cast<Name##Decl*>(const_cast<Decl*>(D));
360#include "clang/AST/DeclNodes.def"
361 assert(false && "a decl that inherits DeclContext isn't handled");
362 return 0;
363 }
Argyrios Kyrtzidis42220c52008-10-12 16:14:48 +0000364}
365
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +0000366CompoundStmt* Decl::getCompoundBody() const {
367 return dyn_cast_or_null<CompoundStmt>(getBody());
Sebastian Redld3a413d2009-04-26 20:35:05 +0000368}
369
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +0000370SourceLocation Decl::getBodyRBrace() const {
371 Stmt *Body = getBody();
Sebastian Redld3a413d2009-04-26 20:35:05 +0000372 if (!Body)
373 return SourceLocation();
374 if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Body))
375 return CS->getRBracLoc();
376 assert(isa<CXXTryStmt>(Body) &&
377 "Body can only be CompoundStmt or CXXTryStmt");
378 return cast<CXXTryStmt>(Body)->getSourceRange().getEnd();
379}
380
Anders Carlsson1329c272009-03-25 23:38:06 +0000381#ifndef NDEBUG
382void Decl::CheckAccessDeclContext() const {
Anders Carlsson35eda442009-08-29 20:47:47 +0000383 // If the decl is the toplevel translation unit or if we're not in a
384 // record decl context, we don't need to check anything.
385 if (isa<TranslationUnitDecl>(this) ||
386 !isa<CXXRecordDecl>(getDeclContext()))
387 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000388
389 assert(Access != AS_none &&
Anders Carlsson1329c272009-03-25 23:38:06 +0000390 "Access specifier is AS_none inside a record decl");
391}
392
393#endif
394
Eli Friedman56d29372008-06-07 16:52:53 +0000395//===----------------------------------------------------------------------===//
396// DeclContext Implementation
397//===----------------------------------------------------------------------===//
398
Argyrios Kyrtzidis3d7641e2009-02-16 14:29:28 +0000399bool DeclContext::classof(const Decl *D) {
400 switch (D->getKind()) {
401#define DECL_CONTEXT(Name) case Decl::Name:
402#define DECL_CONTEXT_BASE(Name)
403#include "clang/AST/DeclNodes.def"
404 return true;
405 default:
406#define DECL_CONTEXT_BASE(Name) \
407 if (D->getKind() >= Decl::Name##First && \
408 D->getKind() <= Decl::Name##Last) \
409 return true;
410#include "clang/AST/DeclNodes.def"
411 return false;
412 }
413}
414
Douglas Gregor44b43212008-12-11 16:49:14 +0000415DeclContext::~DeclContext() {
Douglas Gregorc36c5402009-04-09 17:29:08 +0000416 delete static_cast<StoredDeclsMap*>(LookupPtr);
Douglas Gregor44b43212008-12-11 16:49:14 +0000417}
418
419void DeclContext::DestroyDecls(ASTContext &C) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000420 for (decl_iterator D = decls_begin(); D != decls_end(); )
Douglas Gregor00ad0ef2009-01-20 04:25:11 +0000421 (*D++)->Destroy(C);
Douglas Gregor44b43212008-12-11 16:49:14 +0000422}
423
Douglas Gregore942bbe2009-09-10 16:57:35 +0000424/// \brief Find the parent context of this context that will be
425/// used for unqualified name lookup.
426///
427/// Generally, the parent lookup context is the semantic context. However, for
428/// a friend function the parent lookup context is the lexical context, which
429/// is the class in which the friend is declared.
430DeclContext *DeclContext::getLookupParent() {
431 // FIXME: Find a better way to identify friends
432 if (isa<FunctionDecl>(this))
433 if (getParent()->getLookupContext()->isFileContext() &&
434 getLexicalParent()->getLookupContext()->isRecord())
435 return getLexicalParent();
436
437 return getParent();
438}
439
Douglas Gregorbc221632009-05-28 16:34:51 +0000440bool DeclContext::isDependentContext() const {
441 if (isFileContext())
442 return false;
443
Douglas Gregorc8ab2562009-05-31 09:31:02 +0000444 if (isa<ClassTemplatePartialSpecializationDecl>(this))
445 return true;
446
Douglas Gregorbc221632009-05-28 16:34:51 +0000447 if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this))
448 if (Record->getDescribedClassTemplate())
449 return true;
450
451 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this))
452 if (Function->getDescribedFunctionTemplate())
453 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000454
Douglas Gregorbc221632009-05-28 16:34:51 +0000455 return getParent() && getParent()->isDependentContext();
456}
457
Douglas Gregor074149e2009-01-05 19:45:36 +0000458bool DeclContext::isTransparentContext() const {
459 if (DeclKind == Decl::Enum)
460 return true; // FIXME: Check for C++0x scoped enums
461 else if (DeclKind == Decl::LinkageSpec)
462 return true;
Douglas Gregor65100792009-02-26 00:02:51 +0000463 else if (DeclKind >= Decl::RecordFirst && DeclKind <= Decl::RecordLast)
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000464 return cast<RecordDecl>(this)->isAnonymousStructOrUnion();
Douglas Gregor074149e2009-01-05 19:45:36 +0000465 else if (DeclKind == Decl::Namespace)
466 return false; // FIXME: Check for C++0x inline namespaces
467
468 return false;
469}
470
Douglas Gregor6dd38da2009-08-27 06:03:53 +0000471bool DeclContext::Encloses(DeclContext *DC) {
472 if (getPrimaryContext() != this)
473 return getPrimaryContext()->Encloses(DC);
Mike Stump1eb44332009-09-09 15:08:12 +0000474
Douglas Gregor6dd38da2009-08-27 06:03:53 +0000475 for (; DC; DC = DC->getParent())
476 if (DC->getPrimaryContext() == this)
477 return true;
Mike Stump1eb44332009-09-09 15:08:12 +0000478 return false;
Douglas Gregor6dd38da2009-08-27 06:03:53 +0000479}
480
Steve Naroff0701bbb2009-01-08 17:28:14 +0000481DeclContext *DeclContext::getPrimaryContext() {
Douglas Gregor44b43212008-12-11 16:49:14 +0000482 switch (DeclKind) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000483 case Decl::TranslationUnit:
Douglas Gregor074149e2009-01-05 19:45:36 +0000484 case Decl::LinkageSpec:
Mike Stump1eb44332009-09-09 15:08:12 +0000485 case Decl::Block:
Douglas Gregor44b43212008-12-11 16:49:14 +0000486 // There is only one DeclContext for these entities.
487 return this;
488
489 case Decl::Namespace:
490 // The original namespace is our primary context.
491 return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
492
Douglas Gregor44b43212008-12-11 16:49:14 +0000493 case Decl::ObjCMethod:
494 return this;
495
496 case Decl::ObjCInterface:
Steve Naroff0701bbb2009-01-08 17:28:14 +0000497 case Decl::ObjCProtocol:
498 case Decl::ObjCCategory:
Douglas Gregor44b43212008-12-11 16:49:14 +0000499 // FIXME: Can Objective-C interfaces be forward-declared?
500 return this;
501
Steve Naroff0701bbb2009-01-08 17:28:14 +0000502 case Decl::ObjCImplementation:
503 case Decl::ObjCCategoryImpl:
504 return this;
505
Douglas Gregor44b43212008-12-11 16:49:14 +0000506 default:
Douglas Gregorcc636682009-02-17 23:15:12 +0000507 if (DeclKind >= Decl::TagFirst && DeclKind <= Decl::TagLast) {
508 // If this is a tag type that has a definition or is currently
509 // being defined, that definition is our primary context.
Ted Kremenek6217b802009-07-29 21:53:49 +0000510 if (const TagType *TagT =cast<TagDecl>(this)->TypeForDecl->getAs<TagType>())
Mike Stump1eb44332009-09-09 15:08:12 +0000511 if (TagT->isBeingDefined() ||
Douglas Gregorcc636682009-02-17 23:15:12 +0000512 (TagT->getDecl() && TagT->getDecl()->isDefinition()))
513 return TagT->getDecl();
514 return this;
515 }
516
Douglas Gregor44b43212008-12-11 16:49:14 +0000517 assert(DeclKind >= Decl::FunctionFirst && DeclKind <= Decl::FunctionLast &&
518 "Unknown DeclContext kind");
519 return this;
520 }
521}
522
523DeclContext *DeclContext::getNextContext() {
524 switch (DeclKind) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000525 case Decl::Namespace:
526 // Return the next namespace
527 return static_cast<NamespaceDecl*>(this)->getNextNamespace();
528
529 default:
Douglas Gregor44b43212008-12-11 16:49:14 +0000530 return 0;
531 }
532}
533
Douglas Gregor2cf26342009-04-09 22:27:44 +0000534/// \brief Load the declarations within this lexical storage from an
535/// external source.
Mike Stump1eb44332009-09-09 15:08:12 +0000536void
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000537DeclContext::LoadLexicalDeclsFromExternalStorage() const {
538 ExternalASTSource *Source = getParentASTContext().getExternalSource();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000539 assert(hasExternalLexicalStorage() && Source && "No external storage?");
540
Eli Friedmanb0156ea2009-04-27 23:43:36 +0000541 llvm::SmallVector<uint32_t, 64> Decls;
Mike Stump1eb44332009-09-09 15:08:12 +0000542 if (Source->ReadDeclsLexicallyInContext(const_cast<DeclContext *>(this),
Douglas Gregor2cf26342009-04-09 22:27:44 +0000543 Decls))
544 return;
545
546 // There is no longer any lexical storage in this context
547 ExternalLexicalStorage = false;
548
549 if (Decls.empty())
550 return;
551
552 // Resolve all of the declaration IDs into declarations, building up
553 // a chain of declarations via the Decl::NextDeclInContext field.
554 Decl *FirstNewDecl = 0;
555 Decl *PrevDecl = 0;
556 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
557 Decl *D = Source->GetDecl(Decls[I]);
558 if (PrevDecl)
559 PrevDecl->NextDeclInContext = D;
560 else
561 FirstNewDecl = D;
562
563 PrevDecl = D;
564 }
565
566 // Splice the newly-read declarations into the beginning of the list
567 // of declarations.
568 PrevDecl->NextDeclInContext = FirstDecl;
569 FirstDecl = FirstNewDecl;
570 if (!LastDecl)
571 LastDecl = PrevDecl;
572}
573
Mike Stump1eb44332009-09-09 15:08:12 +0000574void
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000575DeclContext::LoadVisibleDeclsFromExternalStorage() const {
Douglas Gregor2cf26342009-04-09 22:27:44 +0000576 DeclContext *This = const_cast<DeclContext *>(this);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000577 ExternalASTSource *Source = getParentASTContext().getExternalSource();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000578 assert(hasExternalVisibleStorage() && Source && "No external storage?");
579
580 llvm::SmallVector<VisibleDeclaration, 64> Decls;
581 if (Source->ReadDeclsVisibleInContext(This, Decls))
582 return;
583
584 // There is no longer any visible storage in this context
585 ExternalVisibleStorage = false;
586
587 // Load the declaration IDs for all of the names visible in this
588 // context.
589 assert(!LookupPtr && "Have a lookup map before de-serialization?");
590 StoredDeclsMap *Map = new StoredDeclsMap;
591 LookupPtr = Map;
592 for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
593 (*Map)[Decls[I].Name].setFromDeclIDs(Decls[I].Declarations);
594 }
595}
596
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000597DeclContext::decl_iterator DeclContext::decls_begin() const {
Douglas Gregor2cf26342009-04-09 22:27:44 +0000598 if (hasExternalLexicalStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000599 LoadLexicalDeclsFromExternalStorage();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000600
601 // FIXME: Check whether we need to load some declarations from
602 // external storage.
Mike Stump1eb44332009-09-09 15:08:12 +0000603 return decl_iterator(FirstDecl);
Douglas Gregor6ab35242009-04-09 21:40:53 +0000604}
605
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000606DeclContext::decl_iterator DeclContext::decls_end() const {
Douglas Gregor2cf26342009-04-09 22:27:44 +0000607 if (hasExternalLexicalStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000608 LoadLexicalDeclsFromExternalStorage();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000609
Mike Stump1eb44332009-09-09 15:08:12 +0000610 return decl_iterator();
Douglas Gregor6ab35242009-04-09 21:40:53 +0000611}
612
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000613bool DeclContext::decls_empty() const {
Douglas Gregor8038d512009-04-10 17:25:41 +0000614 if (hasExternalLexicalStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000615 LoadLexicalDeclsFromExternalStorage();
Douglas Gregor8038d512009-04-10 17:25:41 +0000616
617 return !FirstDecl;
618}
619
John McCall3f9a8a62009-08-11 06:59:38 +0000620void DeclContext::addHiddenDecl(Decl *D) {
Chris Lattner7f0be132009-02-20 00:56:18 +0000621 assert(D->getLexicalDeclContext() == this &&
622 "Decl inserted into wrong lexical context");
Mike Stump1eb44332009-09-09 15:08:12 +0000623 assert(!D->getNextDeclInContext() && D != LastDecl &&
Douglas Gregor6037fcb2009-01-09 19:42:16 +0000624 "Decl already inserted into a DeclContext");
625
626 if (FirstDecl) {
Chris Lattner244a67d2009-03-28 06:04:26 +0000627 LastDecl->NextDeclInContext = D;
Douglas Gregor6037fcb2009-01-09 19:42:16 +0000628 LastDecl = D;
629 } else {
630 FirstDecl = LastDecl = D;
631 }
John McCall3f9a8a62009-08-11 06:59:38 +0000632}
633
634void DeclContext::addDecl(Decl *D) {
635 addHiddenDecl(D);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000636
637 if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000638 ND->getDeclContext()->makeDeclVisibleInContext(ND);
Douglas Gregor44b43212008-12-11 16:49:14 +0000639}
640
Douglas Gregor074149e2009-01-05 19:45:36 +0000641/// buildLookup - Build the lookup data structure with all of the
642/// declarations in DCtx (and any other contexts linked to it or
643/// transparent contexts nested within it).
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000644void DeclContext::buildLookup(DeclContext *DCtx) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000645 for (; DCtx; DCtx = DCtx->getNextContext()) {
Mike Stump1eb44332009-09-09 15:08:12 +0000646 for (decl_iterator D = DCtx->decls_begin(),
647 DEnd = DCtx->decls_end();
Douglas Gregor4f3b8f82009-01-06 07:17:58 +0000648 D != DEnd; ++D) {
John McCall3f9a8a62009-08-11 06:59:38 +0000649 // Insert this declaration into the lookup structure, but only
650 // if it's semantically in its decl context. During non-lazy
651 // lookup building, this is implicitly enforced by addDecl.
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000652 if (NamedDecl *ND = dyn_cast<NamedDecl>(*D))
John McCall3f9a8a62009-08-11 06:59:38 +0000653 if (D->getDeclContext() == DCtx)
654 makeDeclVisibleInContextImpl(ND);
Douglas Gregor074149e2009-01-05 19:45:36 +0000655
656 // If this declaration is itself a transparent declaration context,
657 // add its members (recursively).
658 if (DeclContext *InnerCtx = dyn_cast<DeclContext>(*D))
659 if (InnerCtx->isTransparentContext())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000660 buildLookup(InnerCtx->getPrimaryContext());
Douglas Gregor074149e2009-01-05 19:45:36 +0000661 }
662 }
663}
664
Mike Stump1eb44332009-09-09 15:08:12 +0000665DeclContext::lookup_result
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000666DeclContext::lookup(DeclarationName Name) {
Steve Naroff0701bbb2009-01-08 17:28:14 +0000667 DeclContext *PrimaryContext = getPrimaryContext();
Douglas Gregor44b43212008-12-11 16:49:14 +0000668 if (PrimaryContext != this)
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000669 return PrimaryContext->lookup(Name);
Douglas Gregor44b43212008-12-11 16:49:14 +0000670
Douglas Gregor2cf26342009-04-09 22:27:44 +0000671 if (hasExternalVisibleStorage())
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000672 LoadVisibleDeclsFromExternalStorage();
Douglas Gregor2cf26342009-04-09 22:27:44 +0000673
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000674 /// If there is no lookup data structure, build one now by walking
Douglas Gregor44b43212008-12-11 16:49:14 +0000675 /// all of the linked DeclContexts (in declaration order!) and
676 /// inserting their values.
Douglas Gregorc36c5402009-04-09 17:29:08 +0000677 if (!LookupPtr) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000678 buildLookup(this);
Douglas Gregor44b43212008-12-11 16:49:14 +0000679
Douglas Gregorc36c5402009-04-09 17:29:08 +0000680 if (!LookupPtr)
Chris Lattner91942502009-02-20 00:55:03 +0000681 return lookup_result(0, 0);
Douglas Gregorc36c5402009-04-09 17:29:08 +0000682 }
Douglas Gregor44b43212008-12-11 16:49:14 +0000683
Douglas Gregorc36c5402009-04-09 17:29:08 +0000684 StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(LookupPtr);
685 StoredDeclsMap::iterator Pos = Map->find(Name);
686 if (Pos == Map->end())
687 return lookup_result(0, 0);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000688 return Pos->second.getLookupResult(getParentASTContext());
Douglas Gregor44b43212008-12-11 16:49:14 +0000689}
690
Mike Stump1eb44332009-09-09 15:08:12 +0000691DeclContext::lookup_const_result
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000692DeclContext::lookup(DeclarationName Name) const {
693 return const_cast<DeclContext*>(this)->lookup(Name);
Douglas Gregor44b43212008-12-11 16:49:14 +0000694}
695
Chris Lattner0cf2b192009-03-27 19:19:59 +0000696DeclContext *DeclContext::getLookupContext() {
697 DeclContext *Ctx = this;
Douglas Gregor72de6672009-01-08 20:45:30 +0000698 // Skip through transparent contexts.
Douglas Gregorce356072009-01-06 23:51:29 +0000699 while (Ctx->isTransparentContext())
700 Ctx = Ctx->getParent();
701 return Ctx;
702}
703
Douglas Gregor88b70942009-02-25 22:02:03 +0000704DeclContext *DeclContext::getEnclosingNamespaceContext() {
705 DeclContext *Ctx = this;
706 // Skip through non-namespace, non-translation-unit contexts.
707 while (!Ctx->isFileContext() || Ctx->isTransparentContext())
708 Ctx = Ctx->getParent();
709 return Ctx->getPrimaryContext();
710}
711
John McCallab88d972009-08-31 22:39:49 +0000712void DeclContext::makeDeclVisibleInContext(NamedDecl *D, bool Recoverable) {
Douglas Gregorcc636682009-02-17 23:15:12 +0000713 // FIXME: This feels like a hack. Should DeclarationName support
714 // template-ids, or is there a better way to keep specializations
715 // from being visible?
716 if (isa<ClassTemplateSpecializationDecl>(D))
717 return;
718
Steve Naroff0701bbb2009-01-08 17:28:14 +0000719 DeclContext *PrimaryContext = getPrimaryContext();
Douglas Gregor44b43212008-12-11 16:49:14 +0000720 if (PrimaryContext != this) {
John McCallab88d972009-08-31 22:39:49 +0000721 PrimaryContext->makeDeclVisibleInContext(D, Recoverable);
Douglas Gregor44b43212008-12-11 16:49:14 +0000722 return;
723 }
724
725 // If we already have a lookup data structure, perform the insertion
726 // into it. Otherwise, be lazy and don't build that structure until
727 // someone asks for it.
John McCallab88d972009-08-31 22:39:49 +0000728 if (LookupPtr || !Recoverable)
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000729 makeDeclVisibleInContextImpl(D);
Douglas Gregor074149e2009-01-05 19:45:36 +0000730
Douglas Gregor074149e2009-01-05 19:45:36 +0000731 // If we are a transparent context, insert into our parent context,
732 // too. This operation is recursive.
733 if (isTransparentContext())
John McCallab88d972009-08-31 22:39:49 +0000734 getParent()->makeDeclVisibleInContext(D, Recoverable);
Douglas Gregor44b43212008-12-11 16:49:14 +0000735}
736
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000737void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D) {
Douglas Gregor074149e2009-01-05 19:45:36 +0000738 // Skip unnamed declarations.
739 if (!D->getDeclName())
740 return;
741
Douglas Gregorcc636682009-02-17 23:15:12 +0000742 // FIXME: This feels like a hack. Should DeclarationName support
743 // template-ids, or is there a better way to keep specializations
744 // from being visible?
745 if (isa<ClassTemplateSpecializationDecl>(D))
746 return;
747
Douglas Gregorc36c5402009-04-09 17:29:08 +0000748 if (!LookupPtr)
749 LookupPtr = new StoredDeclsMap;
Douglas Gregor44b43212008-12-11 16:49:14 +0000750
751 // Insert this declaration into the map.
Douglas Gregorc36c5402009-04-09 17:29:08 +0000752 StoredDeclsMap &Map = *static_cast<StoredDeclsMap*>(LookupPtr);
Chris Lattner67762a32009-02-20 01:44:05 +0000753 StoredDeclsList &DeclNameEntries = Map[D->getDeclName()];
754 if (DeclNameEntries.isNull()) {
755 DeclNameEntries.setOnlyValue(D);
Chris Lattnerbd6c8002009-02-19 07:00:44 +0000756 return;
Douglas Gregor44b43212008-12-11 16:49:14 +0000757 }
Chris Lattner91942502009-02-20 00:55:03 +0000758
Chris Lattnerbdc3d002009-02-20 01:10:07 +0000759 // If it is possible that this is a redeclaration, check to see if there is
760 // already a decl for which declarationReplaces returns true. If there is
761 // one, just replace it and return.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000762 if (DeclNameEntries.HandleRedeclaration(getParentASTContext(), D))
Chris Lattner67762a32009-02-20 01:44:05 +0000763 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000764
Chris Lattnerbd6c8002009-02-19 07:00:44 +0000765 // Put this declaration into the appropriate slot.
Chris Lattner67762a32009-02-20 01:44:05 +0000766 DeclNameEntries.AddSubsequentDecl(D);
Douglas Gregor44b43212008-12-11 16:49:14 +0000767}
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000768
769/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
770/// this context.
Mike Stump1eb44332009-09-09 15:08:12 +0000771DeclContext::udir_iterator_range
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000772DeclContext::getUsingDirectives() const {
773 lookup_const_result Result = lookup(UsingDirectiveDecl::getName());
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000774 return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.first),
775 reinterpret_cast<udir_iterator>(Result.second));
776}
Douglas Gregor2cf26342009-04-09 22:27:44 +0000777
778void StoredDeclsList::materializeDecls(ASTContext &Context) {
779 if (isNull())
780 return;
781
782 switch ((DataKind)(Data & 0x03)) {
783 case DK_Decl:
784 case DK_Decl_Vector:
785 break;
786
787 case DK_DeclID: {
788 // Resolve this declaration ID to an actual declaration by
789 // querying the external AST source.
790 unsigned DeclID = Data >> 2;
791
792 ExternalASTSource *Source = Context.getExternalSource();
793 assert(Source && "No external AST source available!");
794
795 Data = reinterpret_cast<uintptr_t>(Source->GetDecl(DeclID));
796 break;
797 }
798
799 case DK_ID_Vector: {
800 // We have a vector of declaration IDs. Resolve all of them to
801 // actual declarations.
802 VectorTy &Vector = *getAsVector();
803 ExternalASTSource *Source = Context.getExternalSource();
804 assert(Source && "No external AST source available!");
805
806 for (unsigned I = 0, N = Vector.size(); I != N; ++I)
807 Vector[I] = reinterpret_cast<uintptr_t>(Source->GetDecl(Vector[I]));
808
809 Data = (Data & ~0x03) | DK_Decl_Vector;
810 break;
811 }
812 }
813}