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