1//===- DeclBase.h - Base Classes for representing declarations --*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file defines the Decl and DeclContext interfaces. 10// 11//===----------------------------------------------------------------------===// 12 13#ifndef LLVM_CLANG_AST_DECLBASE_H 14#define LLVM_CLANG_AST_DECLBASE_H 15 16#include "clang/AST/ASTDumperUtils.h" 17#include "clang/AST/AttrIterator.h" 18#include "clang/AST/DeclarationName.h" 19#include "clang/AST/SelectorLocationsKind.h" 20#include "clang/Basic/IdentifierTable.h" 21#include "clang/Basic/LLVM.h" 22#include "clang/Basic/LangOptions.h" 23#include "clang/Basic/SourceLocation.h" 24#include "clang/Basic/Specifiers.h" 25#include "llvm/ADT/ArrayRef.h" 26#include "llvm/ADT/PointerIntPair.h" 27#include "llvm/ADT/PointerUnion.h" 28#include "llvm/ADT/iterator.h" 29#include "llvm/ADT/iterator_range.h" 30#include "llvm/Support/Casting.h" 31#include "llvm/Support/Compiler.h" 32#include "llvm/Support/PrettyStackTrace.h" 33#include "llvm/Support/VersionTuple.h" 34#include <algorithm> 35#include <cassert> 36#include <cstddef> 37#include <iterator> 38#include <string> 39#include <type_traits> 40#include <utility> 41 42namespace clang { 43 44class ASTContext; 45class ASTMutationListener; 46class Attr; 47class BlockDecl; 48class DeclContext; 49class ExternalSourceSymbolAttr; 50class FunctionDecl; 51class FunctionType; 52class IdentifierInfo; 53enum class Linkage : unsigned char; 54class LinkageSpecDecl; 55class Module; 56class NamedDecl; 57class ObjCContainerDecl; 58class ObjCMethodDecl; 59struct PrintingPolicy; 60class RecordDecl; 61class SourceManager; 62class Stmt; 63class StoredDeclsMap; 64class TemplateDecl; 65class TemplateParameterList; 66class TranslationUnitDecl; 67class UsingDirectiveDecl; 68 69/// Captures the result of checking the availability of a 70/// declaration. 71enum AvailabilityResult { 72 AR_Available = 0, 73 AR_NotYetIntroduced, 74 AR_Deprecated, 75 AR_Unavailable 76}; 77 78/// Decl - This represents one declaration (or definition), e.g. a variable, 79/// typedef, function, struct, etc. 80/// 81/// Note: There are objects tacked on before the *beginning* of Decl 82/// (and its subclasses) in its Decl::operator new(). Proper alignment 83/// of all subclasses (not requiring more than the alignment of Decl) is 84/// asserted in DeclBase.cpp. 85class alignas(8) Decl { 86public: 87 /// Lists the kind of concrete classes of Decl. 88 enum Kind { 89#define DECL(DERIVED, BASE) DERIVED, 90#define ABSTRACT_DECL(DECL) 91#define DECL_RANGE(BASE, START, END) \ 92 first##BASE = START, last##BASE = END, 93#define LAST_DECL_RANGE(BASE, START, END) \ 94 first##BASE = START, last##BASE = END 95#include "clang/AST/DeclNodes.inc" 96 }; 97 98 /// A placeholder type used to construct an empty shell of a 99 /// decl-derived type that will be filled in later (e.g., by some 100 /// deserialization method). 101 struct EmptyShell {}; 102 103 /// IdentifierNamespace - The different namespaces in which 104 /// declarations may appear. According to C99 6.2.3, there are 105 /// four namespaces, labels, tags, members and ordinary 106 /// identifiers. C++ describes lookup completely differently: 107 /// certain lookups merely "ignore" certain kinds of declarations, 108 /// usually based on whether the declaration is of a type, etc. 109 /// 110 /// These are meant as bitmasks, so that searches in 111 /// C++ can look into the "tag" namespace during ordinary lookup. 112 /// 113 /// Decl currently provides 15 bits of IDNS bits. 114 enum IdentifierNamespace { 115 /// Labels, declared with 'x:' and referenced with 'goto x'. 116 IDNS_Label = 0x0001, 117 118 /// Tags, declared with 'struct foo;' and referenced with 119 /// 'struct foo'. All tags are also types. This is what 120 /// elaborated-type-specifiers look for in C. 121 /// This also contains names that conflict with tags in the 122 /// same scope but that are otherwise ordinary names (non-type 123 /// template parameters and indirect field declarations). 124 IDNS_Tag = 0x0002, 125 126 /// Types, declared with 'struct foo', typedefs, etc. 127 /// This is what elaborated-type-specifiers look for in C++, 128 /// but note that it's ill-formed to find a non-tag. 129 IDNS_Type = 0x0004, 130 131 /// Members, declared with object declarations within tag 132 /// definitions. In C, these can only be found by "qualified" 133 /// lookup in member expressions. In C++, they're found by 134 /// normal lookup. 135 IDNS_Member = 0x0008, 136 137 /// Namespaces, declared with 'namespace foo {}'. 138 /// Lookup for nested-name-specifiers find these. 139 IDNS_Namespace = 0x0010, 140 141 /// Ordinary names. In C, everything that's not a label, tag, 142 /// member, or function-local extern ends up here. 143 IDNS_Ordinary = 0x0020, 144 145 /// Objective C \@protocol. 146 IDNS_ObjCProtocol = 0x0040, 147 148 /// This declaration is a friend function. A friend function 149 /// declaration is always in this namespace but may also be in 150 /// IDNS_Ordinary if it was previously declared. 151 IDNS_OrdinaryFriend = 0x0080, 152 153 /// This declaration is a friend class. A friend class 154 /// declaration is always in this namespace but may also be in 155 /// IDNS_Tag|IDNS_Type if it was previously declared. 156 IDNS_TagFriend = 0x0100, 157 158 /// This declaration is a using declaration. A using declaration 159 /// *introduces* a number of other declarations into the current 160 /// scope, and those declarations use the IDNS of their targets, 161 /// but the actual using declarations go in this namespace. 162 IDNS_Using = 0x0200, 163 164 /// This declaration is a C++ operator declared in a non-class 165 /// context. All such operators are also in IDNS_Ordinary. 166 /// C++ lexical operator lookup looks for these. 167 IDNS_NonMemberOperator = 0x0400, 168 169 /// This declaration is a function-local extern declaration of a 170 /// variable or function. This may also be IDNS_Ordinary if it 171 /// has been declared outside any function. These act mostly like 172 /// invisible friend declarations, but are also visible to unqualified 173 /// lookup within the scope of the declaring function. 174 IDNS_LocalExtern = 0x0800, 175 176 /// This declaration is an OpenMP user defined reduction construction. 177 IDNS_OMPReduction = 0x1000, 178 179 /// This declaration is an OpenMP user defined mapper. 180 IDNS_OMPMapper = 0x2000, 181 }; 182 183 /// ObjCDeclQualifier - 'Qualifiers' written next to the return and 184 /// parameter types in method declarations. Other than remembering 185 /// them and mangling them into the method's signature string, these 186 /// are ignored by the compiler; they are consumed by certain 187 /// remote-messaging frameworks. 188 /// 189 /// in, inout, and out are mutually exclusive and apply only to 190 /// method parameters. bycopy and byref are mutually exclusive and 191 /// apply only to method parameters (?). oneway applies only to 192 /// results. All of these expect their corresponding parameter to 193 /// have a particular type. None of this is currently enforced by 194 /// clang. 195 /// 196 /// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier. 197 enum ObjCDeclQualifier { 198 OBJC_TQ_None = 0x0, 199 OBJC_TQ_In = 0x1, 200 OBJC_TQ_Inout = 0x2, 201 OBJC_TQ_Out = 0x4, 202 OBJC_TQ_Bycopy = 0x8, 203 OBJC_TQ_Byref = 0x10, 204 OBJC_TQ_Oneway = 0x20, 205 206 /// The nullability qualifier is set when the nullability of the 207 /// result or parameter was expressed via a context-sensitive 208 /// keyword. 209 OBJC_TQ_CSNullability = 0x40 210 }; 211 212 /// The kind of ownership a declaration has, for visibility purposes. 213 /// This enumeration is designed such that higher values represent higher 214 /// levels of name hiding. 215 enum class ModuleOwnershipKind : unsigned char { 216 /// This declaration is not owned by a module. 217 Unowned, 218 219 /// This declaration has an owning module, but is globally visible 220 /// (typically because its owning module is visible and we know that 221 /// modules cannot later become hidden in this compilation). 222 /// After serialization and deserialization, this will be converted 223 /// to VisibleWhenImported. 224 Visible, 225 226 /// This declaration has an owning module, and is visible when that 227 /// module is imported. 228 VisibleWhenImported, 229 230 /// This declaration has an owning module, and is visible to lookups 231 /// that occurs within that module. And it is reachable in other module 232 /// when the owning module is transitively imported. 233 ReachableWhenImported, 234 235 /// This declaration has an owning module, but is only visible to 236 /// lookups that occur within that module. 237 /// The discarded declarations in global module fragment belongs 238 /// to this group too. 239 ModulePrivate 240 }; 241 242protected: 243 /// The next declaration within the same lexical 244 /// DeclContext. These pointers form the linked list that is 245 /// traversed via DeclContext's decls_begin()/decls_end(). 246 /// 247 /// The extra three bits are used for the ModuleOwnershipKind. 248 llvm::PointerIntPair<Decl *, 3, ModuleOwnershipKind> NextInContextAndBits; 249 250private: 251 friend class DeclContext; 252 253 struct MultipleDC { 254 DeclContext *SemanticDC; 255 DeclContext *LexicalDC; 256 }; 257 258 /// DeclCtx - Holds either a DeclContext* or a MultipleDC*. 259 /// For declarations that don't contain C++ scope specifiers, it contains 260 /// the DeclContext where the Decl was declared. 261 /// For declarations with C++ scope specifiers, it contains a MultipleDC* 262 /// with the context where it semantically belongs (SemanticDC) and the 263 /// context where it was lexically declared (LexicalDC). 264 /// e.g.: 265 /// 266 /// namespace A { 267 /// void f(); // SemanticDC == LexicalDC == 'namespace A' 268 /// } 269 /// void A::f(); // SemanticDC == namespace 'A' 270 /// // LexicalDC == global namespace 271 llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx; 272 273 bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); } 274 bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); } 275 276 MultipleDC *getMultipleDC() const { 277 return DeclCtx.get<MultipleDC*>(); 278 } 279 280 DeclContext *getSemanticDC() const { 281 return DeclCtx.get<DeclContext*>(); 282 } 283 284 /// Loc - The location of this decl. 285 SourceLocation Loc; 286 287 /// DeclKind - This indicates which class this is. 288 LLVM_PREFERRED_TYPE(Kind) 289 unsigned DeclKind : 7; 290 291 /// InvalidDecl - This indicates a semantic error occurred. 292 LLVM_PREFERRED_TYPE(bool) 293 unsigned InvalidDecl : 1; 294 295 /// HasAttrs - This indicates whether the decl has attributes or not. 296 LLVM_PREFERRED_TYPE(bool) 297 unsigned HasAttrs : 1; 298 299 /// Implicit - Whether this declaration was implicitly generated by 300 /// the implementation rather than explicitly written by the user. 301 LLVM_PREFERRED_TYPE(bool) 302 unsigned Implicit : 1; 303 304 /// Whether this declaration was "used", meaning that a definition is 305 /// required. 306 LLVM_PREFERRED_TYPE(bool) 307 unsigned Used : 1; 308 309 /// Whether this declaration was "referenced". 310 /// The difference with 'Used' is whether the reference appears in a 311 /// evaluated context or not, e.g. functions used in uninstantiated templates 312 /// are regarded as "referenced" but not "used". 313 LLVM_PREFERRED_TYPE(bool) 314 unsigned Referenced : 1; 315 316 /// Whether this declaration is a top-level declaration (function, 317 /// global variable, etc.) that is lexically inside an objc container 318 /// definition. 319 LLVM_PREFERRED_TYPE(bool) 320 unsigned TopLevelDeclInObjCContainer : 1; 321 322 /// Whether statistic collection is enabled. 323 static bool StatisticsEnabled; 324 325protected: 326 friend class ASTDeclReader; 327 friend class ASTDeclWriter; 328 friend class ASTNodeImporter; 329 friend class ASTReader; 330 friend class CXXClassMemberWrapper; 331 friend class LinkageComputer; 332 friend class RecordDecl; 333 template<typename decl_type> friend class Redeclarable; 334 335 /// Access - Used by C++ decls for the access specifier. 336 // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum 337 LLVM_PREFERRED_TYPE(AccessSpecifier) 338 unsigned Access : 2; 339 340 /// Whether this declaration was loaded from an AST file. 341 LLVM_PREFERRED_TYPE(bool) 342 unsigned FromASTFile : 1; 343 344 /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in. 345 LLVM_PREFERRED_TYPE(IdentifierNamespace) 346 unsigned IdentifierNamespace : 14; 347 348 /// If 0, we have not computed the linkage of this declaration. 349 LLVM_PREFERRED_TYPE(Linkage) 350 mutable unsigned CacheValidAndLinkage : 3; 351 352 /// Allocate memory for a deserialized declaration. 353 /// 354 /// This routine must be used to allocate memory for any declaration that is 355 /// deserialized from a module file. 356 /// 357 /// \param Size The size of the allocated object. 358 /// \param Ctx The context in which we will allocate memory. 359 /// \param ID The global ID of the deserialized declaration. 360 /// \param Extra The amount of extra space to allocate after the object. 361 void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID, 362 std::size_t Extra = 0); 363 364 /// Allocate memory for a non-deserialized declaration. 365 void *operator new(std::size_t Size, const ASTContext &Ctx, 366 DeclContext *Parent, std::size_t Extra = 0); 367 368private: 369 bool AccessDeclContextCheck() const; 370 371 /// Get the module ownership kind to use for a local lexical child of \p DC, 372 /// which may be either a local or (rarely) an imported declaration. 373 static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) { 374 if (DC) { 375 auto *D = cast<Decl>(DC); 376 auto MOK = D->getModuleOwnershipKind(); 377 if (MOK != ModuleOwnershipKind::Unowned && 378 (!D->isFromASTFile() || D->hasLocalOwningModuleStorage())) 379 return MOK; 380 // If D is not local and we have no local module storage, then we don't 381 // need to track module ownership at all. 382 } 383 return ModuleOwnershipKind::Unowned; 384 } 385 386public: 387 Decl() = delete; 388 Decl(const Decl&) = delete; 389 Decl(Decl &&) = delete; 390 Decl &operator=(const Decl&) = delete; 391 Decl &operator=(Decl&&) = delete; 392 393protected: 394 Decl(Kind DK, DeclContext *DC, SourceLocation L) 395 : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)), 396 DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false), 397 Implicit(false), Used(false), Referenced(false), 398 TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0), 399 IdentifierNamespace(getIdentifierNamespaceForKind(DK)), 400 CacheValidAndLinkage(llvm::to_underlying(Linkage::Invalid)) { 401 if (StatisticsEnabled) add(DK); 402 } 403 404 Decl(Kind DK, EmptyShell Empty) 405 : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false), 406 Used(false), Referenced(false), TopLevelDeclInObjCContainer(false), 407 Access(AS_none), FromASTFile(0), 408 IdentifierNamespace(getIdentifierNamespaceForKind(DK)), 409 CacheValidAndLinkage(llvm::to_underlying(Linkage::Invalid)) { 410 if (StatisticsEnabled) add(DK); 411 } 412 413 virtual ~Decl(); 414 415 /// Update a potentially out-of-date declaration. 416 void updateOutOfDate(IdentifierInfo &II) const; 417 418 Linkage getCachedLinkage() const { 419 return static_cast<Linkage>(CacheValidAndLinkage); 420 } 421 422 void setCachedLinkage(Linkage L) const { 423 CacheValidAndLinkage = llvm::to_underlying(L); 424 } 425 426 bool hasCachedLinkage() const { 427 return CacheValidAndLinkage; 428 } 429 430public: 431 /// Source range that this declaration covers. 432 virtual SourceRange getSourceRange() const LLVM_READONLY { 433 return SourceRange(getLocation(), getLocation()); 434 } 435 436 SourceLocation getBeginLoc() const LLVM_READONLY { 437 return getSourceRange().getBegin(); 438 } 439 440 SourceLocation getEndLoc() const LLVM_READONLY { 441 return getSourceRange().getEnd(); 442 } 443 444 SourceLocation getLocation() const { return Loc; } 445 void setLocation(SourceLocation L) { Loc = L; } 446 447 Kind getKind() const { return static_cast<Kind>(DeclKind); } 448 const char *getDeclKindName() const; 449 450 Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); } 451 const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();} 452 453 DeclContext *getDeclContext() { 454 if (isInSemaDC()) 455 return getSemanticDC(); 456 return getMultipleDC()->SemanticDC; 457 } 458 const DeclContext *getDeclContext() const { 459 return const_cast<Decl*>(this)->getDeclContext(); 460 } 461 462 /// Return the non transparent context. 463 /// See the comment of `DeclContext::isTransparentContext()` for the 464 /// definition of transparent context. 465 DeclContext *getNonTransparentDeclContext(); 466 const DeclContext *getNonTransparentDeclContext() const { 467 return const_cast<Decl *>(this)->getNonTransparentDeclContext(); 468 } 469 470 /// Find the innermost non-closure ancestor of this declaration, 471 /// walking up through blocks, lambdas, etc. If that ancestor is 472 /// not a code context (!isFunctionOrMethod()), returns null. 473 /// 474 /// A declaration may be its own non-closure context. 475 Decl *getNonClosureContext(); 476 const Decl *getNonClosureContext() const { 477 return const_cast<Decl*>(this)->getNonClosureContext(); 478 } 479 480 TranslationUnitDecl *getTranslationUnitDecl(); 481 const TranslationUnitDecl *getTranslationUnitDecl() const { 482 return const_cast<Decl*>(this)->getTranslationUnitDecl(); 483 } 484 485 bool isInAnonymousNamespace() const; 486 487 bool isInStdNamespace() const; 488 489 // Return true if this is a FileContext Decl. 490 bool isFileContextDecl() const; 491 492 /// Whether it resembles a flexible array member. This is a static member 493 /// because we want to be able to call it with a nullptr. That allows us to 494 /// perform non-Decl specific checks based on the object's type and strict 495 /// flex array level. 496 static bool isFlexibleArrayMemberLike( 497 ASTContext &Context, const Decl *D, QualType Ty, 498 LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, 499 bool IgnoreTemplateOrMacroSubstitution); 500 501 ASTContext &getASTContext() const LLVM_READONLY; 502 503 /// Helper to get the language options from the ASTContext. 504 /// Defined out of line to avoid depending on ASTContext.h. 505 const LangOptions &getLangOpts() const LLVM_READONLY; 506 507 void setAccess(AccessSpecifier AS) { 508 Access = AS; 509 assert(AccessDeclContextCheck()); 510 } 511 512 AccessSpecifier getAccess() const { 513 assert(AccessDeclContextCheck()); 514 return AccessSpecifier(Access); 515 } 516 517 /// Retrieve the access specifier for this declaration, even though 518 /// it may not yet have been properly set. 519 AccessSpecifier getAccessUnsafe() const { 520 return AccessSpecifier(Access); 521 } 522 523 bool hasAttrs() const { return HasAttrs; } 524 525 void setAttrs(const AttrVec& Attrs) { 526 return setAttrsImpl(Attrs, getASTContext()); 527 } 528 529 AttrVec &getAttrs() { 530 return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs()); 531 } 532 533 const AttrVec &getAttrs() const; 534 void dropAttrs(); 535 void addAttr(Attr *A); 536 537 using attr_iterator = AttrVec::const_iterator; 538 using attr_range = llvm::iterator_range<attr_iterator>; 539 540 attr_range attrs() const { 541 return attr_range(attr_begin(), attr_end()); 542 } 543 544 attr_iterator attr_begin() const { 545 return hasAttrs() ? getAttrs().begin() : nullptr; 546 } 547 attr_iterator attr_end() const { 548 return hasAttrs() ? getAttrs().end() : nullptr; 549 } 550 551 template <typename... Ts> void dropAttrs() { 552 if (!HasAttrs) return; 553 554 AttrVec &Vec = getAttrs(); 555 llvm::erase_if(Vec, [](Attr *A) { return isa<Ts...>(A); }); 556 557 if (Vec.empty()) 558 HasAttrs = false; 559 } 560 561 template <typename T> void dropAttr() { dropAttrs<T>(); } 562 563 template <typename T> 564 llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const { 565 return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>()); 566 } 567 568 template <typename T> 569 specific_attr_iterator<T> specific_attr_begin() const { 570 return specific_attr_iterator<T>(attr_begin()); 571 } 572 573 template <typename T> 574 specific_attr_iterator<T> specific_attr_end() const { 575 return specific_attr_iterator<T>(attr_end()); 576 } 577 578 template<typename T> T *getAttr() const { 579 return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr; 580 } 581 582 template<typename T> bool hasAttr() const { 583 return hasAttrs() && hasSpecificAttr<T>(getAttrs()); 584 } 585 586 /// getMaxAlignment - return the maximum alignment specified by attributes 587 /// on this decl, 0 if there are none. 588 unsigned getMaxAlignment() const; 589 590 /// setInvalidDecl - Indicates the Decl had a semantic error. This 591 /// allows for graceful error recovery. 592 void setInvalidDecl(bool Invalid = true); 593 bool isInvalidDecl() const { return (bool) InvalidDecl; } 594 595 /// isImplicit - Indicates whether the declaration was implicitly 596 /// generated by the implementation. If false, this declaration 597 /// was written explicitly in the source code. 598 bool isImplicit() const { return Implicit; } 599 void setImplicit(bool I = true) { Implicit = I; } 600 601 /// Whether *any* (re-)declaration of the entity was used, meaning that 602 /// a definition is required. 603 /// 604 /// \param CheckUsedAttr When true, also consider the "used" attribute 605 /// (in addition to the "used" bit set by \c setUsed()) when determining 606 /// whether the function is used. 607 bool isUsed(bool CheckUsedAttr = true) const; 608 609 /// Set whether the declaration is used, in the sense of odr-use. 610 /// 611 /// This should only be used immediately after creating a declaration. 612 /// It intentionally doesn't notify any listeners. 613 void setIsUsed() { getCanonicalDecl()->Used = true; } 614 615 /// Mark the declaration used, in the sense of odr-use. 616 /// 617 /// This notifies any mutation listeners in addition to setting a bit 618 /// indicating the declaration is used. 619 void markUsed(ASTContext &C); 620 621 /// Whether any declaration of this entity was referenced. 622 bool isReferenced() const; 623 624 /// Whether this declaration was referenced. This should not be relied 625 /// upon for anything other than debugging. 626 bool isThisDeclarationReferenced() const { return Referenced; } 627 628 void setReferenced(bool R = true) { Referenced = R; } 629 630 /// Whether this declaration is a top-level declaration (function, 631 /// global variable, etc.) that is lexically inside an objc container 632 /// definition. 633 bool isTopLevelDeclInObjCContainer() const { 634 return TopLevelDeclInObjCContainer; 635 } 636 637 void setTopLevelDeclInObjCContainer(bool V = true) { 638 TopLevelDeclInObjCContainer = V; 639 } 640 641 /// Looks on this and related declarations for an applicable 642 /// external source symbol attribute. 643 ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const; 644 645 /// Whether this declaration was marked as being private to the 646 /// module in which it was defined. 647 bool isModulePrivate() const { 648 return getModuleOwnershipKind() == ModuleOwnershipKind::ModulePrivate; 649 } 650 651 /// Whether this declaration was exported in a lexical context. 652 /// e.g.: 653 /// 654 /// export namespace A { 655 /// void f1(); // isInExportDeclContext() == true 656 /// } 657 /// void A::f1(); // isInExportDeclContext() == false 658 /// 659 /// namespace B { 660 /// void f2(); // isInExportDeclContext() == false 661 /// } 662 /// export void B::f2(); // isInExportDeclContext() == true 663 bool isInExportDeclContext() const; 664 665 bool isInvisibleOutsideTheOwningModule() const { 666 return getModuleOwnershipKind() > ModuleOwnershipKind::VisibleWhenImported; 667 } 668 669 /// Whether this declaration comes from another module unit. 670 bool isInAnotherModuleUnit() const; 671 672 /// FIXME: Implement discarding declarations actually in global module 673 /// fragment. See [module.global.frag]p3,4 for details. 674 bool isDiscardedInGlobalModuleFragment() const { return false; } 675 676 /// Check if we should skip checking ODRHash for declaration \param D. 677 /// 678 /// The existing ODRHash mechanism seems to be not stable enough and 679 /// the false positive ODR violation reports are annoying and we rarely see 680 /// true ODR violation reports. Also we learned that MSVC disabled ODR checks 681 /// for declarations in GMF. So we try to disable ODR checks in the GMF to 682 /// get better user experiences before we make the ODR violation checks stable 683 /// enough. 684 bool shouldSkipCheckingODR() const; 685 686 /// Return true if this declaration has an attribute which acts as 687 /// definition of the entity, such as 'alias' or 'ifunc'. 688 bool hasDefiningAttr() const; 689 690 /// Return this declaration's defining attribute if it has one. 691 const Attr *getDefiningAttr() const; 692 693protected: 694 /// Specify that this declaration was marked as being private 695 /// to the module in which it was defined. 696 void setModulePrivate() { 697 // The module-private specifier has no effect on unowned declarations. 698 // FIXME: We should track this in some way for source fidelity. 699 if (getModuleOwnershipKind() == ModuleOwnershipKind::Unowned) 700 return; 701 setModuleOwnershipKind(ModuleOwnershipKind::ModulePrivate); 702 } 703 704public: 705 /// Set the FromASTFile flag. This indicates that this declaration 706 /// was deserialized and not parsed from source code and enables 707 /// features such as module ownership information. 708 void setFromASTFile() { 709 FromASTFile = true; 710 } 711 712 /// Set the owning module ID. This may only be called for 713 /// deserialized Decls. 714 void setOwningModuleID(unsigned ID) { 715 assert(isFromASTFile() && "Only works on a deserialized declaration"); 716 *((unsigned*)this - 2) = ID; 717 } 718 719public: 720 /// Determine the availability of the given declaration. 721 /// 722 /// This routine will determine the most restrictive availability of 723 /// the given declaration (e.g., preferring 'unavailable' to 724 /// 'deprecated'). 725 /// 726 /// \param Message If non-NULL and the result is not \c 727 /// AR_Available, will be set to a (possibly empty) message 728 /// describing why the declaration has not been introduced, is 729 /// deprecated, or is unavailable. 730 /// 731 /// \param EnclosingVersion The version to compare with. If empty, assume the 732 /// deployment target version. 733 /// 734 /// \param RealizedPlatform If non-NULL and the availability result is found 735 /// in an available attribute it will set to the platform which is written in 736 /// the available attribute. 737 AvailabilityResult 738 getAvailability(std::string *Message = nullptr, 739 VersionTuple EnclosingVersion = VersionTuple(), 740 StringRef *RealizedPlatform = nullptr) const; 741 742 /// Retrieve the version of the target platform in which this 743 /// declaration was introduced. 744 /// 745 /// \returns An empty version tuple if this declaration has no 'introduced' 746 /// availability attributes, or the version tuple that's specified in the 747 /// attribute otherwise. 748 VersionTuple getVersionIntroduced() const; 749 750 /// Determine whether this declaration is marked 'deprecated'. 751 /// 752 /// \param Message If non-NULL and the declaration is deprecated, 753 /// this will be set to the message describing why the declaration 754 /// was deprecated (which may be empty). 755 bool isDeprecated(std::string *Message = nullptr) const { 756 return getAvailability(Message) == AR_Deprecated; 757 } 758 759 /// Determine whether this declaration is marked 'unavailable'. 760 /// 761 /// \param Message If non-NULL and the declaration is unavailable, 762 /// this will be set to the message describing why the declaration 763 /// was made unavailable (which may be empty). 764 bool isUnavailable(std::string *Message = nullptr) const { 765 return getAvailability(Message) == AR_Unavailable; 766 } 767 768 /// Determine whether this is a weak-imported symbol. 769 /// 770 /// Weak-imported symbols are typically marked with the 771 /// 'weak_import' attribute, but may also be marked with an 772 /// 'availability' attribute where we're targing a platform prior to 773 /// the introduction of this feature. 774 bool isWeakImported() const; 775 776 /// Determines whether this symbol can be weak-imported, 777 /// e.g., whether it would be well-formed to add the weak_import 778 /// attribute. 779 /// 780 /// \param IsDefinition Set to \c true to indicate that this 781 /// declaration cannot be weak-imported because it has a definition. 782 bool canBeWeakImported(bool &IsDefinition) const; 783 784 /// Determine whether this declaration came from an AST file (such as 785 /// a precompiled header or module) rather than having been parsed. 786 bool isFromASTFile() const { return FromASTFile; } 787 788 /// Retrieve the global declaration ID associated with this 789 /// declaration, which specifies where this Decl was loaded from. 790 unsigned getGlobalID() const { 791 if (isFromASTFile()) 792 return *((const unsigned*)this - 1); 793 return 0; 794 } 795 796 /// Retrieve the global ID of the module that owns this particular 797 /// declaration. 798 unsigned getOwningModuleID() const { 799 if (isFromASTFile()) 800 return *((const unsigned*)this - 2); 801 return 0; 802 } 803 804private: 805 Module *getOwningModuleSlow() const; 806 807protected: 808 bool hasLocalOwningModuleStorage() const; 809 810public: 811 /// Get the imported owning module, if this decl is from an imported 812 /// (non-local) module. 813 Module *getImportedOwningModule() const { 814 if (!isFromASTFile() || !hasOwningModule()) 815 return nullptr; 816 817 return getOwningModuleSlow(); 818 } 819 820 /// Get the local owning module, if known. Returns nullptr if owner is 821 /// not yet known or declaration is not from a module. 822 Module *getLocalOwningModule() const { 823 if (isFromASTFile() || !hasOwningModule()) 824 return nullptr; 825 826 assert(hasLocalOwningModuleStorage() && 827 "owned local decl but no local module storage"); 828 return reinterpret_cast<Module *const *>(this)[-1]; 829 } 830 void setLocalOwningModule(Module *M) { 831 assert(!isFromASTFile() && hasOwningModule() && 832 hasLocalOwningModuleStorage() && 833 "should not have a cached owning module"); 834 reinterpret_cast<Module **>(this)[-1] = M; 835 } 836 837 /// Is this declaration owned by some module? 838 bool hasOwningModule() const { 839 return getModuleOwnershipKind() != ModuleOwnershipKind::Unowned; 840 } 841 842 /// Get the module that owns this declaration (for visibility purposes). 843 Module *getOwningModule() const { 844 return isFromASTFile() ? getImportedOwningModule() : getLocalOwningModule(); 845 } 846 847 /// Get the module that owns this declaration for linkage purposes. 848 /// There only ever is such a standard C++ module. 849 /// 850 /// \param IgnoreLinkage Ignore the linkage of the entity; assume that 851 /// all declarations in a global module fragment are unowned. 852 Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const; 853 854 /// Determine whether this declaration is definitely visible to name lookup, 855 /// independent of whether the owning module is visible. 856 /// Note: The declaration may be visible even if this returns \c false if the 857 /// owning module is visible within the query context. This is a low-level 858 /// helper function; most code should be calling Sema::isVisible() instead. 859 bool isUnconditionallyVisible() const { 860 return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible; 861 } 862 863 bool isReachable() const { 864 return (int)getModuleOwnershipKind() <= 865 (int)ModuleOwnershipKind::ReachableWhenImported; 866 } 867 868 /// Set that this declaration is globally visible, even if it came from a 869 /// module that is not visible. 870 void setVisibleDespiteOwningModule() { 871 if (!isUnconditionallyVisible()) 872 setModuleOwnershipKind(ModuleOwnershipKind::Visible); 873 } 874 875 /// Get the kind of module ownership for this declaration. 876 ModuleOwnershipKind getModuleOwnershipKind() const { 877 return NextInContextAndBits.getInt(); 878 } 879 880 /// Set whether this declaration is hidden from name lookup. 881 void setModuleOwnershipKind(ModuleOwnershipKind MOK) { 882 assert(!(getModuleOwnershipKind() == ModuleOwnershipKind::Unowned && 883 MOK != ModuleOwnershipKind::Unowned && !isFromASTFile() && 884 !hasLocalOwningModuleStorage()) && 885 "no storage available for owning module for this declaration"); 886 NextInContextAndBits.setInt(MOK); 887 } 888 889 unsigned getIdentifierNamespace() const { 890 return IdentifierNamespace; 891 } 892 893 bool isInIdentifierNamespace(unsigned NS) const { 894 return getIdentifierNamespace() & NS; 895 } 896 897 static unsigned getIdentifierNamespaceForKind(Kind DK); 898 899 bool hasTagIdentifierNamespace() const { 900 return isTagIdentifierNamespace(getIdentifierNamespace()); 901 } 902 903 static bool isTagIdentifierNamespace(unsigned NS) { 904 // TagDecls have Tag and Type set and may also have TagFriend. 905 return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type); 906 } 907 908 /// getLexicalDeclContext - The declaration context where this Decl was 909 /// lexically declared (LexicalDC). May be different from 910 /// getDeclContext() (SemanticDC). 911 /// e.g.: 912 /// 913 /// namespace A { 914 /// void f(); // SemanticDC == LexicalDC == 'namespace A' 915 /// } 916 /// void A::f(); // SemanticDC == namespace 'A' 917 /// // LexicalDC == global namespace 918 DeclContext *getLexicalDeclContext() { 919 if (isInSemaDC()) 920 return getSemanticDC(); 921 return getMultipleDC()->LexicalDC; 922 } 923 const DeclContext *getLexicalDeclContext() const { 924 return const_cast<Decl*>(this)->getLexicalDeclContext(); 925 } 926 927 /// Determine whether this declaration is declared out of line (outside its 928 /// semantic context). 929 virtual bool isOutOfLine() const; 930 931 /// setDeclContext - Set both the semantic and lexical DeclContext 932 /// to DC. 933 void setDeclContext(DeclContext *DC); 934 935 void setLexicalDeclContext(DeclContext *DC); 936 937 /// Determine whether this declaration is a templated entity (whether it is 938 // within the scope of a template parameter). 939 bool isTemplated() const; 940 941 /// Determine the number of levels of template parameter surrounding this 942 /// declaration. 943 unsigned getTemplateDepth() const; 944 945 /// isDefinedOutsideFunctionOrMethod - This predicate returns true if this 946 /// scoped decl is defined outside the current function or method. This is 947 /// roughly global variables and functions, but also handles enums (which 948 /// could be defined inside or outside a function etc). 949 bool isDefinedOutsideFunctionOrMethod() const { 950 return getParentFunctionOrMethod() == nullptr; 951 } 952 953 /// Determine whether a substitution into this declaration would occur as 954 /// part of a substitution into a dependent local scope. Such a substitution 955 /// transitively substitutes into all constructs nested within this 956 /// declaration. 957 /// 958 /// This recognizes non-defining declarations as well as members of local 959 /// classes and lambdas: 960 /// \code 961 /// template<typename T> void foo() { void bar(); } 962 /// template<typename T> void foo2() { class ABC { void bar(); }; } 963 /// template<typename T> inline int x = [](){ return 0; }(); 964 /// \endcode 965 bool isInLocalScopeForInstantiation() const; 966 967 /// If this decl is defined inside a function/method/block it returns 968 /// the corresponding DeclContext, otherwise it returns null. 969 const DeclContext * 970 getParentFunctionOrMethod(bool LexicalParent = false) const; 971 DeclContext *getParentFunctionOrMethod(bool LexicalParent = false) { 972 return const_cast<DeclContext *>( 973 const_cast<const Decl *>(this)->getParentFunctionOrMethod( 974 LexicalParent)); 975 } 976 977 /// Retrieves the "canonical" declaration of the given declaration. 978 virtual Decl *getCanonicalDecl() { return this; } 979 const Decl *getCanonicalDecl() const { 980 return const_cast<Decl*>(this)->getCanonicalDecl(); 981 } 982 983 /// Whether this particular Decl is a canonical one. 984 bool isCanonicalDecl() const { return getCanonicalDecl() == this; } 985 986protected: 987 /// Returns the next redeclaration or itself if this is the only decl. 988 /// 989 /// Decl subclasses that can be redeclared should override this method so that 990 /// Decl::redecl_iterator can iterate over them. 991 virtual Decl *getNextRedeclarationImpl() { return this; } 992 993 /// Implementation of getPreviousDecl(), to be overridden by any 994 /// subclass that has a redeclaration chain. 995 virtual Decl *getPreviousDeclImpl() { return nullptr; } 996 997 /// Implementation of getMostRecentDecl(), to be overridden by any 998 /// subclass that has a redeclaration chain. 999 virtual Decl *getMostRecentDeclImpl() { return this; } 1000 1001public: 1002 /// Iterates through all the redeclarations of the same decl. 1003 class redecl_iterator { 1004 /// Current - The current declaration. 1005 Decl *Current = nullptr; 1006 Decl *Starter; 1007 1008 public: 1009 using value_type = Decl *; 1010 using reference = const value_type &; 1011 using pointer = const value_type *; 1012 using iterator_category = std::forward_iterator_tag; 1013 using difference_type = std::ptrdiff_t; 1014 1015 redecl_iterator() = default; 1016 explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {} 1017 1018 reference operator*() const { return Current; } 1019 value_type operator->() const { return Current; } 1020 1021 redecl_iterator& operator++() { 1022 assert(Current && "Advancing while iterator has reached end"); 1023 // Get either previous decl or latest decl. 1024 Decl *Next = Current->getNextRedeclarationImpl(); 1025 assert(Next && "Should return next redeclaration or itself, never null!"); 1026 Current = (Next != Starter) ? Next : nullptr; 1027 return *this; 1028 } 1029 1030 redecl_iterator operator++(int) { 1031 redecl_iterator tmp(*this); 1032 ++(*this); 1033 return tmp; 1034 } 1035 1036 friend bool operator==(redecl_iterator x, redecl_iterator y) { 1037 return x.Current == y.Current; 1038 } 1039 1040 friend bool operator!=(redecl_iterator x, redecl_iterator y) { 1041 return x.Current != y.Current; 1042 } 1043 }; 1044 1045 using redecl_range = llvm::iterator_range<redecl_iterator>; 1046 1047 /// Returns an iterator range for all the redeclarations of the same 1048 /// decl. It will iterate at least once (when this decl is the only one). 1049 redecl_range redecls() const { 1050 return redecl_range(redecls_begin(), redecls_end()); 1051 } 1052 1053 redecl_iterator redecls_begin() const { 1054 return redecl_iterator(const_cast<Decl *>(this)); 1055 } 1056 1057 redecl_iterator redecls_end() const { return redecl_iterator(); } 1058 1059 /// Retrieve the previous declaration that declares the same entity 1060 /// as this declaration, or NULL if there is no previous declaration. 1061 Decl *getPreviousDecl() { return getPreviousDeclImpl(); } 1062 1063 /// Retrieve the previous declaration that declares the same entity 1064 /// as this declaration, or NULL if there is no previous declaration. 1065 const Decl *getPreviousDecl() const { 1066 return const_cast<Decl *>(this)->getPreviousDeclImpl(); 1067 } 1068 1069 /// True if this is the first declaration in its redeclaration chain. 1070 bool isFirstDecl() const { 1071 return getPreviousDecl() == nullptr; 1072 } 1073 1074 /// Retrieve the most recent declaration that declares the same entity 1075 /// as this declaration (which may be this declaration). 1076 Decl *getMostRecentDecl() { return getMostRecentDeclImpl(); } 1077 1078 /// Retrieve the most recent declaration that declares the same entity 1079 /// as this declaration (which may be this declaration). 1080 const Decl *getMostRecentDecl() const { 1081 return const_cast<Decl *>(this)->getMostRecentDeclImpl(); 1082 } 1083 1084 /// getBody - If this Decl represents a declaration for a body of code, 1085 /// such as a function or method definition, this method returns the 1086 /// top-level Stmt* of that body. Otherwise this method returns null. 1087 virtual Stmt* getBody() const { return nullptr; } 1088 1089 /// Returns true if this \c Decl represents a declaration for a body of 1090 /// code, such as a function or method definition. 1091 /// Note that \c hasBody can also return true if any redeclaration of this 1092 /// \c Decl represents a declaration for a body of code. 1093 virtual bool hasBody() const { return getBody() != nullptr; } 1094 1095 /// getBodyRBrace - Gets the right brace of the body, if a body exists. 1096 /// This works whether the body is a CompoundStmt or a CXXTryStmt. 1097 SourceLocation getBodyRBrace() const; 1098 1099 // global temp stats (until we have a per-module visitor) 1100 static void add(Kind k); 1101 static void EnableStatistics(); 1102 static void PrintStats(); 1103 1104 /// isTemplateParameter - Determines whether this declaration is a 1105 /// template parameter. 1106 bool isTemplateParameter() const; 1107 1108 /// isTemplateParameter - Determines whether this declaration is a 1109 /// template parameter pack. 1110 bool isTemplateParameterPack() const; 1111 1112 /// Whether this declaration is a parameter pack. 1113 bool isParameterPack() const; 1114 1115 /// returns true if this declaration is a template 1116 bool isTemplateDecl() const; 1117 1118 /// Whether this declaration is a function or function template. 1119 bool isFunctionOrFunctionTemplate() const { 1120 return (DeclKind >= Decl::firstFunction && 1121 DeclKind <= Decl::lastFunction) || 1122 DeclKind == FunctionTemplate; 1123 } 1124 1125 /// If this is a declaration that describes some template, this 1126 /// method returns that template declaration. 1127 /// 1128 /// Note that this returns nullptr for partial specializations, because they 1129 /// are not modeled as TemplateDecls. Use getDescribedTemplateParams to handle 1130 /// those cases. 1131 TemplateDecl *getDescribedTemplate() const; 1132 1133 /// If this is a declaration that describes some template or partial 1134 /// specialization, this returns the corresponding template parameter list. 1135 const TemplateParameterList *getDescribedTemplateParams() const; 1136 1137 /// Returns the function itself, or the templated function if this is a 1138 /// function template. 1139 FunctionDecl *getAsFunction() LLVM_READONLY; 1140 1141 const FunctionDecl *getAsFunction() const { 1142 return const_cast<Decl *>(this)->getAsFunction(); 1143 } 1144 1145 /// Changes the namespace of this declaration to reflect that it's 1146 /// a function-local extern declaration. 1147 /// 1148 /// These declarations appear in the lexical context of the extern 1149 /// declaration, but in the semantic context of the enclosing namespace 1150 /// scope. 1151 void setLocalExternDecl() { 1152 Decl *Prev = getPreviousDecl(); 1153 IdentifierNamespace &= ~IDNS_Ordinary; 1154 1155 // It's OK for the declaration to still have the "invisible friend" flag or 1156 // the "conflicts with tag declarations in this scope" flag for the outer 1157 // scope. 1158 assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 && 1159 "namespace is not ordinary"); 1160 1161 IdentifierNamespace |= IDNS_LocalExtern; 1162 if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary) 1163 IdentifierNamespace |= IDNS_Ordinary; 1164 } 1165 1166 /// Determine whether this is a block-scope declaration with linkage. 1167 /// This will either be a local variable declaration declared 'extern', or a 1168 /// local function declaration. 1169 bool isLocalExternDecl() const { 1170 return IdentifierNamespace & IDNS_LocalExtern; 1171 } 1172 1173 /// Changes the namespace of this declaration to reflect that it's 1174 /// the object of a friend declaration. 1175 /// 1176 /// These declarations appear in the lexical context of the friending 1177 /// class, but in the semantic context of the actual entity. This property 1178 /// applies only to a specific decl object; other redeclarations of the 1179 /// same entity may not (and probably don't) share this property. 1180 void setObjectOfFriendDecl(bool PerformFriendInjection = false) { 1181 unsigned OldNS = IdentifierNamespace; 1182 assert((OldNS & (IDNS_Tag | IDNS_Ordinary | 1183 IDNS_TagFriend | IDNS_OrdinaryFriend | 1184 IDNS_LocalExtern | IDNS_NonMemberOperator)) && 1185 "namespace includes neither ordinary nor tag"); 1186 assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type | 1187 IDNS_TagFriend | IDNS_OrdinaryFriend | 1188 IDNS_LocalExtern | IDNS_NonMemberOperator)) && 1189 "namespace includes other than ordinary or tag"); 1190 1191 Decl *Prev = getPreviousDecl(); 1192 IdentifierNamespace &= ~(IDNS_Ordinary | IDNS_Tag | IDNS_Type); 1193 1194 if (OldNS & (IDNS_Tag | IDNS_TagFriend)) { 1195 IdentifierNamespace |= IDNS_TagFriend; 1196 if (PerformFriendInjection || 1197 (Prev && Prev->getIdentifierNamespace() & IDNS_Tag)) 1198 IdentifierNamespace |= IDNS_Tag | IDNS_Type; 1199 } 1200 1201 if (OldNS & (IDNS_Ordinary | IDNS_OrdinaryFriend | 1202 IDNS_LocalExtern | IDNS_NonMemberOperator)) { 1203 IdentifierNamespace |= IDNS_OrdinaryFriend; 1204 if (PerformFriendInjection || 1205 (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)) 1206 IdentifierNamespace |= IDNS_Ordinary; 1207 } 1208 } 1209 1210 /// Clears the namespace of this declaration. 1211 /// 1212 /// This is useful if we want this declaration to be available for 1213 /// redeclaration lookup but otherwise hidden for ordinary name lookups. 1214 void clearIdentifierNamespace() { IdentifierNamespace = 0; } 1215 1216 enum FriendObjectKind { 1217 FOK_None, ///< Not a friend object. 1218 FOK_Declared, ///< A friend of a previously-declared entity. 1219 FOK_Undeclared ///< A friend of a previously-undeclared entity. 1220 }; 1221 1222 /// Determines whether this declaration is the object of a 1223 /// friend declaration and, if so, what kind. 1224 /// 1225 /// There is currently no direct way to find the associated FriendDecl. 1226 FriendObjectKind getFriendObjectKind() const { 1227 unsigned mask = 1228 (IdentifierNamespace & (IDNS_TagFriend | IDNS_OrdinaryFriend)); 1229 if (!mask) return FOK_None; 1230 return (IdentifierNamespace & (IDNS_Tag | IDNS_Ordinary) ? FOK_Declared 1231 : FOK_Undeclared); 1232 } 1233 1234 /// Specifies that this declaration is a C++ overloaded non-member. 1235 void setNonMemberOperator() { 1236 assert(getKind() == Function || getKind() == FunctionTemplate); 1237 assert((IdentifierNamespace & IDNS_Ordinary) && 1238 "visible non-member operators should be in ordinary namespace"); 1239 IdentifierNamespace |= IDNS_NonMemberOperator; 1240 } 1241 1242 static bool classofKind(Kind K) { return true; } 1243 static DeclContext *castToDeclContext(const Decl *); 1244 static Decl *castFromDeclContext(const DeclContext *); 1245 1246 void print(raw_ostream &Out, unsigned Indentation = 0, 1247 bool PrintInstantiation = false) const; 1248 void print(raw_ostream &Out, const PrintingPolicy &Policy, 1249 unsigned Indentation = 0, bool PrintInstantiation = false) const; 1250 static void printGroup(Decl** Begin, unsigned NumDecls, 1251 raw_ostream &Out, const PrintingPolicy &Policy, 1252 unsigned Indentation = 0); 1253 1254 // Debuggers don't usually respect default arguments. 1255 void dump() const; 1256 1257 // Same as dump(), but forces color printing. 1258 void dumpColor() const; 1259 1260 void dump(raw_ostream &Out, bool Deserialize = false, 1261 ASTDumpOutputFormat OutputFormat = ADOF_Default) const; 1262 1263 /// \return Unique reproducible object identifier 1264 int64_t getID() const; 1265 1266 /// Looks through the Decl's underlying type to extract a FunctionType 1267 /// when possible. Will return null if the type underlying the Decl does not 1268 /// have a FunctionType. 1269 const FunctionType *getFunctionType(bool BlocksToo = true) const; 1270 1271 // Looks through the Decl's underlying type to determine if it's a 1272 // function pointer type. 1273 bool isFunctionPointerType() const; 1274 1275private: 1276 void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx); 1277 void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, 1278 ASTContext &Ctx); 1279 1280protected: 1281 ASTMutationListener *getASTMutationListener() const; 1282}; 1283 1284/// Determine whether two declarations declare the same entity. 1285inline bool declaresSameEntity(const Decl *D1, const Decl *D2) { 1286 if (!D1 || !D2) 1287 return false; 1288 1289 if (D1 == D2) 1290 return true; 1291 1292 return D1->getCanonicalDecl() == D2->getCanonicalDecl(); 1293} 1294 1295/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when 1296/// doing something to a specific decl. 1297class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry { 1298 const Decl *TheDecl; 1299 SourceLocation Loc; 1300 SourceManager &SM; 1301 const char *Message; 1302 1303public: 1304 PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L, 1305 SourceManager &sm, const char *Msg) 1306 : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {} 1307 1308 void print(raw_ostream &OS) const override; 1309}; 1310} // namespace clang 1311 1312// Required to determine the layout of the PointerUnion<NamedDecl*> before 1313// seeing the NamedDecl definition being first used in DeclListNode::operator*. 1314namespace llvm { 1315 template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> { 1316 static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; } 1317 static inline ::clang::NamedDecl *getFromVoidPointer(void *P) { 1318 return static_cast<::clang::NamedDecl *>(P); 1319 } 1320 static constexpr int NumLowBitsAvailable = 3; 1321 }; 1322} 1323 1324namespace clang { 1325/// A list storing NamedDecls in the lookup tables. 1326class DeclListNode { 1327 friend class ASTContext; // allocate, deallocate nodes. 1328 friend class StoredDeclsList; 1329public: 1330 using Decls = llvm::PointerUnion<NamedDecl*, DeclListNode*>; 1331 class iterator { 1332 friend class DeclContextLookupResult; 1333 friend class StoredDeclsList; 1334 1335 Decls Ptr; 1336 iterator(Decls Node) : Ptr(Node) { } 1337 public: 1338 using difference_type = ptrdiff_t; 1339 using value_type = NamedDecl*; 1340 using pointer = void; 1341 using reference = value_type; 1342 using iterator_category = std::forward_iterator_tag; 1343 1344 iterator() = default; 1345 1346 reference operator*() const { 1347 assert(Ptr && "dereferencing end() iterator"); 1348 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>()) 1349 return CurNode->D; 1350 return Ptr.get<NamedDecl*>(); 1351 } 1352 void operator->() const { } // Unsupported. 1353 bool operator==(const iterator &X) const { return Ptr == X.Ptr; } 1354 bool operator!=(const iterator &X) const { return Ptr != X.Ptr; } 1355 inline iterator &operator++() { // ++It 1356 assert(!Ptr.isNull() && "Advancing empty iterator"); 1357 1358 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>()) 1359 Ptr = CurNode->Rest; 1360 else 1361 Ptr = nullptr; 1362 return *this; 1363 } 1364 iterator operator++(int) { // It++ 1365 iterator temp = *this; 1366 ++(*this); 1367 return temp; 1368 } 1369 // Enables the pattern for (iterator I =..., E = I.end(); I != E; ++I) 1370 iterator end() { return iterator(); } 1371 }; 1372private: 1373 NamedDecl *D = nullptr; 1374 Decls Rest = nullptr; 1375 DeclListNode(NamedDecl *ND) : D(ND) {} 1376}; 1377 1378/// The results of name lookup within a DeclContext. 1379class DeclContextLookupResult { 1380 using Decls = DeclListNode::Decls; 1381 1382 /// When in collection form, this is what the Data pointer points to. 1383 Decls Result; 1384 1385public: 1386 DeclContextLookupResult() = default; 1387 DeclContextLookupResult(Decls Result) : Result(Result) {} 1388 1389 using iterator = DeclListNode::iterator; 1390 using const_iterator = iterator; 1391 using reference = iterator::reference; 1392 1393 iterator begin() { return iterator(Result); } 1394 iterator end() { return iterator(); } 1395 const_iterator begin() const { 1396 return const_cast<DeclContextLookupResult*>(this)->begin(); 1397 } 1398 const_iterator end() const { return iterator(); } 1399 1400 bool empty() const { return Result.isNull(); } 1401 bool isSingleResult() const { return Result.dyn_cast<NamedDecl*>(); } 1402 reference front() const { return *begin(); } 1403 1404 // Find the first declaration of the given type in the list. Note that this 1405 // is not in general the earliest-declared declaration, and should only be 1406 // used when it's not possible for there to be more than one match or where 1407 // it doesn't matter which one is found. 1408 template<class T> T *find_first() const { 1409 for (auto *D : *this) 1410 if (T *Decl = dyn_cast<T>(D)) 1411 return Decl; 1412 1413 return nullptr; 1414 } 1415}; 1416 1417/// Only used by CXXDeductionGuideDecl. 1418enum class DeductionCandidate : unsigned char { 1419 Normal, 1420 Copy, 1421 Aggregate, 1422}; 1423 1424enum class RecordArgPassingKind; 1425enum class OMPDeclareReductionInitKind; 1426enum class ObjCImplementationControl; 1427enum class LinkageSpecLanguageIDs; 1428 1429/// DeclContext - This is used only as base class of specific decl types that 1430/// can act as declaration contexts. These decls are (only the top classes 1431/// that directly derive from DeclContext are mentioned, not their subclasses): 1432/// 1433/// TranslationUnitDecl 1434/// ExternCContext 1435/// NamespaceDecl 1436/// TagDecl 1437/// OMPDeclareReductionDecl 1438/// OMPDeclareMapperDecl 1439/// FunctionDecl 1440/// ObjCMethodDecl 1441/// ObjCContainerDecl 1442/// LinkageSpecDecl 1443/// ExportDecl 1444/// BlockDecl 1445/// CapturedDecl 1446class DeclContext { 1447 /// For makeDeclVisibleInContextImpl 1448 friend class ASTDeclReader; 1449 /// For checking the new bits in the Serialization part. 1450 friend class ASTDeclWriter; 1451 /// For reconcileExternalVisibleStorage, CreateStoredDeclsMap, 1452 /// hasNeedToReconcileExternalVisibleStorage 1453 friend class ExternalASTSource; 1454 /// For CreateStoredDeclsMap 1455 friend class DependentDiagnostic; 1456 /// For hasNeedToReconcileExternalVisibleStorage, 1457 /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups 1458 friend class ASTWriter; 1459 1460 // We use uint64_t in the bit-fields below since some bit-fields 1461 // cross the unsigned boundary and this breaks the packing. 1462 1463 /// Stores the bits used by DeclContext. 1464 /// If modified NumDeclContextBit, the ctor of DeclContext and the accessor 1465 /// methods in DeclContext should be updated appropriately. 1466 class DeclContextBitfields { 1467 friend class DeclContext; 1468 /// DeclKind - This indicates which class this is. 1469 LLVM_PREFERRED_TYPE(Decl::Kind) 1470 uint64_t DeclKind : 7; 1471 1472 /// Whether this declaration context also has some external 1473 /// storage that contains additional declarations that are lexically 1474 /// part of this context. 1475 LLVM_PREFERRED_TYPE(bool) 1476 mutable uint64_t ExternalLexicalStorage : 1; 1477 1478 /// Whether this declaration context also has some external 1479 /// storage that contains additional declarations that are visible 1480 /// in this context. 1481 LLVM_PREFERRED_TYPE(bool) 1482 mutable uint64_t ExternalVisibleStorage : 1; 1483 1484 /// Whether this declaration context has had externally visible 1485 /// storage added since the last lookup. In this case, \c LookupPtr's 1486 /// invariant may not hold and needs to be fixed before we perform 1487 /// another lookup. 1488 LLVM_PREFERRED_TYPE(bool) 1489 mutable uint64_t NeedToReconcileExternalVisibleStorage : 1; 1490 1491 /// If \c true, this context may have local lexical declarations 1492 /// that are missing from the lookup table. 1493 LLVM_PREFERRED_TYPE(bool) 1494 mutable uint64_t HasLazyLocalLexicalLookups : 1; 1495 1496 /// If \c true, the external source may have lexical declarations 1497 /// that are missing from the lookup table. 1498 LLVM_PREFERRED_TYPE(bool) 1499 mutable uint64_t HasLazyExternalLexicalLookups : 1; 1500 1501 /// If \c true, lookups should only return identifier from 1502 /// DeclContext scope (for example TranslationUnit). Used in 1503 /// LookupQualifiedName() 1504 LLVM_PREFERRED_TYPE(bool) 1505 mutable uint64_t UseQualifiedLookup : 1; 1506 }; 1507 1508 /// Number of bits in DeclContextBitfields. 1509 enum { NumDeclContextBits = 13 }; 1510 1511 /// Stores the bits used by TagDecl. 1512 /// If modified NumTagDeclBits and the accessor 1513 /// methods in TagDecl should be updated appropriately. 1514 class TagDeclBitfields { 1515 friend class TagDecl; 1516 /// For the bits in DeclContextBitfields 1517 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1518 uint64_t : NumDeclContextBits; 1519 1520 /// The TagKind enum. 1521 LLVM_PREFERRED_TYPE(TagTypeKind) 1522 uint64_t TagDeclKind : 3; 1523 1524 /// True if this is a definition ("struct foo {};"), false if it is a 1525 /// declaration ("struct foo;"). It is not considered a definition 1526 /// until the definition has been fully processed. 1527 LLVM_PREFERRED_TYPE(bool) 1528 uint64_t IsCompleteDefinition : 1; 1529 1530 /// True if this is currently being defined. 1531 LLVM_PREFERRED_TYPE(bool) 1532 uint64_t IsBeingDefined : 1; 1533 1534 /// True if this tag declaration is "embedded" (i.e., defined or declared 1535 /// for the very first time) in the syntax of a declarator. 1536 LLVM_PREFERRED_TYPE(bool) 1537 uint64_t IsEmbeddedInDeclarator : 1; 1538 1539 /// True if this tag is free standing, e.g. "struct foo;". 1540 LLVM_PREFERRED_TYPE(bool) 1541 uint64_t IsFreeStanding : 1; 1542 1543 /// Indicates whether it is possible for declarations of this kind 1544 /// to have an out-of-date definition. 1545 /// 1546 /// This option is only enabled when modules are enabled. 1547 LLVM_PREFERRED_TYPE(bool) 1548 uint64_t MayHaveOutOfDateDef : 1; 1549 1550 /// Has the full definition of this type been required by a use somewhere in 1551 /// the TU. 1552 LLVM_PREFERRED_TYPE(bool) 1553 uint64_t IsCompleteDefinitionRequired : 1; 1554 1555 /// Whether this tag is a definition which was demoted due to 1556 /// a module merge. 1557 LLVM_PREFERRED_TYPE(bool) 1558 uint64_t IsThisDeclarationADemotedDefinition : 1; 1559 }; 1560 1561 /// Number of inherited and non-inherited bits in TagDeclBitfields. 1562 enum { NumTagDeclBits = NumDeclContextBits + 10 }; 1563 1564 /// Stores the bits used by EnumDecl. 1565 /// If modified NumEnumDeclBit and the accessor 1566 /// methods in EnumDecl should be updated appropriately. 1567 class EnumDeclBitfields { 1568 friend class EnumDecl; 1569 /// For the bits in TagDeclBitfields. 1570 LLVM_PREFERRED_TYPE(TagDeclBitfields) 1571 uint64_t : NumTagDeclBits; 1572 1573 /// Width in bits required to store all the non-negative 1574 /// enumerators of this enum. 1575 uint64_t NumPositiveBits : 8; 1576 1577 /// Width in bits required to store all the negative 1578 /// enumerators of this enum. 1579 uint64_t NumNegativeBits : 8; 1580 1581 /// True if this tag declaration is a scoped enumeration. Only 1582 /// possible in C++11 mode. 1583 LLVM_PREFERRED_TYPE(bool) 1584 uint64_t IsScoped : 1; 1585 1586 /// If this tag declaration is a scoped enum, 1587 /// then this is true if the scoped enum was declared using the class 1588 /// tag, false if it was declared with the struct tag. No meaning is 1589 /// associated if this tag declaration is not a scoped enum. 1590 LLVM_PREFERRED_TYPE(bool) 1591 uint64_t IsScopedUsingClassTag : 1; 1592 1593 /// True if this is an enumeration with fixed underlying type. Only 1594 /// possible in C++11, Microsoft extensions, or Objective C mode. 1595 LLVM_PREFERRED_TYPE(bool) 1596 uint64_t IsFixed : 1; 1597 1598 /// True if a valid hash is stored in ODRHash. 1599 LLVM_PREFERRED_TYPE(bool) 1600 uint64_t HasODRHash : 1; 1601 }; 1602 1603 /// Number of inherited and non-inherited bits in EnumDeclBitfields. 1604 enum { NumEnumDeclBits = NumTagDeclBits + 20 }; 1605 1606 /// Stores the bits used by RecordDecl. 1607 /// If modified NumRecordDeclBits and the accessor 1608 /// methods in RecordDecl should be updated appropriately. 1609 class RecordDeclBitfields { 1610 friend class RecordDecl; 1611 /// For the bits in TagDeclBitfields. 1612 LLVM_PREFERRED_TYPE(TagDeclBitfields) 1613 uint64_t : NumTagDeclBits; 1614 1615 /// This is true if this struct ends with a flexible 1616 /// array member (e.g. int X[]) or if this union contains a struct that does. 1617 /// If so, this cannot be contained in arrays or other structs as a member. 1618 LLVM_PREFERRED_TYPE(bool) 1619 uint64_t HasFlexibleArrayMember : 1; 1620 1621 /// Whether this is the type of an anonymous struct or union. 1622 LLVM_PREFERRED_TYPE(bool) 1623 uint64_t AnonymousStructOrUnion : 1; 1624 1625 /// This is true if this struct has at least one member 1626 /// containing an Objective-C object pointer type. 1627 LLVM_PREFERRED_TYPE(bool) 1628 uint64_t HasObjectMember : 1; 1629 1630 /// This is true if struct has at least one member of 1631 /// 'volatile' type. 1632 LLVM_PREFERRED_TYPE(bool) 1633 uint64_t HasVolatileMember : 1; 1634 1635 /// Whether the field declarations of this record have been loaded 1636 /// from external storage. To avoid unnecessary deserialization of 1637 /// methods/nested types we allow deserialization of just the fields 1638 /// when needed. 1639 LLVM_PREFERRED_TYPE(bool) 1640 mutable uint64_t LoadedFieldsFromExternalStorage : 1; 1641 1642 /// Basic properties of non-trivial C structs. 1643 LLVM_PREFERRED_TYPE(bool) 1644 uint64_t NonTrivialToPrimitiveDefaultInitialize : 1; 1645 LLVM_PREFERRED_TYPE(bool) 1646 uint64_t NonTrivialToPrimitiveCopy : 1; 1647 LLVM_PREFERRED_TYPE(bool) 1648 uint64_t NonTrivialToPrimitiveDestroy : 1; 1649 1650 /// The following bits indicate whether this is or contains a C union that 1651 /// is non-trivial to default-initialize, destruct, or copy. These bits 1652 /// imply the associated basic non-triviality predicates declared above. 1653 LLVM_PREFERRED_TYPE(bool) 1654 uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1; 1655 LLVM_PREFERRED_TYPE(bool) 1656 uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1; 1657 LLVM_PREFERRED_TYPE(bool) 1658 uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1; 1659 1660 /// Indicates whether this struct is destroyed in the callee. 1661 LLVM_PREFERRED_TYPE(bool) 1662 uint64_t ParamDestroyedInCallee : 1; 1663 1664 /// Represents the way this type is passed to a function. 1665 LLVM_PREFERRED_TYPE(RecordArgPassingKind) 1666 uint64_t ArgPassingRestrictions : 2; 1667 1668 /// Indicates whether this struct has had its field layout randomized. 1669 LLVM_PREFERRED_TYPE(bool) 1670 uint64_t IsRandomized : 1; 1671 1672 /// True if a valid hash is stored in ODRHash. This should shave off some 1673 /// extra storage and prevent CXXRecordDecl to store unused bits. 1674 uint64_t ODRHash : 26; 1675 }; 1676 1677 /// Number of inherited and non-inherited bits in RecordDeclBitfields. 1678 enum { NumRecordDeclBits = NumTagDeclBits + 41 }; 1679 1680 /// Stores the bits used by OMPDeclareReductionDecl. 1681 /// If modified NumOMPDeclareReductionDeclBits and the accessor 1682 /// methods in OMPDeclareReductionDecl should be updated appropriately. 1683 class OMPDeclareReductionDeclBitfields { 1684 friend class OMPDeclareReductionDecl; 1685 /// For the bits in DeclContextBitfields 1686 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1687 uint64_t : NumDeclContextBits; 1688 1689 /// Kind of initializer, 1690 /// function call or omp_priv<init_expr> initialization. 1691 LLVM_PREFERRED_TYPE(OMPDeclareReductionInitKind) 1692 uint64_t InitializerKind : 2; 1693 }; 1694 1695 /// Number of inherited and non-inherited bits in 1696 /// OMPDeclareReductionDeclBitfields. 1697 enum { NumOMPDeclareReductionDeclBits = NumDeclContextBits + 2 }; 1698 1699 /// Stores the bits used by FunctionDecl. 1700 /// If modified NumFunctionDeclBits and the accessor 1701 /// methods in FunctionDecl and CXXDeductionGuideDecl 1702 /// (for DeductionCandidateKind) should be updated appropriately. 1703 class FunctionDeclBitfields { 1704 friend class FunctionDecl; 1705 /// For DeductionCandidateKind 1706 friend class CXXDeductionGuideDecl; 1707 /// For the bits in DeclContextBitfields. 1708 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1709 uint64_t : NumDeclContextBits; 1710 1711 LLVM_PREFERRED_TYPE(StorageClass) 1712 uint64_t SClass : 3; 1713 LLVM_PREFERRED_TYPE(bool) 1714 uint64_t IsInline : 1; 1715 LLVM_PREFERRED_TYPE(bool) 1716 uint64_t IsInlineSpecified : 1; 1717 1718 LLVM_PREFERRED_TYPE(bool) 1719 uint64_t IsVirtualAsWritten : 1; 1720 LLVM_PREFERRED_TYPE(bool) 1721 uint64_t IsPureVirtual : 1; 1722 LLVM_PREFERRED_TYPE(bool) 1723 uint64_t HasInheritedPrototype : 1; 1724 LLVM_PREFERRED_TYPE(bool) 1725 uint64_t HasWrittenPrototype : 1; 1726 LLVM_PREFERRED_TYPE(bool) 1727 uint64_t IsDeleted : 1; 1728 /// Used by CXXMethodDecl 1729 LLVM_PREFERRED_TYPE(bool) 1730 uint64_t IsTrivial : 1; 1731 1732 /// This flag indicates whether this function is trivial for the purpose of 1733 /// calls. This is meaningful only when this function is a copy/move 1734 /// constructor or a destructor. 1735 LLVM_PREFERRED_TYPE(bool) 1736 uint64_t IsTrivialForCall : 1; 1737 1738 LLVM_PREFERRED_TYPE(bool) 1739 uint64_t IsDefaulted : 1; 1740 LLVM_PREFERRED_TYPE(bool) 1741 uint64_t IsExplicitlyDefaulted : 1; 1742 LLVM_PREFERRED_TYPE(bool) 1743 uint64_t HasDefaultedFunctionInfo : 1; 1744 1745 /// For member functions of complete types, whether this is an ineligible 1746 /// special member function or an unselected destructor. See 1747 /// [class.mem.special]. 1748 LLVM_PREFERRED_TYPE(bool) 1749 uint64_t IsIneligibleOrNotSelected : 1; 1750 1751 LLVM_PREFERRED_TYPE(bool) 1752 uint64_t HasImplicitReturnZero : 1; 1753 LLVM_PREFERRED_TYPE(bool) 1754 uint64_t IsLateTemplateParsed : 1; 1755 1756 /// Kind of contexpr specifier as defined by ConstexprSpecKind. 1757 LLVM_PREFERRED_TYPE(ConstexprSpecKind) 1758 uint64_t ConstexprKind : 2; 1759 LLVM_PREFERRED_TYPE(bool) 1760 uint64_t BodyContainsImmediateEscalatingExpression : 1; 1761 1762 LLVM_PREFERRED_TYPE(bool) 1763 uint64_t InstantiationIsPending : 1; 1764 1765 /// Indicates if the function uses __try. 1766 LLVM_PREFERRED_TYPE(bool) 1767 uint64_t UsesSEHTry : 1; 1768 1769 /// Indicates if the function was a definition 1770 /// but its body was skipped. 1771 LLVM_PREFERRED_TYPE(bool) 1772 uint64_t HasSkippedBody : 1; 1773 1774 /// Indicates if the function declaration will 1775 /// have a body, once we're done parsing it. 1776 LLVM_PREFERRED_TYPE(bool) 1777 uint64_t WillHaveBody : 1; 1778 1779 /// Indicates that this function is a multiversioned 1780 /// function using attribute 'target'. 1781 LLVM_PREFERRED_TYPE(bool) 1782 uint64_t IsMultiVersion : 1; 1783 1784 /// Only used by CXXDeductionGuideDecl. Indicates the kind 1785 /// of the Deduction Guide that is implicitly generated 1786 /// (used during overload resolution). 1787 LLVM_PREFERRED_TYPE(DeductionCandidate) 1788 uint64_t DeductionCandidateKind : 2; 1789 1790 /// Store the ODRHash after first calculation. 1791 LLVM_PREFERRED_TYPE(bool) 1792 uint64_t HasODRHash : 1; 1793 1794 /// Indicates if the function uses Floating Point Constrained Intrinsics 1795 LLVM_PREFERRED_TYPE(bool) 1796 uint64_t UsesFPIntrin : 1; 1797 1798 // Indicates this function is a constrained friend, where the constraint 1799 // refers to an enclosing template for hte purposes of [temp.friend]p9. 1800 LLVM_PREFERRED_TYPE(bool) 1801 uint64_t FriendConstraintRefersToEnclosingTemplate : 1; 1802 }; 1803 1804 /// Number of inherited and non-inherited bits in FunctionDeclBitfields. 1805 enum { NumFunctionDeclBits = NumDeclContextBits + 31 }; 1806 1807 /// Stores the bits used by CXXConstructorDecl. If modified 1808 /// NumCXXConstructorDeclBits and the accessor 1809 /// methods in CXXConstructorDecl should be updated appropriately. 1810 class CXXConstructorDeclBitfields { 1811 friend class CXXConstructorDecl; 1812 /// For the bits in FunctionDeclBitfields. 1813 LLVM_PREFERRED_TYPE(FunctionDeclBitfields) 1814 uint64_t : NumFunctionDeclBits; 1815 1816 /// 20 bits to fit in the remaining available space. 1817 /// Note that this makes CXXConstructorDeclBitfields take 1818 /// exactly 64 bits and thus the width of NumCtorInitializers 1819 /// will need to be shrunk if some bit is added to NumDeclContextBitfields, 1820 /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields. 1821 uint64_t NumCtorInitializers : 17; 1822 LLVM_PREFERRED_TYPE(bool) 1823 uint64_t IsInheritingConstructor : 1; 1824 1825 /// Whether this constructor has a trail-allocated explicit specifier. 1826 LLVM_PREFERRED_TYPE(bool) 1827 uint64_t HasTrailingExplicitSpecifier : 1; 1828 /// If this constructor does't have a trail-allocated explicit specifier. 1829 /// Whether this constructor is explicit specified. 1830 LLVM_PREFERRED_TYPE(bool) 1831 uint64_t IsSimpleExplicit : 1; 1832 }; 1833 1834 /// Number of inherited and non-inherited bits in CXXConstructorDeclBitfields. 1835 enum { NumCXXConstructorDeclBits = NumFunctionDeclBits + 20 }; 1836 1837 /// Stores the bits used by ObjCMethodDecl. 1838 /// If modified NumObjCMethodDeclBits and the accessor 1839 /// methods in ObjCMethodDecl should be updated appropriately. 1840 class ObjCMethodDeclBitfields { 1841 friend class ObjCMethodDecl; 1842 1843 /// For the bits in DeclContextBitfields. 1844 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1845 uint64_t : NumDeclContextBits; 1846 1847 /// The conventional meaning of this method; an ObjCMethodFamily. 1848 /// This is not serialized; instead, it is computed on demand and 1849 /// cached. 1850 LLVM_PREFERRED_TYPE(ObjCMethodFamily) 1851 mutable uint64_t Family : ObjCMethodFamilyBitWidth; 1852 1853 /// instance (true) or class (false) method. 1854 LLVM_PREFERRED_TYPE(bool) 1855 uint64_t IsInstance : 1; 1856 LLVM_PREFERRED_TYPE(bool) 1857 uint64_t IsVariadic : 1; 1858 1859 /// True if this method is the getter or setter for an explicit property. 1860 LLVM_PREFERRED_TYPE(bool) 1861 uint64_t IsPropertyAccessor : 1; 1862 1863 /// True if this method is a synthesized property accessor stub. 1864 LLVM_PREFERRED_TYPE(bool) 1865 uint64_t IsSynthesizedAccessorStub : 1; 1866 1867 /// Method has a definition. 1868 LLVM_PREFERRED_TYPE(bool) 1869 uint64_t IsDefined : 1; 1870 1871 /// Method redeclaration in the same interface. 1872 LLVM_PREFERRED_TYPE(bool) 1873 uint64_t IsRedeclaration : 1; 1874 1875 /// Is redeclared in the same interface. 1876 LLVM_PREFERRED_TYPE(bool) 1877 mutable uint64_t HasRedeclaration : 1; 1878 1879 /// \@required/\@optional 1880 LLVM_PREFERRED_TYPE(ObjCImplementationControl) 1881 uint64_t DeclImplementation : 2; 1882 1883 /// in, inout, etc. 1884 LLVM_PREFERRED_TYPE(Decl::ObjCDeclQualifier) 1885 uint64_t objcDeclQualifier : 7; 1886 1887 /// Indicates whether this method has a related result type. 1888 LLVM_PREFERRED_TYPE(bool) 1889 uint64_t RelatedResultType : 1; 1890 1891 /// Whether the locations of the selector identifiers are in a 1892 /// "standard" position, a enum SelectorLocationsKind. 1893 LLVM_PREFERRED_TYPE(SelectorLocationsKind) 1894 uint64_t SelLocsKind : 2; 1895 1896 /// Whether this method overrides any other in the class hierarchy. 1897 /// 1898 /// A method is said to override any method in the class's 1899 /// base classes, its protocols, or its categories' protocols, that has 1900 /// the same selector and is of the same kind (class or instance). 1901 /// A method in an implementation is not considered as overriding the same 1902 /// method in the interface or its categories. 1903 LLVM_PREFERRED_TYPE(bool) 1904 uint64_t IsOverriding : 1; 1905 1906 /// Indicates if the method was a definition but its body was skipped. 1907 LLVM_PREFERRED_TYPE(bool) 1908 uint64_t HasSkippedBody : 1; 1909 }; 1910 1911 /// Number of inherited and non-inherited bits in ObjCMethodDeclBitfields. 1912 enum { NumObjCMethodDeclBits = NumDeclContextBits + 24 }; 1913 1914 /// Stores the bits used by ObjCContainerDecl. 1915 /// If modified NumObjCContainerDeclBits and the accessor 1916 /// methods in ObjCContainerDecl should be updated appropriately. 1917 class ObjCContainerDeclBitfields { 1918 friend class ObjCContainerDecl; 1919 /// For the bits in DeclContextBitfields 1920 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1921 uint32_t : NumDeclContextBits; 1922 1923 // Not a bitfield but this saves space. 1924 // Note that ObjCContainerDeclBitfields is full. 1925 SourceLocation AtStart; 1926 }; 1927 1928 /// Number of inherited and non-inherited bits in ObjCContainerDeclBitfields. 1929 /// Note that here we rely on the fact that SourceLocation is 32 bits 1930 /// wide. We check this with the static_assert in the ctor of DeclContext. 1931 enum { NumObjCContainerDeclBits = 64 }; 1932 1933 /// Stores the bits used by LinkageSpecDecl. 1934 /// If modified NumLinkageSpecDeclBits and the accessor 1935 /// methods in LinkageSpecDecl should be updated appropriately. 1936 class LinkageSpecDeclBitfields { 1937 friend class LinkageSpecDecl; 1938 /// For the bits in DeclContextBitfields. 1939 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1940 uint64_t : NumDeclContextBits; 1941 1942 /// The language for this linkage specification. 1943 LLVM_PREFERRED_TYPE(LinkageSpecLanguageIDs) 1944 uint64_t Language : 3; 1945 1946 /// True if this linkage spec has braces. 1947 /// This is needed so that hasBraces() returns the correct result while the 1948 /// linkage spec body is being parsed. Once RBraceLoc has been set this is 1949 /// not used, so it doesn't need to be serialized. 1950 LLVM_PREFERRED_TYPE(bool) 1951 uint64_t HasBraces : 1; 1952 }; 1953 1954 /// Number of inherited and non-inherited bits in LinkageSpecDeclBitfields. 1955 enum { NumLinkageSpecDeclBits = NumDeclContextBits + 4 }; 1956 1957 /// Stores the bits used by BlockDecl. 1958 /// If modified NumBlockDeclBits and the accessor 1959 /// methods in BlockDecl should be updated appropriately. 1960 class BlockDeclBitfields { 1961 friend class BlockDecl; 1962 /// For the bits in DeclContextBitfields. 1963 LLVM_PREFERRED_TYPE(DeclContextBitfields) 1964 uint64_t : NumDeclContextBits; 1965 1966 LLVM_PREFERRED_TYPE(bool) 1967 uint64_t IsVariadic : 1; 1968 LLVM_PREFERRED_TYPE(bool) 1969 uint64_t CapturesCXXThis : 1; 1970 LLVM_PREFERRED_TYPE(bool) 1971 uint64_t BlockMissingReturnType : 1; 1972 LLVM_PREFERRED_TYPE(bool) 1973 uint64_t IsConversionFromLambda : 1; 1974 1975 /// A bit that indicates this block is passed directly to a function as a 1976 /// non-escaping parameter. 1977 LLVM_PREFERRED_TYPE(bool) 1978 uint64_t DoesNotEscape : 1; 1979 1980 /// A bit that indicates whether it's possible to avoid coying this block to 1981 /// the heap when it initializes or is assigned to a local variable with 1982 /// automatic storage. 1983 LLVM_PREFERRED_TYPE(bool) 1984 uint64_t CanAvoidCopyToHeap : 1; 1985 }; 1986 1987 /// Number of inherited and non-inherited bits in BlockDeclBitfields. 1988 enum { NumBlockDeclBits = NumDeclContextBits + 5 }; 1989 1990 /// Pointer to the data structure used to lookup declarations 1991 /// within this context (or a DependentStoredDeclsMap if this is a 1992 /// dependent context). We maintain the invariant that, if the map 1993 /// contains an entry for a DeclarationName (and we haven't lazily 1994 /// omitted anything), then it contains all relevant entries for that 1995 /// name (modulo the hasExternalDecls() flag). 1996 mutable StoredDeclsMap *LookupPtr = nullptr; 1997 1998protected: 1999 /// This anonymous union stores the bits belonging to DeclContext and classes 2000 /// deriving from it. The goal is to use otherwise wasted 2001 /// space in DeclContext to store data belonging to derived classes. 2002 /// The space saved is especially significient when pointers are aligned 2003 /// to 8 bytes. In this case due to alignment requirements we have a 2004 /// little less than 8 bytes free in DeclContext which we can use. 2005 /// We check that none of the classes in this union is larger than 2006 /// 8 bytes with static_asserts in the ctor of DeclContext. 2007 union { 2008 DeclContextBitfields DeclContextBits; 2009 TagDeclBitfields TagDeclBits; 2010 EnumDeclBitfields EnumDeclBits; 2011 RecordDeclBitfields RecordDeclBits; 2012 OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits; 2013 FunctionDeclBitfields FunctionDeclBits; 2014 CXXConstructorDeclBitfields CXXConstructorDeclBits; 2015 ObjCMethodDeclBitfields ObjCMethodDeclBits; 2016 ObjCContainerDeclBitfields ObjCContainerDeclBits; 2017 LinkageSpecDeclBitfields LinkageSpecDeclBits; 2018 BlockDeclBitfields BlockDeclBits; 2019 2020 static_assert(sizeof(DeclContextBitfields) <= 8, 2021 "DeclContextBitfields is larger than 8 bytes!"); 2022 static_assert(sizeof(TagDeclBitfields) <= 8, 2023 "TagDeclBitfields is larger than 8 bytes!"); 2024 static_assert(sizeof(EnumDeclBitfields) <= 8, 2025 "EnumDeclBitfields is larger than 8 bytes!"); 2026 static_assert(sizeof(RecordDeclBitfields) <= 8, 2027 "RecordDeclBitfields is larger than 8 bytes!"); 2028 static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8, 2029 "OMPDeclareReductionDeclBitfields is larger than 8 bytes!"); 2030 static_assert(sizeof(FunctionDeclBitfields) <= 8, 2031 "FunctionDeclBitfields is larger than 8 bytes!"); 2032 static_assert(sizeof(CXXConstructorDeclBitfields) <= 8, 2033 "CXXConstructorDeclBitfields is larger than 8 bytes!"); 2034 static_assert(sizeof(ObjCMethodDeclBitfields) <= 8, 2035 "ObjCMethodDeclBitfields is larger than 8 bytes!"); 2036 static_assert(sizeof(ObjCContainerDeclBitfields) <= 8, 2037 "ObjCContainerDeclBitfields is larger than 8 bytes!"); 2038 static_assert(sizeof(LinkageSpecDeclBitfields) <= 8, 2039 "LinkageSpecDeclBitfields is larger than 8 bytes!"); 2040 static_assert(sizeof(BlockDeclBitfields) <= 8, 2041 "BlockDeclBitfields is larger than 8 bytes!"); 2042 }; 2043 2044 /// FirstDecl - The first declaration stored within this declaration 2045 /// context. 2046 mutable Decl *FirstDecl = nullptr; 2047 2048 /// LastDecl - The last declaration stored within this declaration 2049 /// context. FIXME: We could probably cache this value somewhere 2050 /// outside of the DeclContext, to reduce the size of DeclContext by 2051 /// another pointer. 2052 mutable Decl *LastDecl = nullptr; 2053 2054 /// Build up a chain of declarations. 2055 /// 2056 /// \returns the first/last pair of declarations. 2057 static std::pair<Decl *, Decl *> 2058 BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded); 2059 2060 DeclContext(Decl::Kind K); 2061 2062public: 2063 ~DeclContext(); 2064 2065 // For use when debugging; hasValidDeclKind() will always return true for 2066 // a correctly constructed object within its lifetime. 2067 bool hasValidDeclKind() const; 2068 2069 Decl::Kind getDeclKind() const { 2070 return static_cast<Decl::Kind>(DeclContextBits.DeclKind); 2071 } 2072 2073 const char *getDeclKindName() const; 2074 2075 /// getParent - Returns the containing DeclContext. 2076 DeclContext *getParent() { 2077 return cast<Decl>(this)->getDeclContext(); 2078 } 2079 const DeclContext *getParent() const { 2080 return const_cast<DeclContext*>(this)->getParent(); 2081 } 2082 2083 /// getLexicalParent - Returns the containing lexical DeclContext. May be 2084 /// different from getParent, e.g.: 2085 /// 2086 /// namespace A { 2087 /// struct S; 2088 /// } 2089 /// struct A::S {}; // getParent() == namespace 'A' 2090 /// // getLexicalParent() == translation unit 2091 /// 2092 DeclContext *getLexicalParent() { 2093 return cast<Decl>(this)->getLexicalDeclContext(); 2094 } 2095 const DeclContext *getLexicalParent() const { 2096 return const_cast<DeclContext*>(this)->getLexicalParent(); 2097 } 2098 2099 DeclContext *getLookupParent(); 2100 2101 const DeclContext *getLookupParent() const { 2102 return const_cast<DeclContext*>(this)->getLookupParent(); 2103 } 2104 2105 ASTContext &getParentASTContext() const { 2106 return cast<Decl>(this)->getASTContext(); 2107 } 2108 2109 bool isClosure() const { return getDeclKind() == Decl::Block; } 2110 2111 /// Return this DeclContext if it is a BlockDecl. Otherwise, return the 2112 /// innermost enclosing BlockDecl or null if there are no enclosing blocks. 2113 const BlockDecl *getInnermostBlockDecl() const; 2114 2115 bool isObjCContainer() const { 2116 switch (getDeclKind()) { 2117 case Decl::ObjCCategory: 2118 case Decl::ObjCCategoryImpl: 2119 case Decl::ObjCImplementation: 2120 case Decl::ObjCInterface: 2121 case Decl::ObjCProtocol: 2122 return true; 2123 default: 2124 return false; 2125 } 2126 } 2127 2128 bool isFunctionOrMethod() const { 2129 switch (getDeclKind()) { 2130 case Decl::Block: 2131 case Decl::Captured: 2132 case Decl::ObjCMethod: 2133 return true; 2134 default: 2135 return getDeclKind() >= Decl::firstFunction && 2136 getDeclKind() <= Decl::lastFunction; 2137 } 2138 } 2139 2140 /// Test whether the context supports looking up names. 2141 bool isLookupContext() const { 2142 return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec && 2143 getDeclKind() != Decl::Export; 2144 } 2145 2146 bool isFileContext() const { 2147 return getDeclKind() == Decl::TranslationUnit || 2148 getDeclKind() == Decl::Namespace; 2149 } 2150 2151 bool isTranslationUnit() const { 2152 return getDeclKind() == Decl::TranslationUnit; 2153 } 2154 2155 bool isRecord() const { 2156 return getDeclKind() >= Decl::firstRecord && 2157 getDeclKind() <= Decl::lastRecord; 2158 } 2159 2160 bool isNamespace() const { return getDeclKind() == Decl::Namespace; } 2161 2162 bool isStdNamespace() const; 2163 2164 bool isInlineNamespace() const; 2165 2166 /// Determines whether this context is dependent on a 2167 /// template parameter. 2168 bool isDependentContext() const; 2169 2170 /// isTransparentContext - Determines whether this context is a 2171 /// "transparent" context, meaning that the members declared in this 2172 /// context are semantically declared in the nearest enclosing 2173 /// non-transparent (opaque) context but are lexically declared in 2174 /// this context. For example, consider the enumerators of an 2175 /// enumeration type: 2176 /// @code 2177 /// enum E { 2178 /// Val1 2179 /// }; 2180 /// @endcode 2181 /// Here, E is a transparent context, so its enumerator (Val1) will 2182 /// appear (semantically) that it is in the same context of E. 2183 /// Examples of transparent contexts include: enumerations (except for 2184 /// C++0x scoped enums), C++ linkage specifications and export declaration. 2185 bool isTransparentContext() const; 2186 2187 /// Determines whether this context or some of its ancestors is a 2188 /// linkage specification context that specifies C linkage. 2189 bool isExternCContext() const; 2190 2191 /// Retrieve the nearest enclosing C linkage specification context. 2192 const LinkageSpecDecl *getExternCContext() const; 2193 2194 /// Determines whether this context or some of its ancestors is a 2195 /// linkage specification context that specifies C++ linkage. 2196 bool isExternCXXContext() const; 2197 2198 /// Determine whether this declaration context is equivalent 2199 /// to the declaration context DC. 2200 bool Equals(const DeclContext *DC) const { 2201 return DC && this->getPrimaryContext() == DC->getPrimaryContext(); 2202 } 2203 2204 /// Determine whether this declaration context encloses the 2205 /// declaration context DC. 2206 bool Encloses(const DeclContext *DC) const; 2207 2208 /// Find the nearest non-closure ancestor of this context, 2209 /// i.e. the innermost semantic parent of this context which is not 2210 /// a closure. A context may be its own non-closure ancestor. 2211 Decl *getNonClosureAncestor(); 2212 const Decl *getNonClosureAncestor() const { 2213 return const_cast<DeclContext*>(this)->getNonClosureAncestor(); 2214 } 2215 2216 // Retrieve the nearest context that is not a transparent context. 2217 DeclContext *getNonTransparentContext(); 2218 const DeclContext *getNonTransparentContext() const { 2219 return const_cast<DeclContext *>(this)->getNonTransparentContext(); 2220 } 2221 2222 /// getPrimaryContext - There may be many different 2223 /// declarations of the same entity (including forward declarations 2224 /// of classes, multiple definitions of namespaces, etc.), each with 2225 /// a different set of declarations. This routine returns the 2226 /// "primary" DeclContext structure, which will contain the 2227 /// information needed to perform name lookup into this context. 2228 DeclContext *getPrimaryContext(); 2229 const DeclContext *getPrimaryContext() const { 2230 return const_cast<DeclContext*>(this)->getPrimaryContext(); 2231 } 2232 2233 /// getRedeclContext - Retrieve the context in which an entity conflicts with 2234 /// other entities of the same name, or where it is a redeclaration if the 2235 /// two entities are compatible. This skips through transparent contexts. 2236 DeclContext *getRedeclContext(); 2237 const DeclContext *getRedeclContext() const { 2238 return const_cast<DeclContext *>(this)->getRedeclContext(); 2239 } 2240 2241 /// Retrieve the nearest enclosing namespace context. 2242 DeclContext *getEnclosingNamespaceContext(); 2243 const DeclContext *getEnclosingNamespaceContext() const { 2244 return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext(); 2245 } 2246 2247 /// Retrieve the outermost lexically enclosing record context. 2248 RecordDecl *getOuterLexicalRecordContext(); 2249 const RecordDecl *getOuterLexicalRecordContext() const { 2250 return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext(); 2251 } 2252 2253 /// Test if this context is part of the enclosing namespace set of 2254 /// the context NS, as defined in C++0x [namespace.def]p9. If either context 2255 /// isn't a namespace, this is equivalent to Equals(). 2256 /// 2257 /// The enclosing namespace set of a namespace is the namespace and, if it is 2258 /// inline, its enclosing namespace, recursively. 2259 bool InEnclosingNamespaceSetOf(const DeclContext *NS) const; 2260 2261 /// Collects all of the declaration contexts that are semantically 2262 /// connected to this declaration context. 2263 /// 2264 /// For declaration contexts that have multiple semantically connected but 2265 /// syntactically distinct contexts, such as C++ namespaces, this routine 2266 /// retrieves the complete set of such declaration contexts in source order. 2267 /// For example, given: 2268 /// 2269 /// \code 2270 /// namespace N { 2271 /// int x; 2272 /// } 2273 /// namespace N { 2274 /// int y; 2275 /// } 2276 /// \endcode 2277 /// 2278 /// The \c Contexts parameter will contain both definitions of N. 2279 /// 2280 /// \param Contexts Will be cleared and set to the set of declaration 2281 /// contexts that are semanticaly connected to this declaration context, 2282 /// in source order, including this context (which may be the only result, 2283 /// for non-namespace contexts). 2284 void collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts); 2285 2286 /// decl_iterator - Iterates through the declarations stored 2287 /// within this context. 2288 class decl_iterator { 2289 /// Current - The current declaration. 2290 Decl *Current = nullptr; 2291 2292 public: 2293 using value_type = Decl *; 2294 using reference = const value_type &; 2295 using pointer = const value_type *; 2296 using iterator_category = std::forward_iterator_tag; 2297 using difference_type = std::ptrdiff_t; 2298 2299 decl_iterator() = default; 2300 explicit decl_iterator(Decl *C) : Current(C) {} 2301 2302 reference operator*() const { return Current; } 2303 2304 // This doesn't meet the iterator requirements, but it's convenient 2305 value_type operator->() const { return Current; } 2306 2307 decl_iterator& operator++() { 2308 Current = Current->getNextDeclInContext(); 2309 return *this; 2310 } 2311 2312 decl_iterator operator++(int) { 2313 decl_iterator tmp(*this); 2314 ++(*this); 2315 return tmp; 2316 } 2317 2318 friend bool operator==(decl_iterator x, decl_iterator y) { 2319 return x.Current == y.Current; 2320 } 2321 2322 friend bool operator!=(decl_iterator x, decl_iterator y) { 2323 return x.Current != y.Current; 2324 } 2325 }; 2326 2327 using decl_range = llvm::iterator_range<decl_iterator>; 2328 2329 /// decls_begin/decls_end - Iterate over the declarations stored in 2330 /// this context. 2331 decl_range decls() const { return decl_range(decls_begin(), decls_end()); } 2332 decl_iterator decls_begin() const; 2333 decl_iterator decls_end() const { return decl_iterator(); } 2334 bool decls_empty() const; 2335 2336 /// noload_decls_begin/end - Iterate over the declarations stored in this 2337 /// context that are currently loaded; don't attempt to retrieve anything 2338 /// from an external source. 2339 decl_range noload_decls() const { 2340 return decl_range(noload_decls_begin(), noload_decls_end()); 2341 } 2342 decl_iterator noload_decls_begin() const { return decl_iterator(FirstDecl); } 2343 decl_iterator noload_decls_end() const { return decl_iterator(); } 2344 2345 /// specific_decl_iterator - Iterates over a subrange of 2346 /// declarations stored in a DeclContext, providing only those that 2347 /// are of type SpecificDecl (or a class derived from it). This 2348 /// iterator is used, for example, to provide iteration over just 2349 /// the fields within a RecordDecl (with SpecificDecl = FieldDecl). 2350 template<typename SpecificDecl> 2351 class specific_decl_iterator { 2352 /// Current - The current, underlying declaration iterator, which 2353 /// will either be NULL or will point to a declaration of 2354 /// type SpecificDecl. 2355 DeclContext::decl_iterator Current; 2356 2357 /// SkipToNextDecl - Advances the current position up to the next 2358 /// declaration of type SpecificDecl that also meets the criteria 2359 /// required by Acceptable. 2360 void SkipToNextDecl() { 2361 while (*Current && !isa<SpecificDecl>(*Current)) 2362 ++Current; 2363 } 2364 2365 public: 2366 using value_type = SpecificDecl *; 2367 // TODO: Add reference and pointer types (with some appropriate proxy type) 2368 // if we ever have a need for them. 2369 using reference = void; 2370 using pointer = void; 2371 using difference_type = 2372 std::iterator_traits<DeclContext::decl_iterator>::difference_type; 2373 using iterator_category = std::forward_iterator_tag; 2374 2375 specific_decl_iterator() = default; 2376 2377 /// specific_decl_iterator - Construct a new iterator over a 2378 /// subset of the declarations the range [C, 2379 /// end-of-declarations). If A is non-NULL, it is a pointer to a 2380 /// member function of SpecificDecl that should return true for 2381 /// all of the SpecificDecl instances that will be in the subset 2382 /// of iterators. For example, if you want Objective-C instance 2383 /// methods, SpecificDecl will be ObjCMethodDecl and A will be 2384 /// &ObjCMethodDecl::isInstanceMethod. 2385 explicit specific_decl_iterator(DeclContext::decl_iterator C) : Current(C) { 2386 SkipToNextDecl(); 2387 } 2388 2389 value_type operator*() const { return cast<SpecificDecl>(*Current); } 2390 2391 // This doesn't meet the iterator requirements, but it's convenient 2392 value_type operator->() const { return **this; } 2393 2394 specific_decl_iterator& operator++() { 2395 ++Current; 2396 SkipToNextDecl(); 2397 return *this; 2398 } 2399 2400 specific_decl_iterator operator++(int) { 2401 specific_decl_iterator tmp(*this); 2402 ++(*this); 2403 return tmp; 2404 } 2405 2406 friend bool operator==(const specific_decl_iterator& x, 2407 const specific_decl_iterator& y) { 2408 return x.Current == y.Current; 2409 } 2410 2411 friend bool operator!=(const specific_decl_iterator& x, 2412 const specific_decl_iterator& y) { 2413 return x.Current != y.Current; 2414 } 2415 }; 2416 2417 /// Iterates over a filtered subrange of declarations stored 2418 /// in a DeclContext. 2419 /// 2420 /// This iterator visits only those declarations that are of type 2421 /// SpecificDecl (or a class derived from it) and that meet some 2422 /// additional run-time criteria. This iterator is used, for 2423 /// example, to provide access to the instance methods within an 2424 /// Objective-C interface (with SpecificDecl = ObjCMethodDecl and 2425 /// Acceptable = ObjCMethodDecl::isInstanceMethod). 2426 template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const> 2427 class filtered_decl_iterator { 2428 /// Current - The current, underlying declaration iterator, which 2429 /// will either be NULL or will point to a declaration of 2430 /// type SpecificDecl. 2431 DeclContext::decl_iterator Current; 2432 2433 /// SkipToNextDecl - Advances the current position up to the next 2434 /// declaration of type SpecificDecl that also meets the criteria 2435 /// required by Acceptable. 2436 void SkipToNextDecl() { 2437 while (*Current && 2438 (!isa<SpecificDecl>(*Current) || 2439 (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)()))) 2440 ++Current; 2441 } 2442 2443 public: 2444 using value_type = SpecificDecl *; 2445 // TODO: Add reference and pointer types (with some appropriate proxy type) 2446 // if we ever have a need for them. 2447 using reference = void; 2448 using pointer = void; 2449 using difference_type = 2450 std::iterator_traits<DeclContext::decl_iterator>::difference_type; 2451 using iterator_category = std::forward_iterator_tag; 2452 2453 filtered_decl_iterator() = default; 2454 2455 /// filtered_decl_iterator - Construct a new iterator over a 2456 /// subset of the declarations the range [C, 2457 /// end-of-declarations). If A is non-NULL, it is a pointer to a 2458 /// member function of SpecificDecl that should return true for 2459 /// all of the SpecificDecl instances that will be in the subset 2460 /// of iterators. For example, if you want Objective-C instance 2461 /// methods, SpecificDecl will be ObjCMethodDecl and A will be 2462 /// &ObjCMethodDecl::isInstanceMethod. 2463 explicit filtered_decl_iterator(DeclContext::decl_iterator C) : Current(C) { 2464 SkipToNextDecl(); 2465 } 2466 2467 value_type operator*() const { return cast<SpecificDecl>(*Current); } 2468 value_type operator->() const { return cast<SpecificDecl>(*Current); } 2469 2470 filtered_decl_iterator& operator++() { 2471 ++Current; 2472 SkipToNextDecl(); 2473 return *this; 2474 } 2475 2476 filtered_decl_iterator operator++(int) { 2477 filtered_decl_iterator tmp(*this); 2478 ++(*this); 2479 return tmp; 2480 } 2481 2482 friend bool operator==(const filtered_decl_iterator& x, 2483 const filtered_decl_iterator& y) { 2484 return x.Current == y.Current; 2485 } 2486 2487 friend bool operator!=(const filtered_decl_iterator& x, 2488 const filtered_decl_iterator& y) { 2489 return x.Current != y.Current; 2490 } 2491 }; 2492 2493 /// Add the declaration D into this context. 2494 /// 2495 /// This routine should be invoked when the declaration D has first 2496 /// been declared, to place D into the context where it was 2497 /// (lexically) defined. Every declaration must be added to one 2498 /// (and only one!) context, where it can be visited via 2499 /// [decls_begin(), decls_end()). Once a declaration has been added 2500 /// to its lexical context, the corresponding DeclContext owns the 2501 /// declaration. 2502 /// 2503 /// If D is also a NamedDecl, it will be made visible within its 2504 /// semantic context via makeDeclVisibleInContext. 2505 void addDecl(Decl *D); 2506 2507 /// Add the declaration D into this context, but suppress 2508 /// searches for external declarations with the same name. 2509 /// 2510 /// Although analogous in function to addDecl, this removes an 2511 /// important check. This is only useful if the Decl is being 2512 /// added in response to an external search; in all other cases, 2513 /// addDecl() is the right function to use. 2514 /// See the ASTImporter for use cases. 2515 void addDeclInternal(Decl *D); 2516 2517 /// Add the declaration D to this context without modifying 2518 /// any lookup tables. 2519 /// 2520 /// This is useful for some operations in dependent contexts where 2521 /// the semantic context might not be dependent; this basically 2522 /// only happens with friends. 2523 void addHiddenDecl(Decl *D); 2524 2525 /// Removes a declaration from this context. 2526 void removeDecl(Decl *D); 2527 2528 /// Checks whether a declaration is in this context. 2529 bool containsDecl(Decl *D) const; 2530 2531 /// Checks whether a declaration is in this context. 2532 /// This also loads the Decls from the external source before the check. 2533 bool containsDeclAndLoad(Decl *D) const; 2534 2535 using lookup_result = DeclContextLookupResult; 2536 using lookup_iterator = lookup_result::iterator; 2537 2538 /// lookup - Find the declarations (if any) with the given Name in 2539 /// this context. Returns a range of iterators that contains all of 2540 /// the declarations with this name, with object, function, member, 2541 /// and enumerator names preceding any tag name. Note that this 2542 /// routine will not look into parent contexts. 2543 lookup_result lookup(DeclarationName Name) const; 2544 2545 /// Find the declarations with the given name that are visible 2546 /// within this context; don't attempt to retrieve anything from an 2547 /// external source. 2548 lookup_result noload_lookup(DeclarationName Name); 2549 2550 /// A simplistic name lookup mechanism that performs name lookup 2551 /// into this declaration context without consulting the external source. 2552 /// 2553 /// This function should almost never be used, because it subverts the 2554 /// usual relationship between a DeclContext and the external source. 2555 /// See the ASTImporter for the (few, but important) use cases. 2556 /// 2557 /// FIXME: This is very inefficient; replace uses of it with uses of 2558 /// noload_lookup. 2559 void localUncachedLookup(DeclarationName Name, 2560 SmallVectorImpl<NamedDecl *> &Results); 2561 2562 /// Makes a declaration visible within this context. 2563 /// 2564 /// This routine makes the declaration D visible to name lookup 2565 /// within this context and, if this is a transparent context, 2566 /// within its parent contexts up to the first enclosing 2567 /// non-transparent context. Making a declaration visible within a 2568 /// context does not transfer ownership of a declaration, and a 2569 /// declaration can be visible in many contexts that aren't its 2570 /// lexical context. 2571 /// 2572 /// If D is a redeclaration of an existing declaration that is 2573 /// visible from this context, as determined by 2574 /// NamedDecl::declarationReplaces, the previous declaration will be 2575 /// replaced with D. 2576 void makeDeclVisibleInContext(NamedDecl *D); 2577 2578 /// all_lookups_iterator - An iterator that provides a view over the results 2579 /// of looking up every possible name. 2580 class all_lookups_iterator; 2581 2582 using lookups_range = llvm::iterator_range<all_lookups_iterator>; 2583 2584 lookups_range lookups() const; 2585 // Like lookups(), but avoids loading external declarations. 2586 // If PreserveInternalState, avoids building lookup data structures too. 2587 lookups_range noload_lookups(bool PreserveInternalState) const; 2588 2589 /// Iterators over all possible lookups within this context. 2590 all_lookups_iterator lookups_begin() const; 2591 all_lookups_iterator lookups_end() const; 2592 2593 /// Iterators over all possible lookups within this context that are 2594 /// currently loaded; don't attempt to retrieve anything from an external 2595 /// source. 2596 all_lookups_iterator noload_lookups_begin() const; 2597 all_lookups_iterator noload_lookups_end() const; 2598 2599 struct udir_iterator; 2600 2601 using udir_iterator_base = 2602 llvm::iterator_adaptor_base<udir_iterator, lookup_iterator, 2603 typename lookup_iterator::iterator_category, 2604 UsingDirectiveDecl *>; 2605 2606 struct udir_iterator : udir_iterator_base { 2607 udir_iterator(lookup_iterator I) : udir_iterator_base(I) {} 2608 2609 UsingDirectiveDecl *operator*() const; 2610 }; 2611 2612 using udir_range = llvm::iterator_range<udir_iterator>; 2613 2614 udir_range using_directives() const; 2615 2616 // These are all defined in DependentDiagnostic.h. 2617 class ddiag_iterator; 2618 2619 using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>; 2620 2621 inline ddiag_range ddiags() const; 2622 2623 // Low-level accessors 2624 2625 /// Mark that there are external lexical declarations that we need 2626 /// to include in our lookup table (and that are not available as external 2627 /// visible lookups). These extra lookup results will be found by walking 2628 /// the lexical declarations of this context. This should be used only if 2629 /// setHasExternalLexicalStorage() has been called on any decl context for 2630 /// which this is the primary context. 2631 void setMustBuildLookupTable() { 2632 assert(this == getPrimaryContext() && 2633 "should only be called on primary context"); 2634 DeclContextBits.HasLazyExternalLexicalLookups = true; 2635 } 2636 2637 /// Retrieve the internal representation of the lookup structure. 2638 /// This may omit some names if we are lazily building the structure. 2639 StoredDeclsMap *getLookupPtr() const { return LookupPtr; } 2640 2641 /// Ensure the lookup structure is fully-built and return it. 2642 StoredDeclsMap *buildLookup(); 2643 2644 /// Whether this DeclContext has external storage containing 2645 /// additional declarations that are lexically in this context. 2646 bool hasExternalLexicalStorage() const { 2647 return DeclContextBits.ExternalLexicalStorage; 2648 } 2649 2650 /// State whether this DeclContext has external storage for 2651 /// declarations lexically in this context. 2652 void setHasExternalLexicalStorage(bool ES = true) const { 2653 DeclContextBits.ExternalLexicalStorage = ES; 2654 } 2655 2656 /// Whether this DeclContext has external storage containing 2657 /// additional declarations that are visible in this context. 2658 bool hasExternalVisibleStorage() const { 2659 return DeclContextBits.ExternalVisibleStorage; 2660 } 2661 2662 /// State whether this DeclContext has external storage for 2663 /// declarations visible in this context. 2664 void setHasExternalVisibleStorage(bool ES = true) const { 2665 DeclContextBits.ExternalVisibleStorage = ES; 2666 if (ES && LookupPtr) 2667 DeclContextBits.NeedToReconcileExternalVisibleStorage = true; 2668 } 2669 2670 /// Determine whether the given declaration is stored in the list of 2671 /// declarations lexically within this context. 2672 bool isDeclInLexicalTraversal(const Decl *D) const { 2673 return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl || 2674 D == LastDecl); 2675 } 2676 2677 void setUseQualifiedLookup(bool use = true) const { 2678 DeclContextBits.UseQualifiedLookup = use; 2679 } 2680 2681 bool shouldUseQualifiedLookup() const { 2682 return DeclContextBits.UseQualifiedLookup; 2683 } 2684 2685 static bool classof(const Decl *D); 2686 static bool classof(const DeclContext *D) { return true; } 2687 2688 void dumpAsDecl() const; 2689 void dumpAsDecl(const ASTContext *Ctx) const; 2690 void dumpDeclContext() const; 2691 void dumpLookups() const; 2692 void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false, 2693 bool Deserialize = false) const; 2694 2695private: 2696 /// Whether this declaration context has had externally visible 2697 /// storage added since the last lookup. In this case, \c LookupPtr's 2698 /// invariant may not hold and needs to be fixed before we perform 2699 /// another lookup. 2700 bool hasNeedToReconcileExternalVisibleStorage() const { 2701 return DeclContextBits.NeedToReconcileExternalVisibleStorage; 2702 } 2703 2704 /// State that this declaration context has had externally visible 2705 /// storage added since the last lookup. In this case, \c LookupPtr's 2706 /// invariant may not hold and needs to be fixed before we perform 2707 /// another lookup. 2708 void setNeedToReconcileExternalVisibleStorage(bool Need = true) const { 2709 DeclContextBits.NeedToReconcileExternalVisibleStorage = Need; 2710 } 2711 2712 /// If \c true, this context may have local lexical declarations 2713 /// that are missing from the lookup table. 2714 bool hasLazyLocalLexicalLookups() const { 2715 return DeclContextBits.HasLazyLocalLexicalLookups; 2716 } 2717 2718 /// If \c true, this context may have local lexical declarations 2719 /// that are missing from the lookup table. 2720 void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const { 2721 DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL; 2722 } 2723 2724 /// If \c true, the external source may have lexical declarations 2725 /// that are missing from the lookup table. 2726 bool hasLazyExternalLexicalLookups() const { 2727 return DeclContextBits.HasLazyExternalLexicalLookups; 2728 } 2729 2730 /// If \c true, the external source may have lexical declarations 2731 /// that are missing from the lookup table. 2732 void setHasLazyExternalLexicalLookups(bool HasLELL = true) const { 2733 DeclContextBits.HasLazyExternalLexicalLookups = HasLELL; 2734 } 2735 2736 void reconcileExternalVisibleStorage() const; 2737 bool LoadLexicalDeclsFromExternalStorage() const; 2738 2739 StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const; 2740 2741 void loadLazyLocalLexicalLookups(); 2742 void buildLookupImpl(DeclContext *DCtx, bool Internal); 2743 void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal, 2744 bool Rediscoverable); 2745 void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal); 2746}; 2747 2748inline bool Decl::isTemplateParameter() const { 2749 return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm || 2750 getKind() == TemplateTemplateParm; 2751} 2752 2753// Specialization selected when ToTy is not a known subclass of DeclContext. 2754template <class ToTy, 2755 bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value> 2756struct cast_convert_decl_context { 2757 static const ToTy *doit(const DeclContext *Val) { 2758 return static_cast<const ToTy*>(Decl::castFromDeclContext(Val)); 2759 } 2760 2761 static ToTy *doit(DeclContext *Val) { 2762 return static_cast<ToTy*>(Decl::castFromDeclContext(Val)); 2763 } 2764}; 2765 2766// Specialization selected when ToTy is a known subclass of DeclContext. 2767template <class ToTy> 2768struct cast_convert_decl_context<ToTy, true> { 2769 static const ToTy *doit(const DeclContext *Val) { 2770 return static_cast<const ToTy*>(Val); 2771 } 2772 2773 static ToTy *doit(DeclContext *Val) { 2774 return static_cast<ToTy*>(Val); 2775 } 2776}; 2777 2778} // namespace clang 2779 2780namespace llvm { 2781 2782/// isa<T>(DeclContext*) 2783template <typename To> 2784struct isa_impl<To, ::clang::DeclContext> { 2785 static bool doit(const ::clang::DeclContext &Val) { 2786 return To::classofKind(Val.getDeclKind()); 2787 } 2788}; 2789 2790/// cast<T>(DeclContext*) 2791template<class ToTy> 2792struct cast_convert_val<ToTy, 2793 const ::clang::DeclContext,const ::clang::DeclContext> { 2794 static const ToTy &doit(const ::clang::DeclContext &Val) { 2795 return *::clang::cast_convert_decl_context<ToTy>::doit(&Val); 2796 } 2797}; 2798 2799template<class ToTy> 2800struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> { 2801 static ToTy &doit(::clang::DeclContext &Val) { 2802 return *::clang::cast_convert_decl_context<ToTy>::doit(&Val); 2803 } 2804}; 2805 2806template<class ToTy> 2807struct cast_convert_val<ToTy, 2808 const ::clang::DeclContext*, const ::clang::DeclContext*> { 2809 static const ToTy *doit(const ::clang::DeclContext *Val) { 2810 return ::clang::cast_convert_decl_context<ToTy>::doit(Val); 2811 } 2812}; 2813 2814template<class ToTy> 2815struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> { 2816 static ToTy *doit(::clang::DeclContext *Val) { 2817 return ::clang::cast_convert_decl_context<ToTy>::doit(Val); 2818 } 2819}; 2820 2821/// Implement cast_convert_val for Decl -> DeclContext conversions. 2822template<class FromTy> 2823struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> { 2824 static ::clang::DeclContext &doit(const FromTy &Val) { 2825 return *FromTy::castToDeclContext(&Val); 2826 } 2827}; 2828 2829template<class FromTy> 2830struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> { 2831 static ::clang::DeclContext *doit(const FromTy *Val) { 2832 return FromTy::castToDeclContext(Val); 2833 } 2834}; 2835 2836template<class FromTy> 2837struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> { 2838 static const ::clang::DeclContext &doit(const FromTy &Val) { 2839 return *FromTy::castToDeclContext(&Val); 2840 } 2841}; 2842 2843template<class FromTy> 2844struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> { 2845 static const ::clang::DeclContext *doit(const FromTy *Val) { 2846 return FromTy::castToDeclContext(Val); 2847 } 2848}; 2849 2850} // namespace llvm 2851 2852#endif // LLVM_CLANG_AST_DECLBASE_H 2853