Decl.h revision dc0705645276258afddb06cdf0fd7c8840251ee0
1//===--- Decl.h - Classes for representing declarations ---------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the Decl subclasses. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_AST_DECL_H 15#define LLVM_CLANG_AST_DECL_H 16 17#include "clang/AST/APValue.h" 18#include "clang/AST/DeclBase.h" 19#include "clang/AST/DeclarationName.h" 20#include "clang/AST/ExternalASTSource.h" 21#include "clang/AST/Redeclarable.h" 22#include "clang/AST/Type.h" 23#include "clang/Basic/Linkage.h" 24#include "llvm/ADT/ArrayRef.h" 25#include "llvm/ADT/Optional.h" 26#include "llvm/Support/Compiler.h" 27#include "llvm/Support/raw_ostream.h" 28 29namespace clang { 30struct ASTTemplateArgumentListInfo; 31class CXXTemporary; 32class CompoundStmt; 33class DependentFunctionTemplateSpecializationInfo; 34class Expr; 35class FunctionTemplateDecl; 36class FunctionTemplateSpecializationInfo; 37class LabelStmt; 38class MemberSpecializationInfo; 39class Module; 40class NestedNameSpecifier; 41class Stmt; 42class StringLiteral; 43class TemplateArgumentList; 44class TemplateParameterList; 45class TypeLoc; 46class UnresolvedSetImpl; 47 48/// \brief A container of type source information. 49/// 50/// A client can read the relevant info using TypeLoc wrappers, e.g: 51/// @code 52/// TypeLoc TL = TypeSourceInfo->getTypeLoc(); 53/// if (PointerLoc *PL = dyn_cast<PointerLoc>(&TL)) 54/// PL->getStarLoc().print(OS, SrcMgr); 55/// @endcode 56/// 57class TypeSourceInfo { 58 QualType Ty; 59 // Contains a memory block after the class, used for type source information, 60 // allocated by ASTContext. 61 friend class ASTContext; 62 TypeSourceInfo(QualType ty) : Ty(ty) { } 63public: 64 /// \brief Return the type wrapped by this type source info. 65 QualType getType() const { return Ty; } 66 67 /// \brief Return the TypeLoc wrapper for the type source info. 68 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h 69}; 70 71/// TranslationUnitDecl - The top declaration context. 72class TranslationUnitDecl : public Decl, public DeclContext { 73 virtual void anchor(); 74 ASTContext &Ctx; 75 76 /// The (most recently entered) anonymous namespace for this 77 /// translation unit, if one has been created. 78 NamespaceDecl *AnonymousNamespace; 79 80 explicit TranslationUnitDecl(ASTContext &ctx) 81 : Decl(TranslationUnit, 0, SourceLocation()), 82 DeclContext(TranslationUnit), 83 Ctx(ctx), AnonymousNamespace(0) {} 84public: 85 ASTContext &getASTContext() const { return Ctx; } 86 87 NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; } 88 void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; } 89 90 static TranslationUnitDecl *Create(ASTContext &C); 91 // Implement isa/cast/dyncast/etc. 92 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 93 static bool classofKind(Kind K) { return K == TranslationUnit; } 94 static DeclContext *castToDeclContext(const TranslationUnitDecl *D) { 95 return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D)); 96 } 97 static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) { 98 return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC)); 99 } 100}; 101 102/// NamedDecl - This represents a decl with a name. Many decls have names such 103/// as ObjCMethodDecl, but not \@class, etc. 104class NamedDecl : public Decl { 105 virtual void anchor(); 106 /// Name - The name of this declaration, which is typically a normal 107 /// identifier but may also be a special kind of name (C++ 108 /// constructor, Objective-C selector, etc.) 109 DeclarationName Name; 110 111private: 112 NamedDecl *getUnderlyingDeclImpl(); 113 114protected: 115 NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N) 116 : Decl(DK, DC, L), Name(N) { } 117 118public: 119 /// getIdentifier - Get the identifier that names this declaration, 120 /// if there is one. This will return NULL if this declaration has 121 /// no name (e.g., for an unnamed class) or if the name is a special 122 /// name (C++ constructor, Objective-C selector, etc.). 123 IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); } 124 125 /// getName - Get the name of identifier for this declaration as a StringRef. 126 /// This requires that the declaration have a name and that it be a simple 127 /// identifier. 128 StringRef getName() const { 129 assert(Name.isIdentifier() && "Name is not a simple identifier"); 130 return getIdentifier() ? getIdentifier()->getName() : ""; 131 } 132 133 /// getNameAsString - Get a human-readable name for the declaration, even if 134 /// it is one of the special kinds of names (C++ constructor, Objective-C 135 /// selector, etc). Creating this name requires expensive string 136 /// manipulation, so it should be called only when performance doesn't matter. 137 /// For simple declarations, getNameAsCString() should suffice. 138 // 139 // FIXME: This function should be renamed to indicate that it is not just an 140 // alternate form of getName(), and clients should move as appropriate. 141 // 142 // FIXME: Deprecated, move clients to getName(). 143 std::string getNameAsString() const { return Name.getAsString(); } 144 145 void printName(raw_ostream &os) const { os << Name; } 146 147 /// getDeclName - Get the actual, stored name of the declaration, 148 /// which may be a special name. 149 DeclarationName getDeclName() const { return Name; } 150 151 /// \brief Set the name of this declaration. 152 void setDeclName(DeclarationName N) { Name = N; } 153 154 /// printQualifiedName - Returns human-readable qualified name for 155 /// declaration, like A::B::i, for i being member of namespace A::B. 156 /// If declaration is not member of context which can be named (record, 157 /// namespace), it will return same result as printName(). 158 /// Creating this name is expensive, so it should be called only when 159 /// performance doesn't matter. 160 void printQualifiedName(raw_ostream &OS) const; 161 void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const; 162 163 // FIXME: Remove string versions. 164 std::string getQualifiedNameAsString() const; 165 std::string getQualifiedNameAsString(const PrintingPolicy &Policy) const; 166 167 /// getNameForDiagnostic - Appends a human-readable name for this 168 /// declaration into the given stream. 169 /// 170 /// This is the method invoked by Sema when displaying a NamedDecl 171 /// in a diagnostic. It does not necessarily produce the same 172 /// result as printName(); for example, class template 173 /// specializations are printed with their template arguments. 174 virtual void getNameForDiagnostic(raw_ostream &OS, 175 const PrintingPolicy &Policy, 176 bool Qualified) const; 177 178 /// declarationReplaces - Determine whether this declaration, if 179 /// known to be well-formed within its context, will replace the 180 /// declaration OldD if introduced into scope. A declaration will 181 /// replace another declaration if, for example, it is a 182 /// redeclaration of the same variable or function, but not if it is 183 /// a declaration of a different kind (function vs. class) or an 184 /// overloaded function. 185 bool declarationReplaces(NamedDecl *OldD) const; 186 187 /// \brief Determine whether this declaration has linkage. 188 bool hasLinkage() const; 189 190 using Decl::isModulePrivate; 191 using Decl::setModulePrivate; 192 193 /// \brief Determine whether this declaration is hidden from name lookup. 194 bool isHidden() const { return Hidden; } 195 196 /// \brief Determine whether this declaration is a C++ class member. 197 bool isCXXClassMember() const { 198 const DeclContext *DC = getDeclContext(); 199 200 // C++0x [class.mem]p1: 201 // The enumerators of an unscoped enumeration defined in 202 // the class are members of the class. 203 // FIXME: support C++0x scoped enumerations. 204 if (isa<EnumDecl>(DC)) 205 DC = DC->getParent(); 206 207 return DC->isRecord(); 208 } 209 210 /// \brief Determine whether the given declaration is an instance member of 211 /// a C++ class. 212 bool isCXXInstanceMember() const; 213 214 /// \brief Determine what kind of linkage this entity has. 215 /// This is not the linkage as defined by the standard or the codegen notion 216 /// of linkage. It is just an implementation detail that is used to compute 217 /// those. 218 Linkage getLinkageInternal() const; 219 220 /// \brief Get the linkage from a semantic point of view. Entities in 221 /// anonymous namespaces are external (in c++98). 222 Linkage getFormalLinkage() const { 223 return clang::getFormalLinkage(getLinkageInternal()); 224 } 225 226 /// \brief True if this decl has external linkage. 227 bool hasExternalFormalLinkage() const { 228 return isExternalFormalLinkage(getLinkageInternal()); 229 } 230 231 bool isExternallyVisible() const { 232 return clang::isExternallyVisible(getLinkageInternal()); 233 } 234 235 /// \brief Determines the visibility of this entity. 236 Visibility getVisibility() const { 237 return getLinkageAndVisibility().getVisibility(); 238 } 239 240 /// \brief Determines the linkage and visibility of this entity. 241 LinkageInfo getLinkageAndVisibility() const; 242 243 /// Kinds of explicit visibility. 244 enum ExplicitVisibilityKind { 245 VisibilityForType, 246 VisibilityForValue 247 }; 248 249 /// \brief If visibility was explicitly specified for this 250 /// declaration, return that visibility. 251 Optional<Visibility> 252 getExplicitVisibility(ExplicitVisibilityKind kind) const; 253 254 /// \brief True if the computed linkage is valid. Used for consistency 255 /// checking. Should always return true. 256 bool isLinkageValid() const; 257 258 /// \brief Looks through UsingDecls and ObjCCompatibleAliasDecls for 259 /// the underlying named decl. 260 NamedDecl *getUnderlyingDecl() { 261 // Fast-path the common case. 262 if (this->getKind() != UsingShadow && 263 this->getKind() != ObjCCompatibleAlias) 264 return this; 265 266 return getUnderlyingDeclImpl(); 267 } 268 const NamedDecl *getUnderlyingDecl() const { 269 return const_cast<NamedDecl*>(this)->getUnderlyingDecl(); 270 } 271 272 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 273 static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; } 274}; 275 276inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) { 277 ND.printName(OS); 278 return OS; 279} 280 281/// LabelDecl - Represents the declaration of a label. Labels also have a 282/// corresponding LabelStmt, which indicates the position that the label was 283/// defined at. For normal labels, the location of the decl is the same as the 284/// location of the statement. For GNU local labels (__label__), the decl 285/// location is where the __label__ is. 286class LabelDecl : public NamedDecl { 287 virtual void anchor(); 288 LabelStmt *TheStmt; 289 /// LocStart - For normal labels, this is the same as the main declaration 290 /// label, i.e., the location of the identifier; for GNU local labels, 291 /// this is the location of the __label__ keyword. 292 SourceLocation LocStart; 293 294 LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II, 295 LabelStmt *S, SourceLocation StartL) 296 : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {} 297 298public: 299 static LabelDecl *Create(ASTContext &C, DeclContext *DC, 300 SourceLocation IdentL, IdentifierInfo *II); 301 static LabelDecl *Create(ASTContext &C, DeclContext *DC, 302 SourceLocation IdentL, IdentifierInfo *II, 303 SourceLocation GnuLabelL); 304 static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID); 305 306 LabelStmt *getStmt() const { return TheStmt; } 307 void setStmt(LabelStmt *T) { TheStmt = T; } 308 309 bool isGnuLocal() const { return LocStart != getLocation(); } 310 void setLocStart(SourceLocation L) { LocStart = L; } 311 312 SourceRange getSourceRange() const LLVM_READONLY { 313 return SourceRange(LocStart, getLocation()); 314 } 315 316 // Implement isa/cast/dyncast/etc. 317 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 318 static bool classofKind(Kind K) { return K == Label; } 319}; 320 321/// NamespaceDecl - Represent a C++ namespace. 322class NamespaceDecl : public NamedDecl, public DeclContext, 323 public Redeclarable<NamespaceDecl> 324{ 325 virtual void anchor(); 326 327 /// LocStart - The starting location of the source range, pointing 328 /// to either the namespace or the inline keyword. 329 SourceLocation LocStart; 330 /// RBraceLoc - The ending location of the source range. 331 SourceLocation RBraceLoc; 332 333 /// \brief A pointer to either the anonymous namespace that lives just inside 334 /// this namespace or to the first namespace in the chain (the latter case 335 /// only when this is not the first in the chain), along with a 336 /// boolean value indicating whether this is an inline namespace. 337 llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline; 338 339 NamespaceDecl(DeclContext *DC, bool Inline, SourceLocation StartLoc, 340 SourceLocation IdLoc, IdentifierInfo *Id, 341 NamespaceDecl *PrevDecl); 342 343 typedef Redeclarable<NamespaceDecl> redeclarable_base; 344 virtual NamespaceDecl *getNextRedeclaration() { 345 return RedeclLink.getNext(); 346 } 347 virtual NamespaceDecl *getPreviousDeclImpl() { 348 return getPreviousDecl(); 349 } 350 virtual NamespaceDecl *getMostRecentDeclImpl() { 351 return getMostRecentDecl(); 352 } 353 354public: 355 static NamespaceDecl *Create(ASTContext &C, DeclContext *DC, 356 bool Inline, SourceLocation StartLoc, 357 SourceLocation IdLoc, IdentifierInfo *Id, 358 NamespaceDecl *PrevDecl); 359 360 static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID); 361 362 typedef redeclarable_base::redecl_iterator redecl_iterator; 363 using redeclarable_base::redecls_begin; 364 using redeclarable_base::redecls_end; 365 using redeclarable_base::getPreviousDecl; 366 using redeclarable_base::getMostRecentDecl; 367 368 /// \brief Returns true if this is an anonymous namespace declaration. 369 /// 370 /// For example: 371 /// \code 372 /// namespace { 373 /// ... 374 /// }; 375 /// \endcode 376 /// q.v. C++ [namespace.unnamed] 377 bool isAnonymousNamespace() const { 378 return !getIdentifier(); 379 } 380 381 /// \brief Returns true if this is an inline namespace declaration. 382 bool isInline() const { 383 return AnonOrFirstNamespaceAndInline.getInt(); 384 } 385 386 /// \brief Set whether this is an inline namespace declaration. 387 void setInline(bool Inline) { 388 AnonOrFirstNamespaceAndInline.setInt(Inline); 389 } 390 391 /// \brief Get the original (first) namespace declaration. 392 NamespaceDecl *getOriginalNamespace() { 393 if (isFirstDeclaration()) 394 return this; 395 396 return AnonOrFirstNamespaceAndInline.getPointer(); 397 } 398 399 /// \brief Get the original (first) namespace declaration. 400 const NamespaceDecl *getOriginalNamespace() const { 401 if (isFirstDeclaration()) 402 return this; 403 404 return AnonOrFirstNamespaceAndInline.getPointer(); 405 } 406 407 /// \brief Return true if this declaration is an original (first) declaration 408 /// of the namespace. This is false for non-original (subsequent) namespace 409 /// declarations and anonymous namespaces. 410 bool isOriginalNamespace() const { 411 return isFirstDeclaration(); 412 } 413 414 /// \brief Retrieve the anonymous namespace nested inside this namespace, 415 /// if any. 416 NamespaceDecl *getAnonymousNamespace() const { 417 return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer(); 418 } 419 420 void setAnonymousNamespace(NamespaceDecl *D) { 421 getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D); 422 } 423 424 /// Retrieves the canonical declaration of this namespace. 425 NamespaceDecl *getCanonicalDecl() { 426 return getOriginalNamespace(); 427 } 428 const NamespaceDecl *getCanonicalDecl() const { 429 return getOriginalNamespace(); 430 } 431 432 virtual SourceRange getSourceRange() const LLVM_READONLY { 433 return SourceRange(LocStart, RBraceLoc); 434 } 435 436 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; } 437 SourceLocation getRBraceLoc() const { return RBraceLoc; } 438 void setLocStart(SourceLocation L) { LocStart = L; } 439 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; } 440 441 // Implement isa/cast/dyncast/etc. 442 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 443 static bool classofKind(Kind K) { return K == Namespace; } 444 static DeclContext *castToDeclContext(const NamespaceDecl *D) { 445 return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D)); 446 } 447 static NamespaceDecl *castFromDeclContext(const DeclContext *DC) { 448 return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC)); 449 } 450 451 friend class ASTDeclReader; 452 friend class ASTDeclWriter; 453}; 454 455/// ValueDecl - Represent the declaration of a variable (in which case it is 456/// an lvalue) a function (in which case it is a function designator) or 457/// an enum constant. 458class ValueDecl : public NamedDecl { 459 virtual void anchor(); 460 QualType DeclType; 461 462protected: 463 ValueDecl(Kind DK, DeclContext *DC, SourceLocation L, 464 DeclarationName N, QualType T) 465 : NamedDecl(DK, DC, L, N), DeclType(T) {} 466public: 467 QualType getType() const { return DeclType; } 468 void setType(QualType newType) { DeclType = newType; } 469 470 /// \brief Determine whether this symbol is weakly-imported, 471 /// or declared with the weak or weak-ref attr. 472 bool isWeak() const; 473 474 // Implement isa/cast/dyncast/etc. 475 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 476 static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; } 477}; 478 479/// QualifierInfo - A struct with extended info about a syntactic 480/// name qualifier, to be used for the case of out-of-line declarations. 481struct QualifierInfo { 482 NestedNameSpecifierLoc QualifierLoc; 483 484 /// NumTemplParamLists - The number of "outer" template parameter lists. 485 /// The count includes all of the template parameter lists that were matched 486 /// against the template-ids occurring into the NNS and possibly (in the 487 /// case of an explicit specialization) a final "template <>". 488 unsigned NumTemplParamLists; 489 490 /// TemplParamLists - A new-allocated array of size NumTemplParamLists, 491 /// containing pointers to the "outer" template parameter lists. 492 /// It includes all of the template parameter lists that were matched 493 /// against the template-ids occurring into the NNS and possibly (in the 494 /// case of an explicit specialization) a final "template <>". 495 TemplateParameterList** TemplParamLists; 496 497 /// Default constructor. 498 QualifierInfo() : QualifierLoc(), NumTemplParamLists(0), TemplParamLists(0) {} 499 500 /// setTemplateParameterListsInfo - Sets info about "outer" template 501 /// parameter lists. 502 void setTemplateParameterListsInfo(ASTContext &Context, 503 unsigned NumTPLists, 504 TemplateParameterList **TPLists); 505 506private: 507 // Copy constructor and copy assignment are disabled. 508 QualifierInfo(const QualifierInfo&) LLVM_DELETED_FUNCTION; 509 QualifierInfo& operator=(const QualifierInfo&) LLVM_DELETED_FUNCTION; 510}; 511 512/// \brief Represents a ValueDecl that came out of a declarator. 513/// Contains type source information through TypeSourceInfo. 514class DeclaratorDecl : public ValueDecl { 515 // A struct representing both a TInfo and a syntactic qualifier, 516 // to be used for the (uncommon) case of out-of-line declarations. 517 struct ExtInfo : public QualifierInfo { 518 TypeSourceInfo *TInfo; 519 }; 520 521 llvm::PointerUnion<TypeSourceInfo*, ExtInfo*> DeclInfo; 522 523 /// InnerLocStart - The start of the source range for this declaration, 524 /// ignoring outer template declarations. 525 SourceLocation InnerLocStart; 526 527 bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); } 528 ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); } 529 const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); } 530 531protected: 532 DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L, 533 DeclarationName N, QualType T, TypeSourceInfo *TInfo, 534 SourceLocation StartL) 535 : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) { 536 } 537 538public: 539 TypeSourceInfo *getTypeSourceInfo() const { 540 return hasExtInfo() 541 ? getExtInfo()->TInfo 542 : DeclInfo.get<TypeSourceInfo*>(); 543 } 544 void setTypeSourceInfo(TypeSourceInfo *TI) { 545 if (hasExtInfo()) 546 getExtInfo()->TInfo = TI; 547 else 548 DeclInfo = TI; 549 } 550 551 /// getInnerLocStart - Return SourceLocation representing start of source 552 /// range ignoring outer template declarations. 553 SourceLocation getInnerLocStart() const { return InnerLocStart; } 554 void setInnerLocStart(SourceLocation L) { InnerLocStart = L; } 555 556 /// getOuterLocStart - Return SourceLocation representing start of source 557 /// range taking into account any outer template declarations. 558 SourceLocation getOuterLocStart() const; 559 560 virtual SourceRange getSourceRange() const LLVM_READONLY; 561 SourceLocation getLocStart() const LLVM_READONLY { 562 return getOuterLocStart(); 563 } 564 565 /// \brief Retrieve the nested-name-specifier that qualifies the name of this 566 /// declaration, if it was present in the source. 567 NestedNameSpecifier *getQualifier() const { 568 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier() 569 : 0; 570 } 571 572 /// \brief Retrieve the nested-name-specifier (with source-location 573 /// information) that qualifies the name of this declaration, if it was 574 /// present in the source. 575 NestedNameSpecifierLoc getQualifierLoc() const { 576 return hasExtInfo() ? getExtInfo()->QualifierLoc 577 : NestedNameSpecifierLoc(); 578 } 579 580 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc); 581 582 unsigned getNumTemplateParameterLists() const { 583 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0; 584 } 585 TemplateParameterList *getTemplateParameterList(unsigned index) const { 586 assert(index < getNumTemplateParameterLists()); 587 return getExtInfo()->TemplParamLists[index]; 588 } 589 void setTemplateParameterListsInfo(ASTContext &Context, unsigned NumTPLists, 590 TemplateParameterList **TPLists); 591 592 SourceLocation getTypeSpecStartLoc() const; 593 594 // Implement isa/cast/dyncast/etc. 595 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 596 static bool classofKind(Kind K) { 597 return K >= firstDeclarator && K <= lastDeclarator; 598 } 599 600 friend class ASTDeclReader; 601 friend class ASTDeclWriter; 602}; 603 604/// \brief Structure used to store a statement, the constant value to 605/// which it was evaluated (if any), and whether or not the statement 606/// is an integral constant expression (if known). 607struct EvaluatedStmt { 608 EvaluatedStmt() : WasEvaluated(false), IsEvaluating(false), CheckedICE(false), 609 CheckingICE(false), IsICE(false) { } 610 611 /// \brief Whether this statement was already evaluated. 612 bool WasEvaluated : 1; 613 614 /// \brief Whether this statement is being evaluated. 615 bool IsEvaluating : 1; 616 617 /// \brief Whether we already checked whether this statement was an 618 /// integral constant expression. 619 bool CheckedICE : 1; 620 621 /// \brief Whether we are checking whether this statement is an 622 /// integral constant expression. 623 bool CheckingICE : 1; 624 625 /// \brief Whether this statement is an integral constant expression, 626 /// or in C++11, whether the statement is a constant expression. Only 627 /// valid if CheckedICE is true. 628 bool IsICE : 1; 629 630 Stmt *Value; 631 APValue Evaluated; 632}; 633 634/// VarDecl - An instance of this class is created to represent a variable 635/// declaration or definition. 636class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> { 637public: 638 typedef clang::StorageClass StorageClass; 639 640 /// getStorageClassSpecifierString - Return the string used to 641 /// specify the storage class \p SC. 642 /// 643 /// It is illegal to call this function with SC == None. 644 static const char *getStorageClassSpecifierString(StorageClass SC); 645 646 /// \brief Initialization styles. 647 enum InitializationStyle { 648 CInit, ///< C-style initialization with assignment 649 CallInit, ///< Call-style initialization (C++98) 650 ListInit ///< Direct list-initialization (C++11) 651 }; 652 653 /// \brief Kinds of thread-local storage. 654 enum TLSKind { 655 TLS_None, ///< Not a TLS variable. 656 TLS_Static, ///< TLS with a known-constant initializer. 657 TLS_Dynamic ///< TLS with a dynamic initializer. 658 }; 659 660protected: 661 /// \brief Placeholder type used in Init to denote an unparsed C++ default 662 /// argument. 663 struct UnparsedDefaultArgument; 664 665 /// \brief Placeholder type used in Init to denote an uninstantiated C++ 666 /// default argument. 667 struct UninstantiatedDefaultArgument; 668 669 typedef llvm::PointerUnion4<Stmt *, EvaluatedStmt *, 670 UnparsedDefaultArgument *, 671 UninstantiatedDefaultArgument *> InitType; 672 673 /// \brief The initializer for this variable or, for a ParmVarDecl, the 674 /// C++ default argument. 675 mutable InitType Init; 676 677private: 678 class VarDeclBitfields { 679 friend class VarDecl; 680 friend class ASTDeclReader; 681 682 unsigned SClass : 3; 683 unsigned TSCSpec : 2; 684 unsigned InitStyle : 2; 685 686 /// \brief Whether this variable is the exception variable in a C++ catch 687 /// or an Objective-C @catch statement. 688 unsigned ExceptionVar : 1; 689 690 /// \brief Whether this local variable could be allocated in the return 691 /// slot of its function, enabling the named return value optimization 692 /// (NRVO). 693 unsigned NRVOVariable : 1; 694 695 /// \brief Whether this variable is the for-range-declaration in a C++0x 696 /// for-range statement. 697 unsigned CXXForRangeDecl : 1; 698 699 /// \brief Whether this variable is an ARC pseudo-__strong 700 /// variable; see isARCPseudoStrong() for details. 701 unsigned ARCPseudoStrong : 1; 702 703 /// \brief Whether this variable is (C++0x) constexpr. 704 unsigned IsConstexpr : 1; 705 }; 706 enum { NumVarDeclBits = 12 }; 707 708 friend class ASTDeclReader; 709 friend class StmtIteratorBase; 710 711protected: 712 enum { NumParameterIndexBits = 8 }; 713 714 class ParmVarDeclBitfields { 715 friend class ParmVarDecl; 716 friend class ASTDeclReader; 717 718 unsigned : NumVarDeclBits; 719 720 /// Whether this parameter inherits a default argument from a 721 /// prior declaration. 722 unsigned HasInheritedDefaultArg : 1; 723 724 /// Whether this parameter undergoes K&R argument promotion. 725 unsigned IsKNRPromoted : 1; 726 727 /// Whether this parameter is an ObjC method parameter or not. 728 unsigned IsObjCMethodParam : 1; 729 730 /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier. 731 /// Otherwise, the number of function parameter scopes enclosing 732 /// the function parameter scope in which this parameter was 733 /// declared. 734 unsigned ScopeDepthOrObjCQuals : 7; 735 736 /// The number of parameters preceding this parameter in the 737 /// function parameter scope in which it was declared. 738 unsigned ParameterIndex : NumParameterIndexBits; 739 }; 740 741 union { 742 unsigned AllBits; 743 VarDeclBitfields VarDeclBits; 744 ParmVarDeclBitfields ParmVarDeclBits; 745 }; 746 747 VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 748 SourceLocation IdLoc, IdentifierInfo *Id, 749 QualType T, TypeSourceInfo *TInfo, StorageClass SC) 750 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() { 751 assert(sizeof(VarDeclBitfields) <= sizeof(unsigned)); 752 assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned)); 753 AllBits = 0; 754 VarDeclBits.SClass = SC; 755 // Everything else is implicitly initialized to false. 756 } 757 758 typedef Redeclarable<VarDecl> redeclarable_base; 759 virtual VarDecl *getNextRedeclaration() { return RedeclLink.getNext(); } 760 virtual VarDecl *getPreviousDeclImpl() { 761 return getPreviousDecl(); 762 } 763 virtual VarDecl *getMostRecentDeclImpl() { 764 return getMostRecentDecl(); 765 } 766 767public: 768 typedef redeclarable_base::redecl_iterator redecl_iterator; 769 using redeclarable_base::redecls_begin; 770 using redeclarable_base::redecls_end; 771 using redeclarable_base::getPreviousDecl; 772 using redeclarable_base::getMostRecentDecl; 773 774 static VarDecl *Create(ASTContext &C, DeclContext *DC, 775 SourceLocation StartLoc, SourceLocation IdLoc, 776 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, 777 StorageClass S); 778 779 static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID); 780 781 virtual SourceRange getSourceRange() const LLVM_READONLY; 782 783 /// \brief Returns the storage class as written in the source. For the 784 /// computed linkage of symbol, see getLinkage. 785 StorageClass getStorageClass() const { 786 return (StorageClass) VarDeclBits.SClass; 787 } 788 void setStorageClass(StorageClass SC); 789 790 void setTSCSpec(ThreadStorageClassSpecifier TSC) { 791 VarDeclBits.TSCSpec = TSC; 792 } 793 ThreadStorageClassSpecifier getTSCSpec() const { 794 return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec); 795 } 796 TLSKind getTLSKind() const { 797 switch (VarDeclBits.TSCSpec) { 798 case TSCS_unspecified: 799 return TLS_None; 800 case TSCS___thread: // Fall through. 801 case TSCS__Thread_local: 802 return TLS_Static; 803 case TSCS_thread_local: 804 return TLS_Dynamic; 805 } 806 llvm_unreachable("Unknown thread storage class specifier!"); 807 } 808 809 /// hasLocalStorage - Returns true if a variable with function scope 810 /// is a non-static local variable. 811 bool hasLocalStorage() const { 812 if (getStorageClass() == SC_None) 813 // Second check is for C++11 [dcl.stc]p4. 814 return !isFileVarDecl() && getTSCSpec() != TSCS_thread_local; 815 816 // Return true for: Auto, Register. 817 // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal. 818 819 return getStorageClass() >= SC_Auto; 820 } 821 822 /// isStaticLocal - Returns true if a variable with function scope is a 823 /// static local variable. 824 bool isStaticLocal() const { 825 return (getStorageClass() == SC_Static || 826 // C++11 [dcl.stc]p4 827 (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local)) 828 && !isFileVarDecl(); 829 } 830 831 /// \brief Returns true if a variable has extern or __private_extern__ 832 /// storage. 833 bool hasExternalStorage() const { 834 return getStorageClass() == SC_Extern || 835 getStorageClass() == SC_PrivateExtern; 836 } 837 838 /// hasGlobalStorage - Returns true for all variables that do not 839 /// have local storage. This includs all global variables as well 840 /// as static variables declared within a function. 841 bool hasGlobalStorage() const { return !hasLocalStorage(); } 842 843 /// Compute the language linkage. 844 LanguageLinkage getLanguageLinkage() const; 845 846 /// \brief Determines whether this variable is a variable with 847 /// external, C linkage. 848 bool isExternC() const; 849 850 /// \brief Determines whether this variable's context is, or is nested within, 851 /// a C++ extern "C" linkage spec. 852 bool isInExternCContext() const; 853 854 /// \brief Determines whether this variable's context is, or is nested within, 855 /// a C++ extern "C++" linkage spec. 856 bool isInExternCXXContext() const; 857 858 /// isLocalVarDecl - Returns true for local variable declarations 859 /// other than parameters. Note that this includes static variables 860 /// inside of functions. It also includes variables inside blocks. 861 /// 862 /// void foo() { int x; static int y; extern int z; } 863 /// 864 bool isLocalVarDecl() const { 865 if (getKind() != Decl::Var) 866 return false; 867 if (const DeclContext *DC = getDeclContext()) 868 return DC->getRedeclContext()->isFunctionOrMethod(); 869 return false; 870 } 871 872 /// isFunctionOrMethodVarDecl - Similar to isLocalVarDecl, but 873 /// excludes variables declared in blocks. 874 bool isFunctionOrMethodVarDecl() const { 875 if (getKind() != Decl::Var) 876 return false; 877 const DeclContext *DC = getDeclContext()->getRedeclContext(); 878 return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block; 879 } 880 881 /// \brief Determines whether this is a static data member. 882 /// 883 /// This will only be true in C++, and applies to, e.g., the 884 /// variable 'x' in: 885 /// \code 886 /// struct S { 887 /// static int x; 888 /// }; 889 /// \endcode 890 bool isStaticDataMember() const { 891 // If it wasn't static, it would be a FieldDecl. 892 return getKind() != Decl::ParmVar && getDeclContext()->isRecord(); 893 } 894 895 virtual VarDecl *getCanonicalDecl(); 896 const VarDecl *getCanonicalDecl() const { 897 return const_cast<VarDecl*>(this)->getCanonicalDecl(); 898 } 899 900 enum DefinitionKind { 901 DeclarationOnly, ///< This declaration is only a declaration. 902 TentativeDefinition, ///< This declaration is a tentative definition. 903 Definition ///< This declaration is definitely a definition. 904 }; 905 906 /// \brief Check whether this declaration is a definition. If this could be 907 /// a tentative definition (in C), don't check whether there's an overriding 908 /// definition. 909 DefinitionKind isThisDeclarationADefinition(ASTContext &) const; 910 DefinitionKind isThisDeclarationADefinition() const { 911 return isThisDeclarationADefinition(getASTContext()); 912 } 913 914 /// \brief Check whether this variable is defined in this 915 /// translation unit. 916 DefinitionKind hasDefinition(ASTContext &) const; 917 DefinitionKind hasDefinition() const { 918 return hasDefinition(getASTContext()); 919 } 920 921 /// \brief Get the tentative definition that acts as the real definition in 922 /// a TU. Returns null if there is a proper definition available. 923 VarDecl *getActingDefinition(); 924 const VarDecl *getActingDefinition() const { 925 return const_cast<VarDecl*>(this)->getActingDefinition(); 926 } 927 928 /// \brief Determine whether this is a tentative definition of a 929 /// variable in C. 930 bool isTentativeDefinitionNow() const; 931 932 /// \brief Get the real (not just tentative) definition for this declaration. 933 VarDecl *getDefinition(ASTContext &); 934 const VarDecl *getDefinition(ASTContext &C) const { 935 return const_cast<VarDecl*>(this)->getDefinition(C); 936 } 937 VarDecl *getDefinition() { 938 return getDefinition(getASTContext()); 939 } 940 const VarDecl *getDefinition() const { 941 return const_cast<VarDecl*>(this)->getDefinition(); 942 } 943 944 /// \brief Determine whether this is or was instantiated from an out-of-line 945 /// definition of a static data member. 946 virtual bool isOutOfLine() const; 947 948 /// \brief If this is a static data member, find its out-of-line definition. 949 VarDecl *getOutOfLineDefinition(); 950 951 /// isFileVarDecl - Returns true for file scoped variable declaration. 952 bool isFileVarDecl() const { 953 if (getKind() != Decl::Var) 954 return false; 955 956 if (getDeclContext()->getRedeclContext()->isFileContext()) 957 return true; 958 959 if (isStaticDataMember()) 960 return true; 961 962 return false; 963 } 964 965 /// getAnyInitializer - Get the initializer for this variable, no matter which 966 /// declaration it is attached to. 967 const Expr *getAnyInitializer() const { 968 const VarDecl *D; 969 return getAnyInitializer(D); 970 } 971 972 /// getAnyInitializer - Get the initializer for this variable, no matter which 973 /// declaration it is attached to. Also get that declaration. 974 const Expr *getAnyInitializer(const VarDecl *&D) const; 975 976 bool hasInit() const { 977 return !Init.isNull() && (Init.is<Stmt *>() || Init.is<EvaluatedStmt *>()); 978 } 979 const Expr *getInit() const { 980 if (Init.isNull()) 981 return 0; 982 983 const Stmt *S = Init.dyn_cast<Stmt *>(); 984 if (!S) { 985 if (EvaluatedStmt *ES = Init.dyn_cast<EvaluatedStmt*>()) 986 S = ES->Value; 987 } 988 return (const Expr*) S; 989 } 990 Expr *getInit() { 991 if (Init.isNull()) 992 return 0; 993 994 Stmt *S = Init.dyn_cast<Stmt *>(); 995 if (!S) { 996 if (EvaluatedStmt *ES = Init.dyn_cast<EvaluatedStmt*>()) 997 S = ES->Value; 998 } 999 1000 return (Expr*) S; 1001 } 1002 1003 /// \brief Retrieve the address of the initializer expression. 1004 Stmt **getInitAddress() { 1005 if (EvaluatedStmt *ES = Init.dyn_cast<EvaluatedStmt*>()) 1006 return &ES->Value; 1007 1008 // This union hack tip-toes around strict-aliasing rules. 1009 union { 1010 InitType *InitPtr; 1011 Stmt **StmtPtr; 1012 }; 1013 1014 InitPtr = &Init; 1015 return StmtPtr; 1016 } 1017 1018 void setInit(Expr *I); 1019 1020 /// \brief Determine whether this variable is a reference that 1021 /// extends the lifetime of its temporary initializer. 1022 /// 1023 /// A reference extends the lifetime of its temporary initializer if 1024 /// it's initializer is an rvalue that would normally go out of scope 1025 /// at the end of the initializer (a full expression). In such cases, 1026 /// the reference itself takes ownership of the temporary, which will 1027 /// be destroyed when the reference goes out of scope. For example: 1028 /// 1029 /// \code 1030 /// const int &r = 1.0; // creates a temporary of type 'int' 1031 /// \endcode 1032 bool extendsLifetimeOfTemporary() const; 1033 1034 /// \brief Determine whether this variable's value can be used in a 1035 /// constant expression, according to the relevant language standard. 1036 /// This only checks properties of the declaration, and does not check 1037 /// whether the initializer is in fact a constant expression. 1038 bool isUsableInConstantExpressions(ASTContext &C) const; 1039 1040 EvaluatedStmt *ensureEvaluatedStmt() const; 1041 1042 /// \brief Attempt to evaluate the value of the initializer attached to this 1043 /// declaration, and produce notes explaining why it cannot be evaluated or is 1044 /// not a constant expression. Returns a pointer to the value if evaluation 1045 /// succeeded, 0 otherwise. 1046 APValue *evaluateValue() const; 1047 APValue *evaluateValue(SmallVectorImpl<PartialDiagnosticAt> &Notes) const; 1048 1049 /// \brief Return the already-evaluated value of this variable's 1050 /// initializer, or NULL if the value is not yet known. Returns pointer 1051 /// to untyped APValue if the value could not be evaluated. 1052 APValue *getEvaluatedValue() const { 1053 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) 1054 if (Eval->WasEvaluated) 1055 return &Eval->Evaluated; 1056 1057 return 0; 1058 } 1059 1060 /// \brief Determines whether it is already known whether the 1061 /// initializer is an integral constant expression or not. 1062 bool isInitKnownICE() const { 1063 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) 1064 return Eval->CheckedICE; 1065 1066 return false; 1067 } 1068 1069 /// \brief Determines whether the initializer is an integral constant 1070 /// expression, or in C++11, whether the initializer is a constant 1071 /// expression. 1072 /// 1073 /// \pre isInitKnownICE() 1074 bool isInitICE() const { 1075 assert(isInitKnownICE() && 1076 "Check whether we already know that the initializer is an ICE"); 1077 return Init.get<EvaluatedStmt *>()->IsICE; 1078 } 1079 1080 /// \brief Determine whether the value of the initializer attached to this 1081 /// declaration is an integral constant expression. 1082 bool checkInitIsICE() const; 1083 1084 void setInitStyle(InitializationStyle Style) { 1085 VarDeclBits.InitStyle = Style; 1086 } 1087 1088 /// \brief The style of initialization for this declaration. 1089 /// 1090 /// C-style initialization is "int x = 1;". Call-style initialization is 1091 /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be 1092 /// the expression inside the parens or a "ClassType(a,b,c)" class constructor 1093 /// expression for class types. List-style initialization is C++11 syntax, 1094 /// e.g. "int x{1};". Clients can distinguish between different forms of 1095 /// initialization by checking this value. In particular, "int x = {1};" is 1096 /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the 1097 /// Init expression in all three cases is an InitListExpr. 1098 InitializationStyle getInitStyle() const { 1099 return static_cast<InitializationStyle>(VarDeclBits.InitStyle); 1100 } 1101 1102 /// \brief Whether the initializer is a direct-initializer (list or call). 1103 bool isDirectInit() const { 1104 return getInitStyle() != CInit; 1105 } 1106 1107 /// \brief Determine whether this variable is the exception variable in a 1108 /// C++ catch statememt or an Objective-C \@catch statement. 1109 bool isExceptionVariable() const { 1110 return VarDeclBits.ExceptionVar; 1111 } 1112 void setExceptionVariable(bool EV) { VarDeclBits.ExceptionVar = EV; } 1113 1114 /// \brief Determine whether this local variable can be used with the named 1115 /// return value optimization (NRVO). 1116 /// 1117 /// The named return value optimization (NRVO) works by marking certain 1118 /// non-volatile local variables of class type as NRVO objects. These 1119 /// locals can be allocated within the return slot of their containing 1120 /// function, in which case there is no need to copy the object to the 1121 /// return slot when returning from the function. Within the function body, 1122 /// each return that returns the NRVO object will have this variable as its 1123 /// NRVO candidate. 1124 bool isNRVOVariable() const { return VarDeclBits.NRVOVariable; } 1125 void setNRVOVariable(bool NRVO) { VarDeclBits.NRVOVariable = NRVO; } 1126 1127 /// \brief Determine whether this variable is the for-range-declaration in 1128 /// a C++0x for-range statement. 1129 bool isCXXForRangeDecl() const { return VarDeclBits.CXXForRangeDecl; } 1130 void setCXXForRangeDecl(bool FRD) { VarDeclBits.CXXForRangeDecl = FRD; } 1131 1132 /// \brief Determine whether this variable is an ARC pseudo-__strong 1133 /// variable. A pseudo-__strong variable has a __strong-qualified 1134 /// type but does not actually retain the object written into it. 1135 /// Generally such variables are also 'const' for safety. 1136 bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; } 1137 void setARCPseudoStrong(bool ps) { VarDeclBits.ARCPseudoStrong = ps; } 1138 1139 /// Whether this variable is (C++11) constexpr. 1140 bool isConstexpr() const { return VarDeclBits.IsConstexpr; } 1141 void setConstexpr(bool IC) { VarDeclBits.IsConstexpr = IC; } 1142 1143 /// \brief If this variable is an instantiated static data member of a 1144 /// class template specialization, returns the templated static data member 1145 /// from which it was instantiated. 1146 VarDecl *getInstantiatedFromStaticDataMember() const; 1147 1148 /// \brief If this variable is a static data member, determine what kind of 1149 /// template specialization or instantiation this is. 1150 TemplateSpecializationKind getTemplateSpecializationKind() const; 1151 1152 /// \brief If this variable is an instantiation of a static data member of a 1153 /// class template specialization, retrieves the member specialization 1154 /// information. 1155 MemberSpecializationInfo *getMemberSpecializationInfo() const; 1156 1157 /// \brief For a static data member that was instantiated from a static 1158 /// data member of a class template, set the template specialiation kind. 1159 void setTemplateSpecializationKind(TemplateSpecializationKind TSK, 1160 SourceLocation PointOfInstantiation = SourceLocation()); 1161 1162 // Implement isa/cast/dyncast/etc. 1163 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 1164 static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; } 1165}; 1166 1167class ImplicitParamDecl : public VarDecl { 1168 virtual void anchor(); 1169public: 1170 static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC, 1171 SourceLocation IdLoc, IdentifierInfo *Id, 1172 QualType T); 1173 1174 static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID); 1175 1176 ImplicitParamDecl(DeclContext *DC, SourceLocation IdLoc, 1177 IdentifierInfo *Id, QualType Type) 1178 : VarDecl(ImplicitParam, DC, IdLoc, IdLoc, Id, Type, 1179 /*tinfo*/ 0, SC_None) { 1180 setImplicit(); 1181 } 1182 1183 // Implement isa/cast/dyncast/etc. 1184 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 1185 static bool classofKind(Kind K) { return K == ImplicitParam; } 1186}; 1187 1188/// ParmVarDecl - Represents a parameter to a function. 1189class ParmVarDecl : public VarDecl { 1190public: 1191 enum { MaxFunctionScopeDepth = 255 }; 1192 enum { MaxFunctionScopeIndex = 255 }; 1193 1194protected: 1195 ParmVarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 1196 SourceLocation IdLoc, IdentifierInfo *Id, 1197 QualType T, TypeSourceInfo *TInfo, 1198 StorageClass S, Expr *DefArg) 1199 : VarDecl(DK, DC, StartLoc, IdLoc, Id, T, TInfo, S) { 1200 assert(ParmVarDeclBits.HasInheritedDefaultArg == false); 1201 assert(ParmVarDeclBits.IsKNRPromoted == false); 1202 assert(ParmVarDeclBits.IsObjCMethodParam == false); 1203 setDefaultArg(DefArg); 1204 } 1205 1206public: 1207 static ParmVarDecl *Create(ASTContext &C, DeclContext *DC, 1208 SourceLocation StartLoc, 1209 SourceLocation IdLoc, IdentifierInfo *Id, 1210 QualType T, TypeSourceInfo *TInfo, 1211 StorageClass S, Expr *DefArg); 1212 1213 static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID); 1214 1215 virtual SourceRange getSourceRange() const LLVM_READONLY; 1216 1217 void setObjCMethodScopeInfo(unsigned parameterIndex) { 1218 ParmVarDeclBits.IsObjCMethodParam = true; 1219 setParameterIndex(parameterIndex); 1220 } 1221 1222 void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) { 1223 assert(!ParmVarDeclBits.IsObjCMethodParam); 1224 1225 ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth; 1226 assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth 1227 && "truncation!"); 1228 1229 setParameterIndex(parameterIndex); 1230 } 1231 1232 bool isObjCMethodParameter() const { 1233 return ParmVarDeclBits.IsObjCMethodParam; 1234 } 1235 1236 unsigned getFunctionScopeDepth() const { 1237 if (ParmVarDeclBits.IsObjCMethodParam) return 0; 1238 return ParmVarDeclBits.ScopeDepthOrObjCQuals; 1239 } 1240 1241 /// Returns the index of this parameter in its prototype or method scope. 1242 unsigned getFunctionScopeIndex() const { 1243 return getParameterIndex(); 1244 } 1245 1246 ObjCDeclQualifier getObjCDeclQualifier() const { 1247 if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None; 1248 return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals); 1249 } 1250 void setObjCDeclQualifier(ObjCDeclQualifier QTVal) { 1251 assert(ParmVarDeclBits.IsObjCMethodParam); 1252 ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal; 1253 } 1254 1255 /// True if the value passed to this parameter must undergo 1256 /// K&R-style default argument promotion: 1257 /// 1258 /// C99 6.5.2.2. 1259 /// If the expression that denotes the called function has a type 1260 /// that does not include a prototype, the integer promotions are 1261 /// performed on each argument, and arguments that have type float 1262 /// are promoted to double. 1263 bool isKNRPromoted() const { 1264 return ParmVarDeclBits.IsKNRPromoted; 1265 } 1266 void setKNRPromoted(bool promoted) { 1267 ParmVarDeclBits.IsKNRPromoted = promoted; 1268 } 1269 1270 Expr *getDefaultArg(); 1271 const Expr *getDefaultArg() const { 1272 return const_cast<ParmVarDecl *>(this)->getDefaultArg(); 1273 } 1274 1275 void setDefaultArg(Expr *defarg) { 1276 Init = reinterpret_cast<Stmt *>(defarg); 1277 } 1278 1279 /// \brief Retrieve the source range that covers the entire default 1280 /// argument. 1281 SourceRange getDefaultArgRange() const; 1282 void setUninstantiatedDefaultArg(Expr *arg) { 1283 Init = reinterpret_cast<UninstantiatedDefaultArgument *>(arg); 1284 } 1285 Expr *getUninstantiatedDefaultArg() { 1286 return (Expr *)Init.get<UninstantiatedDefaultArgument *>(); 1287 } 1288 const Expr *getUninstantiatedDefaultArg() const { 1289 return (const Expr *)Init.get<UninstantiatedDefaultArgument *>(); 1290 } 1291 1292 /// hasDefaultArg - Determines whether this parameter has a default argument, 1293 /// either parsed or not. 1294 bool hasDefaultArg() const { 1295 return getInit() || hasUnparsedDefaultArg() || 1296 hasUninstantiatedDefaultArg(); 1297 } 1298 1299 /// hasUnparsedDefaultArg - Determines whether this parameter has a 1300 /// default argument that has not yet been parsed. This will occur 1301 /// during the processing of a C++ class whose member functions have 1302 /// default arguments, e.g., 1303 /// @code 1304 /// class X { 1305 /// public: 1306 /// void f(int x = 17); // x has an unparsed default argument now 1307 /// }; // x has a regular default argument now 1308 /// @endcode 1309 bool hasUnparsedDefaultArg() const { 1310 return Init.is<UnparsedDefaultArgument*>(); 1311 } 1312 1313 bool hasUninstantiatedDefaultArg() const { 1314 return Init.is<UninstantiatedDefaultArgument*>(); 1315 } 1316 1317 /// setUnparsedDefaultArg - Specify that this parameter has an 1318 /// unparsed default argument. The argument will be replaced with a 1319 /// real default argument via setDefaultArg when the class 1320 /// definition enclosing the function declaration that owns this 1321 /// default argument is completed. 1322 void setUnparsedDefaultArg() { 1323 Init = (UnparsedDefaultArgument *)0; 1324 } 1325 1326 bool hasInheritedDefaultArg() const { 1327 return ParmVarDeclBits.HasInheritedDefaultArg; 1328 } 1329 1330 void setHasInheritedDefaultArg(bool I = true) { 1331 ParmVarDeclBits.HasInheritedDefaultArg = I; 1332 } 1333 1334 QualType getOriginalType() const { 1335 if (getTypeSourceInfo()) 1336 return getTypeSourceInfo()->getType(); 1337 return getType(); 1338 } 1339 1340 /// \brief Determine whether this parameter is actually a function 1341 /// parameter pack. 1342 bool isParameterPack() const; 1343 1344 /// setOwningFunction - Sets the function declaration that owns this 1345 /// ParmVarDecl. Since ParmVarDecls are often created before the 1346 /// FunctionDecls that own them, this routine is required to update 1347 /// the DeclContext appropriately. 1348 void setOwningFunction(DeclContext *FD) { setDeclContext(FD); } 1349 1350 // Implement isa/cast/dyncast/etc. 1351 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 1352 static bool classofKind(Kind K) { return K == ParmVar; } 1353 1354private: 1355 enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 }; 1356 1357 void setParameterIndex(unsigned parameterIndex) { 1358 if (parameterIndex >= ParameterIndexSentinel) { 1359 setParameterIndexLarge(parameterIndex); 1360 return; 1361 } 1362 1363 ParmVarDeclBits.ParameterIndex = parameterIndex; 1364 assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!"); 1365 } 1366 unsigned getParameterIndex() const { 1367 unsigned d = ParmVarDeclBits.ParameterIndex; 1368 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d; 1369 } 1370 1371 void setParameterIndexLarge(unsigned parameterIndex); 1372 unsigned getParameterIndexLarge() const; 1373}; 1374 1375/// FunctionDecl - An instance of this class is created to represent a 1376/// function declaration or definition. 1377/// 1378/// Since a given function can be declared several times in a program, 1379/// there may be several FunctionDecls that correspond to that 1380/// function. Only one of those FunctionDecls will be found when 1381/// traversing the list of declarations in the context of the 1382/// FunctionDecl (e.g., the translation unit); this FunctionDecl 1383/// contains all of the information known about the function. Other, 1384/// previous declarations of the function are available via the 1385/// getPreviousDecl() chain. 1386class FunctionDecl : public DeclaratorDecl, public DeclContext, 1387 public Redeclarable<FunctionDecl> { 1388public: 1389 typedef clang::StorageClass StorageClass; 1390 1391 /// \brief The kind of templated function a FunctionDecl can be. 1392 enum TemplatedKind { 1393 TK_NonTemplate, 1394 TK_FunctionTemplate, 1395 TK_MemberSpecialization, 1396 TK_FunctionTemplateSpecialization, 1397 TK_DependentFunctionTemplateSpecialization 1398 }; 1399 1400private: 1401 /// ParamInfo - new[]'d array of pointers to VarDecls for the formal 1402 /// parameters of this function. This is null if a prototype or if there are 1403 /// no formals. 1404 ParmVarDecl **ParamInfo; 1405 1406 /// DeclsInPrototypeScope - Array of pointers to NamedDecls for 1407 /// decls defined in the function prototype that are not parameters. E.g. 1408 /// 'enum Y' in 'void f(enum Y {AA} x) {}'. 1409 ArrayRef<NamedDecl *> DeclsInPrototypeScope; 1410 1411 LazyDeclStmtPtr Body; 1412 1413 // FIXME: This can be packed into the bitfields in Decl. 1414 // NOTE: VC++ treats enums as signed, avoid using the StorageClass enum 1415 unsigned SClass : 2; 1416 bool IsInline : 1; 1417 bool IsInlineSpecified : 1; 1418 bool IsVirtualAsWritten : 1; 1419 bool IsPure : 1; 1420 bool HasInheritedPrototype : 1; 1421 bool HasWrittenPrototype : 1; 1422 bool IsDeleted : 1; 1423 bool IsTrivial : 1; // sunk from CXXMethodDecl 1424 bool IsDefaulted : 1; // sunk from CXXMethoDecl 1425 bool IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl 1426 bool HasImplicitReturnZero : 1; 1427 bool IsLateTemplateParsed : 1; 1428 bool IsConstexpr : 1; 1429 1430 /// \brief Indicates if the function was a definition but its body was 1431 /// skipped. 1432 unsigned HasSkippedBody : 1; 1433 1434 /// \brief End part of this FunctionDecl's source range. 1435 /// 1436 /// We could compute the full range in getSourceRange(). However, when we're 1437 /// dealing with a function definition deserialized from a PCH/AST file, 1438 /// we can only compute the full range once the function body has been 1439 /// de-serialized, so it's far better to have the (sometimes-redundant) 1440 /// EndRangeLoc. 1441 SourceLocation EndRangeLoc; 1442 1443 /// \brief The template or declaration that this declaration 1444 /// describes or was instantiated from, respectively. 1445 /// 1446 /// For non-templates, this value will be NULL. For function 1447 /// declarations that describe a function template, this will be a 1448 /// pointer to a FunctionTemplateDecl. For member functions 1449 /// of class template specializations, this will be a MemberSpecializationInfo 1450 /// pointer containing information about the specialization. 1451 /// For function template specializations, this will be a 1452 /// FunctionTemplateSpecializationInfo, which contains information about 1453 /// the template being specialized and the template arguments involved in 1454 /// that specialization. 1455 llvm::PointerUnion4<FunctionTemplateDecl *, 1456 MemberSpecializationInfo *, 1457 FunctionTemplateSpecializationInfo *, 1458 DependentFunctionTemplateSpecializationInfo *> 1459 TemplateOrSpecialization; 1460 1461 /// DNLoc - Provides source/type location info for the 1462 /// declaration name embedded in the DeclaratorDecl base class. 1463 DeclarationNameLoc DNLoc; 1464 1465 /// \brief Specify that this function declaration is actually a function 1466 /// template specialization. 1467 /// 1468 /// \param C the ASTContext. 1469 /// 1470 /// \param Template the function template that this function template 1471 /// specialization specializes. 1472 /// 1473 /// \param TemplateArgs the template arguments that produced this 1474 /// function template specialization from the template. 1475 /// 1476 /// \param InsertPos If non-NULL, the position in the function template 1477 /// specialization set where the function template specialization data will 1478 /// be inserted. 1479 /// 1480 /// \param TSK the kind of template specialization this is. 1481 /// 1482 /// \param TemplateArgsAsWritten location info of template arguments. 1483 /// 1484 /// \param PointOfInstantiation point at which the function template 1485 /// specialization was first instantiated. 1486 void setFunctionTemplateSpecialization(ASTContext &C, 1487 FunctionTemplateDecl *Template, 1488 const TemplateArgumentList *TemplateArgs, 1489 void *InsertPos, 1490 TemplateSpecializationKind TSK, 1491 const TemplateArgumentListInfo *TemplateArgsAsWritten, 1492 SourceLocation PointOfInstantiation); 1493 1494 /// \brief Specify that this record is an instantiation of the 1495 /// member function FD. 1496 void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD, 1497 TemplateSpecializationKind TSK); 1498 1499 void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo); 1500 1501protected: 1502 FunctionDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 1503 const DeclarationNameInfo &NameInfo, 1504 QualType T, TypeSourceInfo *TInfo, 1505 StorageClass S, bool isInlineSpecified, 1506 bool isConstexprSpecified) 1507 : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo, 1508 StartLoc), 1509 DeclContext(DK), 1510 ParamInfo(0), Body(), 1511 SClass(S), 1512 IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified), 1513 IsVirtualAsWritten(false), IsPure(false), HasInheritedPrototype(false), 1514 HasWrittenPrototype(true), IsDeleted(false), IsTrivial(false), 1515 IsDefaulted(false), IsExplicitlyDefaulted(false), 1516 HasImplicitReturnZero(false), IsLateTemplateParsed(false), 1517 IsConstexpr(isConstexprSpecified), HasSkippedBody(false), 1518 EndRangeLoc(NameInfo.getEndLoc()), 1519 TemplateOrSpecialization(), 1520 DNLoc(NameInfo.getInfo()) {} 1521 1522 typedef Redeclarable<FunctionDecl> redeclarable_base; 1523 virtual FunctionDecl *getNextRedeclaration() { return RedeclLink.getNext(); } 1524 virtual FunctionDecl *getPreviousDeclImpl() { 1525 return getPreviousDecl(); 1526 } 1527 virtual FunctionDecl *getMostRecentDeclImpl() { 1528 return getMostRecentDecl(); 1529 } 1530 1531public: 1532 typedef redeclarable_base::redecl_iterator redecl_iterator; 1533 using redeclarable_base::redecls_begin; 1534 using redeclarable_base::redecls_end; 1535 using redeclarable_base::getPreviousDecl; 1536 using redeclarable_base::getMostRecentDecl; 1537 1538 static FunctionDecl *Create(ASTContext &C, DeclContext *DC, 1539 SourceLocation StartLoc, SourceLocation NLoc, 1540 DeclarationName N, QualType T, 1541 TypeSourceInfo *TInfo, 1542 StorageClass SC, 1543 bool isInlineSpecified = false, 1544 bool hasWrittenPrototype = true, 1545 bool isConstexprSpecified = false) { 1546 DeclarationNameInfo NameInfo(N, NLoc); 1547 return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, 1548 SC, 1549 isInlineSpecified, hasWrittenPrototype, 1550 isConstexprSpecified); 1551 } 1552 1553 static FunctionDecl *Create(ASTContext &C, DeclContext *DC, 1554 SourceLocation StartLoc, 1555 const DeclarationNameInfo &NameInfo, 1556 QualType T, TypeSourceInfo *TInfo, 1557 StorageClass SC, 1558 bool isInlineSpecified, 1559 bool hasWrittenPrototype, 1560 bool isConstexprSpecified = false); 1561 1562 static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID); 1563 1564 DeclarationNameInfo getNameInfo() const { 1565 return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc); 1566 } 1567 1568 virtual void getNameForDiagnostic(raw_ostream &OS, 1569 const PrintingPolicy &Policy, 1570 bool Qualified) const; 1571 1572 void setRangeEnd(SourceLocation E) { EndRangeLoc = E; } 1573 1574 virtual SourceRange getSourceRange() const LLVM_READONLY; 1575 1576 /// \brief Returns true if the function has a body (definition). The 1577 /// function body might be in any of the (re-)declarations of this 1578 /// function. The variant that accepts a FunctionDecl pointer will 1579 /// set that function declaration to the actual declaration 1580 /// containing the body (if there is one). 1581 bool hasBody(const FunctionDecl *&Definition) const; 1582 1583 virtual bool hasBody() const { 1584 const FunctionDecl* Definition; 1585 return hasBody(Definition); 1586 } 1587 1588 /// hasTrivialBody - Returns whether the function has a trivial body that does 1589 /// not require any specific codegen. 1590 bool hasTrivialBody() const; 1591 1592 /// isDefined - Returns true if the function is defined at all, including 1593 /// a deleted definition. Except for the behavior when the function is 1594 /// deleted, behaves like hasBody. 1595 bool isDefined(const FunctionDecl *&Definition) const; 1596 1597 virtual bool isDefined() const { 1598 const FunctionDecl* Definition; 1599 return isDefined(Definition); 1600 } 1601 1602 /// getBody - Retrieve the body (definition) of the function. The 1603 /// function body might be in any of the (re-)declarations of this 1604 /// function. The variant that accepts a FunctionDecl pointer will 1605 /// set that function declaration to the actual declaration 1606 /// containing the body (if there is one). 1607 /// NOTE: For checking if there is a body, use hasBody() instead, to avoid 1608 /// unnecessary AST de-serialization of the body. 1609 Stmt *getBody(const FunctionDecl *&Definition) const; 1610 1611 virtual Stmt *getBody() const { 1612 const FunctionDecl* Definition; 1613 return getBody(Definition); 1614 } 1615 1616 /// isThisDeclarationADefinition - Returns whether this specific 1617 /// declaration of the function is also a definition. This does not 1618 /// determine whether the function has been defined (e.g., in a 1619 /// previous definition); for that information, use isDefined. Note 1620 /// that this returns false for a defaulted function unless that function 1621 /// has been implicitly defined (possibly as deleted). 1622 bool isThisDeclarationADefinition() const { 1623 return IsDeleted || Body || IsLateTemplateParsed; 1624 } 1625 1626 /// doesThisDeclarationHaveABody - Returns whether this specific 1627 /// declaration of the function has a body - that is, if it is a non- 1628 /// deleted definition. 1629 bool doesThisDeclarationHaveABody() const { 1630 return Body || IsLateTemplateParsed; 1631 } 1632 1633 void setBody(Stmt *B); 1634 void setLazyBody(uint64_t Offset) { Body = Offset; } 1635 1636 /// Whether this function is variadic. 1637 bool isVariadic() const; 1638 1639 /// Whether this function is marked as virtual explicitly. 1640 bool isVirtualAsWritten() const { return IsVirtualAsWritten; } 1641 void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; } 1642 1643 /// Whether this virtual function is pure, i.e. makes the containing class 1644 /// abstract. 1645 bool isPure() const { return IsPure; } 1646 void setPure(bool P = true); 1647 1648 /// Whether this templated function will be late parsed. 1649 bool isLateTemplateParsed() const { return IsLateTemplateParsed; } 1650 void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; } 1651 1652 /// Whether this function is "trivial" in some specialized C++ senses. 1653 /// Can only be true for default constructors, copy constructors, 1654 /// copy assignment operators, and destructors. Not meaningful until 1655 /// the class has been fully built by Sema. 1656 bool isTrivial() const { return IsTrivial; } 1657 void setTrivial(bool IT) { IsTrivial = IT; } 1658 1659 /// Whether this function is defaulted per C++0x. Only valid for 1660 /// special member functions. 1661 bool isDefaulted() const { return IsDefaulted; } 1662 void setDefaulted(bool D = true) { IsDefaulted = D; } 1663 1664 /// Whether this function is explicitly defaulted per C++0x. Only valid 1665 /// for special member functions. 1666 bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; } 1667 void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; } 1668 1669 /// Whether falling off this function implicitly returns null/zero. 1670 /// If a more specific implicit return value is required, front-ends 1671 /// should synthesize the appropriate return statements. 1672 bool hasImplicitReturnZero() const { return HasImplicitReturnZero; } 1673 void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; } 1674 1675 /// \brief Whether this function has a prototype, either because one 1676 /// was explicitly written or because it was "inherited" by merging 1677 /// a declaration without a prototype with a declaration that has a 1678 /// prototype. 1679 bool hasPrototype() const { 1680 return HasWrittenPrototype || HasInheritedPrototype; 1681 } 1682 1683 bool hasWrittenPrototype() const { return HasWrittenPrototype; } 1684 1685 /// \brief Whether this function inherited its prototype from a 1686 /// previous declaration. 1687 bool hasInheritedPrototype() const { return HasInheritedPrototype; } 1688 void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; } 1689 1690 /// Whether this is a (C++11) constexpr function or constexpr constructor. 1691 bool isConstexpr() const { return IsConstexpr; } 1692 void setConstexpr(bool IC) { IsConstexpr = IC; } 1693 1694 /// \brief Whether this function has been deleted. 1695 /// 1696 /// A function that is "deleted" (via the C++0x "= delete" syntax) 1697 /// acts like a normal function, except that it cannot actually be 1698 /// called or have its address taken. Deleted functions are 1699 /// typically used in C++ overload resolution to attract arguments 1700 /// whose type or lvalue/rvalue-ness would permit the use of a 1701 /// different overload that would behave incorrectly. For example, 1702 /// one might use deleted functions to ban implicit conversion from 1703 /// a floating-point number to an Integer type: 1704 /// 1705 /// @code 1706 /// struct Integer { 1707 /// Integer(long); // construct from a long 1708 /// Integer(double) = delete; // no construction from float or double 1709 /// Integer(long double) = delete; // no construction from long double 1710 /// }; 1711 /// @endcode 1712 // If a function is deleted, its first declaration must be. 1713 bool isDeleted() const { return getCanonicalDecl()->IsDeleted; } 1714 bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; } 1715 void setDeletedAsWritten(bool D = true) { IsDeleted = D; } 1716 1717 /// \brief Determines whether this function is "main", which is the 1718 /// entry point into an executable program. 1719 bool isMain() const; 1720 1721 /// \brief Determines whether this operator new or delete is one 1722 /// of the reserved global placement operators: 1723 /// void *operator new(size_t, void *); 1724 /// void *operator new[](size_t, void *); 1725 /// void operator delete(void *, void *); 1726 /// void operator delete[](void *, void *); 1727 /// These functions have special behavior under [new.delete.placement]: 1728 /// These functions are reserved, a C++ program may not define 1729 /// functions that displace the versions in the Standard C++ library. 1730 /// The provisions of [basic.stc.dynamic] do not apply to these 1731 /// reserved placement forms of operator new and operator delete. 1732 /// 1733 /// This function must be an allocation or deallocation function. 1734 bool isReservedGlobalPlacementOperator() const; 1735 1736 /// Compute the language linkage. 1737 LanguageLinkage getLanguageLinkage() const; 1738 1739 /// \brief Determines whether this function is a function with 1740 /// external, C linkage. 1741 bool isExternC() const; 1742 1743 /// \brief Determines whether this function's context is, or is nested within, 1744 /// a C++ extern "C" linkage spec. 1745 bool isInExternCContext() const; 1746 1747 /// \brief Determines whether this function's context is, or is nested within, 1748 /// a C++ extern "C++" linkage spec. 1749 bool isInExternCXXContext() const; 1750 1751 /// \brief Determines whether this is a global function. 1752 bool isGlobal() const; 1753 1754 /// \brief Determines whether this function is known to be 'noreturn', through 1755 /// an attribute on its declaration or its type. 1756 bool isNoReturn() const; 1757 1758 /// \brief True if the function was a definition but its body was skipped. 1759 bool hasSkippedBody() const { return HasSkippedBody; } 1760 void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; } 1761 1762 void setPreviousDeclaration(FunctionDecl * PrevDecl); 1763 1764 virtual const FunctionDecl *getCanonicalDecl() const; 1765 virtual FunctionDecl *getCanonicalDecl(); 1766 1767 unsigned getBuiltinID() const; 1768 1769 // Iterator access to formal parameters. 1770 unsigned param_size() const { return getNumParams(); } 1771 typedef ParmVarDecl **param_iterator; 1772 typedef ParmVarDecl * const *param_const_iterator; 1773 1774 param_iterator param_begin() { return ParamInfo; } 1775 param_iterator param_end() { return ParamInfo+param_size(); } 1776 1777 param_const_iterator param_begin() const { return ParamInfo; } 1778 param_const_iterator param_end() const { return ParamInfo+param_size(); } 1779 1780 /// getNumParams - Return the number of parameters this function must have 1781 /// based on its FunctionType. This is the length of the ParamInfo array 1782 /// after it has been created. 1783 unsigned getNumParams() const; 1784 1785 const ParmVarDecl *getParamDecl(unsigned i) const { 1786 assert(i < getNumParams() && "Illegal param #"); 1787 return ParamInfo[i]; 1788 } 1789 ParmVarDecl *getParamDecl(unsigned i) { 1790 assert(i < getNumParams() && "Illegal param #"); 1791 return ParamInfo[i]; 1792 } 1793 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) { 1794 setParams(getASTContext(), NewParamInfo); 1795 } 1796 1797 const ArrayRef<NamedDecl *> &getDeclsInPrototypeScope() const { 1798 return DeclsInPrototypeScope; 1799 } 1800 void setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls); 1801 1802 /// getMinRequiredArguments - Returns the minimum number of arguments 1803 /// needed to call this function. This may be fewer than the number of 1804 /// function parameters, if some of the parameters have default 1805 /// arguments (in C++). 1806 unsigned getMinRequiredArguments() const; 1807 1808 QualType getResultType() const { 1809 return getType()->getAs<FunctionType>()->getResultType(); 1810 } 1811 1812 /// \brief Determine the type of an expression that calls this function. 1813 QualType getCallResultType() const { 1814 return getType()->getAs<FunctionType>()->getCallResultType(getASTContext()); 1815 } 1816 1817 /// \brief Returns the storage class as written in the source. For the 1818 /// computed linkage of symbol, see getLinkage. 1819 StorageClass getStorageClass() const { return StorageClass(SClass); } 1820 1821 /// \brief Determine whether the "inline" keyword was specified for this 1822 /// function. 1823 bool isInlineSpecified() const { return IsInlineSpecified; } 1824 1825 /// Set whether the "inline" keyword was specified for this function. 1826 void setInlineSpecified(bool I) { 1827 IsInlineSpecified = I; 1828 IsInline = I; 1829 } 1830 1831 /// Flag that this function is implicitly inline. 1832 void setImplicitlyInline() { 1833 IsInline = true; 1834 } 1835 1836 /// \brief Determine whether this function should be inlined, because it is 1837 /// either marked "inline" or "constexpr" or is a member function of a class 1838 /// that was defined in the class body. 1839 bool isInlined() const { return IsInline; } 1840 1841 bool isInlineDefinitionExternallyVisible() const; 1842 1843 bool doesDeclarationForceExternallyVisibleDefinition() const; 1844 1845 /// isOverloadedOperator - Whether this function declaration 1846 /// represents an C++ overloaded operator, e.g., "operator+". 1847 bool isOverloadedOperator() const { 1848 return getOverloadedOperator() != OO_None; 1849 } 1850 1851 OverloadedOperatorKind getOverloadedOperator() const; 1852 1853 const IdentifierInfo *getLiteralIdentifier() const; 1854 1855 /// \brief If this function is an instantiation of a member function 1856 /// of a class template specialization, retrieves the function from 1857 /// which it was instantiated. 1858 /// 1859 /// This routine will return non-NULL for (non-templated) member 1860 /// functions of class templates and for instantiations of function 1861 /// templates. For example, given: 1862 /// 1863 /// \code 1864 /// template<typename T> 1865 /// struct X { 1866 /// void f(T); 1867 /// }; 1868 /// \endcode 1869 /// 1870 /// The declaration for X<int>::f is a (non-templated) FunctionDecl 1871 /// whose parent is the class template specialization X<int>. For 1872 /// this declaration, getInstantiatedFromFunction() will return 1873 /// the FunctionDecl X<T>::A. When a complete definition of 1874 /// X<int>::A is required, it will be instantiated from the 1875 /// declaration returned by getInstantiatedFromMemberFunction(). 1876 FunctionDecl *getInstantiatedFromMemberFunction() const; 1877 1878 /// \brief What kind of templated function this is. 1879 TemplatedKind getTemplatedKind() const; 1880 1881 /// \brief If this function is an instantiation of a member function of a 1882 /// class template specialization, retrieves the member specialization 1883 /// information. 1884 MemberSpecializationInfo *getMemberSpecializationInfo() const { 1885 return TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>(); 1886 } 1887 1888 /// \brief Specify that this record is an instantiation of the 1889 /// member function FD. 1890 void setInstantiationOfMemberFunction(FunctionDecl *FD, 1891 TemplateSpecializationKind TSK) { 1892 setInstantiationOfMemberFunction(getASTContext(), FD, TSK); 1893 } 1894 1895 /// \brief Retrieves the function template that is described by this 1896 /// function declaration. 1897 /// 1898 /// Every function template is represented as a FunctionTemplateDecl 1899 /// and a FunctionDecl (or something derived from FunctionDecl). The 1900 /// former contains template properties (such as the template 1901 /// parameter lists) while the latter contains the actual 1902 /// description of the template's 1903 /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the 1904 /// FunctionDecl that describes the function template, 1905 /// getDescribedFunctionTemplate() retrieves the 1906 /// FunctionTemplateDecl from a FunctionDecl. 1907 FunctionTemplateDecl *getDescribedFunctionTemplate() const { 1908 return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl*>(); 1909 } 1910 1911 void setDescribedFunctionTemplate(FunctionTemplateDecl *Template) { 1912 TemplateOrSpecialization = Template; 1913 } 1914 1915 /// \brief Determine whether this function is a function template 1916 /// specialization. 1917 bool isFunctionTemplateSpecialization() const { 1918 return getPrimaryTemplate() != 0; 1919 } 1920 1921 /// \brief Retrieve the class scope template pattern that this function 1922 /// template specialization is instantiated from. 1923 FunctionDecl *getClassScopeSpecializationPattern() const; 1924 1925 /// \brief If this function is actually a function template specialization, 1926 /// retrieve information about this function template specialization. 1927 /// Otherwise, returns NULL. 1928 FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const { 1929 return TemplateOrSpecialization. 1930 dyn_cast<FunctionTemplateSpecializationInfo*>(); 1931 } 1932 1933 /// \brief Determines whether this function is a function template 1934 /// specialization or a member of a class template specialization that can 1935 /// be implicitly instantiated. 1936 bool isImplicitlyInstantiable() const; 1937 1938 /// \brief Determines if the given function was instantiated from a 1939 /// function template. 1940 bool isTemplateInstantiation() const; 1941 1942 /// \brief Retrieve the function declaration from which this function could 1943 /// be instantiated, if it is an instantiation (rather than a non-template 1944 /// or a specialization, for example). 1945 FunctionDecl *getTemplateInstantiationPattern() const; 1946 1947 /// \brief Retrieve the primary template that this function template 1948 /// specialization either specializes or was instantiated from. 1949 /// 1950 /// If this function declaration is not a function template specialization, 1951 /// returns NULL. 1952 FunctionTemplateDecl *getPrimaryTemplate() const; 1953 1954 /// \brief Retrieve the template arguments used to produce this function 1955 /// template specialization from the primary template. 1956 /// 1957 /// If this function declaration is not a function template specialization, 1958 /// returns NULL. 1959 const TemplateArgumentList *getTemplateSpecializationArgs() const; 1960 1961 /// \brief Retrieve the template argument list as written in the sources, 1962 /// if any. 1963 /// 1964 /// If this function declaration is not a function template specialization 1965 /// or if it had no explicit template argument list, returns NULL. 1966 /// Note that it an explicit template argument list may be written empty, 1967 /// e.g., template<> void foo<>(char* s); 1968 const ASTTemplateArgumentListInfo* 1969 getTemplateSpecializationArgsAsWritten() const; 1970 1971 /// \brief Specify that this function declaration is actually a function 1972 /// template specialization. 1973 /// 1974 /// \param Template the function template that this function template 1975 /// specialization specializes. 1976 /// 1977 /// \param TemplateArgs the template arguments that produced this 1978 /// function template specialization from the template. 1979 /// 1980 /// \param InsertPos If non-NULL, the position in the function template 1981 /// specialization set where the function template specialization data will 1982 /// be inserted. 1983 /// 1984 /// \param TSK the kind of template specialization this is. 1985 /// 1986 /// \param TemplateArgsAsWritten location info of template arguments. 1987 /// 1988 /// \param PointOfInstantiation point at which the function template 1989 /// specialization was first instantiated. 1990 void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, 1991 const TemplateArgumentList *TemplateArgs, 1992 void *InsertPos, 1993 TemplateSpecializationKind TSK = TSK_ImplicitInstantiation, 1994 const TemplateArgumentListInfo *TemplateArgsAsWritten = 0, 1995 SourceLocation PointOfInstantiation = SourceLocation()) { 1996 setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs, 1997 InsertPos, TSK, TemplateArgsAsWritten, 1998 PointOfInstantiation); 1999 } 2000 2001 /// \brief Specifies that this function declaration is actually a 2002 /// dependent function template specialization. 2003 void setDependentTemplateSpecialization(ASTContext &Context, 2004 const UnresolvedSetImpl &Templates, 2005 const TemplateArgumentListInfo &TemplateArgs); 2006 2007 DependentFunctionTemplateSpecializationInfo * 2008 getDependentSpecializationInfo() const { 2009 return TemplateOrSpecialization. 2010 dyn_cast<DependentFunctionTemplateSpecializationInfo*>(); 2011 } 2012 2013 /// \brief Determine what kind of template instantiation this function 2014 /// represents. 2015 TemplateSpecializationKind getTemplateSpecializationKind() const; 2016 2017 /// \brief Determine what kind of template instantiation this function 2018 /// represents. 2019 void setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2020 SourceLocation PointOfInstantiation = SourceLocation()); 2021 2022 /// \brief Retrieve the (first) point of instantiation of a function template 2023 /// specialization or a member of a class template specialization. 2024 /// 2025 /// \returns the first point of instantiation, if this function was 2026 /// instantiated from a template; otherwise, returns an invalid source 2027 /// location. 2028 SourceLocation getPointOfInstantiation() const; 2029 2030 /// \brief Determine whether this is or was instantiated from an out-of-line 2031 /// definition of a member function. 2032 virtual bool isOutOfLine() const; 2033 2034 /// \brief Identify a memory copying or setting function. 2035 /// If the given function is a memory copy or setting function, returns 2036 /// the corresponding Builtin ID. If the function is not a memory function, 2037 /// returns 0. 2038 unsigned getMemoryFunctionKind() const; 2039 2040 // Implement isa/cast/dyncast/etc. 2041 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2042 static bool classofKind(Kind K) { 2043 return K >= firstFunction && K <= lastFunction; 2044 } 2045 static DeclContext *castToDeclContext(const FunctionDecl *D) { 2046 return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D)); 2047 } 2048 static FunctionDecl *castFromDeclContext(const DeclContext *DC) { 2049 return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC)); 2050 } 2051 2052 friend class ASTDeclReader; 2053 friend class ASTDeclWriter; 2054}; 2055 2056 2057/// FieldDecl - An instance of this class is created by Sema::ActOnField to 2058/// represent a member of a struct/union/class. 2059class FieldDecl : public DeclaratorDecl { 2060 // FIXME: This can be packed into the bitfields in Decl. 2061 bool Mutable : 1; 2062 mutable unsigned CachedFieldIndex : 31; 2063 2064 /// \brief An InClassInitStyle value, and either a bit width expression (if 2065 /// the InClassInitStyle value is ICIS_NoInit), or a pointer to the in-class 2066 /// initializer for this field (otherwise). 2067 /// 2068 /// We can safely combine these two because in-class initializers are not 2069 /// permitted for bit-fields. 2070 /// 2071 /// If the InClassInitStyle is not ICIS_NoInit and the initializer is null, 2072 /// then this field has an in-class initializer which has not yet been parsed 2073 /// and attached. 2074 llvm::PointerIntPair<Expr *, 2, unsigned> InitializerOrBitWidth; 2075protected: 2076 FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 2077 SourceLocation IdLoc, IdentifierInfo *Id, 2078 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, 2079 InClassInitStyle InitStyle) 2080 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), 2081 Mutable(Mutable), CachedFieldIndex(0), 2082 InitializerOrBitWidth(BW, InitStyle) { 2083 assert((!BW || InitStyle == ICIS_NoInit) && "got initializer for bitfield"); 2084 } 2085 2086public: 2087 static FieldDecl *Create(const ASTContext &C, DeclContext *DC, 2088 SourceLocation StartLoc, SourceLocation IdLoc, 2089 IdentifierInfo *Id, QualType T, 2090 TypeSourceInfo *TInfo, Expr *BW, bool Mutable, 2091 InClassInitStyle InitStyle); 2092 2093 static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2094 2095 /// getFieldIndex - Returns the index of this field within its record, 2096 /// as appropriate for passing to ASTRecordLayout::getFieldOffset. 2097 unsigned getFieldIndex() const; 2098 2099 /// isMutable - Determines whether this field is mutable (C++ only). 2100 bool isMutable() const { return Mutable; } 2101 2102 /// isBitfield - Determines whether this field is a bitfield. 2103 bool isBitField() const { 2104 return getInClassInitStyle() == ICIS_NoInit && 2105 InitializerOrBitWidth.getPointer(); 2106 } 2107 2108 /// @brief Determines whether this is an unnamed bitfield. 2109 bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); } 2110 2111 /// isAnonymousStructOrUnion - Determines whether this field is a 2112 /// representative for an anonymous struct or union. Such fields are 2113 /// unnamed and are implicitly generated by the implementation to 2114 /// store the data for the anonymous union or struct. 2115 bool isAnonymousStructOrUnion() const; 2116 2117 Expr *getBitWidth() const { 2118 return isBitField() ? InitializerOrBitWidth.getPointer() : 0; 2119 } 2120 unsigned getBitWidthValue(const ASTContext &Ctx) const; 2121 2122 /// setBitWidth - Set the bit-field width for this member. 2123 // Note: used by some clients (i.e., do not remove it). 2124 void setBitWidth(Expr *Width); 2125 /// removeBitWidth - Remove the bit-field width from this member. 2126 // Note: used by some clients (i.e., do not remove it). 2127 void removeBitWidth() { 2128 assert(isBitField() && "no bitfield width to remove"); 2129 InitializerOrBitWidth.setPointer(0); 2130 } 2131 2132 /// getInClassInitStyle - Get the kind of (C++11) in-class initializer which 2133 /// this field has. 2134 InClassInitStyle getInClassInitStyle() const { 2135 return static_cast<InClassInitStyle>(InitializerOrBitWidth.getInt()); 2136 } 2137 2138 /// hasInClassInitializer - Determine whether this member has a C++11 in-class 2139 /// initializer. 2140 bool hasInClassInitializer() const { 2141 return getInClassInitStyle() != ICIS_NoInit; 2142 } 2143 /// getInClassInitializer - Get the C++11 in-class initializer for this 2144 /// member, or null if one has not been set. If a valid declaration has an 2145 /// in-class initializer, but this returns null, then we have not parsed and 2146 /// attached it yet. 2147 Expr *getInClassInitializer() const { 2148 return hasInClassInitializer() ? InitializerOrBitWidth.getPointer() : 0; 2149 } 2150 /// setInClassInitializer - Set the C++11 in-class initializer for this 2151 /// member. 2152 void setInClassInitializer(Expr *Init); 2153 /// removeInClassInitializer - Remove the C++11 in-class initializer from this 2154 /// member. 2155 void removeInClassInitializer() { 2156 assert(hasInClassInitializer() && "no initializer to remove"); 2157 InitializerOrBitWidth.setPointer(0); 2158 InitializerOrBitWidth.setInt(ICIS_NoInit); 2159 } 2160 2161 /// getParent - Returns the parent of this field declaration, which 2162 /// is the struct in which this method is defined. 2163 const RecordDecl *getParent() const { 2164 return cast<RecordDecl>(getDeclContext()); 2165 } 2166 2167 RecordDecl *getParent() { 2168 return cast<RecordDecl>(getDeclContext()); 2169 } 2170 2171 SourceRange getSourceRange() const LLVM_READONLY; 2172 2173 // Implement isa/cast/dyncast/etc. 2174 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2175 static bool classofKind(Kind K) { return K >= firstField && K <= lastField; } 2176 2177 friend class ASTDeclReader; 2178 friend class ASTDeclWriter; 2179}; 2180 2181/// EnumConstantDecl - An instance of this object exists for each enum constant 2182/// that is defined. For example, in "enum X {a,b}", each of a/b are 2183/// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a 2184/// TagType for the X EnumDecl. 2185class EnumConstantDecl : public ValueDecl { 2186 Stmt *Init; // an integer constant expression 2187 llvm::APSInt Val; // The value. 2188protected: 2189 EnumConstantDecl(DeclContext *DC, SourceLocation L, 2190 IdentifierInfo *Id, QualType T, Expr *E, 2191 const llvm::APSInt &V) 2192 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {} 2193 2194public: 2195 2196 static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC, 2197 SourceLocation L, IdentifierInfo *Id, 2198 QualType T, Expr *E, 2199 const llvm::APSInt &V); 2200 static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2201 2202 const Expr *getInitExpr() const { return (const Expr*) Init; } 2203 Expr *getInitExpr() { return (Expr*) Init; } 2204 const llvm::APSInt &getInitVal() const { return Val; } 2205 2206 void setInitExpr(Expr *E) { Init = (Stmt*) E; } 2207 void setInitVal(const llvm::APSInt &V) { Val = V; } 2208 2209 SourceRange getSourceRange() const LLVM_READONLY; 2210 2211 // Implement isa/cast/dyncast/etc. 2212 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2213 static bool classofKind(Kind K) { return K == EnumConstant; } 2214 2215 friend class StmtIteratorBase; 2216}; 2217 2218/// IndirectFieldDecl - An instance of this class is created to represent a 2219/// field injected from an anonymous union/struct into the parent scope. 2220/// IndirectFieldDecl are always implicit. 2221class IndirectFieldDecl : public ValueDecl { 2222 virtual void anchor(); 2223 NamedDecl **Chaining; 2224 unsigned ChainingSize; 2225 2226 IndirectFieldDecl(DeclContext *DC, SourceLocation L, 2227 DeclarationName N, QualType T, 2228 NamedDecl **CH, unsigned CHS) 2229 : ValueDecl(IndirectField, DC, L, N, T), Chaining(CH), ChainingSize(CHS) {} 2230 2231public: 2232 static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC, 2233 SourceLocation L, IdentifierInfo *Id, 2234 QualType T, NamedDecl **CH, unsigned CHS); 2235 2236 static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2237 2238 typedef NamedDecl * const *chain_iterator; 2239 chain_iterator chain_begin() const { return Chaining; } 2240 chain_iterator chain_end() const { return Chaining+ChainingSize; } 2241 2242 unsigned getChainingSize() const { return ChainingSize; } 2243 2244 FieldDecl *getAnonField() const { 2245 assert(ChainingSize >= 2); 2246 return cast<FieldDecl>(Chaining[ChainingSize - 1]); 2247 } 2248 2249 VarDecl *getVarDecl() const { 2250 assert(ChainingSize >= 2); 2251 return dyn_cast<VarDecl>(*chain_begin()); 2252 } 2253 2254 // Implement isa/cast/dyncast/etc. 2255 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2256 static bool classofKind(Kind K) { return K == IndirectField; } 2257 friend class ASTDeclReader; 2258}; 2259 2260/// TypeDecl - Represents a declaration of a type. 2261/// 2262class TypeDecl : public NamedDecl { 2263 virtual void anchor(); 2264 /// TypeForDecl - This indicates the Type object that represents 2265 /// this TypeDecl. It is a cache maintained by 2266 /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and 2267 /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl. 2268 mutable const Type *TypeForDecl; 2269 /// LocStart - The start of the source range for this declaration. 2270 SourceLocation LocStart; 2271 friend class ASTContext; 2272 friend class DeclContext; 2273 friend class TagDecl; 2274 friend class TemplateTypeParmDecl; 2275 friend class TagType; 2276 friend class ASTReader; 2277 2278protected: 2279 TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, 2280 SourceLocation StartL = SourceLocation()) 2281 : NamedDecl(DK, DC, L, Id), TypeForDecl(0), LocStart(StartL) {} 2282 2283public: 2284 // Low-level accessor. If you just want the type defined by this node, 2285 // check out ASTContext::getTypeDeclType or one of 2286 // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you 2287 // already know the specific kind of node this is. 2288 const Type *getTypeForDecl() const { return TypeForDecl; } 2289 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; } 2290 2291 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; } 2292 void setLocStart(SourceLocation L) { LocStart = L; } 2293 virtual SourceRange getSourceRange() const LLVM_READONLY { 2294 if (LocStart.isValid()) 2295 return SourceRange(LocStart, getLocation()); 2296 else 2297 return SourceRange(getLocation()); 2298 } 2299 2300 // Implement isa/cast/dyncast/etc. 2301 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2302 static bool classofKind(Kind K) { return K >= firstType && K <= lastType; } 2303}; 2304 2305 2306/// Base class for declarations which introduce a typedef-name. 2307class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> { 2308 virtual void anchor(); 2309 /// UnderlyingType - This is the type the typedef is set to. 2310 TypeSourceInfo *TInfo; 2311 2312protected: 2313 TypedefNameDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 2314 SourceLocation IdLoc, IdentifierInfo *Id, 2315 TypeSourceInfo *TInfo) 2316 : TypeDecl(DK, DC, IdLoc, Id, StartLoc), TInfo(TInfo) {} 2317 2318 typedef Redeclarable<TypedefNameDecl> redeclarable_base; 2319 virtual TypedefNameDecl *getNextRedeclaration() { 2320 return RedeclLink.getNext(); 2321 } 2322 virtual TypedefNameDecl *getPreviousDeclImpl() { 2323 return getPreviousDecl(); 2324 } 2325 virtual TypedefNameDecl *getMostRecentDeclImpl() { 2326 return getMostRecentDecl(); 2327 } 2328 2329public: 2330 typedef redeclarable_base::redecl_iterator redecl_iterator; 2331 using redeclarable_base::redecls_begin; 2332 using redeclarable_base::redecls_end; 2333 using redeclarable_base::getPreviousDecl; 2334 using redeclarable_base::getMostRecentDecl; 2335 2336 TypeSourceInfo *getTypeSourceInfo() const { 2337 return TInfo; 2338 } 2339 2340 /// Retrieves the canonical declaration of this typedef-name. 2341 TypedefNameDecl *getCanonicalDecl() { 2342 return getFirstDeclaration(); 2343 } 2344 const TypedefNameDecl *getCanonicalDecl() const { 2345 return getFirstDeclaration(); 2346 } 2347 2348 QualType getUnderlyingType() const { 2349 return TInfo->getType(); 2350 } 2351 void setTypeSourceInfo(TypeSourceInfo *newType) { 2352 TInfo = newType; 2353 } 2354 2355 // Implement isa/cast/dyncast/etc. 2356 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2357 static bool classofKind(Kind K) { 2358 return K >= firstTypedefName && K <= lastTypedefName; 2359 } 2360}; 2361 2362/// TypedefDecl - Represents the declaration of a typedef-name via the 'typedef' 2363/// type specifier. 2364class TypedefDecl : public TypedefNameDecl { 2365 TypedefDecl(DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, 2366 IdentifierInfo *Id, TypeSourceInfo *TInfo) 2367 : TypedefNameDecl(Typedef, DC, StartLoc, IdLoc, Id, TInfo) {} 2368 2369public: 2370 static TypedefDecl *Create(ASTContext &C, DeclContext *DC, 2371 SourceLocation StartLoc, SourceLocation IdLoc, 2372 IdentifierInfo *Id, TypeSourceInfo *TInfo); 2373 static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2374 2375 SourceRange getSourceRange() const LLVM_READONLY; 2376 2377 // Implement isa/cast/dyncast/etc. 2378 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2379 static bool classofKind(Kind K) { return K == Typedef; } 2380}; 2381 2382/// TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x 2383/// alias-declaration. 2384class TypeAliasDecl : public TypedefNameDecl { 2385 TypeAliasDecl(DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, 2386 IdentifierInfo *Id, TypeSourceInfo *TInfo) 2387 : TypedefNameDecl(TypeAlias, DC, StartLoc, IdLoc, Id, TInfo) {} 2388 2389public: 2390 static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC, 2391 SourceLocation StartLoc, SourceLocation IdLoc, 2392 IdentifierInfo *Id, TypeSourceInfo *TInfo); 2393 static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2394 2395 SourceRange getSourceRange() const LLVM_READONLY; 2396 2397 // Implement isa/cast/dyncast/etc. 2398 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2399 static bool classofKind(Kind K) { return K == TypeAlias; } 2400}; 2401 2402/// TagDecl - Represents the declaration of a struct/union/class/enum. 2403class TagDecl 2404 : public TypeDecl, public DeclContext, public Redeclarable<TagDecl> { 2405public: 2406 // This is really ugly. 2407 typedef TagTypeKind TagKind; 2408 2409private: 2410 // FIXME: This can be packed into the bitfields in Decl. 2411 /// TagDeclKind - The TagKind enum. 2412 unsigned TagDeclKind : 3; 2413 2414 /// IsCompleteDefinition - True if this is a definition ("struct foo 2415 /// {};"), false if it is a declaration ("struct foo;"). It is not 2416 /// a definition until the definition has been fully processed. 2417 bool IsCompleteDefinition : 1; 2418 2419protected: 2420 /// IsBeingDefined - True if this is currently being defined. 2421 bool IsBeingDefined : 1; 2422 2423private: 2424 /// IsEmbeddedInDeclarator - True if this tag declaration is 2425 /// "embedded" (i.e., defined or declared for the very first time) 2426 /// in the syntax of a declarator. 2427 bool IsEmbeddedInDeclarator : 1; 2428 2429 /// \brief True if this tag is free standing, e.g. "struct foo;". 2430 bool IsFreeStanding : 1; 2431 2432protected: 2433 // These are used by (and only defined for) EnumDecl. 2434 unsigned NumPositiveBits : 8; 2435 unsigned NumNegativeBits : 8; 2436 2437 /// IsScoped - True if this tag declaration is a scoped enumeration. Only 2438 /// possible in C++11 mode. 2439 bool IsScoped : 1; 2440 /// IsScopedUsingClassTag - If this tag declaration is a scoped enum, 2441 /// then this is true if the scoped enum was declared using the class 2442 /// tag, false if it was declared with the struct tag. No meaning is 2443 /// associated if this tag declaration is not a scoped enum. 2444 bool IsScopedUsingClassTag : 1; 2445 2446 /// IsFixed - True if this is an enumeration with fixed underlying type. Only 2447 /// possible in C++11, Microsoft extensions, or Objective C mode. 2448 bool IsFixed : 1; 2449 2450 /// \brief Indicates whether it is possible for declarations of this kind 2451 /// to have an out-of-date definition. 2452 /// 2453 /// This option is only enabled when modules are enabled. 2454 bool MayHaveOutOfDateDef : 1; 2455 2456private: 2457 SourceLocation RBraceLoc; 2458 2459 // A struct representing syntactic qualifier info, 2460 // to be used for the (uncommon) case of out-of-line declarations. 2461 typedef QualifierInfo ExtInfo; 2462 2463 /// TypedefNameDeclOrQualifier - If the (out-of-line) tag declaration name 2464 /// is qualified, it points to the qualifier info (nns and range); 2465 /// otherwise, if the tag declaration is anonymous and it is part of 2466 /// a typedef or alias, it points to the TypedefNameDecl (used for mangling); 2467 /// otherwise, it is a null (TypedefNameDecl) pointer. 2468 llvm::PointerUnion<TypedefNameDecl*, ExtInfo*> TypedefNameDeclOrQualifier; 2469 2470 bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo*>(); } 2471 ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo*>(); } 2472 const ExtInfo *getExtInfo() const { 2473 return TypedefNameDeclOrQualifier.get<ExtInfo*>(); 2474 } 2475 2476protected: 2477 TagDecl(Kind DK, TagKind TK, DeclContext *DC, 2478 SourceLocation L, IdentifierInfo *Id, 2479 TagDecl *PrevDecl, SourceLocation StartL) 2480 : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), 2481 TypedefNameDeclOrQualifier((TypedefNameDecl*) 0) { 2482 assert((DK != Enum || TK == TTK_Enum) && 2483 "EnumDecl not matched with TTK_Enum"); 2484 TagDeclKind = TK; 2485 IsCompleteDefinition = false; 2486 IsBeingDefined = false; 2487 IsEmbeddedInDeclarator = false; 2488 IsFreeStanding = false; 2489 setPreviousDeclaration(PrevDecl); 2490 } 2491 2492 typedef Redeclarable<TagDecl> redeclarable_base; 2493 virtual TagDecl *getNextRedeclaration() { return RedeclLink.getNext(); } 2494 virtual TagDecl *getPreviousDeclImpl() { 2495 return getPreviousDecl(); 2496 } 2497 virtual TagDecl *getMostRecentDeclImpl() { 2498 return getMostRecentDecl(); 2499 } 2500 2501 /// @brief Completes the definition of this tag declaration. 2502 /// 2503 /// This is a helper function for derived classes. 2504 void completeDefinition(); 2505 2506public: 2507 typedef redeclarable_base::redecl_iterator redecl_iterator; 2508 using redeclarable_base::redecls_begin; 2509 using redeclarable_base::redecls_end; 2510 using redeclarable_base::getPreviousDecl; 2511 using redeclarable_base::getMostRecentDecl; 2512 2513 SourceLocation getRBraceLoc() const { return RBraceLoc; } 2514 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; } 2515 2516 /// getInnerLocStart - Return SourceLocation representing start of source 2517 /// range ignoring outer template declarations. 2518 SourceLocation getInnerLocStart() const { return getLocStart(); } 2519 2520 /// getOuterLocStart - Return SourceLocation representing start of source 2521 /// range taking into account any outer template declarations. 2522 SourceLocation getOuterLocStart() const; 2523 virtual SourceRange getSourceRange() const LLVM_READONLY; 2524 2525 virtual TagDecl* getCanonicalDecl(); 2526 const TagDecl* getCanonicalDecl() const { 2527 return const_cast<TagDecl*>(this)->getCanonicalDecl(); 2528 } 2529 2530 /// isThisDeclarationADefinition() - Return true if this declaration 2531 /// is a completion definintion of the type. Provided for consistency. 2532 bool isThisDeclarationADefinition() const { 2533 return isCompleteDefinition(); 2534 } 2535 2536 /// isCompleteDefinition - Return true if this decl has its body 2537 /// fully specified. 2538 bool isCompleteDefinition() const { 2539 return IsCompleteDefinition; 2540 } 2541 2542 /// isBeingDefined - Return true if this decl is currently being defined. 2543 bool isBeingDefined() const { 2544 return IsBeingDefined; 2545 } 2546 2547 bool isEmbeddedInDeclarator() const { 2548 return IsEmbeddedInDeclarator; 2549 } 2550 void setEmbeddedInDeclarator(bool isInDeclarator) { 2551 IsEmbeddedInDeclarator = isInDeclarator; 2552 } 2553 2554 bool isFreeStanding() const { return IsFreeStanding; } 2555 void setFreeStanding(bool isFreeStanding = true) { 2556 IsFreeStanding = isFreeStanding; 2557 } 2558 2559 /// \brief Whether this declaration declares a type that is 2560 /// dependent, i.e., a type that somehow depends on template 2561 /// parameters. 2562 bool isDependentType() const { return isDependentContext(); } 2563 2564 /// @brief Starts the definition of this tag declaration. 2565 /// 2566 /// This method should be invoked at the beginning of the definition 2567 /// of this tag declaration. It will set the tag type into a state 2568 /// where it is in the process of being defined. 2569 void startDefinition(); 2570 2571 /// getDefinition - Returns the TagDecl that actually defines this 2572 /// struct/union/class/enum. When determining whether or not a 2573 /// struct/union/class/enum has a definition, one should use this 2574 /// method as opposed to 'isDefinition'. 'isDefinition' indicates 2575 /// whether or not a specific TagDecl is defining declaration, not 2576 /// whether or not the struct/union/class/enum type is defined. 2577 /// This method returns NULL if there is no TagDecl that defines 2578 /// the struct/union/class/enum. 2579 TagDecl *getDefinition() const; 2580 2581 void setCompleteDefinition(bool V) { IsCompleteDefinition = V; } 2582 2583 // FIXME: Return StringRef; 2584 const char *getKindName() const { 2585 return TypeWithKeyword::getTagTypeKindName(getTagKind()); 2586 } 2587 2588 TagKind getTagKind() const { 2589 return TagKind(TagDeclKind); 2590 } 2591 2592 void setTagKind(TagKind TK) { TagDeclKind = TK; } 2593 2594 bool isStruct() const { return getTagKind() == TTK_Struct; } 2595 bool isInterface() const { return getTagKind() == TTK_Interface; } 2596 bool isClass() const { return getTagKind() == TTK_Class; } 2597 bool isUnion() const { return getTagKind() == TTK_Union; } 2598 bool isEnum() const { return getTagKind() == TTK_Enum; } 2599 2600 /// Is this tag type named, either directly or via being defined in 2601 /// a typedef of this type? 2602 /// 2603 /// C++11 [basic.link]p8: 2604 /// A type is said to have linkage if and only if: 2605 /// - it is a class or enumeration type that is named (or has a 2606 /// name for linkage purposes) and the name has linkage; ... 2607 /// C++11 [dcl.typedef]p9: 2608 /// If the typedef declaration defines an unnamed class (or enum), 2609 /// the first typedef-name declared by the declaration to be that 2610 /// class type (or enum type) is used to denote the class type (or 2611 /// enum type) for linkage purposes only. 2612 /// 2613 /// C does not have an analogous rule, but the same concept is 2614 /// nonetheless useful in some places. 2615 bool hasNameForLinkage() const { 2616 return (getDeclName() || getTypedefNameForAnonDecl()); 2617 } 2618 2619 TypedefNameDecl *getTypedefNameForAnonDecl() const { 2620 return hasExtInfo() ? 0 : 2621 TypedefNameDeclOrQualifier.get<TypedefNameDecl*>(); 2622 } 2623 2624 void setTypedefNameForAnonDecl(TypedefNameDecl *TDD); 2625 2626 /// \brief Retrieve the nested-name-specifier that qualifies the name of this 2627 /// declaration, if it was present in the source. 2628 NestedNameSpecifier *getQualifier() const { 2629 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier() 2630 : 0; 2631 } 2632 2633 /// \brief Retrieve the nested-name-specifier (with source-location 2634 /// information) that qualifies the name of this declaration, if it was 2635 /// present in the source. 2636 NestedNameSpecifierLoc getQualifierLoc() const { 2637 return hasExtInfo() ? getExtInfo()->QualifierLoc 2638 : NestedNameSpecifierLoc(); 2639 } 2640 2641 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc); 2642 2643 unsigned getNumTemplateParameterLists() const { 2644 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0; 2645 } 2646 TemplateParameterList *getTemplateParameterList(unsigned i) const { 2647 assert(i < getNumTemplateParameterLists()); 2648 return getExtInfo()->TemplParamLists[i]; 2649 } 2650 void setTemplateParameterListsInfo(ASTContext &Context, unsigned NumTPLists, 2651 TemplateParameterList **TPLists); 2652 2653 // Implement isa/cast/dyncast/etc. 2654 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2655 static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; } 2656 2657 static DeclContext *castToDeclContext(const TagDecl *D) { 2658 return static_cast<DeclContext *>(const_cast<TagDecl*>(D)); 2659 } 2660 static TagDecl *castFromDeclContext(const DeclContext *DC) { 2661 return static_cast<TagDecl *>(const_cast<DeclContext*>(DC)); 2662 } 2663 2664 friend class ASTDeclReader; 2665 friend class ASTDeclWriter; 2666}; 2667 2668/// EnumDecl - Represents an enum. In C++11, enums can be forward-declared 2669/// with a fixed underlying type, and in C we allow them to be forward-declared 2670/// with no underlying type as an extension. 2671class EnumDecl : public TagDecl { 2672 virtual void anchor(); 2673 /// IntegerType - This represent the integer type that the enum corresponds 2674 /// to for code generation purposes. Note that the enumerator constants may 2675 /// have a different type than this does. 2676 /// 2677 /// If the underlying integer type was explicitly stated in the source 2678 /// code, this is a TypeSourceInfo* for that type. Otherwise this type 2679 /// was automatically deduced somehow, and this is a Type*. 2680 /// 2681 /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in 2682 /// some cases it won't. 2683 /// 2684 /// The underlying type of an enumeration never has any qualifiers, so 2685 /// we can get away with just storing a raw Type*, and thus save an 2686 /// extra pointer when TypeSourceInfo is needed. 2687 2688 llvm::PointerUnion<const Type*, TypeSourceInfo*> IntegerType; 2689 2690 /// PromotionType - The integer type that values of this type should 2691 /// promote to. In C, enumerators are generally of an integer type 2692 /// directly, but gcc-style large enumerators (and all enumerators 2693 /// in C++) are of the enum type instead. 2694 QualType PromotionType; 2695 2696 /// \brief If this enumeration is an instantiation of a member enumeration 2697 /// of a class template specialization, this is the member specialization 2698 /// information. 2699 MemberSpecializationInfo *SpecializationInfo; 2700 2701 EnumDecl(DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, 2702 IdentifierInfo *Id, EnumDecl *PrevDecl, 2703 bool Scoped, bool ScopedUsingClassTag, bool Fixed) 2704 : TagDecl(Enum, TTK_Enum, DC, IdLoc, Id, PrevDecl, StartLoc), 2705 SpecializationInfo(0) { 2706 assert(Scoped || !ScopedUsingClassTag); 2707 IntegerType = (const Type*)0; 2708 NumNegativeBits = 0; 2709 NumPositiveBits = 0; 2710 IsScoped = Scoped; 2711 IsScopedUsingClassTag = ScopedUsingClassTag; 2712 IsFixed = Fixed; 2713 } 2714 2715 void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED, 2716 TemplateSpecializationKind TSK); 2717public: 2718 EnumDecl *getCanonicalDecl() { 2719 return cast<EnumDecl>(TagDecl::getCanonicalDecl()); 2720 } 2721 const EnumDecl *getCanonicalDecl() const { 2722 return cast<EnumDecl>(TagDecl::getCanonicalDecl()); 2723 } 2724 2725 const EnumDecl *getPreviousDecl() const { 2726 return cast_or_null<EnumDecl>(TagDecl::getPreviousDecl()); 2727 } 2728 EnumDecl *getPreviousDecl() { 2729 return cast_or_null<EnumDecl>(TagDecl::getPreviousDecl()); 2730 } 2731 2732 const EnumDecl *getMostRecentDecl() const { 2733 return cast<EnumDecl>(TagDecl::getMostRecentDecl()); 2734 } 2735 EnumDecl *getMostRecentDecl() { 2736 return cast<EnumDecl>(TagDecl::getMostRecentDecl()); 2737 } 2738 2739 EnumDecl *getDefinition() const { 2740 return cast_or_null<EnumDecl>(TagDecl::getDefinition()); 2741 } 2742 2743 static EnumDecl *Create(ASTContext &C, DeclContext *DC, 2744 SourceLocation StartLoc, SourceLocation IdLoc, 2745 IdentifierInfo *Id, EnumDecl *PrevDecl, 2746 bool IsScoped, bool IsScopedUsingClassTag, 2747 bool IsFixed); 2748 static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID); 2749 2750 /// completeDefinition - When created, the EnumDecl corresponds to a 2751 /// forward-declared enum. This method is used to mark the 2752 /// declaration as being defined; it's enumerators have already been 2753 /// added (via DeclContext::addDecl). NewType is the new underlying 2754 /// type of the enumeration type. 2755 void completeDefinition(QualType NewType, 2756 QualType PromotionType, 2757 unsigned NumPositiveBits, 2758 unsigned NumNegativeBits); 2759 2760 // enumerator_iterator - Iterates through the enumerators of this 2761 // enumeration. 2762 typedef specific_decl_iterator<EnumConstantDecl> enumerator_iterator; 2763 2764 enumerator_iterator enumerator_begin() const { 2765 const EnumDecl *E = getDefinition(); 2766 if (!E) 2767 E = this; 2768 return enumerator_iterator(E->decls_begin()); 2769 } 2770 2771 enumerator_iterator enumerator_end() const { 2772 const EnumDecl *E = getDefinition(); 2773 if (!E) 2774 E = this; 2775 return enumerator_iterator(E->decls_end()); 2776 } 2777 2778 /// getPromotionType - Return the integer type that enumerators 2779 /// should promote to. 2780 QualType getPromotionType() const { return PromotionType; } 2781 2782 /// \brief Set the promotion type. 2783 void setPromotionType(QualType T) { PromotionType = T; } 2784 2785 /// getIntegerType - Return the integer type this enum decl corresponds to. 2786 /// This returns a null qualtype for an enum forward definition. 2787 QualType getIntegerType() const { 2788 if (!IntegerType) 2789 return QualType(); 2790 if (const Type* T = IntegerType.dyn_cast<const Type*>()) 2791 return QualType(T, 0); 2792 return IntegerType.get<TypeSourceInfo*>()->getType(); 2793 } 2794 2795 /// \brief Set the underlying integer type. 2796 void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); } 2797 2798 /// \brief Set the underlying integer type source info. 2799 void setIntegerTypeSourceInfo(TypeSourceInfo* TInfo) { IntegerType = TInfo; } 2800 2801 /// \brief Return the type source info for the underlying integer type, 2802 /// if no type source info exists, return 0. 2803 TypeSourceInfo* getIntegerTypeSourceInfo() const { 2804 return IntegerType.dyn_cast<TypeSourceInfo*>(); 2805 } 2806 2807 /// \brief Returns the width in bits required to store all the 2808 /// non-negative enumerators of this enum. 2809 unsigned getNumPositiveBits() const { 2810 return NumPositiveBits; 2811 } 2812 void setNumPositiveBits(unsigned Num) { 2813 NumPositiveBits = Num; 2814 assert(NumPositiveBits == Num && "can't store this bitcount"); 2815 } 2816 2817 /// \brief Returns the width in bits required to store all the 2818 /// negative enumerators of this enum. These widths include 2819 /// the rightmost leading 1; that is: 2820 /// 2821 /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS 2822 /// ------------------------ ------- ----------------- 2823 /// -1 1111111 1 2824 /// -10 1110110 5 2825 /// -101 1001011 8 2826 unsigned getNumNegativeBits() const { 2827 return NumNegativeBits; 2828 } 2829 void setNumNegativeBits(unsigned Num) { 2830 NumNegativeBits = Num; 2831 } 2832 2833 /// \brief Returns true if this is a C++11 scoped enumeration. 2834 bool isScoped() const { 2835 return IsScoped; 2836 } 2837 2838 /// \brief Returns true if this is a C++11 scoped enumeration. 2839 bool isScopedUsingClassTag() const { 2840 return IsScopedUsingClassTag; 2841 } 2842 2843 /// \brief Returns true if this is an Objective-C, C++11, or 2844 /// Microsoft-style enumeration with a fixed underlying type. 2845 bool isFixed() const { 2846 return IsFixed; 2847 } 2848 2849 /// \brief Returns true if this can be considered a complete type. 2850 bool isComplete() const { 2851 return isCompleteDefinition() || isFixed(); 2852 } 2853 2854 /// \brief Returns the enumeration (declared within the template) 2855 /// from which this enumeration type was instantiated, or NULL if 2856 /// this enumeration was not instantiated from any template. 2857 EnumDecl *getInstantiatedFromMemberEnum() const; 2858 2859 /// \brief If this enumeration is a member of a specialization of a 2860 /// templated class, determine what kind of template specialization 2861 /// or instantiation this is. 2862 TemplateSpecializationKind getTemplateSpecializationKind() const; 2863 2864 /// \brief For an enumeration member that was instantiated from a member 2865 /// enumeration of a templated class, set the template specialiation kind. 2866 void setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2867 SourceLocation PointOfInstantiation = SourceLocation()); 2868 2869 /// \brief If this enumeration is an instantiation of a member enumeration of 2870 /// a class template specialization, retrieves the member specialization 2871 /// information. 2872 MemberSpecializationInfo *getMemberSpecializationInfo() const { 2873 return SpecializationInfo; 2874 } 2875 2876 /// \brief Specify that this enumeration is an instantiation of the 2877 /// member enumeration ED. 2878 void setInstantiationOfMemberEnum(EnumDecl *ED, 2879 TemplateSpecializationKind TSK) { 2880 setInstantiationOfMemberEnum(getASTContext(), ED, TSK); 2881 } 2882 2883 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 2884 static bool classofKind(Kind K) { return K == Enum; } 2885 2886 friend class ASTDeclReader; 2887}; 2888 2889 2890/// RecordDecl - Represents a struct/union/class. For example: 2891/// struct X; // Forward declaration, no "body". 2892/// union Y { int A, B; }; // Has body with members A and B (FieldDecls). 2893/// This decl will be marked invalid if *any* members are invalid. 2894/// 2895class RecordDecl : public TagDecl { 2896 // FIXME: This can be packed into the bitfields in Decl. 2897 /// HasFlexibleArrayMember - This is true if this struct ends with a flexible 2898 /// array member (e.g. int X[]) or if this union contains a struct that does. 2899 /// If so, this cannot be contained in arrays or other structs as a member. 2900 bool HasFlexibleArrayMember : 1; 2901 2902 /// AnonymousStructOrUnion - Whether this is the type of an anonymous struct 2903 /// or union. 2904 bool AnonymousStructOrUnion : 1; 2905 2906 /// HasObjectMember - This is true if this struct has at least one member 2907 /// containing an Objective-C object pointer type. 2908 bool HasObjectMember : 1; 2909 2910 /// HasVolatileMember - This is true if struct has at least one member of 2911 /// 'volatile' type. 2912 bool HasVolatileMember : 1; 2913 2914 /// \brief Whether the field declarations of this record have been loaded 2915 /// from external storage. To avoid unnecessary deserialization of 2916 /// methods/nested types we allow deserialization of just the fields 2917 /// when needed. 2918 mutable bool LoadedFieldsFromExternalStorage : 1; 2919 friend class DeclContext; 2920 2921protected: 2922 RecordDecl(Kind DK, TagKind TK, DeclContext *DC, 2923 SourceLocation StartLoc, SourceLocation IdLoc, 2924 IdentifierInfo *Id, RecordDecl *PrevDecl); 2925 2926public: 2927 static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC, 2928 SourceLocation StartLoc, SourceLocation IdLoc, 2929 IdentifierInfo *Id, RecordDecl* PrevDecl = 0); 2930 static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID); 2931 2932 const RecordDecl *getPreviousDecl() const { 2933 return cast_or_null<RecordDecl>(TagDecl::getPreviousDecl()); 2934 } 2935 RecordDecl *getPreviousDecl() { 2936 return cast_or_null<RecordDecl>(TagDecl::getPreviousDecl()); 2937 } 2938 2939 const RecordDecl *getMostRecentDecl() const { 2940 return cast<RecordDecl>(TagDecl::getMostRecentDecl()); 2941 } 2942 RecordDecl *getMostRecentDecl() { 2943 return cast<RecordDecl>(TagDecl::getMostRecentDecl()); 2944 } 2945 2946 bool hasFlexibleArrayMember() const { return HasFlexibleArrayMember; } 2947 void setHasFlexibleArrayMember(bool V) { HasFlexibleArrayMember = V; } 2948 2949 /// isAnonymousStructOrUnion - Whether this is an anonymous struct 2950 /// or union. To be an anonymous struct or union, it must have been 2951 /// declared without a name and there must be no objects of this 2952 /// type declared, e.g., 2953 /// @code 2954 /// union { int i; float f; }; 2955 /// @endcode 2956 /// is an anonymous union but neither of the following are: 2957 /// @code 2958 /// union X { int i; float f; }; 2959 /// union { int i; float f; } obj; 2960 /// @endcode 2961 bool isAnonymousStructOrUnion() const { return AnonymousStructOrUnion; } 2962 void setAnonymousStructOrUnion(bool Anon) { 2963 AnonymousStructOrUnion = Anon; 2964 } 2965 2966 bool hasObjectMember() const { return HasObjectMember; } 2967 void setHasObjectMember (bool val) { HasObjectMember = val; } 2968 2969 bool hasVolatileMember() const { return HasVolatileMember; } 2970 void setHasVolatileMember (bool val) { HasVolatileMember = val; } 2971 2972 /// \brief Determines whether this declaration represents the 2973 /// injected class name. 2974 /// 2975 /// The injected class name in C++ is the name of the class that 2976 /// appears inside the class itself. For example: 2977 /// 2978 /// \code 2979 /// struct C { 2980 /// // C is implicitly declared here as a synonym for the class name. 2981 /// }; 2982 /// 2983 /// C::C c; // same as "C c;" 2984 /// \endcode 2985 bool isInjectedClassName() const; 2986 2987 /// getDefinition - Returns the RecordDecl that actually defines 2988 /// this struct/union/class. When determining whether or not a 2989 /// struct/union/class is completely defined, one should use this 2990 /// method as opposed to 'isCompleteDefinition'. 2991 /// 'isCompleteDefinition' indicates whether or not a specific 2992 /// RecordDecl is a completed definition, not whether or not the 2993 /// record type is defined. This method returns NULL if there is 2994 /// no RecordDecl that defines the struct/union/tag. 2995 RecordDecl *getDefinition() const { 2996 return cast_or_null<RecordDecl>(TagDecl::getDefinition()); 2997 } 2998 2999 // Iterator access to field members. The field iterator only visits 3000 // the non-static data members of this class, ignoring any static 3001 // data members, functions, constructors, destructors, etc. 3002 typedef specific_decl_iterator<FieldDecl> field_iterator; 3003 3004 field_iterator field_begin() const; 3005 3006 field_iterator field_end() const { 3007 return field_iterator(decl_iterator()); 3008 } 3009 3010 // field_empty - Whether there are any fields (non-static data 3011 // members) in this record. 3012 bool field_empty() const { 3013 return field_begin() == field_end(); 3014 } 3015 3016 /// completeDefinition - Notes that the definition of this type is 3017 /// now complete. 3018 virtual void completeDefinition(); 3019 3020 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 3021 static bool classofKind(Kind K) { 3022 return K >= firstRecord && K <= lastRecord; 3023 } 3024 3025 /// isMsStrust - Get whether or not this is an ms_struct which can 3026 /// be turned on with an attribute, pragma, or -mms-bitfields 3027 /// commandline option. 3028 bool isMsStruct(const ASTContext &C) const; 3029 3030private: 3031 /// \brief Deserialize just the fields. 3032 void LoadFieldsFromExternalStorage() const; 3033}; 3034 3035class FileScopeAsmDecl : public Decl { 3036 virtual void anchor(); 3037 StringLiteral *AsmString; 3038 SourceLocation RParenLoc; 3039 FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring, 3040 SourceLocation StartL, SourceLocation EndL) 3041 : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {} 3042public: 3043 static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC, 3044 StringLiteral *Str, SourceLocation AsmLoc, 3045 SourceLocation RParenLoc); 3046 3047 static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID); 3048 3049 SourceLocation getAsmLoc() const { return getLocation(); } 3050 SourceLocation getRParenLoc() const { return RParenLoc; } 3051 void setRParenLoc(SourceLocation L) { RParenLoc = L; } 3052 SourceRange getSourceRange() const LLVM_READONLY { 3053 return SourceRange(getAsmLoc(), getRParenLoc()); 3054 } 3055 3056 const StringLiteral *getAsmString() const { return AsmString; } 3057 StringLiteral *getAsmString() { return AsmString; } 3058 void setAsmString(StringLiteral *Asm) { AsmString = Asm; } 3059 3060 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 3061 static bool classofKind(Kind K) { return K == FileScopeAsm; } 3062}; 3063 3064/// BlockDecl - This represents a block literal declaration, which is like an 3065/// unnamed FunctionDecl. For example: 3066/// ^{ statement-body } or ^(int arg1, float arg2){ statement-body } 3067/// 3068class BlockDecl : public Decl, public DeclContext { 3069public: 3070 /// A class which contains all the information about a particular 3071 /// captured value. 3072 class Capture { 3073 enum { 3074 flag_isByRef = 0x1, 3075 flag_isNested = 0x2 3076 }; 3077 3078 /// The variable being captured. 3079 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags; 3080 3081 /// The copy expression, expressed in terms of a DeclRef (or 3082 /// BlockDeclRef) to the captured variable. Only required if the 3083 /// variable has a C++ class type. 3084 Expr *CopyExpr; 3085 3086 public: 3087 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy) 3088 : VariableAndFlags(variable, 3089 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)), 3090 CopyExpr(copy) {} 3091 3092 /// The variable being captured. 3093 VarDecl *getVariable() const { return VariableAndFlags.getPointer(); } 3094 3095 /// Whether this is a "by ref" capture, i.e. a capture of a __block 3096 /// variable. 3097 bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; } 3098 3099 /// Whether this is a nested capture, i.e. the variable captured 3100 /// is not from outside the immediately enclosing function/block. 3101 bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; } 3102 3103 bool hasCopyExpr() const { return CopyExpr != 0; } 3104 Expr *getCopyExpr() const { return CopyExpr; } 3105 void setCopyExpr(Expr *e) { CopyExpr = e; } 3106 }; 3107 3108private: 3109 // FIXME: This can be packed into the bitfields in Decl. 3110 bool IsVariadic : 1; 3111 bool CapturesCXXThis : 1; 3112 bool BlockMissingReturnType : 1; 3113 bool IsConversionFromLambda : 1; 3114 /// ParamInfo - new[]'d array of pointers to ParmVarDecls for the formal 3115 /// parameters of this function. This is null if a prototype or if there are 3116 /// no formals. 3117 ParmVarDecl **ParamInfo; 3118 unsigned NumParams; 3119 3120 Stmt *Body; 3121 TypeSourceInfo *SignatureAsWritten; 3122 3123 Capture *Captures; 3124 unsigned NumCaptures; 3125 3126protected: 3127 BlockDecl(DeclContext *DC, SourceLocation CaretLoc) 3128 : Decl(Block, DC, CaretLoc), DeclContext(Block), 3129 IsVariadic(false), CapturesCXXThis(false), 3130 BlockMissingReturnType(true), IsConversionFromLambda(false), 3131 ParamInfo(0), NumParams(0), Body(0), 3132 SignatureAsWritten(0), Captures(0), NumCaptures(0) {} 3133 3134public: 3135 static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L); 3136 static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID); 3137 3138 SourceLocation getCaretLocation() const { return getLocation(); } 3139 3140 bool isVariadic() const { return IsVariadic; } 3141 void setIsVariadic(bool value) { IsVariadic = value; } 3142 3143 CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; } 3144 Stmt *getBody() const { return (Stmt*) Body; } 3145 void setBody(CompoundStmt *B) { Body = (Stmt*) B; } 3146 3147 void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; } 3148 TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; } 3149 3150 // Iterator access to formal parameters. 3151 unsigned param_size() const { return getNumParams(); } 3152 typedef ParmVarDecl **param_iterator; 3153 typedef ParmVarDecl * const *param_const_iterator; 3154 3155 bool param_empty() const { return NumParams == 0; } 3156 param_iterator param_begin() { return ParamInfo; } 3157 param_iterator param_end() { return ParamInfo+param_size(); } 3158 3159 param_const_iterator param_begin() const { return ParamInfo; } 3160 param_const_iterator param_end() const { return ParamInfo+param_size(); } 3161 3162 unsigned getNumParams() const { return NumParams; } 3163 const ParmVarDecl *getParamDecl(unsigned i) const { 3164 assert(i < getNumParams() && "Illegal param #"); 3165 return ParamInfo[i]; 3166 } 3167 ParmVarDecl *getParamDecl(unsigned i) { 3168 assert(i < getNumParams() && "Illegal param #"); 3169 return ParamInfo[i]; 3170 } 3171 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo); 3172 3173 /// hasCaptures - True if this block (or its nested blocks) captures 3174 /// anything of local storage from its enclosing scopes. 3175 bool hasCaptures() const { return NumCaptures != 0 || CapturesCXXThis; } 3176 3177 /// getNumCaptures - Returns the number of captured variables. 3178 /// Does not include an entry for 'this'. 3179 unsigned getNumCaptures() const { return NumCaptures; } 3180 3181 typedef const Capture *capture_iterator; 3182 typedef const Capture *capture_const_iterator; 3183 capture_iterator capture_begin() { return Captures; } 3184 capture_iterator capture_end() { return Captures + NumCaptures; } 3185 capture_const_iterator capture_begin() const { return Captures; } 3186 capture_const_iterator capture_end() const { return Captures + NumCaptures; } 3187 3188 bool capturesCXXThis() const { return CapturesCXXThis; } 3189 bool blockMissingReturnType() const { return BlockMissingReturnType; } 3190 void setBlockMissingReturnType(bool val) { BlockMissingReturnType = val; } 3191 3192 bool isConversionFromLambda() const { return IsConversionFromLambda; } 3193 void setIsConversionFromLambda(bool val) { IsConversionFromLambda = val; } 3194 3195 bool capturesVariable(const VarDecl *var) const; 3196 3197 void setCaptures(ASTContext &Context, 3198 const Capture *begin, 3199 const Capture *end, 3200 bool capturesCXXThis); 3201 3202 virtual SourceRange getSourceRange() const LLVM_READONLY; 3203 3204 // Implement isa/cast/dyncast/etc. 3205 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 3206 static bool classofKind(Kind K) { return K == Block; } 3207 static DeclContext *castToDeclContext(const BlockDecl *D) { 3208 return static_cast<DeclContext *>(const_cast<BlockDecl*>(D)); 3209 } 3210 static BlockDecl *castFromDeclContext(const DeclContext *DC) { 3211 return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC)); 3212 } 3213}; 3214 3215/// \brief This represents the body of a CapturedStmt, and serves as its 3216/// DeclContext. 3217class CapturedDecl : public Decl, public DeclContext { 3218private: 3219 /// \brief The number of parameters to the outlined function. 3220 unsigned NumParams; 3221 /// \brief The body of the outlined function. 3222 Stmt *Body; 3223 3224 explicit CapturedDecl(DeclContext *DC, unsigned NumParams) 3225 : Decl(Captured, DC, SourceLocation()), DeclContext(Captured), 3226 NumParams(NumParams), Body(0) { } 3227 3228 ImplicitParamDecl **getParams() const { 3229 return reinterpret_cast<ImplicitParamDecl **>( 3230 const_cast<CapturedDecl *>(this) + 1); 3231 } 3232 3233public: 3234 static CapturedDecl *Create(ASTContext &C, DeclContext *DC, unsigned NumParams); 3235 static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID, 3236 unsigned NumParams); 3237 3238 Stmt *getBody() const { return Body; } 3239 void setBody(Stmt *B) { Body = B; } 3240 3241 unsigned getNumParams() const { return NumParams; } 3242 3243 ImplicitParamDecl *getParam(unsigned i) const { 3244 assert(i < NumParams); 3245 return getParams()[i]; 3246 } 3247 void setParam(unsigned i, ImplicitParamDecl *P) { 3248 assert(i < NumParams); 3249 getParams()[i] = P; 3250 } 3251 3252 /// \brief Retrieve the parameter containing captured variables. 3253 ImplicitParamDecl *getContextParam() const { return getParam(0); } 3254 void setContextParam(ImplicitParamDecl *P) { setParam(0, P); } 3255 3256 typedef ImplicitParamDecl **param_iterator; 3257 /// \brief Retrieve an iterator pointing to the first parameter decl. 3258 param_iterator param_begin() const { return getParams(); } 3259 /// \brief Retrieve an iterator one past the last parameter decl. 3260 param_iterator param_end() const { return getParams() + NumParams; } 3261 3262 // Implement isa/cast/dyncast/etc. 3263 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 3264 static bool classofKind(Kind K) { return K == Captured; } 3265 static DeclContext *castToDeclContext(const CapturedDecl *D) { 3266 return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D)); 3267 } 3268 static CapturedDecl *castFromDeclContext(const DeclContext *DC) { 3269 return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC)); 3270 } 3271 3272 friend class ASTDeclReader; 3273 friend class ASTDeclWriter; 3274}; 3275 3276/// \brief Describes a module import declaration, which makes the contents 3277/// of the named module visible in the current translation unit. 3278/// 3279/// An import declaration imports the named module (or submodule). For example: 3280/// \code 3281/// @import std.vector; 3282/// \endcode 3283/// 3284/// Import declarations can also be implicitly generated from 3285/// \#include/\#import directives. 3286class ImportDecl : public Decl { 3287 /// \brief The imported module, along with a bit that indicates whether 3288 /// we have source-location information for each identifier in the module 3289 /// name. 3290 /// 3291 /// When the bit is false, we only have a single source location for the 3292 /// end of the import declaration. 3293 llvm::PointerIntPair<Module *, 1, bool> ImportedAndComplete; 3294 3295 /// \brief The next import in the list of imports local to the translation 3296 /// unit being parsed (not loaded from an AST file). 3297 ImportDecl *NextLocalImport; 3298 3299 friend class ASTReader; 3300 friend class ASTDeclReader; 3301 friend class ASTContext; 3302 3303 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported, 3304 ArrayRef<SourceLocation> IdentifierLocs); 3305 3306 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported, 3307 SourceLocation EndLoc); 3308 3309 ImportDecl(EmptyShell Empty) : Decl(Import, Empty), NextLocalImport() { } 3310 3311public: 3312 /// \brief Create a new module import declaration. 3313 static ImportDecl *Create(ASTContext &C, DeclContext *DC, 3314 SourceLocation StartLoc, Module *Imported, 3315 ArrayRef<SourceLocation> IdentifierLocs); 3316 3317 /// \brief Create a new module import declaration for an implicitly-generated 3318 /// import. 3319 static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC, 3320 SourceLocation StartLoc, Module *Imported, 3321 SourceLocation EndLoc); 3322 3323 /// \brief Create a new, deserialized module import declaration. 3324 static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID, 3325 unsigned NumLocations); 3326 3327 /// \brief Retrieve the module that was imported by the import declaration. 3328 Module *getImportedModule() const { return ImportedAndComplete.getPointer(); } 3329 3330 /// \brief Retrieves the locations of each of the identifiers that make up 3331 /// the complete module name in the import declaration. 3332 /// 3333 /// This will return an empty array if the locations of the individual 3334 /// identifiers aren't available. 3335 ArrayRef<SourceLocation> getIdentifierLocs() const; 3336 3337 virtual SourceRange getSourceRange() const LLVM_READONLY; 3338 3339 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 3340 static bool classofKind(Kind K) { return K == Import; } 3341}; 3342 3343/// \brief Represents an empty-declaration. 3344class EmptyDecl : public Decl { 3345 virtual void anchor(); 3346 EmptyDecl(DeclContext *DC, SourceLocation L) 3347 : Decl(Empty, DC, L) { } 3348 3349public: 3350 static EmptyDecl *Create(ASTContext &C, DeclContext *DC, 3351 SourceLocation L); 3352 static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID); 3353 3354 static bool classof(const Decl *D) { return classofKind(D->getKind()); } 3355 static bool classofKind(Kind K) { return K == Empty; } 3356}; 3357 3358/// Insertion operator for diagnostics. This allows sending NamedDecl's 3359/// into a diagnostic with <<. 3360inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, 3361 const NamedDecl* ND) { 3362 DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND), 3363 DiagnosticsEngine::ak_nameddecl); 3364 return DB; 3365} 3366inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD, 3367 const NamedDecl* ND) { 3368 PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND), 3369 DiagnosticsEngine::ak_nameddecl); 3370 return PD; 3371} 3372 3373template<typename decl_type> 3374void Redeclarable<decl_type>::setPreviousDeclaration(decl_type *PrevDecl) { 3375 // Note: This routine is implemented here because we need both NamedDecl 3376 // and Redeclarable to be defined. 3377 3378 decl_type *First; 3379 3380 if (PrevDecl) { 3381 // Point to previous. Make sure that this is actually the most recent 3382 // redeclaration, or we can build invalid chains. If the most recent 3383 // redeclaration is invalid, it won't be PrevDecl, but we want it anyway. 3384 First = PrevDecl->getFirstDeclaration(); 3385 assert(First->RedeclLink.NextIsLatest() && "Expected first"); 3386 decl_type *MostRecent = First->RedeclLink.getNext(); 3387 RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent)); 3388 } else { 3389 // Make this first. 3390 First = static_cast<decl_type*>(this); 3391 } 3392 3393 // First one will point to this one as latest. 3394 First->RedeclLink = LatestDeclLink(static_cast<decl_type*>(this)); 3395 assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) || 3396 cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid()); 3397} 3398 3399// Inline function definitions. 3400 3401/// \brief Check if the given decl is complete. 3402/// 3403/// We use this function to break a cycle between the inline definitions in 3404/// Type.h and Decl.h. 3405inline bool IsEnumDeclComplete(EnumDecl *ED) { 3406 return ED->isComplete(); 3407} 3408 3409/// \brief Check if the given decl is scoped. 3410/// 3411/// We use this function to break a cycle between the inline definitions in 3412/// Type.h and Decl.h. 3413inline bool IsEnumDeclScoped(EnumDecl *ED) { 3414 return ED->isScoped(); 3415} 3416 3417} // end namespace clang 3418 3419#endif 3420