diff options
Diffstat (limited to 'include/clang/AST/DeclTemplate.h')
| -rw-r--r-- | include/clang/AST/DeclTemplate.h | 160 |
1 files changed, 97 insertions, 63 deletions
diff --git a/include/clang/AST/DeclTemplate.h b/include/clang/AST/DeclTemplate.h index 36549ea..7affc7e 100644 --- a/include/clang/AST/DeclTemplate.h +++ b/include/clang/AST/DeclTemplate.h @@ -6,9 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This file defines the C++ template declaration subclasses. -// +/// +/// \file +/// \brief Defines the C++ template declaration subclasses. +/// //===----------------------------------------------------------------------===// #ifndef LLVM_CLANG_AST_DECLTEMPLATE_H @@ -38,8 +39,8 @@ class TypeAliasTemplateDecl; typedef llvm::PointerUnion3<TemplateTypeParmDecl*, NonTypeTemplateParmDecl*, TemplateTemplateParmDecl*> TemplateParameter; -/// TemplateParameterList - Stores a list of template parameters for a -/// TemplateDecl and its derived classes. +/// \brief Stores a list of template parameters for a TemplateDecl and its +/// derived classes. class TemplateParameterList { /// The location of the 'template' keyword. SourceLocation TemplateLoc; @@ -64,10 +65,10 @@ public: unsigned NumParams, SourceLocation RAngleLoc); - /// iterator - Iterates through the template parameters in this list. + /// \brief Iterates through the template parameters in this list. typedef NamedDecl** iterator; - /// const_iterator - Iterates through the template parameters in this list. + /// \brief Iterates through the template parameters in this list. typedef NamedDecl* const* const_iterator; iterator begin() { return reinterpret_cast<NamedDecl **>(this + 1); } @@ -90,9 +91,10 @@ public: } /// \brief Returns the minimum number of arguments needed to form a - /// template specialization. This may be fewer than the number of - /// template parameters, if some of the parameters have default - /// arguments or if there is a parameter pack. + /// template specialization. + /// + /// This may be fewer than the number of template parameters, if some of + /// the parameters have default arguments or if there is a parameter pack. unsigned getMinRequiredArguments() const; /// \brief Get the depth of this template parameter list in the set of @@ -111,8 +113,8 @@ public: } }; -/// FixedSizeTemplateParameterList - Stores a list of template parameters for a -/// TemplateDecl and its derived classes. Suitable for creating on the stack. +/// \brief Stores a list of template parameters for a TemplateDecl and its +/// derived classes. Suitable for creating on the stack. template<size_t N> class FixedSizeTemplateParameterList : public TemplateParameterList { NamedDecl *Params[N]; @@ -195,10 +197,11 @@ public: // Kinds of Templates //===----------------------------------------------------------------------===// -/// TemplateDecl - The base class of all kinds of template declarations (e.g., -/// class, function, etc.). The TemplateDecl class stores the list of template -/// parameters and a reference to the templated scoped declaration: the -/// underlying AST node. +/// \brief The base class of all kinds of template declarations (e.g., +/// class, function, etc.). +/// +/// The TemplateDecl class stores the list of template parameters and a +/// reference to the templated scoped declaration: the underlying AST node. class TemplateDecl : public NamedDecl { virtual void anchor(); protected: @@ -404,16 +407,19 @@ public: }; /// \brief Provides information about a dependent function-template -/// specialization declaration. Since explicit function template -/// specialization and instantiation declarations can only appear in -/// namespace scope, and you can only specialize a member of a -/// fully-specialized class, the only way to get one of these is in -/// a friend declaration like the following: +/// specialization declaration. +/// +/// Since explicit function template specialization and instantiation +/// declarations can only appear in namespace scope, and you can only +/// specialize a member of a fully-specialized class, the only way to +/// get one of these is in a friend declaration like the following: /// -/// template <class T> void foo(T); -/// template <class T> class A { +/// \code +/// template \<class T> void foo(T); +/// template \<class T> class A { /// friend void foo<>(T); /// }; +/// \endcode class DependentFunctionTemplateSpecializationInfo { union { // Force sizeof to be a multiple of sizeof(void*) so that the @@ -512,7 +518,8 @@ protected: typedef _SETraits SETraits; typedef _DeclType DeclType; - typedef typename llvm::FoldingSet<EntryType>::iterator SetIteratorType; + typedef typename llvm::FoldingSetVector<EntryType>::iterator + SetIteratorType; SetIteratorType SetIter; @@ -541,13 +548,13 @@ protected: }; template <typename EntryType> - SpecIterator<EntryType> makeSpecIterator(llvm::FoldingSet<EntryType> &Specs, - bool isEnd) { + SpecIterator<EntryType> + makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) { return SpecIterator<EntryType>(isEnd ? Specs.end() : Specs.begin()); } template <class EntryType> typename SpecEntryTraits<EntryType>::DeclType* - findSpecializationImpl(llvm::FoldingSet<EntryType> &Specs, + findSpecializationImpl(llvm::FoldingSetVector<EntryType> &Specs, const TemplateArgument *Args, unsigned NumArgs, void *&InsertPos); @@ -583,7 +590,7 @@ protected: public: template <class decl_type> friend class RedeclarableTemplate; - /// Retrieves the canonical declaration of this template. + /// \brief Retrieves the canonical declaration of this template. RedeclarableTemplateDecl *getCanonicalDecl() { return getFirstDeclaration(); } const RedeclarableTemplateDecl *getCanonicalDecl() const { return getFirstDeclaration(); @@ -646,7 +653,7 @@ public: /// /// which was itself created during the instantiation of \c X<int>. Calling /// getInstantiatedFromMemberTemplate() on this FunctionTemplateDecl will - /// retrieve the FunctionTemplateDecl for the original template "f" within + /// retrieve the FunctionTemplateDecl for the original template \c f within /// the class template \c X<T>, i.e., /// /// \code @@ -706,7 +713,7 @@ protected: /// \brief The function template specializations for this function /// template, including explicit specializations and instantiations. - llvm::FoldingSet<FunctionTemplateSpecializationInfo> Specializations; + llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> Specializations; /// \brief The set of "injected" template arguments used within this /// function template. @@ -732,13 +739,14 @@ protected: /// \brief Retrieve the set of function template specializations of this /// function template. - llvm::FoldingSet<FunctionTemplateSpecializationInfo> &getSpecializations() { + llvm::FoldingSetVector<FunctionTemplateSpecializationInfo> & + getSpecializations() { return getCommonPtr()->Specializations; } /// \brief Add a specialization of this function template. /// - /// \param InsertPos Insert position in the FoldingSet, must have been + /// \param InsertPos Insert position in the FoldingSetVector, must have been /// retrieved by an earlier call to findSpecialization(). void addSpecialization(FunctionTemplateSpecializationInfo* Info, void *InsertPos); @@ -830,8 +838,10 @@ public: // Kinds of Template Parameters //===----------------------------------------------------------------------===// -/// The TemplateParmPosition class defines the position of a template parameter -/// within a template parameter list. Because template parameter can be listed +/// \brief Defines the position of a template parameter within a template +/// parameter list. +/// +/// Because template parameter can be listed /// sequentially for out-of-line template members, each template parameter is /// given a Depth - the nesting of template parameter scopes - and a Position - /// the occurrence within the parameter list. @@ -866,15 +876,17 @@ public: unsigned getIndex() const { return Position; } }; -/// TemplateTypeParmDecl - Declaration of a template type parameter, -/// e.g., "T" in -/// @code +/// \brief Declaration of a template type parameter. +/// +/// For example, "T" in +/// \code /// template<typename T> class vector; -/// @endcode +/// \endcode class TemplateTypeParmDecl : public TypeDecl { /// \brief Whether this template type parameter was declaration with - /// the 'typename' keyword. If false, it was declared with the - /// 'class' keyword. + /// the 'typename' keyword. + /// + /// If false, it was declared with the 'class' keyword. bool Typename : 1; /// \brief Whether this template type parameter inherited its @@ -904,8 +916,9 @@ public: unsigned ID); /// \brief Whether this template type parameter was declared with - /// the 'typename' keyword. If not, it was declared with the 'class' - /// keyword. + /// the 'typename' keyword. + /// + /// If not, it was declared with the 'class' keyword. bool wasDeclaredWithTypename() const { return Typename; } /// \brief Determine whether this template parameter has a default @@ -1688,11 +1701,11 @@ protected: /// \brief The class template specializations for this class /// template, including explicit specializations and instantiations. - llvm::FoldingSet<ClassTemplateSpecializationDecl> Specializations; + llvm::FoldingSetVector<ClassTemplateSpecializationDecl> Specializations; /// \brief The class template partial specializations for this class /// template. - llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> + llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> PartialSpecializations; /// \brief The injected-class-name type for this class template. @@ -1710,11 +1723,11 @@ protected: void LoadLazySpecializations(); /// \brief Retrieve the set of specializations of this class template. - llvm::FoldingSet<ClassTemplateSpecializationDecl> &getSpecializations(); + llvm::FoldingSetVector<ClassTemplateSpecializationDecl> &getSpecializations(); /// \brief Retrieve the set of partial specializations of this class /// template. - llvm::FoldingSet<ClassTemplatePartialSpecializationDecl> & + llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> & getPartialSpecializations(); ClassTemplateDecl(DeclContext *DC, SourceLocation L, DeclarationName Name, @@ -1732,18 +1745,18 @@ protected: } public: - /// Get the underlying class declarations of the template. + /// \brief Get the underlying class declarations of the template. CXXRecordDecl *getTemplatedDecl() const { return static_cast<CXXRecordDecl *>(TemplatedDecl); } - /// Returns whether this template declaration defines the primary + /// \brief Returns whether this template declaration defines the primary /// class pattern. bool isThisDeclarationADefinition() const { return getTemplatedDecl()->isThisDeclarationADefinition(); } - /// Create a class template node. + /// \brief Create a class template node. static ClassTemplateDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName Name, @@ -1751,7 +1764,7 @@ public: NamedDecl *Decl, ClassTemplateDecl *PrevDecl); - /// Create an empty class template node. + /// \brief Create an empty class template node. static ClassTemplateDecl *CreateDeserialized(ASTContext &C, unsigned ID); /// \brief Return the specialization with the provided arguments if it exists, @@ -1880,14 +1893,18 @@ public: friend class ASTDeclWriter; }; -/// Declaration of a friend template. For example: +/// \brief Declaration of a friend template. /// -/// template <typename T> class A { +/// For example: +/// \code +/// template \<typename T> class A { /// friend class MyVector<T>; // not a friend template -/// template <typename U> friend class B; // not a friend template -/// template <typename U> friend class Foo<T>::Nested; // friend template +/// template \<typename U> friend class B; // not a friend template +/// template \<typename U> friend class Foo<T>::Nested; // friend template /// }; -/// NOTE: This class is not currently in use. All of the above +/// \endcode +/// +/// \note This class is not currently in use. All of the above /// will yield a FriendDecl, not a FriendTemplateDecl. class FriendTemplateDecl : public Decl { virtual void anchor(); @@ -1950,7 +1967,7 @@ public: return Friend.dyn_cast<NamedDecl*>(); } - /// Retrieves the location of the 'friend' keyword. + /// \brief Retrieves the location of the 'friend' keyword. SourceLocation getFriendLoc() const { return FriendLoc; } @@ -1972,9 +1989,12 @@ public: friend class ASTDeclReader; }; -/// Declaration of an alias template. For example: +/// \brief Declaration of an alias template. /// -/// template <typename T> using V = std::map<T*, int, MyCompare<T>>; +/// For example: +/// \code +/// template \<typename T> using V = std::map<T*, int, MyCompare<T>>; +/// \endcode class TypeAliasTemplateDecl : public RedeclarableTemplateDecl { static void DeallocateCommon(void *Ptr); @@ -2046,14 +2066,18 @@ public: friend class ASTDeclWriter; }; -/// Declaration of a function specialization at template class scope. +/// \brief Declaration of a function specialization at template class scope. +/// /// This is a non standard extension needed to support MSVC. +/// /// For example: +/// \code /// template <class T> /// class A { /// template <class U> void foo(U a) { } /// template<> void foo(int a) { } /// } +/// \endcode /// /// "template<> foo(int a)" will be saved in Specialization as a normal /// CXXMethodDecl. Then during an instantiation of class A, it will be @@ -2062,23 +2086,33 @@ class ClassScopeFunctionSpecializationDecl : public Decl { virtual void anchor(); ClassScopeFunctionSpecializationDecl(DeclContext *DC, SourceLocation Loc, - CXXMethodDecl *FD) + CXXMethodDecl *FD, bool Args, + TemplateArgumentListInfo TemplArgs) : Decl(Decl::ClassScopeFunctionSpecialization, DC, Loc), - Specialization(FD) {} + Specialization(FD), HasExplicitTemplateArgs(Args), + TemplateArgs(TemplArgs) {} ClassScopeFunctionSpecializationDecl(EmptyShell Empty) : Decl(Decl::ClassScopeFunctionSpecialization, Empty) {} CXXMethodDecl *Specialization; + bool HasExplicitTemplateArgs; + TemplateArgumentListInfo TemplateArgs; public: CXXMethodDecl *getSpecialization() const { return Specialization; } + bool hasExplicitTemplateArgs() const { return HasExplicitTemplateArgs; } + const TemplateArgumentListInfo& templateArgs() const { return TemplateArgs; } static ClassScopeFunctionSpecializationDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, - CXXMethodDecl *FD) { - return new (C) ClassScopeFunctionSpecializationDecl(DC , Loc, FD); + CXXMethodDecl *FD, + bool HasExplicitTemplateArgs, + TemplateArgumentListInfo TemplateArgs) { + return new (C) ClassScopeFunctionSpecializationDecl(DC , Loc, FD, + HasExplicitTemplateArgs, + TemplateArgs); } static ClassScopeFunctionSpecializationDecl * |
