Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 1 | //===--- 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" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 15 | #include "clang/AST/ASTContext.h" |
| 16 | #include "clang/AST/ASTMutationListener.h" |
| 17 | #include "clang/AST/Attr.h" |
Douglas Gregor | 64650af | 2009-02-02 23:39:07 +0000 | [diff] [blame] | 18 | #include "clang/AST/Decl.h" |
Argyrios Kyrtzidis | d3bb44f | 2008-06-09 21:05:31 +0000 | [diff] [blame] | 19 | #include "clang/AST/DeclCXX.h" |
Chandler Carruth | 55fc873 | 2012-12-04 09:13:33 +0000 | [diff] [blame] | 20 | #include "clang/AST/DeclContextInternals.h" |
John McCall | 92b7f70 | 2010-03-11 07:50:04 +0000 | [diff] [blame] | 21 | #include "clang/AST/DeclFriend.h" |
Douglas Gregor | aaba5e3 | 2009-02-04 19:02:06 +0000 | [diff] [blame] | 22 | #include "clang/AST/DeclObjC.h" |
Alexey Bataev | c640058 | 2013-03-22 06:34:35 +0000 | [diff] [blame] | 23 | #include "clang/AST/DeclOpenMP.h" |
Douglas Gregor | aaba5e3 | 2009-02-04 19:02:06 +0000 | [diff] [blame] | 24 | #include "clang/AST/DeclTemplate.h" |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 25 | #include "clang/AST/DependentDiagnostic.h" |
Benjamin Kramer | 2fa67ef | 2012-12-01 15:09:41 +0000 | [diff] [blame] | 26 | #include "clang/AST/ExternalASTSource.h" |
Sebastian Redl | d3a413d | 2009-04-26 20:35:05 +0000 | [diff] [blame] | 27 | #include "clang/AST/Stmt.h" |
| 28 | #include "clang/AST/StmtCXX.h" |
Benjamin Kramer | 2fa67ef | 2012-12-01 15:09:41 +0000 | [diff] [blame] | 29 | #include "clang/AST/Type.h" |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 30 | #include "clang/Basic/TargetInfo.h" |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 31 | #include "llvm/ADT/DenseMap.h" |
Chris Lattner | 49f28ca | 2009-03-05 08:00:35 +0000 | [diff] [blame] | 32 | #include "llvm/Support/raw_ostream.h" |
Douglas Gregor | 6ed40e3 | 2008-12-23 21:05:05 +0000 | [diff] [blame] | 33 | #include <algorithm> |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 34 | using namespace clang; |
| 35 | |
| 36 | //===----------------------------------------------------------------------===// |
| 37 | // Statistics |
| 38 | //===----------------------------------------------------------------------===// |
| 39 | |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 40 | #define DECL(DERIVED, BASE) static int n##DERIVED##s = 0; |
| 41 | #define ABSTRACT_DECL(DECL) |
| 42 | #include "clang/AST/DeclNodes.inc" |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 43 | |
Douglas Gregor | 6bd9929 | 2013-02-09 01:35:03 +0000 | [diff] [blame] | 44 | void Decl::updateOutOfDate(IdentifierInfo &II) const { |
| 45 | getASTContext().getExternalSource()->updateOutOfDateIdentifier(II); |
| 46 | } |
| 47 | |
Douglas Gregor | 1e68ecc | 2012-01-05 21:55:30 +0000 | [diff] [blame] | 48 | void *Decl::AllocateDeserializedDecl(const ASTContext &Context, |
| 49 | unsigned ID, |
| 50 | unsigned Size) { |
Douglas Gregor | 5d1f496 | 2012-01-05 23:49:36 +0000 | [diff] [blame] | 51 | // Allocate an extra 8 bytes worth of storage, which ensures that the |
Douglas Gregor | c6c8e0e | 2012-01-09 17:30:44 +0000 | [diff] [blame] | 52 | // resulting pointer will still be 8-byte aligned. |
Douglas Gregor | 5d1f496 | 2012-01-05 23:49:36 +0000 | [diff] [blame] | 53 | void *Start = Context.Allocate(Size + 8); |
| 54 | void *Result = (char*)Start + 8; |
Douglas Gregor | b6b60c1 | 2012-01-05 22:27:05 +0000 | [diff] [blame] | 55 | |
Douglas Gregor | c6c8e0e | 2012-01-09 17:30:44 +0000 | [diff] [blame] | 56 | unsigned *PrefixPtr = (unsigned *)Result - 2; |
| 57 | |
| 58 | // Zero out the first 4 bytes; this is used to store the owning module ID. |
| 59 | PrefixPtr[0] = 0; |
| 60 | |
| 61 | // Store the global declaration ID in the second 4 bytes. |
| 62 | PrefixPtr[1] = ID; |
Douglas Gregor | b6b60c1 | 2012-01-05 22:27:05 +0000 | [diff] [blame] | 63 | |
| 64 | return Result; |
Douglas Gregor | 1e68ecc | 2012-01-05 21:55:30 +0000 | [diff] [blame] | 65 | } |
| 66 | |
Douglas Gregor | ca2ab45 | 2013-01-12 01:29:50 +0000 | [diff] [blame] | 67 | Module *Decl::getOwningModuleSlow() const { |
| 68 | assert(isFromASTFile() && "Not from AST file?"); |
| 69 | return getASTContext().getExternalSource()->getModule(getOwningModuleID()); |
| 70 | } |
| 71 | |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 72 | const char *Decl::getDeclKindName() const { |
| 73 | switch (DeclKind) { |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 74 | default: llvm_unreachable("Declaration not in DeclNodes.inc!"); |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 75 | #define DECL(DERIVED, BASE) case DERIVED: return #DERIVED; |
| 76 | #define ABSTRACT_DECL(DECL) |
| 77 | #include "clang/AST/DeclNodes.inc" |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 78 | } |
| 79 | } |
| 80 | |
Douglas Gregor | 4273857 | 2010-03-05 00:26:45 +0000 | [diff] [blame] | 81 | void Decl::setInvalidDecl(bool Invalid) { |
| 82 | InvalidDecl = Invalid; |
Argyrios Kyrtzidis | ba50b3e | 2012-03-09 21:09:04 +0000 | [diff] [blame] | 83 | if (Invalid && !isa<ParmVarDecl>(this)) { |
Douglas Gregor | 4273857 | 2010-03-05 00:26:45 +0000 | [diff] [blame] | 84 | // Defensive maneuver for ill-formed code: we're likely not to make it to |
| 85 | // a point where we set the access specifier, so default it to "public" |
| 86 | // to avoid triggering asserts elsewhere in the front end. |
| 87 | setAccess(AS_public); |
| 88 | } |
| 89 | } |
| 90 | |
Steve Naroff | 0a47393 | 2009-01-20 19:53:53 +0000 | [diff] [blame] | 91 | const char *DeclContext::getDeclKindName() const { |
| 92 | switch (DeclKind) { |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 93 | default: llvm_unreachable("Declaration context not in DeclNodes.inc!"); |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 94 | #define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED; |
| 95 | #define ABSTRACT_DECL(DECL) |
| 96 | #include "clang/AST/DeclNodes.inc" |
Steve Naroff | 0a47393 | 2009-01-20 19:53:53 +0000 | [diff] [blame] | 97 | } |
| 98 | } |
| 99 | |
Daniel Dunbar | 02892a6 | 2012-03-05 21:42:49 +0000 | [diff] [blame] | 100 | bool Decl::StatisticsEnabled = false; |
| 101 | void Decl::EnableStatistics() { |
| 102 | StatisticsEnabled = true; |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 103 | } |
| 104 | |
| 105 | void Decl::PrintStats() { |
Chandler Carruth | b43c8ec | 2011-07-04 06:13:27 +0000 | [diff] [blame] | 106 | llvm::errs() << "\n*** Decl Stats:\n"; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 107 | |
Douglas Gregor | 64650af | 2009-02-02 23:39:07 +0000 | [diff] [blame] | 108 | int totalDecls = 0; |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 109 | #define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s; |
| 110 | #define ABSTRACT_DECL(DECL) |
| 111 | #include "clang/AST/DeclNodes.inc" |
Chandler Carruth | b43c8ec | 2011-07-04 06:13:27 +0000 | [diff] [blame] | 112 | llvm::errs() << " " << totalDecls << " decls total.\n"; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 113 | |
Douglas Gregor | 64650af | 2009-02-02 23:39:07 +0000 | [diff] [blame] | 114 | int totalBytes = 0; |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 115 | #define DECL(DERIVED, BASE) \ |
| 116 | if (n##DERIVED##s > 0) { \ |
| 117 | totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl)); \ |
Chandler Carruth | b43c8ec | 2011-07-04 06:13:27 +0000 | [diff] [blame] | 118 | llvm::errs() << " " << n##DERIVED##s << " " #DERIVED " decls, " \ |
| 119 | << sizeof(DERIVED##Decl) << " each (" \ |
| 120 | << n##DERIVED##s * sizeof(DERIVED##Decl) \ |
| 121 | << " bytes)\n"; \ |
Douglas Gregor | 64650af | 2009-02-02 23:39:07 +0000 | [diff] [blame] | 122 | } |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 123 | #define ABSTRACT_DECL(DECL) |
| 124 | #include "clang/AST/DeclNodes.inc" |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 125 | |
Chandler Carruth | b43c8ec | 2011-07-04 06:13:27 +0000 | [diff] [blame] | 126 | llvm::errs() << "Total bytes = " << totalBytes << "\n"; |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 127 | } |
| 128 | |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 129 | void Decl::add(Kind k) { |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 130 | switch (k) { |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 131 | #define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break; |
| 132 | #define ABSTRACT_DECL(DECL) |
| 133 | #include "clang/AST/DeclNodes.inc" |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 134 | } |
| 135 | } |
| 136 | |
Anders Carlsson | 67e3320 | 2009-06-13 00:08:58 +0000 | [diff] [blame] | 137 | bool Decl::isTemplateParameterPack() const { |
| 138 | if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this)) |
| 139 | return TTP->isParameterPack(); |
Douglas Gregor | 10738d3 | 2010-12-23 23:51:58 +0000 | [diff] [blame] | 140 | if (const NonTypeTemplateParmDecl *NTTP |
Douglas Gregor | 61c4d28 | 2011-01-05 15:48:55 +0000 | [diff] [blame] | 141 | = dyn_cast<NonTypeTemplateParmDecl>(this)) |
Douglas Gregor | 10738d3 | 2010-12-23 23:51:58 +0000 | [diff] [blame] | 142 | return NTTP->isParameterPack(); |
Douglas Gregor | 61c4d28 | 2011-01-05 15:48:55 +0000 | [diff] [blame] | 143 | if (const TemplateTemplateParmDecl *TTP |
| 144 | = dyn_cast<TemplateTemplateParmDecl>(this)) |
| 145 | return TTP->isParameterPack(); |
Anders Carlsson | 67e3320 | 2009-06-13 00:08:58 +0000 | [diff] [blame] | 146 | return false; |
| 147 | } |
| 148 | |
Douglas Gregor | 1fe85ea | 2011-01-05 21:11:38 +0000 | [diff] [blame] | 149 | bool Decl::isParameterPack() const { |
| 150 | if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(this)) |
| 151 | return Parm->isParameterPack(); |
| 152 | |
| 153 | return isTemplateParameterPack(); |
| 154 | } |
| 155 | |
Douglas Gregor | e53060f | 2009-06-25 22:08:12 +0000 | [diff] [blame] | 156 | bool Decl::isFunctionOrFunctionTemplate() const { |
John McCall | 9488ea1 | 2009-11-17 05:59:44 +0000 | [diff] [blame] | 157 | if (const UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(this)) |
Anders Carlsson | 58badb7 | 2009-06-26 05:26:50 +0000 | [diff] [blame] | 158 | return UD->getTargetDecl()->isFunctionOrFunctionTemplate(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 159 | |
Douglas Gregor | e53060f | 2009-06-25 22:08:12 +0000 | [diff] [blame] | 160 | return isa<FunctionDecl>(this) || isa<FunctionTemplateDecl>(this); |
| 161 | } |
| 162 | |
Caitlin Sadowski | ed9d84a | 2011-09-08 17:42:31 +0000 | [diff] [blame] | 163 | bool Decl::isTemplateDecl() const { |
| 164 | return isa<TemplateDecl>(this); |
| 165 | } |
| 166 | |
Argyrios Kyrtzidis | c8680f4 | 2011-09-28 02:45:33 +0000 | [diff] [blame] | 167 | const DeclContext *Decl::getParentFunctionOrMethod() const { |
| 168 | for (const DeclContext *DC = getDeclContext(); |
| 169 | DC && !DC->isTranslationUnit() && !DC->isNamespace(); |
Douglas Gregor | 79c2278 | 2010-01-16 20:21:20 +0000 | [diff] [blame] | 170 | DC = DC->getParent()) |
| 171 | if (DC->isFunctionOrMethod()) |
Argyrios Kyrtzidis | c8680f4 | 2011-09-28 02:45:33 +0000 | [diff] [blame] | 172 | return DC; |
Douglas Gregor | 79c2278 | 2010-01-16 20:21:20 +0000 | [diff] [blame] | 173 | |
Argyrios Kyrtzidis | c8680f4 | 2011-09-28 02:45:33 +0000 | [diff] [blame] | 174 | return 0; |
Douglas Gregor | 79c2278 | 2010-01-16 20:21:20 +0000 | [diff] [blame] | 175 | } |
| 176 | |
Douglas Gregor | 4c3e0ee | 2011-02-17 08:47:29 +0000 | [diff] [blame] | 177 | |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 178 | //===----------------------------------------------------------------------===// |
Chris Lattner | 49f28ca | 2009-03-05 08:00:35 +0000 | [diff] [blame] | 179 | // PrettyStackTraceDecl Implementation |
| 180 | //===----------------------------------------------------------------------===// |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 181 | |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 182 | void PrettyStackTraceDecl::print(raw_ostream &OS) const { |
Chris Lattner | 49f28ca | 2009-03-05 08:00:35 +0000 | [diff] [blame] | 183 | SourceLocation TheLoc = Loc; |
| 184 | if (TheLoc.isInvalid() && TheDecl) |
| 185 | TheLoc = TheDecl->getLocation(); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 186 | |
Chris Lattner | 49f28ca | 2009-03-05 08:00:35 +0000 | [diff] [blame] | 187 | if (TheLoc.isValid()) { |
| 188 | TheLoc.print(OS, SM); |
| 189 | OS << ": "; |
| 190 | } |
| 191 | |
| 192 | OS << Message; |
| 193 | |
Benjamin Kramer | b063ef0 | 2013-02-23 13:53:57 +0000 | [diff] [blame] | 194 | if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) { |
| 195 | OS << " '"; |
| 196 | DN->printQualifiedName(OS); |
| 197 | OS << '\''; |
| 198 | } |
Chris Lattner | 49f28ca | 2009-03-05 08:00:35 +0000 | [diff] [blame] | 199 | OS << '\n'; |
| 200 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 201 | |
Chris Lattner | 49f28ca | 2009-03-05 08:00:35 +0000 | [diff] [blame] | 202 | //===----------------------------------------------------------------------===// |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 203 | // Decl Implementation |
| 204 | //===----------------------------------------------------------------------===// |
| 205 | |
Douglas Gregor | da2142f | 2011-02-19 18:51:44 +0000 | [diff] [blame] | 206 | // Out-of-line virtual method providing a home for Decl. |
| 207 | Decl::~Decl() { } |
Douglas Gregor | f4a03cc | 2011-02-17 07:02:32 +0000 | [diff] [blame] | 208 | |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 209 | void Decl::setDeclContext(DeclContext *DC) { |
Chris Lattner | ee219fd | 2009-03-29 06:06:59 +0000 | [diff] [blame] | 210 | DeclCtx = DC; |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 211 | } |
| 212 | |
| 213 | void Decl::setLexicalDeclContext(DeclContext *DC) { |
| 214 | if (DC == getLexicalDeclContext()) |
| 215 | return; |
| 216 | |
| 217 | if (isInSemaDC()) { |
Argyrios Kyrtzidis | 4bbb850 | 2012-02-09 02:44:08 +0000 | [diff] [blame] | 218 | setDeclContextsImpl(getDeclContext(), DC, getASTContext()); |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 219 | } else { |
| 220 | getMultipleDC()->LexicalDC = DC; |
| 221 | } |
| 222 | } |
| 223 | |
Argyrios Kyrtzidis | 4bbb850 | 2012-02-09 02:44:08 +0000 | [diff] [blame] | 224 | void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, |
| 225 | ASTContext &Ctx) { |
| 226 | if (SemaDC == LexicalDC) { |
| 227 | DeclCtx = SemaDC; |
| 228 | } else { |
| 229 | Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC(); |
| 230 | MDC->SemanticDC = SemaDC; |
| 231 | MDC->LexicalDC = LexicalDC; |
| 232 | DeclCtx = MDC; |
| 233 | } |
| 234 | } |
| 235 | |
John McCall | 9aeed32 | 2009-10-01 00:25:31 +0000 | [diff] [blame] | 236 | bool Decl::isInAnonymousNamespace() const { |
| 237 | const DeclContext *DC = getDeclContext(); |
| 238 | do { |
| 239 | if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC)) |
| 240 | if (ND->isAnonymousNamespace()) |
| 241 | return true; |
| 242 | } while ((DC = DC->getParent())); |
| 243 | |
| 244 | return false; |
| 245 | } |
| 246 | |
Argyrios Kyrtzidis | 3708b3d | 2009-06-29 17:38:40 +0000 | [diff] [blame] | 247 | TranslationUnitDecl *Decl::getTranslationUnitDecl() { |
Argyrios Kyrtzidis | 9b34669 | 2009-06-30 02:34:53 +0000 | [diff] [blame] | 248 | if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this)) |
| 249 | return TUD; |
| 250 | |
Argyrios Kyrtzidis | 3708b3d | 2009-06-29 17:38:40 +0000 | [diff] [blame] | 251 | DeclContext *DC = getDeclContext(); |
| 252 | assert(DC && "This decl is not contained in a translation unit!"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 253 | |
Argyrios Kyrtzidis | 3708b3d | 2009-06-29 17:38:40 +0000 | [diff] [blame] | 254 | while (!DC->isTranslationUnit()) { |
| 255 | DC = DC->getParent(); |
| 256 | assert(DC && "This decl is not contained in a translation unit!"); |
| 257 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 258 | |
Argyrios Kyrtzidis | 3708b3d | 2009-06-29 17:38:40 +0000 | [diff] [blame] | 259 | return cast<TranslationUnitDecl>(DC); |
| 260 | } |
| 261 | |
| 262 | ASTContext &Decl::getASTContext() const { |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 263 | return getTranslationUnitDecl()->getASTContext(); |
Argyrios Kyrtzidis | 3708b3d | 2009-06-29 17:38:40 +0000 | [diff] [blame] | 264 | } |
| 265 | |
Argyrios Kyrtzidis | 7b90340 | 2010-10-24 17:26:36 +0000 | [diff] [blame] | 266 | ASTMutationListener *Decl::getASTMutationListener() const { |
| 267 | return getASTContext().getASTMutationListener(); |
| 268 | } |
| 269 | |
Benjamin Kramer | 2fa67ef | 2012-12-01 15:09:41 +0000 | [diff] [blame] | 270 | unsigned Decl::getMaxAlignment() const { |
| 271 | if (!hasAttrs()) |
| 272 | return 0; |
| 273 | |
| 274 | unsigned Align = 0; |
| 275 | const AttrVec &V = getAttrs(); |
| 276 | ASTContext &Ctx = getASTContext(); |
| 277 | specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end()); |
| 278 | for (; I != E; ++I) |
| 279 | Align = std::max(Align, I->getAlignment(Ctx)); |
| 280 | return Align; |
| 281 | } |
| 282 | |
Douglas Gregor | c070cc6 | 2010-06-17 23:14:26 +0000 | [diff] [blame] | 283 | bool Decl::isUsed(bool CheckUsedAttr) const { |
Tanya Lattner | 12ead49 | 2010-02-17 02:17:21 +0000 | [diff] [blame] | 284 | if (Used) |
| 285 | return true; |
| 286 | |
| 287 | // Check for used attribute. |
Douglas Gregor | c070cc6 | 2010-06-17 23:14:26 +0000 | [diff] [blame] | 288 | if (CheckUsedAttr && hasAttr<UsedAttr>()) |
Tanya Lattner | 12ead49 | 2010-02-17 02:17:21 +0000 | [diff] [blame] | 289 | return true; |
Rafael Espindola | 919b7e6 | 2012-11-23 16:26:30 +0000 | [diff] [blame] | 290 | |
Tanya Lattner | 12ead49 | 2010-02-17 02:17:21 +0000 | [diff] [blame] | 291 | return false; |
| 292 | } |
| 293 | |
Eli Friedman | 86164e8 | 2013-09-05 00:02:25 +0000 | [diff] [blame] | 294 | void Decl::markUsed(ASTContext &C) { |
| 295 | if (Used) |
| 296 | return; |
| 297 | |
| 298 | if (C.getASTMutationListener()) |
| 299 | C.getASTMutationListener()->DeclarationMarkedUsed(this); |
| 300 | |
| 301 | Used = true; |
| 302 | } |
| 303 | |
Argyrios Kyrtzidis | 6b6b42a | 2011-04-19 19:51:10 +0000 | [diff] [blame] | 304 | bool Decl::isReferenced() const { |
| 305 | if (Referenced) |
| 306 | return true; |
| 307 | |
| 308 | // Check redeclarations. |
| 309 | for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) |
| 310 | if (I->Referenced) |
| 311 | return true; |
| 312 | |
| 313 | return false; |
| 314 | } |
| 315 | |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 316 | /// \brief Determine the availability of the given declaration based on |
| 317 | /// the target platform. |
| 318 | /// |
| 319 | /// When it returns an availability result other than \c AR_Available, |
| 320 | /// if the \p Message parameter is non-NULL, it will be set to a |
| 321 | /// string describing why the entity is unavailable. |
| 322 | /// |
| 323 | /// FIXME: Make these strings localizable, since they end up in |
| 324 | /// diagnostics. |
| 325 | static AvailabilityResult CheckAvailability(ASTContext &Context, |
| 326 | const AvailabilityAttr *A, |
| 327 | std::string *Message) { |
Douglas Gregor | bcfd1f5 | 2011-09-02 00:18:52 +0000 | [diff] [blame] | 328 | StringRef TargetPlatform = Context.getTargetInfo().getPlatformName(); |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 329 | StringRef PrettyPlatformName |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 330 | = AvailabilityAttr::getPrettyPlatformName(TargetPlatform); |
| 331 | if (PrettyPlatformName.empty()) |
| 332 | PrettyPlatformName = TargetPlatform; |
| 333 | |
Douglas Gregor | bcfd1f5 | 2011-09-02 00:18:52 +0000 | [diff] [blame] | 334 | VersionTuple TargetMinVersion = Context.getTargetInfo().getPlatformMinVersion(); |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 335 | if (TargetMinVersion.empty()) |
| 336 | return AR_Available; |
| 337 | |
| 338 | // Match the platform name. |
| 339 | if (A->getPlatform()->getName() != TargetPlatform) |
| 340 | return AR_Available; |
Fariborz Jahanian | 006e42f | 2011-12-10 00:28:41 +0000 | [diff] [blame] | 341 | |
| 342 | std::string HintMessage; |
| 343 | if (!A->getMessage().empty()) { |
| 344 | HintMessage = " - "; |
| 345 | HintMessage += A->getMessage(); |
| 346 | } |
| 347 | |
Douglas Gregor | b53e417 | 2011-03-26 03:35:55 +0000 | [diff] [blame] | 348 | // Make sure that this declaration has not been marked 'unavailable'. |
| 349 | if (A->getUnavailable()) { |
| 350 | if (Message) { |
| 351 | Message->clear(); |
| 352 | llvm::raw_string_ostream Out(*Message); |
Fariborz Jahanian | 006e42f | 2011-12-10 00:28:41 +0000 | [diff] [blame] | 353 | Out << "not available on " << PrettyPlatformName |
| 354 | << HintMessage; |
Douglas Gregor | b53e417 | 2011-03-26 03:35:55 +0000 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | return AR_Unavailable; |
| 358 | } |
| 359 | |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 360 | // Make sure that this declaration has already been introduced. |
| 361 | if (!A->getIntroduced().empty() && |
| 362 | TargetMinVersion < A->getIntroduced()) { |
| 363 | if (Message) { |
| 364 | Message->clear(); |
| 365 | llvm::raw_string_ostream Out(*Message); |
| 366 | Out << "introduced in " << PrettyPlatformName << ' ' |
Fariborz Jahanian | 006e42f | 2011-12-10 00:28:41 +0000 | [diff] [blame] | 367 | << A->getIntroduced() << HintMessage; |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 368 | } |
| 369 | |
| 370 | return AR_NotYetIntroduced; |
| 371 | } |
| 372 | |
| 373 | // Make sure that this declaration hasn't been obsoleted. |
| 374 | if (!A->getObsoleted().empty() && TargetMinVersion >= A->getObsoleted()) { |
| 375 | if (Message) { |
| 376 | Message->clear(); |
| 377 | llvm::raw_string_ostream Out(*Message); |
| 378 | Out << "obsoleted in " << PrettyPlatformName << ' ' |
Fariborz Jahanian | 006e42f | 2011-12-10 00:28:41 +0000 | [diff] [blame] | 379 | << A->getObsoleted() << HintMessage; |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 380 | } |
| 381 | |
| 382 | return AR_Unavailable; |
| 383 | } |
| 384 | |
| 385 | // Make sure that this declaration hasn't been deprecated. |
| 386 | if (!A->getDeprecated().empty() && TargetMinVersion >= A->getDeprecated()) { |
| 387 | if (Message) { |
| 388 | Message->clear(); |
| 389 | llvm::raw_string_ostream Out(*Message); |
| 390 | Out << "first deprecated in " << PrettyPlatformName << ' ' |
Fariborz Jahanian | 006e42f | 2011-12-10 00:28:41 +0000 | [diff] [blame] | 391 | << A->getDeprecated() << HintMessage; |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 392 | } |
| 393 | |
| 394 | return AR_Deprecated; |
| 395 | } |
| 396 | |
| 397 | return AR_Available; |
| 398 | } |
| 399 | |
| 400 | AvailabilityResult Decl::getAvailability(std::string *Message) const { |
| 401 | AvailabilityResult Result = AR_Available; |
| 402 | std::string ResultMessage; |
| 403 | |
| 404 | for (attr_iterator A = attr_begin(), AEnd = attr_end(); A != AEnd; ++A) { |
| 405 | if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) { |
| 406 | if (Result >= AR_Deprecated) |
| 407 | continue; |
| 408 | |
| 409 | if (Message) |
| 410 | ResultMessage = Deprecated->getMessage(); |
| 411 | |
| 412 | Result = AR_Deprecated; |
| 413 | continue; |
| 414 | } |
| 415 | |
| 416 | if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) { |
| 417 | if (Message) |
| 418 | *Message = Unavailable->getMessage(); |
| 419 | return AR_Unavailable; |
| 420 | } |
| 421 | |
| 422 | if (AvailabilityAttr *Availability = dyn_cast<AvailabilityAttr>(*A)) { |
| 423 | AvailabilityResult AR = CheckAvailability(getASTContext(), Availability, |
| 424 | Message); |
| 425 | |
| 426 | if (AR == AR_Unavailable) |
| 427 | return AR_Unavailable; |
| 428 | |
| 429 | if (AR > Result) { |
| 430 | Result = AR; |
| 431 | if (Message) |
| 432 | ResultMessage.swap(*Message); |
| 433 | } |
| 434 | continue; |
| 435 | } |
| 436 | } |
| 437 | |
| 438 | if (Message) |
| 439 | Message->swap(ResultMessage); |
| 440 | return Result; |
| 441 | } |
| 442 | |
| 443 | bool Decl::canBeWeakImported(bool &IsDefinition) const { |
| 444 | IsDefinition = false; |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 445 | |
| 446 | // Variables, if they aren't definitions. |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 447 | if (const VarDecl *Var = dyn_cast<VarDecl>(this)) { |
Rafael Espindola | d2615cc | 2013-04-03 19:27:57 +0000 | [diff] [blame] | 448 | if (Var->isThisDeclarationADefinition()) { |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 449 | IsDefinition = true; |
| 450 | return false; |
| 451 | } |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 452 | return true; |
| 453 | |
| 454 | // Functions, if they aren't definitions. |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 455 | } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) { |
| 456 | if (FD->hasBody()) { |
| 457 | IsDefinition = true; |
| 458 | return false; |
| 459 | } |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 460 | return true; |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 461 | |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 462 | // Objective-C classes, if this is the non-fragile runtime. |
| 463 | } else if (isa<ObjCInterfaceDecl>(this) && |
John McCall | 0b92fcb | 2012-06-20 21:58:02 +0000 | [diff] [blame] | 464 | getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) { |
John McCall | 260611a | 2012-06-20 06:18:46 +0000 | [diff] [blame] | 465 | return true; |
| 466 | |
| 467 | // Nothing else. |
| 468 | } else { |
| 469 | return false; |
| 470 | } |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 471 | } |
| 472 | |
| 473 | bool Decl::isWeakImported() const { |
| 474 | bool IsDefinition; |
| 475 | if (!canBeWeakImported(IsDefinition)) |
| 476 | return false; |
| 477 | |
Douglas Gregor | 0a0d2b1 | 2011-03-23 00:50:03 +0000 | [diff] [blame] | 478 | for (attr_iterator A = attr_begin(), AEnd = attr_end(); A != AEnd; ++A) { |
| 479 | if (isa<WeakImportAttr>(*A)) |
| 480 | return true; |
| 481 | |
| 482 | if (AvailabilityAttr *Availability = dyn_cast<AvailabilityAttr>(*A)) { |
| 483 | if (CheckAvailability(getASTContext(), Availability, 0) |
| 484 | == AR_NotYetIntroduced) |
| 485 | return true; |
| 486 | } |
| 487 | } |
| 488 | |
| 489 | return false; |
| 490 | } |
Tanya Lattner | 12ead49 | 2010-02-17 02:17:21 +0000 | [diff] [blame] | 491 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 492 | unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) { |
| 493 | switch (DeclKind) { |
John McCall | 9488ea1 | 2009-11-17 05:59:44 +0000 | [diff] [blame] | 494 | case Function: |
| 495 | case CXXMethod: |
| 496 | case CXXConstructor: |
| 497 | case CXXDestructor: |
| 498 | case CXXConversion: |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 499 | case EnumConstant: |
| 500 | case Var: |
| 501 | case ImplicitParam: |
| 502 | case ParmVar: |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 503 | case NonTypeTemplateParm: |
| 504 | case ObjCMethod: |
Daniel Dunbar | 00b40d3 | 2010-04-23 13:07:39 +0000 | [diff] [blame] | 505 | case ObjCProperty: |
John McCall | 76da55d | 2013-04-16 07:28:30 +0000 | [diff] [blame] | 506 | case MSProperty: |
Daniel Dunbar | 00b40d3 | 2010-04-23 13:07:39 +0000 | [diff] [blame] | 507 | return IDNS_Ordinary; |
Chris Lattner | ad8dcf4 | 2011-02-17 07:39:24 +0000 | [diff] [blame] | 508 | case Label: |
| 509 | return IDNS_Label; |
Francois Pichet | 87c2e12 | 2010-11-21 06:08:52 +0000 | [diff] [blame] | 510 | case IndirectField: |
| 511 | return IDNS_Ordinary | IDNS_Member; |
| 512 | |
John McCall | 0d6b164 | 2010-04-23 18:46:30 +0000 | [diff] [blame] | 513 | case ObjCCompatibleAlias: |
| 514 | case ObjCInterface: |
| 515 | return IDNS_Ordinary | IDNS_Type; |
| 516 | |
| 517 | case Typedef: |
Richard Smith | 162e1c1 | 2011-04-15 14:24:37 +0000 | [diff] [blame] | 518 | case TypeAlias: |
Richard Smith | 3e4c6c4 | 2011-05-05 21:57:07 +0000 | [diff] [blame] | 519 | case TypeAliasTemplate: |
John McCall | 0d6b164 | 2010-04-23 18:46:30 +0000 | [diff] [blame] | 520 | case UnresolvedUsingTypename: |
| 521 | case TemplateTypeParm: |
| 522 | return IDNS_Ordinary | IDNS_Type; |
| 523 | |
John McCall | 9488ea1 | 2009-11-17 05:59:44 +0000 | [diff] [blame] | 524 | case UsingShadow: |
| 525 | return 0; // we'll actually overwrite this later |
| 526 | |
John McCall | 7ba107a | 2009-11-18 02:36:19 +0000 | [diff] [blame] | 527 | case UnresolvedUsingValue: |
John McCall | 7ba107a | 2009-11-18 02:36:19 +0000 | [diff] [blame] | 528 | return IDNS_Ordinary | IDNS_Using; |
John McCall | 9488ea1 | 2009-11-17 05:59:44 +0000 | [diff] [blame] | 529 | |
| 530 | case Using: |
| 531 | return IDNS_Using; |
| 532 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 533 | case ObjCProtocol: |
Douglas Gregor | 8fc463a | 2009-04-24 00:11:27 +0000 | [diff] [blame] | 534 | return IDNS_ObjCProtocol; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 535 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 536 | case Field: |
| 537 | case ObjCAtDefsField: |
| 538 | case ObjCIvar: |
| 539 | return IDNS_Member; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 540 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 541 | case Record: |
| 542 | case CXXRecord: |
| 543 | case Enum: |
John McCall | 0d6b164 | 2010-04-23 18:46:30 +0000 | [diff] [blame] | 544 | return IDNS_Tag | IDNS_Type; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 545 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 546 | case Namespace: |
John McCall | 0d6b164 | 2010-04-23 18:46:30 +0000 | [diff] [blame] | 547 | case NamespaceAlias: |
| 548 | return IDNS_Namespace; |
| 549 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 550 | case FunctionTemplate: |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 551 | case VarTemplate: |
John McCall | 0d6b164 | 2010-04-23 18:46:30 +0000 | [diff] [blame] | 552 | return IDNS_Ordinary; |
| 553 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 554 | case ClassTemplate: |
| 555 | case TemplateTemplateParm: |
John McCall | 0d6b164 | 2010-04-23 18:46:30 +0000 | [diff] [blame] | 556 | return IDNS_Ordinary | IDNS_Tag | IDNS_Type; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 557 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 558 | // Never have names. |
John McCall | 02cace7 | 2009-08-28 07:59:38 +0000 | [diff] [blame] | 559 | case Friend: |
John McCall | dd4a3b0 | 2009-09-16 22:47:08 +0000 | [diff] [blame] | 560 | case FriendTemplate: |
Abramo Bagnara | 6206d53 | 2010-06-05 05:09:32 +0000 | [diff] [blame] | 561 | case AccessSpec: |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 562 | case LinkageSpec: |
| 563 | case FileScopeAsm: |
| 564 | case StaticAssert: |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 565 | case ObjCPropertyImpl: |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 566 | case Block: |
Tareq A. Siraj | 6afcf88 | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 567 | case Captured: |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 568 | case TranslationUnit: |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 569 | |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 570 | case UsingDirective: |
| 571 | case ClassTemplateSpecialization: |
Douglas Gregor | c8ab256 | 2009-05-31 09:31:02 +0000 | [diff] [blame] | 572 | case ClassTemplatePartialSpecialization: |
Francois Pichet | af0f4d0 | 2011-08-14 03:52:19 +0000 | [diff] [blame] | 573 | case ClassScopeFunctionSpecialization: |
Larisse Voufo | ef4579c | 2013-08-06 01:03:05 +0000 | [diff] [blame] | 574 | case VarTemplateSpecialization: |
| 575 | case VarTemplatePartialSpecialization: |
Douglas Gregor | bd4187b | 2010-04-22 23:19:50 +0000 | [diff] [blame] | 576 | case ObjCImplementation: |
| 577 | case ObjCCategory: |
| 578 | case ObjCCategoryImpl: |
Douglas Gregor | 15de72c | 2011-12-02 23:23:56 +0000 | [diff] [blame] | 579 | case Import: |
Alexey Bataev | c640058 | 2013-03-22 06:34:35 +0000 | [diff] [blame] | 580 | case OMPThreadPrivate: |
Michael Han | 684aa73 | 2013-02-22 17:15:32 +0000 | [diff] [blame] | 581 | case Empty: |
Douglas Gregor | bd4187b | 2010-04-22 23:19:50 +0000 | [diff] [blame] | 582 | // Never looked up by name. |
Chris Lattner | 769dbdf | 2009-03-27 20:18:19 +0000 | [diff] [blame] | 583 | return 0; |
| 584 | } |
John McCall | 9488ea1 | 2009-11-17 05:59:44 +0000 | [diff] [blame] | 585 | |
David Blaikie | 3026348 | 2012-01-20 21:50:17 +0000 | [diff] [blame] | 586 | llvm_unreachable("Invalid DeclKind!"); |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 587 | } |
| 588 | |
Argyrios Kyrtzidis | 4bbb850 | 2012-02-09 02:44:08 +0000 | [diff] [blame] | 589 | void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) { |
Argyrios Kyrtzidis | 1715bf5 | 2010-06-11 23:09:25 +0000 | [diff] [blame] | 590 | assert(!HasAttrs && "Decl already contains attrs."); |
| 591 | |
Argyrios Kyrtzidis | 4bbb850 | 2012-02-09 02:44:08 +0000 | [diff] [blame] | 592 | AttrVec &AttrBlank = Ctx.getDeclAttrs(this); |
Sean Hunt | cf807c4 | 2010-08-18 23:23:40 +0000 | [diff] [blame] | 593 | assert(AttrBlank.empty() && "HasAttrs was wrong?"); |
Argyrios Kyrtzidis | 1715bf5 | 2010-06-11 23:09:25 +0000 | [diff] [blame] | 594 | |
| 595 | AttrBlank = attrs; |
| 596 | HasAttrs = true; |
| 597 | } |
| 598 | |
Sean Hunt | cf807c4 | 2010-08-18 23:23:40 +0000 | [diff] [blame] | 599 | void Decl::dropAttrs() { |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 600 | if (!HasAttrs) return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 601 | |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 602 | HasAttrs = false; |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 603 | getASTContext().eraseDeclAttrs(this); |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 604 | } |
| 605 | |
Sean Hunt | cf807c4 | 2010-08-18 23:23:40 +0000 | [diff] [blame] | 606 | const AttrVec &Decl::getAttrs() const { |
| 607 | assert(HasAttrs && "No attrs to get!"); |
Argyrios Kyrtzidis | 40b598e | 2009-06-30 02:34:44 +0000 | [diff] [blame] | 608 | return getASTContext().getDeclAttrs(this); |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 609 | } |
| 610 | |
Argyrios Kyrtzidis | 42220c5 | 2008-10-12 16:14:48 +0000 | [diff] [blame] | 611 | Decl *Decl::castFromDeclContext (const DeclContext *D) { |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 612 | Decl::Kind DK = D->getDeclKind(); |
| 613 | switch(DK) { |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 614 | #define DECL(NAME, BASE) |
| 615 | #define DECL_CONTEXT(NAME) \ |
| 616 | case Decl::NAME: \ |
| 617 | return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D)); |
| 618 | #define DECL_CONTEXT_BASE(NAME) |
| 619 | #include "clang/AST/DeclNodes.inc" |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 620 | default: |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 621 | #define DECL(NAME, BASE) |
| 622 | #define DECL_CONTEXT_BASE(NAME) \ |
| 623 | if (DK >= first##NAME && DK <= last##NAME) \ |
| 624 | return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D)); |
| 625 | #include "clang/AST/DeclNodes.inc" |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 626 | llvm_unreachable("a decl that inherits DeclContext isn't handled"); |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 627 | } |
Argyrios Kyrtzidis | 42220c5 | 2008-10-12 16:14:48 +0000 | [diff] [blame] | 628 | } |
| 629 | |
| 630 | DeclContext *Decl::castToDeclContext(const Decl *D) { |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 631 | Decl::Kind DK = D->getKind(); |
| 632 | switch(DK) { |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 633 | #define DECL(NAME, BASE) |
| 634 | #define DECL_CONTEXT(NAME) \ |
| 635 | case Decl::NAME: \ |
| 636 | return static_cast<NAME##Decl*>(const_cast<Decl*>(D)); |
| 637 | #define DECL_CONTEXT_BASE(NAME) |
| 638 | #include "clang/AST/DeclNodes.inc" |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 639 | default: |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 640 | #define DECL(NAME, BASE) |
| 641 | #define DECL_CONTEXT_BASE(NAME) \ |
| 642 | if (DK >= first##NAME && DK <= last##NAME) \ |
| 643 | return static_cast<NAME##Decl*>(const_cast<Decl*>(D)); |
| 644 | #include "clang/AST/DeclNodes.inc" |
David Blaikie | b219cfc | 2011-09-23 05:06:16 +0000 | [diff] [blame] | 645 | llvm_unreachable("a decl that inherits DeclContext isn't handled"); |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 646 | } |
Argyrios Kyrtzidis | 42220c5 | 2008-10-12 16:14:48 +0000 | [diff] [blame] | 647 | } |
| 648 | |
Argyrios Kyrtzidis | 6fb0aee | 2009-06-30 02:35:26 +0000 | [diff] [blame] | 649 | SourceLocation Decl::getBodyRBrace() const { |
Argyrios Kyrtzidis | 06a54a3 | 2010-07-07 11:31:19 +0000 | [diff] [blame] | 650 | // Special handling of FunctionDecl to avoid de-serializing the body from PCH. |
| 651 | // FunctionDecl stores EndRangeLoc for this purpose. |
| 652 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) { |
| 653 | const FunctionDecl *Definition; |
| 654 | if (FD->hasBody(Definition)) |
| 655 | return Definition->getSourceRange().getEnd(); |
| 656 | return SourceLocation(); |
| 657 | } |
| 658 | |
Argyrios Kyrtzidis | 6717ef4 | 2010-07-07 11:31:27 +0000 | [diff] [blame] | 659 | if (Stmt *Body = getBody()) |
| 660 | return Body->getSourceRange().getEnd(); |
| 661 | |
| 662 | return SourceLocation(); |
Sebastian Redl | d3a413d | 2009-04-26 20:35:05 +0000 | [diff] [blame] | 663 | } |
| 664 | |
Anders Carlsson | 1329c27 | 2009-03-25 23:38:06 +0000 | [diff] [blame] | 665 | void Decl::CheckAccessDeclContext() const { |
Douglas Gregor | 3a1c36c | 2010-12-02 00:22:25 +0000 | [diff] [blame] | 666 | #ifndef NDEBUG |
John McCall | 46460a6 | 2010-01-20 21:53:11 +0000 | [diff] [blame] | 667 | // Suppress this check if any of the following hold: |
| 668 | // 1. this is the translation unit (and thus has no parent) |
| 669 | // 2. this is a template parameter (and thus doesn't belong to its context) |
Argyrios Kyrtzidis | d580e56 | 2010-09-08 21:58:42 +0000 | [diff] [blame] | 670 | // 3. this is a non-type template parameter |
| 671 | // 4. the context is not a record |
| 672 | // 5. it's invalid |
| 673 | // 6. it's a C++0x static_assert. |
Anders Carlsson | 35eda44 | 2009-08-29 20:47:47 +0000 | [diff] [blame] | 674 | if (isa<TranslationUnitDecl>(this) || |
Argyrios Kyrtzidis | 04aed0e | 2010-07-02 11:55:44 +0000 | [diff] [blame] | 675 | isa<TemplateTypeParmDecl>(this) || |
Argyrios Kyrtzidis | d580e56 | 2010-09-08 21:58:42 +0000 | [diff] [blame] | 676 | isa<NonTypeTemplateParmDecl>(this) || |
Douglas Gregor | fdd8ab1 | 2010-02-22 17:53:38 +0000 | [diff] [blame] | 677 | !isa<CXXRecordDecl>(getDeclContext()) || |
Argyrios Kyrtzidis | 65b63ec | 2010-09-08 21:32:35 +0000 | [diff] [blame] | 678 | isInvalidDecl() || |
| 679 | isa<StaticAssertDecl>(this) || |
| 680 | // FIXME: a ParmVarDecl can have ClassTemplateSpecialization |
| 681 | // as DeclContext (?). |
Argyrios Kyrtzidis | d580e56 | 2010-09-08 21:58:42 +0000 | [diff] [blame] | 682 | isa<ParmVarDecl>(this) || |
| 683 | // FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have |
| 684 | // AS_none as access specifier. |
Francois Pichet | bc84532 | 2011-08-17 01:06:54 +0000 | [diff] [blame] | 685 | isa<CXXRecordDecl>(this) || |
| 686 | isa<ClassScopeFunctionSpecializationDecl>(this)) |
Anders Carlsson | 35eda44 | 2009-08-29 20:47:47 +0000 | [diff] [blame] | 687 | return; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 688 | |
| 689 | assert(Access != AS_none && |
Anders Carlsson | 1329c27 | 2009-03-25 23:38:06 +0000 | [diff] [blame] | 690 | "Access specifier is AS_none inside a record decl"); |
Douglas Gregor | 3a1c36c | 2010-12-02 00:22:25 +0000 | [diff] [blame] | 691 | #endif |
Anders Carlsson | 1329c27 | 2009-03-25 23:38:06 +0000 | [diff] [blame] | 692 | } |
| 693 | |
John McCall | f5ebf9b | 2013-05-03 07:33:41 +0000 | [diff] [blame] | 694 | static Decl::Kind getKind(const Decl *D) { return D->getKind(); } |
| 695 | static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); } |
| 696 | |
| 697 | /// Starting at a given context (a Decl or DeclContext), look for a |
| 698 | /// code context that is not a closure (a lambda, block, etc.). |
| 699 | template <class T> static Decl *getNonClosureContext(T *D) { |
| 700 | if (getKind(D) == Decl::CXXMethod) { |
| 701 | CXXMethodDecl *MD = cast<CXXMethodDecl>(D); |
John McCall | 000817b | 2013-05-03 17:11:14 +0000 | [diff] [blame] | 702 | if (MD->getOverloadedOperator() == OO_Call && |
| 703 | MD->getParent()->isLambda()) |
John McCall | f5ebf9b | 2013-05-03 07:33:41 +0000 | [diff] [blame] | 704 | return getNonClosureContext(MD->getParent()->getParent()); |
| 705 | return MD; |
| 706 | } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { |
| 707 | return FD; |
| 708 | } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { |
| 709 | return MD; |
| 710 | } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) { |
| 711 | return getNonClosureContext(BD->getParent()); |
| 712 | } else if (CapturedDecl *CD = dyn_cast<CapturedDecl>(D)) { |
| 713 | return getNonClosureContext(CD->getParent()); |
| 714 | } else { |
| 715 | return 0; |
| 716 | } |
John McCall | 4b9c2d2 | 2011-11-06 09:01:30 +0000 | [diff] [blame] | 717 | } |
| 718 | |
John McCall | f5ebf9b | 2013-05-03 07:33:41 +0000 | [diff] [blame] | 719 | Decl *Decl::getNonClosureContext() { |
| 720 | return ::getNonClosureContext(this); |
| 721 | } |
John McCall | aab9e31 | 2011-02-22 22:25:23 +0000 | [diff] [blame] | 722 | |
John McCall | f5ebf9b | 2013-05-03 07:33:41 +0000 | [diff] [blame] | 723 | Decl *DeclContext::getNonClosureAncestor() { |
| 724 | return ::getNonClosureContext(this); |
John McCall | aab9e31 | 2011-02-22 22:25:23 +0000 | [diff] [blame] | 725 | } |
Anders Carlsson | 1329c27 | 2009-03-25 23:38:06 +0000 | [diff] [blame] | 726 | |
Eli Friedman | 56d2937 | 2008-06-07 16:52:53 +0000 | [diff] [blame] | 727 | //===----------------------------------------------------------------------===// |
| 728 | // DeclContext Implementation |
| 729 | //===----------------------------------------------------------------------===// |
| 730 | |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 731 | bool DeclContext::classof(const Decl *D) { |
| 732 | switch (D->getKind()) { |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 733 | #define DECL(NAME, BASE) |
| 734 | #define DECL_CONTEXT(NAME) case Decl::NAME: |
| 735 | #define DECL_CONTEXT_BASE(NAME) |
| 736 | #include "clang/AST/DeclNodes.inc" |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 737 | return true; |
| 738 | default: |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 739 | #define DECL(NAME, BASE) |
| 740 | #define DECL_CONTEXT_BASE(NAME) \ |
| 741 | if (D->getKind() >= Decl::first##NAME && \ |
| 742 | D->getKind() <= Decl::last##NAME) \ |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 743 | return true; |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 744 | #include "clang/AST/DeclNodes.inc" |
Argyrios Kyrtzidis | 3d7641e | 2009-02-16 14:29:28 +0000 | [diff] [blame] | 745 | return false; |
| 746 | } |
| 747 | } |
| 748 | |
Douglas Gregor | a2da780 | 2010-07-25 18:38:02 +0000 | [diff] [blame] | 749 | DeclContext::~DeclContext() { } |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 750 | |
Douglas Gregor | e942bbe | 2009-09-10 16:57:35 +0000 | [diff] [blame] | 751 | /// \brief Find the parent context of this context that will be |
| 752 | /// used for unqualified name lookup. |
| 753 | /// |
| 754 | /// Generally, the parent lookup context is the semantic context. However, for |
| 755 | /// a friend function the parent lookup context is the lexical context, which |
| 756 | /// is the class in which the friend is declared. |
| 757 | DeclContext *DeclContext::getLookupParent() { |
| 758 | // FIXME: Find a better way to identify friends |
| 759 | if (isa<FunctionDecl>(this)) |
Sebastian Redl | 7a126a4 | 2010-08-31 00:36:30 +0000 | [diff] [blame] | 760 | if (getParent()->getRedeclContext()->isFileContext() && |
| 761 | getLexicalParent()->getRedeclContext()->isRecord()) |
Douglas Gregor | e942bbe | 2009-09-10 16:57:35 +0000 | [diff] [blame] | 762 | return getLexicalParent(); |
| 763 | |
| 764 | return getParent(); |
| 765 | } |
| 766 | |
Sebastian Redl | 410c4f2 | 2010-08-31 20:53:31 +0000 | [diff] [blame] | 767 | bool DeclContext::isInlineNamespace() const { |
| 768 | return isNamespace() && |
| 769 | cast<NamespaceDecl>(this)->isInline(); |
| 770 | } |
| 771 | |
Douglas Gregor | bc22163 | 2009-05-28 16:34:51 +0000 | [diff] [blame] | 772 | bool DeclContext::isDependentContext() const { |
| 773 | if (isFileContext()) |
| 774 | return false; |
| 775 | |
Douglas Gregor | c8ab256 | 2009-05-31 09:31:02 +0000 | [diff] [blame] | 776 | if (isa<ClassTemplatePartialSpecializationDecl>(this)) |
| 777 | return true; |
| 778 | |
Douglas Gregor | f4b7de1 | 2012-02-21 19:11:17 +0000 | [diff] [blame] | 779 | if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) { |
Douglas Gregor | bc22163 | 2009-05-28 16:34:51 +0000 | [diff] [blame] | 780 | if (Record->getDescribedClassTemplate()) |
| 781 | return true; |
Douglas Gregor | f4b7de1 | 2012-02-21 19:11:17 +0000 | [diff] [blame] | 782 | |
| 783 | if (Record->isDependentLambda()) |
| 784 | return true; |
| 785 | } |
| 786 | |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 787 | if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) { |
Douglas Gregor | bc22163 | 2009-05-28 16:34:51 +0000 | [diff] [blame] | 788 | if (Function->getDescribedFunctionTemplate()) |
| 789 | return true; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 790 | |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 791 | // Friend function declarations are dependent if their *lexical* |
| 792 | // context is dependent. |
| 793 | if (cast<Decl>(this)->getFriendObjectKind()) |
| 794 | return getLexicalParent()->isDependentContext(); |
| 795 | } |
| 796 | |
Douglas Gregor | bc22163 | 2009-05-28 16:34:51 +0000 | [diff] [blame] | 797 | return getParent() && getParent()->isDependentContext(); |
| 798 | } |
| 799 | |
Douglas Gregor | 074149e | 2009-01-05 19:45:36 +0000 | [diff] [blame] | 800 | bool DeclContext::isTransparentContext() const { |
| 801 | if (DeclKind == Decl::Enum) |
Douglas Gregor | 1274ccd | 2010-10-08 23:50:27 +0000 | [diff] [blame] | 802 | return !cast<EnumDecl>(this)->isScoped(); |
Douglas Gregor | 074149e | 2009-01-05 19:45:36 +0000 | [diff] [blame] | 803 | else if (DeclKind == Decl::LinkageSpec) |
| 804 | return true; |
Douglas Gregor | 074149e | 2009-01-05 19:45:36 +0000 | [diff] [blame] | 805 | |
| 806 | return false; |
| 807 | } |
| 808 | |
Sebastian Redl | 7a126a4 | 2010-08-31 00:36:30 +0000 | [diff] [blame] | 809 | bool DeclContext::Encloses(const DeclContext *DC) const { |
Douglas Gregor | 6dd38da | 2009-08-27 06:03:53 +0000 | [diff] [blame] | 810 | if (getPrimaryContext() != this) |
| 811 | return getPrimaryContext()->Encloses(DC); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 812 | |
Douglas Gregor | 6dd38da | 2009-08-27 06:03:53 +0000 | [diff] [blame] | 813 | for (; DC; DC = DC->getParent()) |
| 814 | if (DC->getPrimaryContext() == this) |
| 815 | return true; |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 816 | return false; |
Douglas Gregor | 6dd38da | 2009-08-27 06:03:53 +0000 | [diff] [blame] | 817 | } |
| 818 | |
Steve Naroff | 0701bbb | 2009-01-08 17:28:14 +0000 | [diff] [blame] | 819 | DeclContext *DeclContext::getPrimaryContext() { |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 820 | switch (DeclKind) { |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 821 | case Decl::TranslationUnit: |
Douglas Gregor | 074149e | 2009-01-05 19:45:36 +0000 | [diff] [blame] | 822 | case Decl::LinkageSpec: |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 823 | case Decl::Block: |
Tareq A. Siraj | 6afcf88 | 2013-04-16 19:37:38 +0000 | [diff] [blame] | 824 | case Decl::Captured: |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 825 | // There is only one DeclContext for these entities. |
| 826 | return this; |
| 827 | |
| 828 | case Decl::Namespace: |
| 829 | // The original namespace is our primary context. |
| 830 | return static_cast<NamespaceDecl*>(this)->getOriginalNamespace(); |
| 831 | |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 832 | case Decl::ObjCMethod: |
| 833 | return this; |
| 834 | |
| 835 | case Decl::ObjCInterface: |
Douglas Gregor | 53df7a1 | 2011-12-15 18:03:09 +0000 | [diff] [blame] | 836 | if (ObjCInterfaceDecl *Def = cast<ObjCInterfaceDecl>(this)->getDefinition()) |
| 837 | return Def; |
| 838 | |
| 839 | return this; |
| 840 | |
Steve Naroff | 0701bbb | 2009-01-08 17:28:14 +0000 | [diff] [blame] | 841 | case Decl::ObjCProtocol: |
Douglas Gregor | 1d784b2 | 2012-01-01 19:51:50 +0000 | [diff] [blame] | 842 | if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(this)->getDefinition()) |
| 843 | return Def; |
| 844 | |
| 845 | return this; |
Douglas Gregor | 53df7a1 | 2011-12-15 18:03:09 +0000 | [diff] [blame] | 846 | |
Steve Naroff | 0701bbb | 2009-01-08 17:28:14 +0000 | [diff] [blame] | 847 | case Decl::ObjCCategory: |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 848 | return this; |
| 849 | |
Steve Naroff | 0701bbb | 2009-01-08 17:28:14 +0000 | [diff] [blame] | 850 | case Decl::ObjCImplementation: |
| 851 | case Decl::ObjCCategoryImpl: |
| 852 | return this; |
| 853 | |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 854 | default: |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 855 | if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) { |
Douglas Gregor | cc63668 | 2009-02-17 23:15:12 +0000 | [diff] [blame] | 856 | // If this is a tag type that has a definition or is currently |
| 857 | // being defined, that definition is our primary context. |
John McCall | 3cb0ebd | 2010-03-10 03:28:59 +0000 | [diff] [blame] | 858 | TagDecl *Tag = cast<TagDecl>(this); |
| 859 | assert(isa<TagType>(Tag->TypeForDecl) || |
| 860 | isa<InjectedClassNameType>(Tag->TypeForDecl)); |
| 861 | |
| 862 | if (TagDecl *Def = Tag->getDefinition()) |
| 863 | return Def; |
| 864 | |
| 865 | if (!isa<InjectedClassNameType>(Tag->TypeForDecl)) { |
| 866 | const TagType *TagTy = cast<TagType>(Tag->TypeForDecl); |
| 867 | if (TagTy->isBeingDefined()) |
| 868 | // FIXME: is it necessarily being defined in the decl |
| 869 | // that owns the type? |
| 870 | return TagTy->getDecl(); |
| 871 | } |
| 872 | |
| 873 | return Tag; |
Douglas Gregor | cc63668 | 2009-02-17 23:15:12 +0000 | [diff] [blame] | 874 | } |
| 875 | |
Sean Hunt | 9a55591 | 2010-05-30 07:21:58 +0000 | [diff] [blame] | 876 | assert(DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction && |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 877 | "Unknown DeclContext kind"); |
| 878 | return this; |
| 879 | } |
| 880 | } |
| 881 | |
Douglas Gregor | f5c9f9f | 2012-01-07 09:11:48 +0000 | [diff] [blame] | 882 | void |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 883 | DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){ |
Douglas Gregor | f5c9f9f | 2012-01-07 09:11:48 +0000 | [diff] [blame] | 884 | Contexts.clear(); |
| 885 | |
| 886 | if (DeclKind != Decl::Namespace) { |
| 887 | Contexts.push_back(this); |
| 888 | return; |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 889 | } |
Douglas Gregor | f5c9f9f | 2012-01-07 09:11:48 +0000 | [diff] [blame] | 890 | |
| 891 | NamespaceDecl *Self = static_cast<NamespaceDecl *>(this); |
Douglas Gregor | ef96ee0 | 2012-01-14 16:38:05 +0000 | [diff] [blame] | 892 | for (NamespaceDecl *N = Self->getMostRecentDecl(); N; |
| 893 | N = N->getPreviousDecl()) |
Douglas Gregor | f5c9f9f | 2012-01-07 09:11:48 +0000 | [diff] [blame] | 894 | Contexts.push_back(N); |
| 895 | |
| 896 | std::reverse(Contexts.begin(), Contexts.end()); |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 897 | } |
| 898 | |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 899 | std::pair<Decl *, Decl *> |
Bill Wendling | 341785e | 2012-02-22 09:51:33 +0000 | [diff] [blame] | 900 | DeclContext::BuildDeclChain(ArrayRef<Decl*> Decls, |
Argyrios Kyrtzidis | ec2ec1f | 2011-10-07 21:55:43 +0000 | [diff] [blame] | 901 | bool FieldsAlreadyLoaded) { |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 902 | // Build up a chain of declarations via the Decl::NextInContextAndBits field. |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 903 | Decl *FirstNewDecl = 0; |
| 904 | Decl *PrevDecl = 0; |
| 905 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) { |
Argyrios Kyrtzidis | ec2ec1f | 2011-10-07 21:55:43 +0000 | [diff] [blame] | 906 | if (FieldsAlreadyLoaded && isa<FieldDecl>(Decls[I])) |
| 907 | continue; |
| 908 | |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 909 | Decl *D = Decls[I]; |
| 910 | if (PrevDecl) |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 911 | PrevDecl->NextInContextAndBits.setPointer(D); |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 912 | else |
| 913 | FirstNewDecl = D; |
| 914 | |
| 915 | PrevDecl = D; |
| 916 | } |
| 917 | |
| 918 | return std::make_pair(FirstNewDecl, PrevDecl); |
| 919 | } |
| 920 | |
Richard Smith | bbcd0f3 | 2013-02-07 03:37:08 +0000 | [diff] [blame] | 921 | /// \brief We have just acquired external visible storage, and we already have |
| 922 | /// built a lookup map. For every name in the map, pull in the new names from |
| 923 | /// the external storage. |
| 924 | void DeclContext::reconcileExternalVisibleStorage() { |
Richard Smith | 8896339 | 2013-02-11 22:02:16 +0000 | [diff] [blame] | 925 | assert(NeedToReconcileExternalVisibleStorage && LookupPtr.getPointer()); |
Richard Smith | bbcd0f3 | 2013-02-07 03:37:08 +0000 | [diff] [blame] | 926 | NeedToReconcileExternalVisibleStorage = false; |
| 927 | |
| 928 | StoredDeclsMap &Map = *LookupPtr.getPointer(); |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 929 | for (StoredDeclsMap::iterator I = Map.begin(); I != Map.end(); ++I) |
| 930 | I->second.setHasExternalDecls(); |
Richard Smith | bbcd0f3 | 2013-02-07 03:37:08 +0000 | [diff] [blame] | 931 | } |
| 932 | |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 933 | /// \brief Load the declarations within this lexical storage from an |
| 934 | /// external source. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 935 | void |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 936 | DeclContext::LoadLexicalDeclsFromExternalStorage() const { |
| 937 | ExternalASTSource *Source = getParentASTContext().getExternalSource(); |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 938 | assert(hasExternalLexicalStorage() && Source && "No external storage?"); |
| 939 | |
Argyrios Kyrtzidis | 0dbbc04 | 2010-07-30 10:03:23 +0000 | [diff] [blame] | 940 | // Notify that we have a DeclContext that is initializing. |
| 941 | ExternalASTSource::Deserializing ADeclContext(Source); |
Douglas Gregor | 9fc18c9 | 2011-08-26 21:23:06 +0000 | [diff] [blame] | 942 | |
Douglas Gregor | ba6ffaf | 2011-07-15 21:46:17 +0000 | [diff] [blame] | 943 | // Load the external declarations, if any. |
Chris Lattner | 5f9e272 | 2011-07-23 10:55:15 +0000 | [diff] [blame] | 944 | SmallVector<Decl*, 64> Decls; |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 945 | ExternalLexicalStorage = false; |
Douglas Gregor | ba6ffaf | 2011-07-15 21:46:17 +0000 | [diff] [blame] | 946 | switch (Source->FindExternalLexicalDecls(this, Decls)) { |
| 947 | case ELR_Success: |
| 948 | break; |
| 949 | |
| 950 | case ELR_Failure: |
| 951 | case ELR_AlreadyLoaded: |
| 952 | return; |
| 953 | } |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 954 | |
| 955 | if (Decls.empty()) |
| 956 | return; |
| 957 | |
Argyrios Kyrtzidis | ec2ec1f | 2011-10-07 21:55:43 +0000 | [diff] [blame] | 958 | // We may have already loaded just the fields of this record, in which case |
| 959 | // we need to ignore them. |
| 960 | bool FieldsAlreadyLoaded = false; |
| 961 | if (const RecordDecl *RD = dyn_cast<RecordDecl>(this)) |
| 962 | FieldsAlreadyLoaded = RD->LoadedFieldsFromExternalStorage; |
| 963 | |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 964 | // Splice the newly-read declarations into the beginning of the list |
| 965 | // of declarations. |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 966 | Decl *ExternalFirst, *ExternalLast; |
Argyrios Kyrtzidis | ec2ec1f | 2011-10-07 21:55:43 +0000 | [diff] [blame] | 967 | llvm::tie(ExternalFirst, ExternalLast) = BuildDeclChain(Decls, |
| 968 | FieldsAlreadyLoaded); |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 969 | ExternalLast->NextInContextAndBits.setPointer(FirstDecl); |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 970 | FirstDecl = ExternalFirst; |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 971 | if (!LastDecl) |
Argyrios Kyrtzidis | eb5e998 | 2010-10-14 20:14:34 +0000 | [diff] [blame] | 972 | LastDecl = ExternalLast; |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 973 | } |
| 974 | |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 975 | DeclContext::lookup_result |
| 976 | ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC, |
| 977 | DeclarationName Name) { |
| 978 | ASTContext &Context = DC->getParentASTContext(); |
| 979 | StoredDeclsMap *Map; |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 980 | if (!(Map = DC->LookupPtr.getPointer())) |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 981 | Map = DC->CreateStoredDeclsMap(Context); |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 982 | |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 983 | (*Map)[Name].removeExternalDecls(); |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 984 | |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 985 | return DeclContext::lookup_result(); |
| 986 | } |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 987 | |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 988 | DeclContext::lookup_result |
| 989 | ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC, |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 990 | DeclarationName Name, |
Argyrios Kyrtzidis | 45df9c6 | 2011-09-09 06:44:14 +0000 | [diff] [blame] | 991 | ArrayRef<NamedDecl*> Decls) { |
Dmitri Gribenko | 1ad23d6 | 2012-09-10 21:20:09 +0000 | [diff] [blame] | 992 | ASTContext &Context = DC->getParentASTContext(); |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 993 | StoredDeclsMap *Map; |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 994 | if (!(Map = DC->LookupPtr.getPointer())) |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 995 | Map = DC->CreateStoredDeclsMap(Context); |
| 996 | |
| 997 | StoredDeclsList &List = (*Map)[Name]; |
Richard Smith | ddb10f7 | 2013-06-24 01:46:41 +0000 | [diff] [blame] | 998 | |
| 999 | // Clear out any old external visible declarations, to avoid quadratic |
| 1000 | // performance in the redeclaration checks below. |
| 1001 | List.removeExternalDecls(); |
| 1002 | |
| 1003 | if (!List.isNull()) { |
| 1004 | // We have both existing declarations and new declarations for this name. |
| 1005 | // Some of the declarations may simply replace existing ones. Handle those |
| 1006 | // first. |
| 1007 | llvm::SmallVector<unsigned, 8> Skip; |
| 1008 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) |
| 1009 | if (List.HandleRedeclaration(Decls[I])) |
| 1010 | Skip.push_back(I); |
| 1011 | Skip.push_back(Decls.size()); |
| 1012 | |
| 1013 | // Add in any new declarations. |
| 1014 | unsigned SkipPos = 0; |
| 1015 | for (unsigned I = 0, N = Decls.size(); I != N; ++I) { |
| 1016 | if (I == Skip[SkipPos]) |
| 1017 | ++SkipPos; |
| 1018 | else |
| 1019 | List.AddSubsequentDecl(Decls[I]); |
| 1020 | } |
| 1021 | } else { |
| 1022 | // Convert the array to a StoredDeclsList. |
| 1023 | for (ArrayRef<NamedDecl*>::iterator |
| 1024 | I = Decls.begin(), E = Decls.end(); I != E; ++I) { |
| 1025 | if (List.isNull()) |
| 1026 | List.setOnlyValue(*I); |
| 1027 | else |
| 1028 | List.AddSubsequentDecl(*I); |
| 1029 | } |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 1030 | } |
| 1031 | |
Argyrios Kyrtzidis | 074dcc8 | 2010-08-20 16:04:35 +0000 | [diff] [blame] | 1032 | return List.getLookupResult(); |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 1033 | } |
| 1034 | |
Sebastian Redl | 681d723 | 2010-07-27 00:17:23 +0000 | [diff] [blame] | 1035 | DeclContext::decl_iterator DeclContext::noload_decls_begin() const { |
| 1036 | return decl_iterator(FirstDecl); |
| 1037 | } |
| 1038 | |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1039 | DeclContext::decl_iterator DeclContext::decls_begin() const { |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 1040 | if (hasExternalLexicalStorage()) |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1041 | LoadLexicalDeclsFromExternalStorage(); |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 1042 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1043 | return decl_iterator(FirstDecl); |
Douglas Gregor | 6ab3524 | 2009-04-09 21:40:53 +0000 | [diff] [blame] | 1044 | } |
| 1045 | |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1046 | bool DeclContext::decls_empty() const { |
Douglas Gregor | 8038d51 | 2009-04-10 17:25:41 +0000 | [diff] [blame] | 1047 | if (hasExternalLexicalStorage()) |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1048 | LoadLexicalDeclsFromExternalStorage(); |
Douglas Gregor | 8038d51 | 2009-04-10 17:25:41 +0000 | [diff] [blame] | 1049 | |
| 1050 | return !FirstDecl; |
| 1051 | } |
| 1052 | |
Sean Callanan | cd904e8 | 2013-05-04 02:04:27 +0000 | [diff] [blame] | 1053 | bool DeclContext::containsDecl(Decl *D) const { |
| 1054 | return (D->getLexicalDeclContext() == this && |
| 1055 | (D->NextInContextAndBits.getPointer() || D == LastDecl)); |
| 1056 | } |
| 1057 | |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1058 | void DeclContext::removeDecl(Decl *D) { |
| 1059 | assert(D->getLexicalDeclContext() == this && |
| 1060 | "decl being removed from non-lexical context"); |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 1061 | assert((D->NextInContextAndBits.getPointer() || D == LastDecl) && |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1062 | "decl is not in decls list"); |
| 1063 | |
| 1064 | // Remove D from the decl chain. This is O(n) but hopefully rare. |
| 1065 | if (D == FirstDecl) { |
| 1066 | if (D == LastDecl) |
| 1067 | FirstDecl = LastDecl = 0; |
| 1068 | else |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 1069 | FirstDecl = D->NextInContextAndBits.getPointer(); |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1070 | } else { |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 1071 | for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) { |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1072 | assert(I && "decl not found in linked list"); |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 1073 | if (I->NextInContextAndBits.getPointer() == D) { |
| 1074 | I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer()); |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1075 | if (D == LastDecl) LastDecl = I; |
| 1076 | break; |
| 1077 | } |
| 1078 | } |
| 1079 | } |
| 1080 | |
| 1081 | // Mark that D is no longer in the decl chain. |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 1082 | D->NextInContextAndBits.setPointer(0); |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1083 | |
| 1084 | // Remove D from the lookup table if necessary. |
| 1085 | if (isa<NamedDecl>(D)) { |
| 1086 | NamedDecl *ND = cast<NamedDecl>(D); |
| 1087 | |
Axel Naumann | 02368d0 | 2011-08-26 14:06:12 +0000 | [diff] [blame] | 1088 | // Remove only decls that have a name |
| 1089 | if (!ND->getDeclName()) return; |
| 1090 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1091 | StoredDeclsMap *Map = getPrimaryContext()->LookupPtr.getPointer(); |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1092 | if (!Map) return; |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1093 | |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1094 | StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName()); |
| 1095 | assert(Pos != Map->end() && "no lookup entry for decl"); |
Axel Naumann | d9d137e | 2011-11-08 18:21:06 +0000 | [diff] [blame] | 1096 | if (Pos->second.getAsVector() || Pos->second.getAsDecl() == ND) |
| 1097 | Pos->second.remove(ND); |
John McCall | 9f54ad4 | 2009-12-10 09:41:52 +0000 | [diff] [blame] | 1098 | } |
| 1099 | } |
| 1100 | |
John McCall | 3f9a8a6 | 2009-08-11 06:59:38 +0000 | [diff] [blame] | 1101 | void DeclContext::addHiddenDecl(Decl *D) { |
Chris Lattner | 7f0be13 | 2009-02-20 00:56:18 +0000 | [diff] [blame] | 1102 | assert(D->getLexicalDeclContext() == this && |
| 1103 | "Decl inserted into wrong lexical context"); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1104 | assert(!D->getNextDeclInContext() && D != LastDecl && |
Douglas Gregor | 6037fcb | 2009-01-09 19:42:16 +0000 | [diff] [blame] | 1105 | "Decl already inserted into a DeclContext"); |
| 1106 | |
| 1107 | if (FirstDecl) { |
Douglas Gregor | 46cd218 | 2012-01-06 16:59:53 +0000 | [diff] [blame] | 1108 | LastDecl->NextInContextAndBits.setPointer(D); |
Douglas Gregor | 6037fcb | 2009-01-09 19:42:16 +0000 | [diff] [blame] | 1109 | LastDecl = D; |
| 1110 | } else { |
| 1111 | FirstDecl = LastDecl = D; |
| 1112 | } |
Douglas Gregor | 27c08ab | 2010-09-27 22:06:20 +0000 | [diff] [blame] | 1113 | |
| 1114 | // Notify a C++ record declaration that we've added a member, so it can |
| 1115 | // update it's class-specific state. |
| 1116 | if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) |
| 1117 | Record->addedMember(D); |
Douglas Gregor | e664977 | 2011-12-03 00:30:27 +0000 | [diff] [blame] | 1118 | |
| 1119 | // If this is a newly-created (not de-serialized) import declaration, wire |
| 1120 | // it in to the list of local import declarations. |
| 1121 | if (!D->isFromASTFile()) { |
| 1122 | if (ImportDecl *Import = dyn_cast<ImportDecl>(D)) |
| 1123 | D->getASTContext().addedLocalImportDecl(Import); |
| 1124 | } |
John McCall | 3f9a8a6 | 2009-08-11 06:59:38 +0000 | [diff] [blame] | 1125 | } |
| 1126 | |
| 1127 | void DeclContext::addDecl(Decl *D) { |
| 1128 | addHiddenDecl(D); |
Douglas Gregor | 4afa39d | 2009-01-20 01:17:11 +0000 | [diff] [blame] | 1129 | |
| 1130 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1131 | ND->getDeclContext()->getPrimaryContext()-> |
| 1132 | makeDeclVisibleInContextWithFlags(ND, false, true); |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1133 | } |
| 1134 | |
Sean Callanan | 9faf810 | 2011-10-21 02:57:43 +0000 | [diff] [blame] | 1135 | void DeclContext::addDeclInternal(Decl *D) { |
| 1136 | addHiddenDecl(D); |
| 1137 | |
| 1138 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1139 | ND->getDeclContext()->getPrimaryContext()-> |
| 1140 | makeDeclVisibleInContextWithFlags(ND, true, true); |
| 1141 | } |
| 1142 | |
| 1143 | /// shouldBeHidden - Determine whether a declaration which was declared |
| 1144 | /// within its semantic context should be invisible to qualified name lookup. |
| 1145 | static bool shouldBeHidden(NamedDecl *D) { |
| 1146 | // Skip unnamed declarations. |
| 1147 | if (!D->getDeclName()) |
| 1148 | return true; |
| 1149 | |
| 1150 | // Skip entities that can't be found by name lookup into a particular |
| 1151 | // context. |
| 1152 | if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) || |
| 1153 | D->isTemplateParameter()) |
| 1154 | return true; |
| 1155 | |
| 1156 | // Skip template specializations. |
| 1157 | // FIXME: This feels like a hack. Should DeclarationName support |
| 1158 | // template-ids, or is there a better way to keep specializations |
| 1159 | // from being visible? |
| 1160 | if (isa<ClassTemplateSpecializationDecl>(D)) |
| 1161 | return true; |
| 1162 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) |
| 1163 | if (FD->isFunctionTemplateSpecialization()) |
| 1164 | return true; |
| 1165 | |
| 1166 | return false; |
| 1167 | } |
| 1168 | |
| 1169 | /// buildLookup - Build the lookup data structure with all of the |
| 1170 | /// declarations in this DeclContext (and any other contexts linked |
| 1171 | /// to it or transparent contexts nested within it) and return it. |
| 1172 | StoredDeclsMap *DeclContext::buildLookup() { |
| 1173 | assert(this == getPrimaryContext() && "buildLookup called on non-primary DC"); |
| 1174 | |
Richard Smith | 8896339 | 2013-02-11 22:02:16 +0000 | [diff] [blame] | 1175 | // FIXME: Should we keep going if hasExternalVisibleStorage? |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1176 | if (!LookupPtr.getInt()) |
| 1177 | return LookupPtr.getPointer(); |
| 1178 | |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 1179 | SmallVector<DeclContext *, 2> Contexts; |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1180 | collectAllContexts(Contexts); |
| 1181 | for (unsigned I = 0, N = Contexts.size(); I != N; ++I) |
Richard Smith | e7bae15 | 2013-07-13 02:00:19 +0000 | [diff] [blame] | 1182 | buildLookupImpl<&DeclContext::decls_begin, |
| 1183 | &DeclContext::decls_end>(Contexts[I]); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1184 | |
| 1185 | // We no longer have any lazy decls. |
| 1186 | LookupPtr.setInt(false); |
Richard Smith | 8896339 | 2013-02-11 22:02:16 +0000 | [diff] [blame] | 1187 | NeedToReconcileExternalVisibleStorage = false; |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1188 | return LookupPtr.getPointer(); |
| 1189 | } |
| 1190 | |
| 1191 | /// buildLookupImpl - Build part of the lookup data structure for the |
| 1192 | /// declarations contained within DCtx, which will either be this |
| 1193 | /// DeclContext, a DeclContext linked to it, or a transparent context |
| 1194 | /// nested within it. |
Richard Smith | e7bae15 | 2013-07-13 02:00:19 +0000 | [diff] [blame] | 1195 | template<DeclContext::decl_iterator (DeclContext::*Begin)() const, |
| 1196 | DeclContext::decl_iterator (DeclContext::*End)() const> |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1197 | void DeclContext::buildLookupImpl(DeclContext *DCtx) { |
Richard Smith | e7bae15 | 2013-07-13 02:00:19 +0000 | [diff] [blame] | 1198 | for (decl_iterator I = (DCtx->*Begin)(), E = (DCtx->*End)(); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1199 | I != E; ++I) { |
| 1200 | Decl *D = *I; |
| 1201 | |
| 1202 | // Insert this declaration into the lookup structure, but only if |
| 1203 | // it's semantically within its decl context. Any other decls which |
| 1204 | // should be found in this context are added eagerly. |
Richard Smith | 096a394 | 2013-06-24 07:20:36 +0000 | [diff] [blame] | 1205 | // |
| 1206 | // If it's from an AST file, don't add it now. It'll get handled by |
| 1207 | // FindExternalVisibleDeclsByName if needed. Exception: if we're not |
| 1208 | // in C++, we do not track external visible decls for the TU, so in |
| 1209 | // that case we need to collect them all here. |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1210 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) |
Richard Smith | 096a394 | 2013-06-24 07:20:36 +0000 | [diff] [blame] | 1211 | if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) && |
| 1212 | (!ND->isFromASTFile() || |
| 1213 | (isTranslationUnit() && |
| 1214 | !getParentASTContext().getLangOpts().CPlusPlus))) |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1215 | makeDeclVisibleInContextImpl(ND, false); |
| 1216 | |
| 1217 | // If this declaration is itself a transparent declaration context |
| 1218 | // or inline namespace, add the members of this declaration of that |
| 1219 | // context (recursively). |
| 1220 | if (DeclContext *InnerCtx = dyn_cast<DeclContext>(D)) |
| 1221 | if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace()) |
Richard Smith | e7bae15 | 2013-07-13 02:00:19 +0000 | [diff] [blame] | 1222 | buildLookupImpl<Begin, End>(InnerCtx); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1223 | } |
Sean Callanan | 9faf810 | 2011-10-21 02:57:43 +0000 | [diff] [blame] | 1224 | } |
| 1225 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1226 | DeclContext::lookup_result |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1227 | DeclContext::lookup(DeclarationName Name) { |
Nick Lewycky | 65daef1 | 2012-03-13 04:12:34 +0000 | [diff] [blame] | 1228 | assert(DeclKind != Decl::LinkageSpec && |
| 1229 | "Should not perform lookups into linkage specs!"); |
| 1230 | |
Steve Naroff | 0701bbb | 2009-01-08 17:28:14 +0000 | [diff] [blame] | 1231 | DeclContext *PrimaryContext = getPrimaryContext(); |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1232 | if (PrimaryContext != this) |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1233 | return PrimaryContext->lookup(Name); |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1234 | |
Richard Smith | 1b7f9cb | 2012-03-13 03:12:56 +0000 | [diff] [blame] | 1235 | if (hasExternalVisibleStorage()) { |
Richard Smith | bbcd0f3 | 2013-02-07 03:37:08 +0000 | [diff] [blame] | 1236 | StoredDeclsMap *Map = LookupPtr.getPointer(); |
| 1237 | if (LookupPtr.getInt()) |
| 1238 | Map = buildLookup(); |
Richard Smith | 8896339 | 2013-02-11 22:02:16 +0000 | [diff] [blame] | 1239 | else if (NeedToReconcileExternalVisibleStorage) |
| 1240 | reconcileExternalVisibleStorage(); |
Richard Smith | bbcd0f3 | 2013-02-07 03:37:08 +0000 | [diff] [blame] | 1241 | |
Richard Smith | 2bb07c1 | 2013-02-08 00:37:45 +0000 | [diff] [blame] | 1242 | if (!Map) |
| 1243 | Map = CreateStoredDeclsMap(getParentASTContext()); |
| 1244 | |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 1245 | // If we have a lookup result with no external decls, we are done. |
Richard Smith | 2bb07c1 | 2013-02-08 00:37:45 +0000 | [diff] [blame] | 1246 | std::pair<StoredDeclsMap::iterator, bool> R = |
| 1247 | Map->insert(std::make_pair(Name, StoredDeclsList())); |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 1248 | if (!R.second && !R.first->second.hasExternalDecls()) |
Richard Smith | 2bb07c1 | 2013-02-08 00:37:45 +0000 | [diff] [blame] | 1249 | return R.first->second.getLookupResult(); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1250 | |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 1251 | ExternalASTSource *Source = getParentASTContext().getExternalSource(); |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 1252 | if (Source->FindExternalVisibleDeclsByName(this, Name) || R.second) { |
Richard Smith | 3646c68 | 2013-02-07 03:30:24 +0000 | [diff] [blame] | 1253 | if (StoredDeclsMap *Map = LookupPtr.getPointer()) { |
| 1254 | StoredDeclsMap::iterator I = Map->find(Name); |
| 1255 | if (I != Map->end()) |
| 1256 | return I->second.getLookupResult(); |
| 1257 | } |
| 1258 | } |
| 1259 | |
| 1260 | return lookup_result(lookup_iterator(0), lookup_iterator(0)); |
John McCall | 76bd1f3 | 2010-06-01 09:23:16 +0000 | [diff] [blame] | 1261 | } |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 1262 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1263 | StoredDeclsMap *Map = LookupPtr.getPointer(); |
| 1264 | if (LookupPtr.getInt()) |
| 1265 | Map = buildLookup(); |
| 1266 | |
| 1267 | if (!Map) |
| 1268 | return lookup_result(lookup_iterator(0), lookup_iterator(0)); |
| 1269 | |
| 1270 | StoredDeclsMap::iterator I = Map->find(Name); |
| 1271 | if (I == Map->end()) |
| 1272 | return lookup_result(lookup_iterator(0), lookup_iterator(0)); |
| 1273 | |
| 1274 | return I->second.getLookupResult(); |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1275 | } |
| 1276 | |
Richard Smith | e7bae15 | 2013-07-13 02:00:19 +0000 | [diff] [blame] | 1277 | DeclContext::lookup_result |
| 1278 | DeclContext::noload_lookup(DeclarationName Name) { |
| 1279 | assert(DeclKind != Decl::LinkageSpec && |
| 1280 | "Should not perform lookups into linkage specs!"); |
| 1281 | if (!hasExternalVisibleStorage()) |
| 1282 | return lookup(Name); |
| 1283 | |
| 1284 | DeclContext *PrimaryContext = getPrimaryContext(); |
| 1285 | if (PrimaryContext != this) |
| 1286 | return PrimaryContext->noload_lookup(Name); |
| 1287 | |
| 1288 | StoredDeclsMap *Map = LookupPtr.getPointer(); |
| 1289 | if (LookupPtr.getInt()) { |
| 1290 | // Carefully build the lookup map, without deserializing anything. |
| 1291 | SmallVector<DeclContext *, 2> Contexts; |
| 1292 | collectAllContexts(Contexts); |
| 1293 | for (unsigned I = 0, N = Contexts.size(); I != N; ++I) |
| 1294 | buildLookupImpl<&DeclContext::noload_decls_begin, |
| 1295 | &DeclContext::noload_decls_end>(Contexts[I]); |
| 1296 | |
| 1297 | // We no longer have any lazy decls. |
| 1298 | LookupPtr.setInt(false); |
| 1299 | |
| 1300 | // There may now be names for which we have local decls but are |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 1301 | // missing the external decls. FIXME: Just set the hasExternalDecls |
| 1302 | // flag on those names that have external decls. |
Richard Smith | e7bae15 | 2013-07-13 02:00:19 +0000 | [diff] [blame] | 1303 | NeedToReconcileExternalVisibleStorage = true; |
| 1304 | |
| 1305 | Map = LookupPtr.getPointer(); |
| 1306 | } |
| 1307 | |
| 1308 | if (!Map) |
| 1309 | return lookup_result(lookup_iterator(0), lookup_iterator(0)); |
| 1310 | |
| 1311 | StoredDeclsMap::iterator I = Map->find(Name); |
| 1312 | return I != Map->end() |
| 1313 | ? I->second.getLookupResult() |
| 1314 | : lookup_result(lookup_iterator(0), lookup_iterator(0)); |
| 1315 | } |
| 1316 | |
Dmitri Gribenko | cfa88f8 | 2013-01-12 19:30:44 +0000 | [diff] [blame] | 1317 | void DeclContext::localUncachedLookup(DeclarationName Name, |
| 1318 | SmallVectorImpl<NamedDecl *> &Results) { |
Douglas Gregor | b75a345 | 2011-10-15 00:10:27 +0000 | [diff] [blame] | 1319 | Results.clear(); |
| 1320 | |
| 1321 | // If there's no external storage, just perform a normal lookup and copy |
| 1322 | // the results. |
Douglas Gregor | 93ed7cf | 2012-07-17 21:16:27 +0000 | [diff] [blame] | 1323 | if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage() && Name) { |
Douglas Gregor | b75a345 | 2011-10-15 00:10:27 +0000 | [diff] [blame] | 1324 | lookup_result LookupResults = lookup(Name); |
David Blaikie | 3bc93e3 | 2012-12-19 00:45:41 +0000 | [diff] [blame] | 1325 | Results.insert(Results.end(), LookupResults.begin(), LookupResults.end()); |
Douglas Gregor | b75a345 | 2011-10-15 00:10:27 +0000 | [diff] [blame] | 1326 | return; |
| 1327 | } |
| 1328 | |
| 1329 | // If we have a lookup table, check there first. Maybe we'll get lucky. |
Richard Smith | bbcd0f3 | 2013-02-07 03:37:08 +0000 | [diff] [blame] | 1330 | if (Name && !LookupPtr.getInt()) { |
Douglas Gregor | 93ed7cf | 2012-07-17 21:16:27 +0000 | [diff] [blame] | 1331 | if (StoredDeclsMap *Map = LookupPtr.getPointer()) { |
| 1332 | StoredDeclsMap::iterator Pos = Map->find(Name); |
| 1333 | if (Pos != Map->end()) { |
| 1334 | Results.insert(Results.end(), |
David Blaikie | 3bc93e3 | 2012-12-19 00:45:41 +0000 | [diff] [blame] | 1335 | Pos->second.getLookupResult().begin(), |
| 1336 | Pos->second.getLookupResult().end()); |
Douglas Gregor | 93ed7cf | 2012-07-17 21:16:27 +0000 | [diff] [blame] | 1337 | return; |
| 1338 | } |
Douglas Gregor | b75a345 | 2011-10-15 00:10:27 +0000 | [diff] [blame] | 1339 | } |
| 1340 | } |
Douglas Gregor | 93ed7cf | 2012-07-17 21:16:27 +0000 | [diff] [blame] | 1341 | |
Douglas Gregor | b75a345 | 2011-10-15 00:10:27 +0000 | [diff] [blame] | 1342 | // Slow case: grovel through the declarations in our chain looking for |
| 1343 | // matches. |
| 1344 | for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) { |
| 1345 | if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) |
| 1346 | if (ND->getDeclName() == Name) |
| 1347 | Results.push_back(ND); |
| 1348 | } |
| 1349 | } |
| 1350 | |
Sebastian Redl | 7a126a4 | 2010-08-31 00:36:30 +0000 | [diff] [blame] | 1351 | DeclContext *DeclContext::getRedeclContext() { |
Chris Lattner | 0cf2b19 | 2009-03-27 19:19:59 +0000 | [diff] [blame] | 1352 | DeclContext *Ctx = this; |
Sebastian Redl | 410c4f2 | 2010-08-31 20:53:31 +0000 | [diff] [blame] | 1353 | // Skip through transparent contexts. |
| 1354 | while (Ctx->isTransparentContext()) |
Douglas Gregor | ce35607 | 2009-01-06 23:51:29 +0000 | [diff] [blame] | 1355 | Ctx = Ctx->getParent(); |
| 1356 | return Ctx; |
| 1357 | } |
| 1358 | |
Douglas Gregor | 88b7094 | 2009-02-25 22:02:03 +0000 | [diff] [blame] | 1359 | DeclContext *DeclContext::getEnclosingNamespaceContext() { |
| 1360 | DeclContext *Ctx = this; |
| 1361 | // Skip through non-namespace, non-translation-unit contexts. |
Sebastian Redl | 51a8a37 | 2010-08-31 00:36:23 +0000 | [diff] [blame] | 1362 | while (!Ctx->isFileContext()) |
Douglas Gregor | 88b7094 | 2009-02-25 22:02:03 +0000 | [diff] [blame] | 1363 | Ctx = Ctx->getParent(); |
| 1364 | return Ctx->getPrimaryContext(); |
| 1365 | } |
| 1366 | |
Sebastian Redl | 7a126a4 | 2010-08-31 00:36:30 +0000 | [diff] [blame] | 1367 | bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const { |
| 1368 | // For non-file contexts, this is equivalent to Equals. |
| 1369 | if (!isFileContext()) |
| 1370 | return O->Equals(this); |
| 1371 | |
| 1372 | do { |
| 1373 | if (O->Equals(this)) |
| 1374 | return true; |
| 1375 | |
| 1376 | const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(O); |
| 1377 | if (!NS || !NS->isInline()) |
| 1378 | break; |
| 1379 | O = NS->getParent(); |
| 1380 | } while (O); |
| 1381 | |
| 1382 | return false; |
| 1383 | } |
| 1384 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1385 | void DeclContext::makeDeclVisibleInContext(NamedDecl *D) { |
| 1386 | DeclContext *PrimaryDC = this->getPrimaryContext(); |
| 1387 | DeclContext *DeclDC = D->getDeclContext()->getPrimaryContext(); |
| 1388 | // If the decl is being added outside of its semantic decl context, we |
| 1389 | // need to ensure that we eagerly build the lookup information for it. |
| 1390 | PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC); |
Sean Callanan | 9faf810 | 2011-10-21 02:57:43 +0000 | [diff] [blame] | 1391 | } |
| 1392 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1393 | void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal, |
| 1394 | bool Recoverable) { |
| 1395 | assert(this == getPrimaryContext() && "expected a primary DC"); |
Sean Callanan | 9faf810 | 2011-10-21 02:57:43 +0000 | [diff] [blame] | 1396 | |
Richard Smith | 1b7f9cb | 2012-03-13 03:12:56 +0000 | [diff] [blame] | 1397 | // Skip declarations within functions. |
Richard Smith | 4e9686b | 2013-08-09 04:35:01 +0000 | [diff] [blame] | 1398 | if (isFunctionOrMethod()) |
Richard Smith | 1b7f9cb | 2012-03-13 03:12:56 +0000 | [diff] [blame] | 1399 | return; |
| 1400 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1401 | // Skip declarations which should be invisible to name lookup. |
| 1402 | if (shouldBeHidden(D)) |
| 1403 | return; |
| 1404 | |
| 1405 | // If we already have a lookup data structure, perform the insertion into |
| 1406 | // it. If we might have externally-stored decls with this name, look them |
| 1407 | // up and perform the insertion. If this decl was declared outside its |
| 1408 | // semantic context, buildLookup won't add it, so add it now. |
| 1409 | // |
| 1410 | // FIXME: As a performance hack, don't add such decls into the translation |
| 1411 | // unit unless we're in C++, since qualified lookup into the TU is never |
| 1412 | // performed. |
| 1413 | if (LookupPtr.getPointer() || hasExternalVisibleStorage() || |
| 1414 | ((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) && |
| 1415 | (getParentASTContext().getLangOpts().CPlusPlus || |
| 1416 | !isTranslationUnit()))) { |
| 1417 | // If we have lazily omitted any decls, they might have the same name as |
| 1418 | // the decl which we are adding, so build a full lookup table before adding |
| 1419 | // this decl. |
| 1420 | buildLookup(); |
| 1421 | makeDeclVisibleInContextImpl(D, Internal); |
| 1422 | } else { |
| 1423 | LookupPtr.setInt(true); |
| 1424 | } |
| 1425 | |
| 1426 | // If we are a transparent context or inline namespace, insert into our |
| 1427 | // parent context, too. This operation is recursive. |
| 1428 | if (isTransparentContext() || isInlineNamespace()) |
| 1429 | getParent()->getPrimaryContext()-> |
| 1430 | makeDeclVisibleInContextWithFlags(D, Internal, Recoverable); |
| 1431 | |
| 1432 | Decl *DCAsDecl = cast<Decl>(this); |
| 1433 | // Notify that a decl was made visible unless we are a Tag being defined. |
| 1434 | if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined())) |
| 1435 | if (ASTMutationListener *L = DCAsDecl->getASTMutationListener()) |
| 1436 | L->AddedVisibleDecl(this, D); |
| 1437 | } |
| 1438 | |
| 1439 | void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) { |
| 1440 | // Find or create the stored declaration map. |
| 1441 | StoredDeclsMap *Map = LookupPtr.getPointer(); |
| 1442 | if (!Map) { |
| 1443 | ASTContext *C = &getParentASTContext(); |
| 1444 | Map = CreateStoredDeclsMap(*C); |
Argyrios Kyrtzidis | 5586b01 | 2010-07-04 21:44:25 +0000 | [diff] [blame] | 1445 | } |
| 1446 | |
Argyrios Kyrtzidis | 074dcc8 | 2010-08-20 16:04:35 +0000 | [diff] [blame] | 1447 | // If there is an external AST source, load any declarations it knows about |
| 1448 | // with this declaration's name. |
| 1449 | // If the lookup table contains an entry about this name it means that we |
| 1450 | // have already checked the external source. |
Sean Callanan | 9faf810 | 2011-10-21 02:57:43 +0000 | [diff] [blame] | 1451 | if (!Internal) |
| 1452 | if (ExternalASTSource *Source = getParentASTContext().getExternalSource()) |
| 1453 | if (hasExternalVisibleStorage() && |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1454 | Map->find(D->getDeclName()) == Map->end()) |
Sean Callanan | 9faf810 | 2011-10-21 02:57:43 +0000 | [diff] [blame] | 1455 | Source->FindExternalVisibleDeclsByName(this, D->getDeclName()); |
Argyrios Kyrtzidis | 074dcc8 | 2010-08-20 16:04:35 +0000 | [diff] [blame] | 1456 | |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1457 | // Insert this declaration into the map. |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1458 | StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()]; |
Richard Smith | b716558 | 2013-09-09 07:34:56 +0000 | [diff] [blame] | 1459 | |
| 1460 | if (Internal) { |
| 1461 | // If this is being added as part of loading an external declaration, |
| 1462 | // this may not be the only external declaration with this name. |
| 1463 | // In this case, we never try to replace an existing declaration; we'll |
| 1464 | // handle that when we finalize the list of declarations for this name. |
| 1465 | DeclNameEntries.setHasExternalDecls(); |
| 1466 | DeclNameEntries.AddSubsequentDecl(D); |
| 1467 | return; |
| 1468 | } |
| 1469 | |
| 1470 | else if (DeclNameEntries.isNull()) { |
Chris Lattner | 67762a3 | 2009-02-20 01:44:05 +0000 | [diff] [blame] | 1471 | DeclNameEntries.setOnlyValue(D); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1472 | return; |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1473 | } |
Chris Lattner | 9194250 | 2009-02-20 00:55:03 +0000 | [diff] [blame] | 1474 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1475 | if (DeclNameEntries.HandleRedeclaration(D)) { |
| 1476 | // This declaration has replaced an existing one for which |
| 1477 | // declarationReplaces returns true. |
| 1478 | return; |
| 1479 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1480 | |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1481 | // Put this declaration into the appropriate slot. |
| 1482 | DeclNameEntries.AddSubsequentDecl(D); |
Douglas Gregor | 44b4321 | 2008-12-11 16:49:14 +0000 | [diff] [blame] | 1483 | } |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 1484 | |
| 1485 | /// Returns iterator range [First, Last) of UsingDirectiveDecls stored within |
| 1486 | /// this context. |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 1487 | DeclContext::udir_iterator_range |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1488 | DeclContext::getUsingDirectives() const { |
Richard Smith | 1b7f9cb | 2012-03-13 03:12:56 +0000 | [diff] [blame] | 1489 | // FIXME: Use something more efficient than normal lookup for using |
| 1490 | // directives. In C++, using directives are looked up more than anything else. |
Argyrios Kyrtzidis | 17945a0 | 2009-06-30 02:36:12 +0000 | [diff] [blame] | 1491 | lookup_const_result Result = lookup(UsingDirectiveDecl::getName()); |
David Blaikie | 3bc93e3 | 2012-12-19 00:45:41 +0000 | [diff] [blame] | 1492 | return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.begin()), |
| 1493 | reinterpret_cast<udir_iterator>(Result.end())); |
Douglas Gregor | 2a3009a | 2009-02-03 19:21:40 +0000 | [diff] [blame] | 1494 | } |
Douglas Gregor | 2cf2634 | 2009-04-09 22:27:44 +0000 | [diff] [blame] | 1495 | |
Ted Kremenek | 3478eb6 | 2010-02-11 07:12:28 +0000 | [diff] [blame] | 1496 | //===----------------------------------------------------------------------===// |
| 1497 | // Creation and Destruction of StoredDeclsMaps. // |
| 1498 | //===----------------------------------------------------------------------===// |
| 1499 | |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1500 | StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const { |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1501 | assert(!LookupPtr.getPointer() && "context already has a decls map"); |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1502 | assert(getPrimaryContext() == this && |
| 1503 | "creating decls map on non-primary context"); |
| 1504 | |
| 1505 | StoredDeclsMap *M; |
| 1506 | bool Dependent = isDependentContext(); |
| 1507 | if (Dependent) |
| 1508 | M = new DependentStoredDeclsMap(); |
| 1509 | else |
| 1510 | M = new StoredDeclsMap(); |
| 1511 | M->Previous = C.LastSDM; |
| 1512 | C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1513 | LookupPtr.setPointer(M); |
Ted Kremenek | 3478eb6 | 2010-02-11 07:12:28 +0000 | [diff] [blame] | 1514 | return M; |
| 1515 | } |
| 1516 | |
| 1517 | void ASTContext::ReleaseDeclContextMaps() { |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1518 | // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap |
| 1519 | // pointer because the subclass doesn't add anything that needs to |
| 1520 | // be deleted. |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1521 | StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt()); |
| 1522 | } |
| 1523 | |
| 1524 | void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) { |
| 1525 | while (Map) { |
| 1526 | // Advance the iteration before we invalidate memory. |
| 1527 | llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous; |
| 1528 | |
| 1529 | if (Dependent) |
| 1530 | delete static_cast<DependentStoredDeclsMap*>(Map); |
| 1531 | else |
| 1532 | delete Map; |
| 1533 | |
| 1534 | Map = Next.getPointer(); |
| 1535 | Dependent = Next.getInt(); |
| 1536 | } |
| 1537 | } |
| 1538 | |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1539 | DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C, |
| 1540 | DeclContext *Parent, |
| 1541 | const PartialDiagnostic &PDiag) { |
| 1542 | assert(Parent->isDependentContext() |
| 1543 | && "cannot iterate dependent diagnostics of non-dependent context"); |
| 1544 | Parent = Parent->getPrimaryContext(); |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1545 | if (!Parent->LookupPtr.getPointer()) |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1546 | Parent->CreateStoredDeclsMap(C); |
| 1547 | |
| 1548 | DependentStoredDeclsMap *Map |
Richard Smith | c5d3e80 | 2012-03-16 06:12:59 +0000 | [diff] [blame] | 1549 | = static_cast<DependentStoredDeclsMap*>(Parent->LookupPtr.getPointer()); |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1550 | |
Douglas Gregor | b836518 | 2010-03-29 23:56:53 +0000 | [diff] [blame] | 1551 | // Allocate the copy of the PartialDiagnostic via the ASTContext's |
Douglas Gregor | fe6b2d4 | 2010-03-29 23:34:08 +0000 | [diff] [blame] | 1552 | // BumpPtrAllocator, rather than the ASTContext itself. |
Douglas Gregor | b836518 | 2010-03-29 23:56:53 +0000 | [diff] [blame] | 1553 | PartialDiagnostic::Storage *DiagStorage = 0; |
| 1554 | if (PDiag.hasStorage()) |
| 1555 | DiagStorage = new (C) PartialDiagnostic::Storage; |
| 1556 | |
| 1557 | DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage); |
John McCall | 0c01d18 | 2010-03-24 05:22:00 +0000 | [diff] [blame] | 1558 | |
| 1559 | // TODO: Maybe we shouldn't reverse the order during insertion. |
| 1560 | DD->NextDiagnostic = Map->FirstDiagnostic; |
| 1561 | Map->FirstDiagnostic = DD; |
| 1562 | |
| 1563 | return DD; |
Ted Kremenek | 3478eb6 | 2010-02-11 07:12:28 +0000 | [diff] [blame] | 1564 | } |