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