DeclBase.h revision 79c2278a66d8fc0943774d1b7c71a32f7764e1e2
1//===-- DeclBase.h - Base Classes for representing declarations -*- C++ -*-===// 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 defines the Decl and DeclContext interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_AST_DECLBASE_H 15#define LLVM_CLANG_AST_DECLBASE_H 16 17#include "clang/AST/Attr.h" 18#include "clang/AST/Type.h" 19// FIXME: Layering violation 20#include "clang/Parse/AccessSpecifier.h" 21#include "llvm/Support/PrettyStackTrace.h" 22#include "llvm/ADT/PointerUnion.h" 23 24namespace clang { 25class DeclContext; 26class TranslationUnitDecl; 27class NamespaceDecl; 28class UsingDirectiveDecl; 29class NamedDecl; 30class FunctionDecl; 31class CXXRecordDecl; 32class EnumDecl; 33class ObjCMethodDecl; 34class ObjCContainerDecl; 35class ObjCInterfaceDecl; 36class ObjCCategoryDecl; 37class ObjCProtocolDecl; 38class ObjCImplementationDecl; 39class ObjCCategoryImplDecl; 40class ObjCImplDecl; 41class LinkageSpecDecl; 42class BlockDecl; 43class DeclarationName; 44class CompoundStmt; 45} 46 47namespace llvm { 48// DeclContext* is only 4-byte aligned on 32-bit systems. 49template<> 50 class PointerLikeTypeTraits<clang::DeclContext*> { 51 typedef clang::DeclContext* PT; 52public: 53 static inline void *getAsVoidPointer(PT P) { return P; } 54 static inline PT getFromVoidPointer(void *P) { 55 return static_cast<PT>(P); 56 } 57 enum { NumLowBitsAvailable = 2 }; 58}; 59} 60 61namespace clang { 62 63/// Decl - This represents one declaration (or definition), e.g. a variable, 64/// typedef, function, struct, etc. 65/// 66class Decl { 67public: 68 /// \brief Lists the kind of concrete classes of Decl. 69 enum Kind { 70#define DECL(Derived, Base) Derived, 71#define DECL_RANGE(CommonBase, Start, End) \ 72 CommonBase##First = Start, CommonBase##Last = End, 73#define LAST_DECL_RANGE(CommonBase, Start, End) \ 74 CommonBase##First = Start, CommonBase##Last = End 75#include "clang/AST/DeclNodes.def" 76 }; 77 78 /// IdentifierNamespace - According to C99 6.2.3, there are four 79 /// namespaces, labels, tags, members and ordinary 80 /// identifiers. These are meant as bitmasks, so that searches in 81 /// C++ can look into the "tag" namespace during ordinary lookup. We 82 /// use additional namespaces for Objective-C entities. We also put 83 /// C++ friend declarations (of previously-undeclared entities) in 84 /// shadow namespaces, and 'using' declarations (as opposed to their 85 /// implicit shadow declarations) can be found in their own 86 /// namespace. 87 enum IdentifierNamespace { 88 IDNS_Label = 0x1, 89 IDNS_Tag = 0x2, 90 IDNS_Member = 0x4, 91 IDNS_Ordinary = 0x8, 92 IDNS_ObjCProtocol = 0x10, 93 IDNS_ObjCImplementation = 0x20, 94 IDNS_ObjCCategoryName = 0x40, 95 IDNS_OrdinaryFriend = 0x80, 96 IDNS_TagFriend = 0x100, 97 IDNS_Using = 0x200 98 }; 99 100 /// ObjCDeclQualifier - Qualifier used on types in method declarations 101 /// for remote messaging. They are meant for the arguments though and 102 /// applied to the Decls (ObjCMethodDecl and ParmVarDecl). 103 enum ObjCDeclQualifier { 104 OBJC_TQ_None = 0x0, 105 OBJC_TQ_In = 0x1, 106 OBJC_TQ_Inout = 0x2, 107 OBJC_TQ_Out = 0x4, 108 OBJC_TQ_Bycopy = 0x8, 109 OBJC_TQ_Byref = 0x10, 110 OBJC_TQ_Oneway = 0x20 111 }; 112 113private: 114 /// NextDeclInContext - The next declaration within the same lexical 115 /// DeclContext. These pointers form the linked list that is 116 /// traversed via DeclContext's decls_begin()/decls_end(). 117 Decl *NextDeclInContext; 118 119 friend class DeclContext; 120 121 struct MultipleDC { 122 DeclContext *SemanticDC; 123 DeclContext *LexicalDC; 124 }; 125 126 127 /// DeclCtx - Holds either a DeclContext* or a MultipleDC*. 128 /// For declarations that don't contain C++ scope specifiers, it contains 129 /// the DeclContext where the Decl was declared. 130 /// For declarations with C++ scope specifiers, it contains a MultipleDC* 131 /// with the context where it semantically belongs (SemanticDC) and the 132 /// context where it was lexically declared (LexicalDC). 133 /// e.g.: 134 /// 135 /// namespace A { 136 /// void f(); // SemanticDC == LexicalDC == 'namespace A' 137 /// } 138 /// void A::f(); // SemanticDC == namespace 'A' 139 /// // LexicalDC == global namespace 140 llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx; 141 142 inline bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); } 143 inline bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); } 144 inline MultipleDC *getMultipleDC() const { 145 return DeclCtx.get<MultipleDC*>(); 146 } 147 inline DeclContext *getSemanticDC() const { 148 return DeclCtx.get<DeclContext*>(); 149 } 150 151 /// Loc - The location that this decl. 152 SourceLocation Loc; 153 154 /// DeclKind - This indicates which class this is. 155 Kind DeclKind : 8; 156 157 /// InvalidDecl - This indicates a semantic error occurred. 158 unsigned int InvalidDecl : 1; 159 160 /// HasAttrs - This indicates whether the decl has attributes or not. 161 unsigned int HasAttrs : 1; 162 163 /// Implicit - Whether this declaration was implicitly generated by 164 /// the implementation rather than explicitly written by the user. 165 bool Implicit : 1; 166 167 /// \brief Whether this declaration was "used", meaning that a definition is 168 /// required. 169 bool Used : 1; 170 171protected: 172 /// Access - Used by C++ decls for the access specifier. 173 // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum 174 unsigned Access : 2; 175 friend class CXXClassMemberWrapper; 176 177 // PCHLevel - the "level" of precompiled header/AST file from which this 178 // declaration was built. 179 unsigned PCHLevel : 2; 180 181 /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in. 182 unsigned IdentifierNamespace : 16; 183 184private: 185#ifndef NDEBUG 186 void CheckAccessDeclContext() const; 187#else 188 void CheckAccessDeclContext() const { } 189#endif 190 191protected: 192 193 Decl(Kind DK, DeclContext *DC, SourceLocation L) 194 : NextDeclInContext(0), DeclCtx(DC), 195 Loc(L), DeclKind(DK), InvalidDecl(0), 196 HasAttrs(false), Implicit(false), Used(false), 197 Access(AS_none), PCHLevel(0), 198 IdentifierNamespace(getIdentifierNamespaceForKind(DK)) { 199 if (Decl::CollectingStats()) addDeclKind(DK); 200 } 201 202 virtual ~Decl(); 203 204public: 205 206 /// \brief Source range that this declaration covers. 207 virtual SourceRange getSourceRange() const { 208 return SourceRange(getLocation(), getLocation()); 209 } 210 SourceLocation getLocStart() const { return getSourceRange().getBegin(); } 211 SourceLocation getLocEnd() const { return getSourceRange().getEnd(); } 212 213 SourceLocation getLocation() const { return Loc; } 214 void setLocation(SourceLocation L) { Loc = L; } 215 216 Kind getKind() const { return DeclKind; } 217 const char *getDeclKindName() const; 218 219 Decl *getNextDeclInContext() { return NextDeclInContext; } 220 const Decl *getNextDeclInContext() const { return NextDeclInContext; } 221 222 DeclContext *getDeclContext() { 223 if (isInSemaDC()) 224 return getSemanticDC(); 225 return getMultipleDC()->SemanticDC; 226 } 227 const DeclContext *getDeclContext() const { 228 return const_cast<Decl*>(this)->getDeclContext(); 229 } 230 231 TranslationUnitDecl *getTranslationUnitDecl(); 232 const TranslationUnitDecl *getTranslationUnitDecl() const { 233 return const_cast<Decl*>(this)->getTranslationUnitDecl(); 234 } 235 236 bool isInAnonymousNamespace() const; 237 238 ASTContext &getASTContext() const; 239 240 void setAccess(AccessSpecifier AS) { 241 Access = AS; 242 CheckAccessDeclContext(); 243 } 244 245 AccessSpecifier getAccess() const { 246 CheckAccessDeclContext(); 247 return AccessSpecifier(Access); 248 } 249 250 bool hasAttrs() const { return HasAttrs; } 251 void addAttr(Attr *attr); 252 const Attr *getAttrs() const { 253 if (!HasAttrs) return 0; // common case, no attributes. 254 return getAttrsImpl(); // Uncommon case, out of line hash lookup. 255 } 256 void swapAttrs(Decl *D); 257 void invalidateAttrs(); 258 259 template<typename T> const T *getAttr() const { 260 for (const Attr *attr = getAttrs(); attr; attr = attr->getNext()) 261 if (const T *V = dyn_cast<T>(attr)) 262 return V; 263 return 0; 264 } 265 266 template<typename T> bool hasAttr() const { 267 return getAttr<T>() != 0; 268 } 269 270 /// setInvalidDecl - Indicates the Decl had a semantic error. This 271 /// allows for graceful error recovery. 272 void setInvalidDecl(bool Invalid = true) { InvalidDecl = Invalid; } 273 bool isInvalidDecl() const { return (bool) InvalidDecl; } 274 275 /// isImplicit - Indicates whether the declaration was implicitly 276 /// generated by the implementation. If false, this declaration 277 /// was written explicitly in the source code. 278 bool isImplicit() const { return Implicit; } 279 void setImplicit(bool I = true) { Implicit = I; } 280 281 /// \brief Whether this declaration was used, meaning that a definition 282 /// is required. 283 bool isUsed() const { return Used; } 284 void setUsed(bool U = true) { Used = U; } 285 286 /// \brief Retrieve the level of precompiled header from which this 287 /// declaration was generated. 288 /// 289 /// The PCH level of a declaration describes where the declaration originated 290 /// from. A PCH level of 0 indicates that the declaration was not from a 291 /// precompiled header. A PCH level of 1 indicates that the declaration was 292 /// from a top-level precompiled header; 2 indicates that the declaration 293 /// comes from a precompiled header on which the top-level precompiled header 294 /// depends, and so on. 295 unsigned getPCHLevel() const { return PCHLevel; } 296 297 /// \brief The maximum PCH level that any declaration may have. 298 static const unsigned MaxPCHLevel = 3; 299 300 /// \brief Set the PCH level of this declaration. 301 void setPCHLevel(unsigned Level) { 302 assert(Level < MaxPCHLevel && "PCH level exceeds the maximum"); 303 PCHLevel = Level; 304 } 305 306 unsigned getIdentifierNamespace() const { 307 return IdentifierNamespace; 308 } 309 bool isInIdentifierNamespace(unsigned NS) const { 310 return getIdentifierNamespace() & NS; 311 } 312 static unsigned getIdentifierNamespaceForKind(Kind DK); 313 314 315 /// getLexicalDeclContext - The declaration context where this Decl was 316 /// lexically declared (LexicalDC). May be different from 317 /// getDeclContext() (SemanticDC). 318 /// e.g.: 319 /// 320 /// namespace A { 321 /// void f(); // SemanticDC == LexicalDC == 'namespace A' 322 /// } 323 /// void A::f(); // SemanticDC == namespace 'A' 324 /// // LexicalDC == global namespace 325 DeclContext *getLexicalDeclContext() { 326 if (isInSemaDC()) 327 return getSemanticDC(); 328 return getMultipleDC()->LexicalDC; 329 } 330 const DeclContext *getLexicalDeclContext() const { 331 return const_cast<Decl*>(this)->getLexicalDeclContext(); 332 } 333 334 bool isOutOfLine() const { 335 return getLexicalDeclContext() != getDeclContext(); 336 } 337 338 /// setDeclContext - Set both the semantic and lexical DeclContext 339 /// to DC. 340 void setDeclContext(DeclContext *DC); 341 342 void setLexicalDeclContext(DeclContext *DC); 343 344 // isDefinedOutsideFunctionOrMethod - This predicate returns true if this 345 // scoped decl is defined outside the current function or method. This is 346 // roughly global variables and functions, but also handles enums (which could 347 // be defined inside or outside a function etc). 348 bool isDefinedOutsideFunctionOrMethod() const; 349 350 /// \brief Retrieves the "canonical" declaration of the given declaration. 351 virtual Decl *getCanonicalDecl() { return this; } 352 const Decl *getCanonicalDecl() const { 353 return const_cast<Decl*>(this)->getCanonicalDecl(); 354 } 355 356 /// \brief Whether this particular Decl is a canonical one. 357 bool isCanonicalDecl() const { return getCanonicalDecl() == this; } 358 359protected: 360 /// \brief Returns the next redeclaration or itself if this is the only decl. 361 /// 362 /// Decl subclasses that can be redeclared should override this method so that 363 /// Decl::redecl_iterator can iterate over them. 364 virtual Decl *getNextRedeclaration() { return this; } 365 366public: 367 /// \brief Iterates through all the redeclarations of the same decl. 368 class redecl_iterator { 369 /// Current - The current declaration. 370 Decl *Current; 371 Decl *Starter; 372 373 public: 374 typedef Decl* value_type; 375 typedef Decl* reference; 376 typedef Decl* pointer; 377 typedef std::forward_iterator_tag iterator_category; 378 typedef std::ptrdiff_t difference_type; 379 380 redecl_iterator() : Current(0) { } 381 explicit redecl_iterator(Decl *C) : Current(C), Starter(C) { } 382 383 reference operator*() const { return Current; } 384 pointer operator->() const { return Current; } 385 386 redecl_iterator& operator++() { 387 assert(Current && "Advancing while iterator has reached end"); 388 // Get either previous decl or latest decl. 389 Decl *Next = Current->getNextRedeclaration(); 390 assert(Next && "Should return next redeclaration or itself, never null!"); 391 Current = (Next != Starter ? Next : 0); 392 return *this; 393 } 394 395 redecl_iterator operator++(int) { 396 redecl_iterator tmp(*this); 397 ++(*this); 398 return tmp; 399 } 400 401 friend bool operator==(redecl_iterator x, redecl_iterator y) { 402 return x.Current == y.Current; 403 } 404 friend bool operator!=(redecl_iterator x, redecl_iterator y) { 405 return x.Current != y.Current; 406 } 407 }; 408 409 /// \brief Returns iterator for all the redeclarations of the same decl. 410 /// It will iterate at least once (when this decl is the only one). 411 redecl_iterator redecls_begin() const { 412 return redecl_iterator(const_cast<Decl*>(this)); 413 } 414 redecl_iterator redecls_end() const { return redecl_iterator(); } 415 416 /// getBody - If this Decl represents a declaration for a body of code, 417 /// such as a function or method definition, this method returns the 418 /// top-level Stmt* of that body. Otherwise this method returns null. 419 virtual Stmt* getBody() const { return 0; } 420 421 /// getCompoundBody - Returns getBody(), dyn_casted to a CompoundStmt. 422 CompoundStmt* getCompoundBody() const; 423 424 /// getBodyRBrace - Gets the right brace of the body, if a body exists. 425 /// This works whether the body is a CompoundStmt or a CXXTryStmt. 426 SourceLocation getBodyRBrace() const; 427 428 // global temp stats (until we have a per-module visitor) 429 static void addDeclKind(Kind k); 430 static bool CollectingStats(bool Enable = false); 431 static void PrintStats(); 432 433 /// isTemplateParameter - Determines whether this declaration is a 434 /// template parameter. 435 bool isTemplateParameter() const; 436 437 /// isTemplateParameter - Determines whether this declaration is a 438 /// template parameter pack. 439 bool isTemplateParameterPack() const; 440 441 /// \brief Whether this declaration is a function or function template. 442 bool isFunctionOrFunctionTemplate() const; 443 444 /// \brief Changes the namespace of this declaration to reflect that it's 445 /// the object of a friend declaration. 446 /// 447 /// These declarations appear in the lexical context of the friending 448 /// class, but in the semantic context of the actual entity. This property 449 /// applies only to a specific decl object; other redeclarations of the 450 /// same entity may not (and probably don't) share this property. 451 void setObjectOfFriendDecl(bool PreviouslyDeclared) { 452 unsigned OldNS = IdentifierNamespace; 453 assert((OldNS == IDNS_Tag || OldNS == IDNS_Ordinary || 454 OldNS == (IDNS_Tag | IDNS_Ordinary)) 455 && "unsupported namespace for undeclared friend"); 456 if (!PreviouslyDeclared) IdentifierNamespace = 0; 457 458 if (OldNS == IDNS_Tag) 459 IdentifierNamespace |= IDNS_TagFriend; 460 else 461 IdentifierNamespace |= IDNS_OrdinaryFriend; 462 } 463 464 enum FriendObjectKind { 465 FOK_None, // not a friend object 466 FOK_Declared, // a friend of a previously-declared entity 467 FOK_Undeclared // a friend of a previously-undeclared entity 468 }; 469 470 /// \brief Determines whether this declaration is the object of a 471 /// friend declaration and, if so, what kind. 472 /// 473 /// There is currently no direct way to find the associated FriendDecl. 474 FriendObjectKind getFriendObjectKind() const { 475 unsigned mask 476 = (IdentifierNamespace & (IDNS_TagFriend | IDNS_OrdinaryFriend)); 477 if (!mask) return FOK_None; 478 return (IdentifierNamespace & (IDNS_Tag | IDNS_Ordinary) ? 479 FOK_Declared : FOK_Undeclared); 480 } 481 482 // Implement isa/cast/dyncast/etc. 483 static bool classof(const Decl *) { return true; } 484 static DeclContext *castToDeclContext(const Decl *); 485 static Decl *castFromDeclContext(const DeclContext *); 486 487 /// Destroy - Call destructors and release memory. 488 virtual void Destroy(ASTContext& C); 489 490 void print(llvm::raw_ostream &Out, unsigned Indentation = 0) const; 491 void print(llvm::raw_ostream &Out, const PrintingPolicy &Policy, 492 unsigned Indentation = 0) const; 493 static void printGroup(Decl** Begin, unsigned NumDecls, 494 llvm::raw_ostream &Out, const PrintingPolicy &Policy, 495 unsigned Indentation = 0); 496 void dump() const; 497 498private: 499 const Attr *getAttrsImpl() const; 500 501}; 502 503/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when 504/// doing something to a specific decl. 505class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry { 506 const Decl *TheDecl; 507 SourceLocation Loc; 508 SourceManager &SM; 509 const char *Message; 510public: 511 PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L, 512 SourceManager &sm, const char *Msg) 513 : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {} 514 515 virtual void print(llvm::raw_ostream &OS) const; 516}; 517 518 519/// DeclContext - This is used only as base class of specific decl types that 520/// can act as declaration contexts. These decls are (only the top classes 521/// that directly derive from DeclContext are mentioned, not their subclasses): 522/// 523/// TranslationUnitDecl 524/// NamespaceDecl 525/// FunctionDecl 526/// TagDecl 527/// ObjCMethodDecl 528/// ObjCContainerDecl 529/// LinkageSpecDecl 530/// BlockDecl 531/// 532class DeclContext { 533 /// DeclKind - This indicates which class this is. 534 Decl::Kind DeclKind : 8; 535 536 /// \brief Whether this declaration context also has some external 537 /// storage that contains additional declarations that are lexically 538 /// part of this context. 539 mutable bool ExternalLexicalStorage : 1; 540 541 /// \brief Whether this declaration context also has some external 542 /// storage that contains additional declarations that are visible 543 /// in this context. 544 mutable bool ExternalVisibleStorage : 1; 545 546 /// \brief Pointer to the data structure used to lookup declarations 547 /// within this context, which is a DenseMap<DeclarationName, 548 /// StoredDeclsList>. 549 mutable void* LookupPtr; 550 551 /// FirstDecl - The first declaration stored within this declaration 552 /// context. 553 mutable Decl *FirstDecl; 554 555 /// LastDecl - The last declaration stored within this declaration 556 /// context. FIXME: We could probably cache this value somewhere 557 /// outside of the DeclContext, to reduce the size of DeclContext by 558 /// another pointer. 559 mutable Decl *LastDecl; 560 561protected: 562 DeclContext(Decl::Kind K) 563 : DeclKind(K), ExternalLexicalStorage(false), 564 ExternalVisibleStorage(false), LookupPtr(0), FirstDecl(0), 565 LastDecl(0) { } 566 567 void DestroyDecls(ASTContext &C); 568 569public: 570 ~DeclContext(); 571 572 Decl::Kind getDeclKind() const { 573 return DeclKind; 574 } 575 const char *getDeclKindName() const; 576 577 /// getParent - Returns the containing DeclContext. 578 DeclContext *getParent() { 579 return cast<Decl>(this)->getDeclContext(); 580 } 581 const DeclContext *getParent() const { 582 return const_cast<DeclContext*>(this)->getParent(); 583 } 584 585 /// getLexicalParent - Returns the containing lexical DeclContext. May be 586 /// different from getParent, e.g.: 587 /// 588 /// namespace A { 589 /// struct S; 590 /// } 591 /// struct A::S {}; // getParent() == namespace 'A' 592 /// // getLexicalParent() == translation unit 593 /// 594 DeclContext *getLexicalParent() { 595 return cast<Decl>(this)->getLexicalDeclContext(); 596 } 597 const DeclContext *getLexicalParent() const { 598 return const_cast<DeclContext*>(this)->getLexicalParent(); 599 } 600 601 DeclContext *getLookupParent(); 602 603 const DeclContext *getLookupParent() const { 604 return const_cast<DeclContext*>(this)->getLookupParent(); 605 } 606 607 ASTContext &getParentASTContext() const { 608 return cast<Decl>(this)->getASTContext(); 609 } 610 611 bool isFunctionOrMethod() const { 612 switch (DeclKind) { 613 case Decl::Block: 614 case Decl::ObjCMethod: 615 return true; 616 default: 617 return DeclKind >= Decl::FunctionFirst && DeclKind <= Decl::FunctionLast; 618 } 619 } 620 621 bool isFileContext() const { 622 return DeclKind == Decl::TranslationUnit || DeclKind == Decl::Namespace; 623 } 624 625 bool isTranslationUnit() const { 626 return DeclKind == Decl::TranslationUnit; 627 } 628 629 bool isRecord() const { 630 return DeclKind >= Decl::RecordFirst && DeclKind <= Decl::RecordLast; 631 } 632 633 bool isNamespace() const { 634 return DeclKind == Decl::Namespace; 635 } 636 637 /// \brief Determines whether this context is dependent on a 638 /// template parameter. 639 bool isDependentContext() const; 640 641 /// isTransparentContext - Determines whether this context is a 642 /// "transparent" context, meaning that the members declared in this 643 /// context are semantically declared in the nearest enclosing 644 /// non-transparent (opaque) context but are lexically declared in 645 /// this context. For example, consider the enumerators of an 646 /// enumeration type: 647 /// @code 648 /// enum E { 649 /// Val1 650 /// }; 651 /// @endcode 652 /// Here, E is a transparent context, so its enumerator (Val1) will 653 /// appear (semantically) that it is in the same context of E. 654 /// Examples of transparent contexts include: enumerations (except for 655 /// C++0x scoped enums), C++ linkage specifications, and C++0x 656 /// inline namespaces. 657 bool isTransparentContext() const; 658 659 /// \brief Determine whether this declaration context is equivalent 660 /// to the declaration context DC. 661 bool Equals(DeclContext *DC) { 662 return this->getPrimaryContext() == DC->getPrimaryContext(); 663 } 664 665 /// \brief Determine whether this declaration context encloses the 666 /// declaration context DC. 667 bool Encloses(DeclContext *DC); 668 669 /// getPrimaryContext - There may be many different 670 /// declarations of the same entity (including forward declarations 671 /// of classes, multiple definitions of namespaces, etc.), each with 672 /// a different set of declarations. This routine returns the 673 /// "primary" DeclContext structure, which will contain the 674 /// information needed to perform name lookup into this context. 675 DeclContext *getPrimaryContext(); 676 677 /// getLookupContext - Retrieve the innermost non-transparent 678 /// context of this context, which corresponds to the innermost 679 /// location from which name lookup can find the entities in this 680 /// context. 681 DeclContext *getLookupContext(); 682 const DeclContext *getLookupContext() const { 683 return const_cast<DeclContext *>(this)->getLookupContext(); 684 } 685 686 /// \brief Retrieve the nearest enclosing namespace context. 687 DeclContext *getEnclosingNamespaceContext(); 688 const DeclContext *getEnclosingNamespaceContext() const { 689 return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext(); 690 } 691 692 /// getNextContext - If this is a DeclContext that may have other 693 /// DeclContexts that are semantically connected but syntactically 694 /// different, such as C++ namespaces, this routine retrieves the 695 /// next DeclContext in the link. Iteration through the chain of 696 /// DeclContexts should begin at the primary DeclContext and 697 /// continue until this function returns NULL. For example, given: 698 /// @code 699 /// namespace N { 700 /// int x; 701 /// } 702 /// namespace N { 703 /// int y; 704 /// } 705 /// @endcode 706 /// The first occurrence of namespace N will be the primary 707 /// DeclContext. Its getNextContext will return the second 708 /// occurrence of namespace N. 709 DeclContext *getNextContext(); 710 711 /// decl_iterator - Iterates through the declarations stored 712 /// within this context. 713 class decl_iterator { 714 /// Current - The current declaration. 715 Decl *Current; 716 717 public: 718 typedef Decl* value_type; 719 typedef Decl* reference; 720 typedef Decl* pointer; 721 typedef std::forward_iterator_tag iterator_category; 722 typedef std::ptrdiff_t difference_type; 723 724 decl_iterator() : Current(0) { } 725 explicit decl_iterator(Decl *C) : Current(C) { } 726 727 reference operator*() const { return Current; } 728 pointer operator->() const { return Current; } 729 730 decl_iterator& operator++() { 731 Current = Current->getNextDeclInContext(); 732 return *this; 733 } 734 735 decl_iterator operator++(int) { 736 decl_iterator tmp(*this); 737 ++(*this); 738 return tmp; 739 } 740 741 friend bool operator==(decl_iterator x, decl_iterator y) { 742 return x.Current == y.Current; 743 } 744 friend bool operator!=(decl_iterator x, decl_iterator y) { 745 return x.Current != y.Current; 746 } 747 }; 748 749 /// decls_begin/decls_end - Iterate over the declarations stored in 750 /// this context. 751 decl_iterator decls_begin() const; 752 decl_iterator decls_end() const; 753 bool decls_empty() const; 754 755 /// specific_decl_iterator - Iterates over a subrange of 756 /// declarations stored in a DeclContext, providing only those that 757 /// are of type SpecificDecl (or a class derived from it). This 758 /// iterator is used, for example, to provide iteration over just 759 /// the fields within a RecordDecl (with SpecificDecl = FieldDecl). 760 template<typename SpecificDecl> 761 class specific_decl_iterator { 762 /// Current - The current, underlying declaration iterator, which 763 /// will either be NULL or will point to a declaration of 764 /// type SpecificDecl. 765 DeclContext::decl_iterator Current; 766 767 /// SkipToNextDecl - Advances the current position up to the next 768 /// declaration of type SpecificDecl that also meets the criteria 769 /// required by Acceptable. 770 void SkipToNextDecl() { 771 while (*Current && !isa<SpecificDecl>(*Current)) 772 ++Current; 773 } 774 775 public: 776 typedef SpecificDecl* value_type; 777 typedef SpecificDecl* reference; 778 typedef SpecificDecl* pointer; 779 typedef std::iterator_traits<DeclContext::decl_iterator>::difference_type 780 difference_type; 781 typedef std::forward_iterator_tag iterator_category; 782 783 specific_decl_iterator() : Current() { } 784 785 /// specific_decl_iterator - Construct a new iterator over a 786 /// subset of the declarations the range [C, 787 /// end-of-declarations). If A is non-NULL, it is a pointer to a 788 /// member function of SpecificDecl that should return true for 789 /// all of the SpecificDecl instances that will be in the subset 790 /// of iterators. For example, if you want Objective-C instance 791 /// methods, SpecificDecl will be ObjCMethodDecl and A will be 792 /// &ObjCMethodDecl::isInstanceMethod. 793 explicit specific_decl_iterator(DeclContext::decl_iterator C) : Current(C) { 794 SkipToNextDecl(); 795 } 796 797 reference operator*() const { return cast<SpecificDecl>(*Current); } 798 pointer operator->() const { return cast<SpecificDecl>(*Current); } 799 800 specific_decl_iterator& operator++() { 801 ++Current; 802 SkipToNextDecl(); 803 return *this; 804 } 805 806 specific_decl_iterator operator++(int) { 807 specific_decl_iterator tmp(*this); 808 ++(*this); 809 return tmp; 810 } 811 812 friend bool 813 operator==(const specific_decl_iterator& x, const specific_decl_iterator& y) { 814 return x.Current == y.Current; 815 } 816 817 friend bool 818 operator!=(const specific_decl_iterator& x, const specific_decl_iterator& y) { 819 return x.Current != y.Current; 820 } 821 }; 822 823 /// \brief Iterates over a filtered subrange of declarations stored 824 /// in a DeclContext. 825 /// 826 /// This iterator visits only those declarations that are of type 827 /// SpecificDecl (or a class derived from it) and that meet some 828 /// additional run-time criteria. This iterator is used, for 829 /// example, to provide access to the instance methods within an 830 /// Objective-C interface (with SpecificDecl = ObjCMethodDecl and 831 /// Acceptable = ObjCMethodDecl::isInstanceMethod). 832 template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const> 833 class filtered_decl_iterator { 834 /// Current - The current, underlying declaration iterator, which 835 /// will either be NULL or will point to a declaration of 836 /// type SpecificDecl. 837 DeclContext::decl_iterator Current; 838 839 /// SkipToNextDecl - Advances the current position up to the next 840 /// declaration of type SpecificDecl that also meets the criteria 841 /// required by Acceptable. 842 void SkipToNextDecl() { 843 while (*Current && 844 (!isa<SpecificDecl>(*Current) || 845 (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)()))) 846 ++Current; 847 } 848 849 public: 850 typedef SpecificDecl* value_type; 851 typedef SpecificDecl* reference; 852 typedef SpecificDecl* pointer; 853 typedef std::iterator_traits<DeclContext::decl_iterator>::difference_type 854 difference_type; 855 typedef std::forward_iterator_tag iterator_category; 856 857 filtered_decl_iterator() : Current() { } 858 859 /// specific_decl_iterator - Construct a new iterator over a 860 /// subset of the declarations the range [C, 861 /// end-of-declarations). If A is non-NULL, it is a pointer to a 862 /// member function of SpecificDecl that should return true for 863 /// all of the SpecificDecl instances that will be in the subset 864 /// of iterators. For example, if you want Objective-C instance 865 /// methods, SpecificDecl will be ObjCMethodDecl and A will be 866 /// &ObjCMethodDecl::isInstanceMethod. 867 explicit filtered_decl_iterator(DeclContext::decl_iterator C) : Current(C) { 868 SkipToNextDecl(); 869 } 870 871 reference operator*() const { return cast<SpecificDecl>(*Current); } 872 pointer operator->() const { return cast<SpecificDecl>(*Current); } 873 874 filtered_decl_iterator& operator++() { 875 ++Current; 876 SkipToNextDecl(); 877 return *this; 878 } 879 880 filtered_decl_iterator operator++(int) { 881 filtered_decl_iterator tmp(*this); 882 ++(*this); 883 return tmp; 884 } 885 886 friend bool 887 operator==(const filtered_decl_iterator& x, const filtered_decl_iterator& y) { 888 return x.Current == y.Current; 889 } 890 891 friend bool 892 operator!=(const filtered_decl_iterator& x, const filtered_decl_iterator& y) { 893 return x.Current != y.Current; 894 } 895 }; 896 897 /// @brief Add the declaration D into this context. 898 /// 899 /// This routine should be invoked when the declaration D has first 900 /// been declared, to place D into the context where it was 901 /// (lexically) defined. Every declaration must be added to one 902 /// (and only one!) context, where it can be visited via 903 /// [decls_begin(), decls_end()). Once a declaration has been added 904 /// to its lexical context, the corresponding DeclContext owns the 905 /// declaration. 906 /// 907 /// If D is also a NamedDecl, it will be made visible within its 908 /// semantic context via makeDeclVisibleInContext. 909 void addDecl(Decl *D); 910 911 /// @brief Add the declaration D to this context without modifying 912 /// any lookup tables. 913 /// 914 /// This is useful for some operations in dependent contexts where 915 /// the semantic context might not be dependent; this basically 916 /// only happens with friends. 917 void addHiddenDecl(Decl *D); 918 919 /// @brief Removes a declaration from this context. 920 void removeDecl(Decl *D); 921 922 /// lookup_iterator - An iterator that provides access to the results 923 /// of looking up a name within this context. 924 typedef NamedDecl **lookup_iterator; 925 926 /// lookup_const_iterator - An iterator that provides non-mutable 927 /// access to the results of lookup up a name within this context. 928 typedef NamedDecl * const * lookup_const_iterator; 929 930 typedef std::pair<lookup_iterator, lookup_iterator> lookup_result; 931 typedef std::pair<lookup_const_iterator, lookup_const_iterator> 932 lookup_const_result; 933 934 /// lookup - Find the declarations (if any) with the given Name in 935 /// this context. Returns a range of iterators that contains all of 936 /// the declarations with this name, with object, function, member, 937 /// and enumerator names preceding any tag name. Note that this 938 /// routine will not look into parent contexts. 939 lookup_result lookup(DeclarationName Name); 940 lookup_const_result lookup(DeclarationName Name) const; 941 942 /// @brief Makes a declaration visible within this context. 943 /// 944 /// This routine makes the declaration D visible to name lookup 945 /// within this context and, if this is a transparent context, 946 /// within its parent contexts up to the first enclosing 947 /// non-transparent context. Making a declaration visible within a 948 /// context does not transfer ownership of a declaration, and a 949 /// declaration can be visible in many contexts that aren't its 950 /// lexical context. 951 /// 952 /// If D is a redeclaration of an existing declaration that is 953 /// visible from this context, as determined by 954 /// NamedDecl::declarationReplaces, the previous declaration will be 955 /// replaced with D. 956 /// 957 /// @param Recoverable true if it's okay to not add this decl to 958 /// the lookup tables because it can be easily recovered by walking 959 /// the declaration chains. 960 void makeDeclVisibleInContext(NamedDecl *D, bool Recoverable = true); 961 962 /// udir_iterator - Iterates through the using-directives stored 963 /// within this context. 964 typedef UsingDirectiveDecl * const * udir_iterator; 965 966 typedef std::pair<udir_iterator, udir_iterator> udir_iterator_range; 967 968 udir_iterator_range getUsingDirectives() const; 969 970 udir_iterator using_directives_begin() const { 971 return getUsingDirectives().first; 972 } 973 974 udir_iterator using_directives_end() const { 975 return getUsingDirectives().second; 976 } 977 978 // Low-level accessors 979 980 /// \brief Retrieve the internal representation of the lookup structure. 981 void* getLookupPtr() const { return LookupPtr; } 982 983 /// \brief Whether this DeclContext has external storage containing 984 /// additional declarations that are lexically in this context. 985 bool hasExternalLexicalStorage() const { return ExternalLexicalStorage; } 986 987 /// \brief State whether this DeclContext has external storage for 988 /// declarations lexically in this context. 989 void setHasExternalLexicalStorage(bool ES = true) { 990 ExternalLexicalStorage = ES; 991 } 992 993 /// \brief Whether this DeclContext has external storage containing 994 /// additional declarations that are visible in this context. 995 bool hasExternalVisibleStorage() const { return ExternalVisibleStorage; } 996 997 /// \brief State whether this DeclContext has external storage for 998 /// declarations visible in this context. 999 void setHasExternalVisibleStorage(bool ES = true) { 1000 ExternalVisibleStorage = ES; 1001 } 1002 1003 static bool classof(const Decl *D); 1004 static bool classof(const DeclContext *D) { return true; } 1005#define DECL_CONTEXT(Name) \ 1006 static bool classof(const Name##Decl *D) { return true; } 1007#include "clang/AST/DeclNodes.def" 1008 1009 void dumpDeclContext() const; 1010 1011private: 1012 void LoadLexicalDeclsFromExternalStorage() const; 1013 void LoadVisibleDeclsFromExternalStorage() const; 1014 1015 void buildLookup(DeclContext *DCtx); 1016 void makeDeclVisibleInContextImpl(NamedDecl *D); 1017}; 1018 1019inline bool Decl::isTemplateParameter() const { 1020 return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm || 1021 getKind() == TemplateTemplateParm; 1022} 1023 1024} // end clang. 1025 1026namespace llvm { 1027 1028/// Implement a isa_impl_wrap specialization to check whether a DeclContext is 1029/// a specific Decl. 1030template<class ToTy> 1031struct isa_impl_wrap<ToTy, 1032 const ::clang::DeclContext,const ::clang::DeclContext> { 1033 static bool doit(const ::clang::DeclContext &Val) { 1034 return ToTy::classof(::clang::Decl::castFromDeclContext(&Val)); 1035 } 1036}; 1037template<class ToTy> 1038struct isa_impl_wrap<ToTy, ::clang::DeclContext, ::clang::DeclContext> 1039 : public isa_impl_wrap<ToTy, 1040 const ::clang::DeclContext,const ::clang::DeclContext> {}; 1041 1042/// Implement cast_convert_val for Decl -> DeclContext conversions. 1043template<class FromTy> 1044struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> { 1045 static ::clang::DeclContext &doit(const FromTy &Val) { 1046 return *FromTy::castToDeclContext(&Val); 1047 } 1048}; 1049 1050template<class FromTy> 1051struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> { 1052 static ::clang::DeclContext *doit(const FromTy *Val) { 1053 return FromTy::castToDeclContext(Val); 1054 } 1055}; 1056 1057template<class FromTy> 1058struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> { 1059 static const ::clang::DeclContext &doit(const FromTy &Val) { 1060 return *FromTy::castToDeclContext(&Val); 1061 } 1062}; 1063 1064template<class FromTy> 1065struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> { 1066 static const ::clang::DeclContext *doit(const FromTy *Val) { 1067 return FromTy::castToDeclContext(Val); 1068 } 1069}; 1070 1071/// Implement cast_convert_val for DeclContext -> Decl conversions. 1072template<class ToTy> 1073struct cast_convert_val<ToTy, 1074 const ::clang::DeclContext,const ::clang::DeclContext> { 1075 static ToTy &doit(const ::clang::DeclContext &Val) { 1076 return *reinterpret_cast<ToTy*>(ToTy::castFromDeclContext(&Val)); 1077 } 1078}; 1079template<class ToTy> 1080struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> 1081 : public cast_convert_val<ToTy, 1082 const ::clang::DeclContext,const ::clang::DeclContext> {}; 1083 1084template<class ToTy> 1085struct cast_convert_val<ToTy, 1086 const ::clang::DeclContext*, const ::clang::DeclContext*> { 1087 static ToTy *doit(const ::clang::DeclContext *Val) { 1088 return reinterpret_cast<ToTy*>(ToTy::castFromDeclContext(Val)); 1089 } 1090}; 1091template<class ToTy> 1092struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> 1093 : public cast_convert_val<ToTy, 1094 const ::clang::DeclContext*,const ::clang::DeclContext*> {}; 1095 1096} // end namespace llvm 1097 1098#endif 1099