Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- DeclTemplate.h - Classes for representing C++ templates --*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

/// \file

/// Defines the C++ template declaration subclasses.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_AST_DECLTEMPLATE_H

#define LLVM_CLANG_AST_DECLTEMPLATE_H

#include "clang/AST/ASTConcept.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclBase.h"

#include "clang/AST/DeclCXX.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Redeclarable.h"

#include "clang/AST/TemplateBase.h"

#include "clang/AST/Type.h"

#include "clang/Basic/LLVM.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/PointerIntPair.h"

#include "llvm/ADT/PointerUnion.h"

#include "llvm/ADT/iterator.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/TrailingObjects.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <iterator>

#include <optional>

#include <utility>

namespace clang {

enum BuiltinTemplateKind : int;

class ClassTemplateDecl;

class ClassTemplatePartialSpecializationDecl;

class Expr;

class FunctionTemplateDecl;

class IdentifierInfo;

class NonTypeTemplateParmDecl;

class TemplateDecl;

class TemplateTemplateParmDecl;

class TemplateTypeParmDecl;

class ConceptDecl;

class UnresolvedSetImpl;

class VarTemplateDecl;

class VarTemplatePartialSpecializationDecl;

/// Stores a template parameter of any kind.

using TemplateParameter =

    llvm::PointerUnion<TemplateTypeParmDecl *, NonTypeTemplateParmDecl *,

                       TemplateTemplateParmDecl *>;

NamedDecl *getAsNamedDecl(TemplateParameter P);

/// Stores a list of template parameters for a TemplateDecl and its

/// derived classes.

class TemplateParameterList final

    : private llvm::TrailingObjects<TemplateParameterList, NamedDecl *,

                                    Expr *> {

  /// The location of the 'template' keyword.

  SourceLocation TemplateLoc;

  /// The locations of the '<' and '>' angle brackets.

  SourceLocation LAngleLoc, RAngleLoc;

  /// The number of template parameters in this template

  /// parameter list.

  unsigned NumParams : 29;

  /// Whether this template parameter list contains an unexpanded parameter

  /// pack.

  unsigned ContainsUnexpandedParameterPack : 1;

  /// Whether this template parameter list has a requires clause.

  unsigned HasRequiresClause : 1;

  /// Whether any of the template parameters has constrained-parameter

  /// constraint-expression.

  unsigned HasConstrainedParameters : 1;

protected:

  TemplateParameterList(const ASTContext& C, SourceLocation TemplateLoc,

                        SourceLocation LAngleLoc, ArrayRef<NamedDecl *> Params,

                        SourceLocation RAngleLoc, Expr *RequiresClause);

  size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {

    return NumParams;

  }

  size_t numTrailingObjects(OverloadToken<Expr *>) const {

    return HasRequiresClause ? 1 : 0;

  }

public:

  template <size_t N, bool HasRequiresClause>

  friend class FixedSizeTemplateParameterListStorage;

  friend TrailingObjects;

  static TemplateParameterList *Create(const ASTContext &C,

                                       SourceLocation TemplateLoc,

                                       SourceLocation LAngleLoc,

                                       ArrayRef<NamedDecl *> Params,

                                       SourceLocation RAngleLoc,

                                       Expr *RequiresClause);

  /// Iterates through the template parameters in this list.

  using iterator = NamedDecl **;

  /// Iterates through the template parameters in this list.

  using const_iterator = NamedDecl * const *;

  iterator begin() { return getTrailingObjects<NamedDecl *>(); }

  const_iterator begin() const { return getTrailingObjects<NamedDecl *>(); }

  iterator end() { return begin() + NumParams; }

  const_iterator end() const { return begin() + NumParams; }

  unsigned size() const { return NumParams; }

  ArrayRef<NamedDecl *> asArray() { return llvm::ArrayRef(begin(), end()); }

  ArrayRef<const NamedDecl*> asArray() const {

    return llvm::ArrayRef(begin(), size());

  }

  NamedDecl* getParam(unsigned Idx) {

    assert(Idx < size() && "Template parameter index out-of-range");

    return begin()[Idx];

  }

  const NamedDecl* getParam(unsigned Idx) const {

    assert(Idx < size() && "Template parameter index out-of-range");

    return begin()[Idx];

  }

  /// 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.

  unsigned getMinRequiredArguments() const;

  /// Get the depth of this template parameter list in the set of

  /// template parameter lists.

  ///

  /// The first template parameter list in a declaration will have depth 0,

  /// the second template parameter list will have depth 1, etc.

  unsigned getDepth() const;

  /// Determine whether this template parameter list contains an

  /// unexpanded parameter pack.

  bool containsUnexpandedParameterPack() const;

  /// Determine whether this template parameter list contains a parameter pack.

  bool hasParameterPack() const {

    for (const NamedDecl *P : asArray())

      if (P->isParameterPack())

        return true;

    return false;

  }

  /// The constraint-expression of the associated requires-clause.

  Expr *getRequiresClause() {

    return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;

  }

  /// The constraint-expression of the associated requires-clause.

  const Expr *getRequiresClause() const {

    return HasRequiresClause ? getTrailingObjects<Expr *>()[0] : nullptr;

  }

  /// \brief All associated constraints derived from this template parameter

  /// list, including the requires clause and any constraints derived from

  /// constrained-parameters.

  ///

  /// The constraints in the resulting list are to be treated as if in a

  /// conjunction ("and").

  void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;

  bool hasAssociatedConstraints() const;

  SourceLocation getTemplateLoc() const { return TemplateLoc; }

  SourceLocation getLAngleLoc() const { return LAngleLoc; }

  SourceLocation getRAngleLoc() const { return RAngleLoc; }

  SourceRange getSourceRange() const LLVM_READONLY {

    return SourceRange(TemplateLoc, RAngleLoc);

  }

  void print(raw_ostream &Out, const ASTContext &Context,

             bool OmitTemplateKW = false) const;

  void print(raw_ostream &Out, const ASTContext &Context,

             const PrintingPolicy &Policy, bool OmitTemplateKW = false) const;

  static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy,

                                           const TemplateParameterList *TPL,

                                           unsigned Idx);

};

/// Stores a list of template parameters and the associated

/// requires-clause (if any) for a TemplateDecl and its derived classes.

/// Suitable for creating on the stack.

template <size_t N, bool HasRequiresClause>

class FixedSizeTemplateParameterListStorage

    : public TemplateParameterList::FixedSizeStorageOwner {

  typename TemplateParameterList::FixedSizeStorage<

      NamedDecl *, Expr *>::with_counts<

      N, HasRequiresClause ? 1u : 0u

      >::type storage;

public:

  FixedSizeTemplateParameterListStorage(const ASTContext &C,

                                        SourceLocation TemplateLoc,

                                        SourceLocation LAngleLoc,

                                        ArrayRef<NamedDecl *> Params,

                                        SourceLocation RAngleLoc,

                                        Expr *RequiresClause)

      : FixedSizeStorageOwner(

            (assert(N == Params.size()),

             assert(HasRequiresClause == (RequiresClause != nullptr)),

             new (static_cast<void *>(&storage)) TemplateParameterList(C,

                 TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause))) {}

};

/// A template argument list.

class TemplateArgumentList final

    : private llvm::TrailingObjects<TemplateArgumentList, TemplateArgument> {

  /// The template argument list.

  const TemplateArgument *Arguments;

  /// The number of template arguments in this template

  /// argument list.

  unsigned NumArguments;

  // Constructs an instance with an internal Argument list, containing

  // a copy of the Args array. (Called by CreateCopy)

  TemplateArgumentList(ArrayRef<TemplateArgument> Args);

public:

  friend TrailingObjects;

  TemplateArgumentList(const TemplateArgumentList &) = delete;

  TemplateArgumentList &operator=(const TemplateArgumentList &) = delete;

  /// Type used to indicate that the template argument list itself is a

  /// stack object. It does not own its template arguments.

  enum OnStackType { OnStack };

  /// Create a new template argument list that copies the given set of

  /// template arguments.

  static TemplateArgumentList *CreateCopy(ASTContext &Context,

                                          ArrayRef<TemplateArgument> Args);

  /// Construct a new, temporary template argument list on the stack.

  ///

  /// The template argument list does not own the template arguments

  /// provided.

  explicit TemplateArgumentList(OnStackType, ArrayRef<TemplateArgument> Args)

      : Arguments(Args.data()), NumArguments(Args.size()) {}

  /// Produces a shallow copy of the given template argument list.

  ///

  /// This operation assumes that the input argument list outlives it.

  /// This takes the list as a pointer to avoid looking like a copy

  /// constructor, since this really isn't safe to use that way.

  explicit TemplateArgumentList(const TemplateArgumentList *Other)

      : Arguments(Other->data()), NumArguments(Other->size()) {}

  /// Retrieve the template argument at a given index.

  const TemplateArgument &get(unsigned Idx) const {

    assert(Idx < NumArguments && "Invalid template argument index");

    return data()[Idx];

  }

  /// Retrieve the template argument at a given index.

  const TemplateArgument &operator[](unsigned Idx) const { return get(Idx); }

  /// Produce this as an array ref.

  ArrayRef<TemplateArgument> asArray() const {

    return llvm::ArrayRef(data(), size());

  }

  /// Retrieve the number of template arguments in this

  /// template argument list.

  unsigned size() const { return NumArguments; }

  /// Retrieve a pointer to the template argument list.

  const TemplateArgument *data() const { return Arguments; }

};

void *allocateDefaultArgStorageChain(const ASTContext &C);

/// Storage for a default argument. This is conceptually either empty, or an

/// argument value, or a pointer to a previous declaration that had a default

/// argument.

///

/// However, this is complicated by modules: while we require all the default

/// arguments for a template to be equivalent, there may be more than one, and

/// we need to track all the originating parameters to determine if the default

/// argument is visible.

template<typename ParmDecl, typename ArgType>

class DefaultArgStorage {

  /// Storage for both the value *and* another parameter from which we inherit

  /// the default argument. This is used when multiple default arguments for a

  /// parameter are merged together from different modules.

  struct Chain {

    ParmDecl *PrevDeclWithDefaultArg;

    ArgType Value;

  };

  static_assert(sizeof(Chain) == sizeof(void *) * 2,

                "non-pointer argument type?");

  llvm::PointerUnion<ArgType, ParmDecl*, Chain*> ValueOrInherited;

  static ParmDecl *getParmOwningDefaultArg(ParmDecl *Parm) {

    const DefaultArgStorage &Storage = Parm->getDefaultArgStorage();

    if (auto *Prev = Storage.ValueOrInherited.template dyn_cast<ParmDecl *>())

      Parm = Prev;

    assert(!Parm->getDefaultArgStorage()

                .ValueOrInherited.template is<ParmDecl *>() &&

           "should only be one level of indirection");

    return Parm;

  }

public:

  DefaultArgStorage() : ValueOrInherited(ArgType()) {}

  /// Determine whether there is a default argument for this parameter.

  bool isSet() const { return !ValueOrInherited.isNull(); }

  /// Determine whether the default argument for this parameter was inherited

  /// from a previous declaration of the same entity.

  bool isInherited() const { return ValueOrInherited.template is<ParmDecl*>(); }

  /// Get the default argument's value. This does not consider whether the

  /// default argument is visible.

  ArgType get() const {

    const DefaultArgStorage *Storage = this;

    if (const auto *Prev = ValueOrInherited.template dyn_cast<ParmDecl *>())

      Storage = &Prev->getDefaultArgStorage();

    if (const auto *C = Storage->ValueOrInherited.template dyn_cast<Chain *>())

      return C->Value;

    return Storage->ValueOrInherited.template get<ArgType>();

  }

  /// Get the parameter from which we inherit the default argument, if any.

  /// This is the parameter on which the default argument was actually written.

  const ParmDecl *getInheritedFrom() const {

    if (const auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>())

      return D;

    if (const auto *C = ValueOrInherited.template dyn_cast<Chain *>())

      return C->PrevDeclWithDefaultArg;

    return nullptr;

  }

  /// Set the default argument.

  void set(ArgType Arg) {

    assert(!isSet() && "default argument already set");

    ValueOrInherited = Arg;

  }

  /// Set that the default argument was inherited from another parameter.

  void setInherited(const ASTContext &C, ParmDecl *InheritedFrom) {

    InheritedFrom = getParmOwningDefaultArg(InheritedFrom);

    if (!isSet())

      ValueOrInherited = InheritedFrom;

    else if (auto *D = ValueOrInherited.template dyn_cast<ParmDecl *>()) {

      assert(C.isSameDefaultTemplateArgument(D, InheritedFrom));

      ValueOrInherited =

          new (allocateDefaultArgStorageChain(C)) Chain{InheritedFrom, get()};

    } else if (auto *Inherited =

                   ValueOrInherited.template dyn_cast<Chain *>()) {

      assert(C.isSameDefaultTemplateArgument(Inherited->PrevDeclWithDefaultArg,

                                             InheritedFrom));

      Inherited->PrevDeclWithDefaultArg = InheritedFrom;

    } else

      ValueOrInherited = new (allocateDefaultArgStorageChain(C))

          Chain{InheritedFrom, ValueOrInherited.template get<ArgType>()};

  }

  /// Remove the default argument, even if it was inherited.

  void clear() {

    ValueOrInherited = ArgType();

  }

};

//===----------------------------------------------------------------------===//

// Kinds of Templates

//===----------------------------------------------------------------------===//

/// \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 {

  void anchor() override;

protected:

  // Construct a template decl with name, parameters, and templated element.

  TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,

               TemplateParameterList *Params, NamedDecl *Decl);

  // Construct a template decl with the given name and parameters.

  // Used when there is no templated element (e.g., for tt-params).

  TemplateDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName Name,

               TemplateParameterList *Params)

      : TemplateDecl(DK, DC, L, Name, Params, nullptr) {}

public:

  friend class ASTDeclReader;

  friend class ASTDeclWriter;

  /// Get the list of template parameters

  TemplateParameterList *getTemplateParameters() const {

    return TemplateParams;

  }

  /// \brief Get the total constraint-expression associated with this template,

  /// including constraint-expressions derived from the requires-clause,

  /// trailing requires-clause (for functions and methods) and constrained

  /// template parameters.

  void getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const;

  bool hasAssociatedConstraints() const;

  /// Get the underlying, templated declaration.

  NamedDecl *getTemplatedDecl() const { return TemplatedDecl; }

  // Should a specialization behave like an alias for another type.

  bool isTypeAlias() const;

  // Implement isa/cast/dyncast/etc.

  static bool classof(const Decl *D) { return classofKind(D->getKind()); }

  static bool classofKind(Kind K) {

    return K >= firstTemplate && K <= lastTemplate;

  }

  SourceRange getSourceRange() const override LLVM_READONLY {

    return SourceRange(getTemplateParameters()->getTemplateLoc(),

                       TemplatedDecl->getSourceRange().getEnd());

  }

protected:

  NamedDecl *TemplatedDecl;

  TemplateParameterList *TemplateParams;

public:

  void setTemplateParameters(TemplateParameterList *TParams) {

    TemplateParams = TParams;

  }

  /// Initialize the underlying templated declaration.

  void init(NamedDecl *NewTemplatedDecl) {

    if (TemplatedDecl)

      assert(TemplatedDecl == NewTemplatedDecl && "Inconsistent TemplatedDecl");

    else

      TemplatedDecl = NewTemplatedDecl;

  }

};

/// Provides information about a function template specialization,

/// which is a FunctionDecl that has been explicitly specialization or

/// instantiated from a function template.

class FunctionTemplateSpecializationInfo final

    : public llvm::FoldingSetNode,

      private llvm::TrailingObjects<FunctionTemplateSpecializationInfo,

                                    MemberSpecializationInfo *> {

  /// The function template specialization that this structure describes and a

  /// flag indicating if the function is a member specialization.

  llvm::PointerIntPair<FunctionDecl *, 1, bool> Function;

  /// The function template from which this function template

  /// specialization was generated.

  ///

  /// The two bits contain the top 4 values of TemplateSpecializationKind.

  llvm::PointerIntPair<FunctionTemplateDecl *, 2> Template;

public:

  /// The template arguments used to produce the function template

  /// specialization from the function template.

  const TemplateArgumentList *TemplateArguments;

  /// The template arguments as written in the sources, if provided.

  /// FIXME: Normally null; tail-allocate this.

  const ASTTemplateArgumentListInfo *TemplateArgumentsAsWritten;

  /// The point at which this function template specialization was

  /// first instantiated.

  SourceLocation PointOfInstantiation;

private:

  FunctionTemplateSpecializationInfo(

      FunctionDecl *FD, FunctionTemplateDecl *Template,

      TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,

      const ASTTemplateArgumentListInfo *TemplateArgsAsWritten,

      SourceLocation POI, MemberSpecializationInfo *MSInfo)

      : Function(FD, MSInfo ? true : false), Template(Template, TSK - 1),

        TemplateArguments(TemplateArgs),

        TemplateArgumentsAsWritten(TemplateArgsAsWritten),

        PointOfInstantiation(POI) {

    if (MSInfo)

      getTrailingObjects<MemberSpecializationInfo *>()[0] = MSInfo;

  }

  size_t numTrailingObjects(OverloadToken<MemberSpecializationInfo*>) const {

    return Function.getInt();

  }

public:

  friend TrailingObjects;

  static FunctionTemplateSpecializationInfo *

  Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,

         TemplateSpecializationKind TSK,

         const TemplateArgumentList *TemplateArgs,

         const TemplateArgumentListInfo *TemplateArgsAsWritten,

         SourceLocation POI, MemberSpecializationInfo *MSInfo);

  /// Retrieve the declaration of the function template specialization.

  FunctionDecl *getFunction() const { return Function.getPointer(); }

  /// Retrieve the template from which this function was specialized.

  FunctionTemplateDecl *getTemplate() const { return Template.getPointer(); }

  /// Determine what kind of template specialization this is.

  TemplateSpecializationKind getTemplateSpecializationKind() const {

    return (TemplateSpecializationKind)(Template.getInt() + 1);

  }

  bool isExplicitSpecialization() const {

    return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;

  }

  /// True if this declaration is an explicit specialization,

  /// explicit instantiation declaration, or explicit instantiation

  /// definition.

  bool isExplicitInstantiationOrSpecialization() const {

    return isTemplateExplicitInstantiationOrSpecialization(

        getTemplateSpecializationKind());

  }

  /// Set the template specialization kind.

  void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {

    assert(TSK != TSK_Undeclared &&

         "Cannot encode TSK_Undeclared for a function template specialization");

    Template.setInt(TSK - 1);

  }

  /// Retrieve the first point of instantiation of this function

  /// template specialization.

  ///

  /// The point of instantiation may be an invalid source location if this

  /// function has yet to be instantiated.

  SourceLocation getPointOfInstantiation() const {

    return PointOfInstantiation;

  }

  /// Set the (first) point of instantiation of this function template

  /// specialization.

  void setPointOfInstantiation(SourceLocation POI) {

    PointOfInstantiation = POI;

  }

  /// Get the specialization info if this function template specialization is

  /// also a member specialization:

  ///

  /// \code

  /// template<typename> struct A {

  ///   template<typename> void f();

  ///   template<> void f<int>(); // ClassScopeFunctionSpecializationDecl

  /// };

  /// \endcode

  ///

  /// Here, A<int>::f<int> is a function template specialization that is

  /// an explicit specialization of A<int>::f, but it's also a member

  /// specialization (an implicit instantiation in this case) of A::f<int>.

  /// Further:

  ///

  /// \code

  /// template<> template<> void A<int>::f<int>() {}

  /// \endcode

  ///

  /// ... declares a function template specialization that is an explicit

  /// specialization of A<int>::f, and is also an explicit member

  /// specialization of A::f<int>.

  ///

  /// Note that the TemplateSpecializationKind of the MemberSpecializationInfo

  /// need not be the same as that returned by getTemplateSpecializationKind(),

  /// and represents the relationship between the function and the class-scope

  /// explicit specialization in the original templated class -- whereas our

  /// TemplateSpecializationKind represents the relationship between the

  /// function and the function template, and should always be

  /// TSK_ExplicitSpecialization whenever we have MemberSpecializationInfo.

  MemberSpecializationInfo *getMemberSpecializationInfo() const {

    return numTrailingObjects(OverloadToken<MemberSpecializationInfo *>())

               ? getTrailingObjects<MemberSpecializationInfo *>()[0]

               : nullptr;

  }

  void Profile(llvm::FoldingSetNodeID &ID) {

    Profile(ID, TemplateArguments->asArray(), getFunction()->getASTContext());

  }

  static void

  Profile(llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,

          ASTContext &Context) {

    ID.AddInteger(TemplateArgs.size());

    for (const TemplateArgument &TemplateArg : TemplateArgs)

      TemplateArg.Profile(ID, Context);

  }

};

/// Provides information a specialization of a member of a class

/// template, which may be a member function, static data member,

/// member class or member enumeration.

class MemberSpecializationInfo {

  // The member declaration from which this member was instantiated, and the

  // manner in which the instantiation occurred (in the lower two bits).

  llvm::PointerIntPair<NamedDecl *, 2> MemberAndTSK;

  // The point at which this member was first instantiated.

  SourceLocation PointOfInstantiation;

public:

  explicit

  MemberSpecializationInfo(NamedDecl *IF, TemplateSpecializationKind TSK,

                           SourceLocation POI = SourceLocation())

      : MemberAndTSK(IF, TSK - 1), PointOfInstantiation(POI) {

    assert(TSK != TSK_Undeclared &&

           "Cannot encode undeclared template specializations for members");

  }

  /// Retrieve the member declaration from which this member was

  /// instantiated.

  NamedDecl *getInstantiatedFrom() const { return MemberAndTSK.getPointer(); }

  /// Determine what kind of template specialization this is.

  TemplateSpecializationKind getTemplateSpecializationKind() const {

    return (TemplateSpecializationKind)(MemberAndTSK.getInt() + 1);

  }

  bool isExplicitSpecialization() const {

    return getTemplateSpecializationKind() == TSK_ExplicitSpecialization;

  }

  /// Set the template specialization kind.

  void setTemplateSpecializationKind(TemplateSpecializationKind TSK) {

    assert(TSK != TSK_Undeclared &&

           "Cannot encode undeclared template specializations for members");

    MemberAndTSK.setInt(TSK - 1);

  }

  /// Retrieve the first point of instantiation of this member.

  /// If the point of instantiation is an invalid location, then this member

  /// has not yet been instantiated.

  SourceLocation getPointOfInstantiation() const {

    return PointOfInstantiation;

  }

  /// Set the first point of instantiation.

  void setPointOfInstantiation(SourceLocation POI) {

    PointOfInstantiation = POI;

  }

};

/// 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:

///

/// \code

///   template \<class T> void foo(T);

///   template \<class T> class A {

///     friend void foo<>(T);

///   };

/// \endcode

class DependentFunctionTemplateSpecializationInfo final

    : private llvm::TrailingObjects<DependentFunctionTemplateSpecializationInfo,

                                    TemplateArgumentLoc,

                                    FunctionTemplateDecl *> {

  /// The number of potential template candidates.

  unsigned NumTemplates;

  /// The number of template arguments.

  unsigned NumArgs;

  /// The locations of the left and right angle brackets.

  SourceRange AngleLocs;

  size_t numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {

    return NumArgs;

  }

  size_t numTrailingObjects(OverloadToken<FunctionTemplateDecl *>) const {

    return NumTemplates;

  }

  DependentFunctionTemplateSpecializationInfo(

                                 const UnresolvedSetImpl &Templates,

                                 const TemplateArgumentListInfo &TemplateArgs);

public:

  friend TrailingObjects;

  static DependentFunctionTemplateSpecializationInfo *

  Create(ASTContext &Context, const UnresolvedSetImpl &Templates,

         const TemplateArgumentListInfo &TemplateArgs);

  /// Returns the number of function templates that this might

  /// be a specialization of.

  unsigned getNumTemplates() const { return NumTemplates; }

  /// Returns the i'th template candidate.

  FunctionTemplateDecl *getTemplate(unsigned I) const {

    assert(I < getNumTemplates() && "template index out of range");

    return getTrailingObjects<FunctionTemplateDecl *>()[I];

  }

  /// Returns the explicit template arguments that were given.

  const TemplateArgumentLoc *getTemplateArgs() const {

    return getTrailingObjects<TemplateArgumentLoc>();

  }

  /// Returns the number of explicit template arguments that were given.

  unsigned getNumTemplateArgs() const { return NumArgs; }

  llvm::ArrayRef<TemplateArgumentLoc> arguments() const {

    return llvm::ArrayRef(getTemplateArgs(), getNumTemplateArgs());

  }

  /// Returns the nth template argument.

  const TemplateArgumentLoc &getTemplateArg(unsigned I) const {

    assert(I < getNumTemplateArgs() && "template arg index out of range");

    return getTemplateArgs()[I];

  }

  SourceLocation getLAngleLoc() const {

    return AngleLocs.getBegin();

  }

  SourceLocation getRAngleLoc() const {

    return AngleLocs.getEnd();

  }

};

/// Declaration of a redeclarable template.

class RedeclarableTemplateDecl : public TemplateDecl,

                                 public Redeclarable<RedeclarableTemplateDecl>

{

  using redeclarable_base = Redeclarable<RedeclarableTemplateDecl>;

  RedeclarableTemplateDecl *getNextRedeclarationImpl() override {

    return getNextRedeclaration();

  }

  RedeclarableTemplateDecl *getPreviousDeclImpl() override {

    return getPreviousDecl();

  }

  RedeclarableTemplateDecl *getMostRecentDeclImpl() override {

    return getMostRecentDecl();

  }

  void anchor() override;

protected:

  template <typename EntryType> struct SpecEntryTraits {

    using DeclType = EntryType;

    static DeclType *getDecl(EntryType *D) {

      return D;

    }

    static ArrayRef<TemplateArgument> getTemplateArgs(EntryType *D) {

      return D->getTemplateArgs().asArray();

    }

  };

  template <typename EntryType, typename SETraits = SpecEntryTraits<EntryType>,

            typename DeclType = typename SETraits::DeclType>

  struct SpecIterator

      : llvm::iterator_adaptor_base<

            SpecIterator<EntryType, SETraits, DeclType>,

            typename llvm::FoldingSetVector<EntryType>::iterator,

            typename std::iterator_traits<typename llvm::FoldingSetVector<

                EntryType>::iterator>::iterator_category,

            DeclType *, ptrdiff_t, DeclType *, DeclType *> {

    SpecIterator() = default;

    explicit SpecIterator(

        typename llvm::FoldingSetVector<EntryType>::iterator SetIter)

        : SpecIterator::iterator_adaptor_base(std::move(SetIter)) {}

    DeclType *operator*() const {

      return SETraits::getDecl(&*this->I)->getMostRecentDecl();

    }

    DeclType *operator->() const { return **this; }

  };

  template <typename EntryType>

  static SpecIterator<EntryType>

  makeSpecIterator(llvm::FoldingSetVector<EntryType> &Specs, bool isEnd) {