contrib/llvm/tools/clang/include/clang/Sema/ParsedTemplate.h

   1 //===--- ParsedTemplate.h - Template Parsing Data Types ---------*- 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 provides data structures that store the parsed representation of
  11 //  templates.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_SEMA_PARSEDTEMPLATE_H
  16 #define LLVM_CLANG_SEMA_PARSEDTEMPLATE_H
  17
  18 #include "clang/Basic/OperatorKinds.h"
  19 #include "clang/Basic/SourceLocation.h"
  20 #include "clang/Basic/TemplateKinds.h"
  21 #include "clang/Sema/DeclSpec.h"
  22 #include "clang/Sema/Ownership.h"
  23 #include "llvm/ADT/SmallVector.h"
  24 #include <cassert>
  25 #include <cstdlib>
  26 #include <new>
  27
  28 namespace clang {
  29   /// \brief Represents the parsed form of a C++ template argument.
  30   class ParsedTemplateArgument {
  31   public:
  32     /// \brief Describes the kind of template argument that was parsed.
  33     enum KindType {
  34       /// \brief A template type parameter, stored as a type.
  35       Type,
  36       /// \brief A non-type template parameter, stored as an expression.
  37       NonType,
  38       /// \brief A template template argument, stored as a template name.
  39       Template
  40     };
  41
  42     /// \brief Build an empty template argument.
  43     ///
  44     /// This template argument is invalid.
  45     ParsedTemplateArgument() : Kind(Type), Arg(nullptr) { }
  46
  47     /// \brief Create a template type argument or non-type template argument.
  48     ///
  49     /// \param Arg the template type argument or non-type template argument.
  50     /// \param Loc the location of the type.
  51     ParsedTemplateArgument(KindType Kind, void *Arg, SourceLocation Loc)
  52       : Kind(Kind), Arg(Arg), Loc(Loc) { }
  53
  54     /// \brief Create a template template argument.
  55     ///
  56     /// \param SS the C++ scope specifier that precedes the template name, if
  57     /// any.
  58     ///
  59     /// \param Template the template to which this template template
  60     /// argument refers.
  61     ///
  62     /// \param TemplateLoc the location of the template name.
  63     ParsedTemplateArgument(const CXXScopeSpec &SS,
  64                            ParsedTemplateTy Template,
  65                            SourceLocation TemplateLoc)
  66       : Kind(ParsedTemplateArgument::Template),
  67         Arg(Template.getAsOpaquePtr()),
  68         SS(SS), Loc(TemplateLoc), EllipsisLoc() { }
  69
  70     /// \brief Determine whether the given template argument is invalid.
  71     bool isInvalid() const { return Arg == nullptr; }
  72
  73     /// \brief Determine what kind of template argument we have.
  74     KindType getKind() const { return Kind; }
  75
  76     /// \brief Retrieve the template type argument's type.
  77     ParsedType getAsType() const {
  78       assert(Kind == Type && "Not a template type argument");
  79       return ParsedType::getFromOpaquePtr(Arg);
  80     }
  81
  82     /// \brief Retrieve the non-type template argument's expression.
  83     Expr *getAsExpr() const {
  84       assert(Kind == NonType && "Not a non-type template argument");
  85       return static_cast<Expr*>(Arg);
  86     }
  87
  88     /// \brief Retrieve the template template argument's template name.
  89     ParsedTemplateTy getAsTemplate() const {
  90       assert(Kind == Template && "Not a template template argument");
  91       return ParsedTemplateTy::getFromOpaquePtr(Arg);
  92     }
  93
  94     /// \brief Retrieve the location of the template argument.
  95     SourceLocation getLocation() const { return Loc; }
  96
  97     /// \brief Retrieve the nested-name-specifier that precedes the template
  98     /// name in a template template argument.
  99     const CXXScopeSpec &getScopeSpec() const {
 100       assert(Kind == Template &&
 101              "Only template template arguments can have a scope specifier");
 102       return SS;
 103     }
 104
 105     /// \brief Retrieve the location of the ellipsis that makes a template
 106     /// template argument into a pack expansion.
 107     SourceLocation getEllipsisLoc() const {
 108       assert(Kind == Template &&
 109              "Only template template arguments can have an ellipsis");
 110       return EllipsisLoc;
 111     }
 112
 113     /// \brief Retrieve a pack expansion of the given template template
 114     /// argument.
 115     ///
 116     /// \param EllipsisLoc The location of the ellipsis.
 117     ParsedTemplateArgument getTemplatePackExpansion(
 118                                               SourceLocation EllipsisLoc) const;
 119
 120   private:
 121     KindType Kind;
 122
 123     /// \brief The actual template argument representation, which may be
 124     /// an \c Sema::TypeTy* (for a type), an Expr* (for an
 125     /// expression), or an Sema::TemplateTy (for a template).
 126     void *Arg;
 127
 128     /// \brief The nested-name-specifier that can accompany a template template
 129     /// argument.
 130     CXXScopeSpec SS;
 131
 132     /// \brief the location of the template argument.
 133     SourceLocation Loc;
 134
 135     /// \brief The ellipsis location that can accompany a template template
 136     /// argument (turning it into a template template argument expansion).
 137     SourceLocation EllipsisLoc;
 138   };
 139
 140   /// \brief Information about a template-id annotation
 141   /// token.
 142   ///
 143   /// A template-id annotation token contains the template declaration,
 144   /// template arguments, whether those template arguments were types,
 145   /// expressions, or template names, and the source locations for important
 146   /// tokens. All of the information about template arguments is allocated
 147   /// directly after this structure.
 148   struct TemplateIdAnnotation {
 149     /// \brief The nested-name-specifier that precedes the template name.
 150     CXXScopeSpec SS;
 151
 152     /// TemplateKWLoc - The location of the template keyword within the
 153     /// source.
 154     SourceLocation TemplateKWLoc;
 155
 156     /// TemplateNameLoc - The location of the template name within the
 157     /// source.
 158     SourceLocation TemplateNameLoc;
 159
 160     /// FIXME: Temporarily stores the name of a specialization
 161     IdentifierInfo *Name;
 162
 163     /// FIXME: Temporarily stores the overloaded operator kind.
 164     OverloadedOperatorKind Operator;
 165
 166     /// The declaration of the template corresponding to the
 167     /// template-name.
 168     ParsedTemplateTy Template;
 169
 170     /// The kind of template that Template refers to.
 171     TemplateNameKind Kind;
 172
 173     /// The location of the '<' before the template argument
 174     /// list.
 175     SourceLocation LAngleLoc;
 176
 177     /// The location of the '>' after the template argument
 178     /// list.
 179     SourceLocation RAngleLoc;
 180
 181     /// NumArgs - The number of template arguments.
 182     unsigned NumArgs;
 183
 184     /// \brief Retrieves a pointer to the template arguments
 185     ParsedTemplateArgument *getTemplateArgs() {
 186       return reinterpret_cast<ParsedTemplateArgument *>(this + 1);
 187     }
 188
 189     /// \brief Creates a new TemplateIdAnnotation with NumArgs arguments and
 190     /// appends it to List.
 191     static TemplateIdAnnotation *
 192     Allocate(unsigned NumArgs, SmallVectorImpl<TemplateIdAnnotation*> &List) {
 193       TemplateIdAnnotation *TemplateId
 194         = (TemplateIdAnnotation *)std::malloc(sizeof(TemplateIdAnnotation) +
 195                                       sizeof(ParsedTemplateArgument) * NumArgs);
 196       TemplateId->NumArgs = NumArgs;
 197
 198       // Default-construct nested-name-specifier.
 199       new (&TemplateId->SS) CXXScopeSpec();
 200
 201       // Default-construct parsed template arguments.
 202       ParsedTemplateArgument *TemplateArgs = TemplateId->getTemplateArgs();
 203       for (unsigned I = 0; I != NumArgs; ++I)
 204         new (TemplateArgs + I) ParsedTemplateArgument();
 205
 206       List.push_back(TemplateId);
 207       return TemplateId;
 208     }
 209
 210     void Destroy() {
 211       SS.~CXXScopeSpec();
 212       free(this);
 213     }
 214   };
 215
 216   /// Retrieves the range of the given template parameter lists.
 217   SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params,
 218                                      unsigned NumParams);
 219 } // end namespace clang
 220
 221 #endif // LLVM_CLANG_SEMA_PARSEDTEMPLATE_H