contrib/llvm/tools/clang/include/clang/AST/TemplateName.h

   1 //===--- TemplateName.h - C++ Template Name Representation-------*- 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 TemplateName interface and subclasses.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_TEMPLATENAME_H
  15 #define LLVM_CLANG_AST_TEMPLATENAME_H
  16
  17 #include "clang/Basic/LLVM.h"
  18 #include "llvm/ADT/FoldingSet.h"
  19 #include "llvm/ADT/PointerUnion.h"
  20 #include "clang/Basic/OperatorKinds.h"
  21
  22 namespace clang {
  23
  24 class ASTContext;
  25 class DependentTemplateName;
  26 class DiagnosticBuilder;
  27 class IdentifierInfo;
  28 class NestedNameSpecifier;
  29 class OverloadedTemplateStorage;
  30 struct PrintingPolicy;
  31 class QualifiedTemplateName;
  32 class NamedDecl;
  33 class SubstTemplateTemplateParmStorage;
  34 class SubstTemplateTemplateParmPackStorage;
  35 class TemplateArgument;
  36 class TemplateDecl;
  37 class TemplateTemplateParmDecl;
  38
  39 /// \brief Implementation class used to describe either a set of overloaded
  40 /// template names or an already-substituted template template parameter pack.
  41 class UncommonTemplateNameStorage {
  42 protected:
  43   enum Kind {
  44     Overloaded,
  45     SubstTemplateTemplateParm,
  46     SubstTemplateTemplateParmPack
  47   };
  48
  49   union {
  50     struct {
  51       /// \brief A Kind.
  52       unsigned Kind : 2;
  53
  54       /// \brief The number of stored templates or template arguments,
  55       /// depending on which subclass we have.
  56       unsigned Size : 30;
  57     } Bits;
  58
  59     void *PointerAlignment;
  60   };
  61
  62   UncommonTemplateNameStorage(Kind kind, unsigned size) {
  63     Bits.Kind = kind;
  64     Bits.Size = size;
  65   }
  66
  67 public:
  68   unsigned size() const { return Bits.Size; }
  69
  70   OverloadedTemplateStorage *getAsOverloadedStorage()  {
  71     return Bits.Kind == Overloaded
  72              ? reinterpret_cast<OverloadedTemplateStorage *>(this)
  73              : 0;
  74   }
  75
  76   SubstTemplateTemplateParmStorage *getAsSubstTemplateTemplateParm() {
  77     return Bits.Kind == SubstTemplateTemplateParm
  78              ? reinterpret_cast<SubstTemplateTemplateParmStorage *>(this)
  79              : 0;
  80   }
  81
  82   SubstTemplateTemplateParmPackStorage *getAsSubstTemplateTemplateParmPack() {
  83     return Bits.Kind == SubstTemplateTemplateParmPack
  84              ? reinterpret_cast<SubstTemplateTemplateParmPackStorage *>(this)
  85              : 0;
  86   }
  87 };
  88
  89 /// \brief A structure for storing the information associated with an
  90 /// overloaded template name.
  91 class OverloadedTemplateStorage : public UncommonTemplateNameStorage {
  92   friend class ASTContext;
  93
  94   OverloadedTemplateStorage(unsigned size)
  95     : UncommonTemplateNameStorage(Overloaded, size) { }
  96
  97   NamedDecl **getStorage() {
  98     return reinterpret_cast<NamedDecl **>(this + 1);
  99   }
 100   NamedDecl * const *getStorage() const {
 101     return reinterpret_cast<NamedDecl *const *>(this + 1);
 102   }
 103
 104 public:
 105   typedef NamedDecl *const *iterator;
 106
 107   iterator begin() const { return getStorage(); }
 108   iterator end() const { return getStorage() + size(); }
 109 };
 110
 111 /// \brief A structure for storing an already-substituted template template
 112 /// parameter pack.
 113 ///
 114 /// This kind of template names occurs when the parameter pack has been
 115 /// provided with a template template argument pack in a context where its
 116 /// enclosing pack expansion could not be fully expanded.
 117 class SubstTemplateTemplateParmPackStorage
 118   : public UncommonTemplateNameStorage, public llvm::FoldingSetNode
 119 {
 120   TemplateTemplateParmDecl *Parameter;
 121   const TemplateArgument *Arguments;
 122
 123 public:
 124   SubstTemplateTemplateParmPackStorage(TemplateTemplateParmDecl *Parameter,
 125                                        unsigned Size,
 126                                        const TemplateArgument *Arguments)
 127     : UncommonTemplateNameStorage(SubstTemplateTemplateParmPack, Size),
 128       Parameter(Parameter), Arguments(Arguments) { }
 129
 130   /// \brief Retrieve the template template parameter pack being substituted.
 131   TemplateTemplateParmDecl *getParameterPack() const {
 132     return Parameter;
 133   }
 134
 135   /// \brief Retrieve the template template argument pack with which this
 136   /// parameter was substituted.
 137   TemplateArgument getArgumentPack() const;
 138
 139   void Profile(llvm::FoldingSetNodeID &ID, ASTContext &Context);
 140
 141   static void Profile(llvm::FoldingSetNodeID &ID,
 142                       ASTContext &Context,
 143                       TemplateTemplateParmDecl *Parameter,
 144                       const TemplateArgument &ArgPack);
 145 };
 146
 147 /// \brief Represents a C++ template name within the type system.
 148 ///
 149 /// A C++ template name refers to a template within the C++ type
 150 /// system. In most cases, a template name is simply a reference to a
 151 /// class template, e.g.
 152 ///
 153 /// \code
 154 /// template<typename T> class X { };
 155 ///
 156 /// X<int> xi;
 157 /// \endcode
 158 ///
 159 /// Here, the 'X' in \c X<int> is a template name that refers to the
 160 /// declaration of the class template X, above. Template names can
 161 /// also refer to function templates, C++0x template aliases, etc.
 162 ///
 163 /// Some template names are dependent. For example, consider:
 164 ///
 165 /// \code
 166 /// template<typename MetaFun, typename T1, typename T2> struct apply2 {
 167 ///   typedef typename MetaFun::template apply<T1, T2>::type type;
 168 /// };
 169 /// \endcode
 170 ///
 171 /// Here, "apply" is treated as a template name within the typename
 172 /// specifier in the typedef. "apply" is a nested template, and can
 173 /// only be understood in the context of
 174 class TemplateName {
 175   typedef llvm::PointerUnion4<TemplateDecl *,
 176                               UncommonTemplateNameStorage *,
 177                               QualifiedTemplateName *,
 178                               DependentTemplateName *> StorageType;
 179
 180   StorageType Storage;
 181
 182   explicit TemplateName(void *Ptr) {
 183     Storage = StorageType::getFromOpaqueValue(Ptr);
 184   }
 185
 186 public:
 187   // \brief Kind of name that is actually stored.
 188   enum NameKind {
 189     /// \brief A single template declaration.
 190     Template,
 191     /// \brief A set of overloaded template declarations.
 192     OverloadedTemplate,
 193     /// \brief A qualified template name, where the qualification is kept
 194     /// to describe the source code as written.
 195     QualifiedTemplate,
 196     /// \brief A dependent template name that has not been resolved to a
 197     /// template (or set of templates).
 198     DependentTemplate,
 199     /// \brief A template template parameter that has been substituted
 200     /// for some other template name.
 201     SubstTemplateTemplateParm,
 202     /// \brief A template template parameter pack that has been substituted for
 203     /// a template template argument pack, but has not yet been expanded into
 204     /// individual arguments.
 205     SubstTemplateTemplateParmPack
 206   };
 207
 208   TemplateName() : Storage() { }
 209   explicit TemplateName(TemplateDecl *Template) : Storage(Template) { }
 210   explicit TemplateName(OverloadedTemplateStorage *Storage)
 211     : Storage(Storage) { }
 212   explicit TemplateName(SubstTemplateTemplateParmStorage *Storage);
 213   explicit TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
 214     : Storage(Storage) { }
 215   explicit TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) { }
 216   explicit TemplateName(DependentTemplateName *Dep) : Storage(Dep) { }
 217
 218   /// \brief Determine whether this template name is NULL.
 219   bool isNull() const { return Storage.isNull(); }
 220
 221   // \brief Get the kind of name that is actually stored.
 222   NameKind getKind() const;
 223
 224   /// \brief Retrieve the underlying template declaration that
 225   /// this template name refers to, if known.
 226   ///
 227   /// \returns The template declaration that this template name refers
 228   /// to, if any. If the template name does not refer to a specific
 229   /// declaration because it is a dependent name, or if it refers to a
 230   /// set of function templates, returns NULL.
 231   TemplateDecl *getAsTemplateDecl() const;
 232
 233   /// \brief Retrieve the underlying, overloaded function template
 234   // declarations that this template name refers to, if known.
 235   ///
 236   /// \returns The set of overloaded function templates that this template
 237   /// name refers to, if known. If the template name does not refer to a
 238   /// specific set of function templates because it is a dependent name or
 239   /// refers to a single template, returns NULL.
 240   OverloadedTemplateStorage *getAsOverloadedTemplate() const {
 241     if (UncommonTemplateNameStorage *Uncommon =
 242                               Storage.dyn_cast<UncommonTemplateNameStorage *>())
 243       return Uncommon->getAsOverloadedStorage();
 244
 245     return 0;
 246   }
 247
 248   /// \brief Retrieve the substituted template template parameter, if
 249   /// known.
 250   ///
 251   /// \returns The storage for the substituted template template parameter,
 252   /// if known. Otherwise, returns NULL.
 253   SubstTemplateTemplateParmStorage *getAsSubstTemplateTemplateParm() const {
 254     if (UncommonTemplateNameStorage *uncommon =
 255           Storage.dyn_cast<UncommonTemplateNameStorage *>())
 256       return uncommon->getAsSubstTemplateTemplateParm();
 257
 258     return 0;
 259   }
 260
 261   /// \brief Retrieve the substituted template template parameter pack, if
 262   /// known.
 263   ///
 264   /// \returns The storage for the substituted template template parameter pack,
 265   /// if known. Otherwise, returns NULL.
 266   SubstTemplateTemplateParmPackStorage *
 267   getAsSubstTemplateTemplateParmPack() const {
 268     if (UncommonTemplateNameStorage *Uncommon =
 269         Storage.dyn_cast<UncommonTemplateNameStorage *>())
 270       return Uncommon->getAsSubstTemplateTemplateParmPack();
 271
 272     return 0;
 273   }
 274
 275   /// \brief Retrieve the underlying qualified template name
 276   /// structure, if any.
 277   QualifiedTemplateName *getAsQualifiedTemplateName() const {
 278     return Storage.dyn_cast<QualifiedTemplateName *>();
 279   }
 280
 281   /// \brief Retrieve the underlying dependent template name
 282   /// structure, if any.
 283   DependentTemplateName *getAsDependentTemplateName() const {
 284     return Storage.dyn_cast<DependentTemplateName *>();
 285   }
 286
 287   TemplateName getUnderlying() const;
 288
 289   /// \brief Determines whether this is a dependent template name.
 290   bool isDependent() const;
 291
 292   /// \brief Determines whether this is a template name that somehow
 293   /// depends on a template parameter.
 294   bool isInstantiationDependent() const;
 295
 296   /// \brief Determines whether this template name contains an
 297   /// unexpanded parameter pack (for C++0x variadic templates).
 298   bool containsUnexpandedParameterPack() const;
 299
 300   /// \brief Print the template name.
 301   ///
 302   /// \param OS the output stream to which the template name will be
 303   /// printed.
 304   ///
 305   /// \param SuppressNNS if true, don't print the
 306   /// nested-name-specifier that precedes the template name (if it has
 307   /// one).
 308   void print(raw_ostream &OS, const PrintingPolicy &Policy,
 309              bool SuppressNNS = false) const;
 310
 311   /// \brief Debugging aid that dumps the template name to standard
 312   /// error.
 313   void dump() const;
 314
 315   void Profile(llvm::FoldingSetNodeID &ID) {
 316     ID.AddPointer(Storage.getOpaqueValue());
 317   }
 318
 319   /// \brief Retrieve the template name as a void pointer.
 320   void *getAsVoidPointer() const { return Storage.getOpaqueValue(); }
 321
 322   /// \brief Build a template name from a void pointer.
 323   static TemplateName getFromVoidPointer(void *Ptr) {
 324     return TemplateName(Ptr);
 325   }
 326 };
 327
 328 /// Insertion operator for diagnostics.  This allows sending TemplateName's
 329 /// into a diagnostic with <<.
 330 const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 331                                     TemplateName N);
 332
 333 /// \brief A structure for storing the information associated with a
 334 /// substituted template template parameter.
 335 class SubstTemplateTemplateParmStorage
 336   : public UncommonTemplateNameStorage, public llvm::FoldingSetNode {
 337   friend class ASTContext;
 338
 339   TemplateTemplateParmDecl *Parameter;
 340   TemplateName Replacement;
 341
 342   SubstTemplateTemplateParmStorage(TemplateTemplateParmDecl *parameter,
 343                                    TemplateName replacement)
 344     : UncommonTemplateNameStorage(SubstTemplateTemplateParm, 0),
 345       Parameter(parameter), Replacement(replacement) {}
 346
 347 public:
 348   TemplateTemplateParmDecl *getParameter() const { return Parameter; }
 349   TemplateName getReplacement() const { return Replacement; }
 350
 351   void Profile(llvm::FoldingSetNodeID &ID);
 352
 353   static void Profile(llvm::FoldingSetNodeID &ID,
 354                       TemplateTemplateParmDecl *parameter,
 355                       TemplateName replacement);
 356 };
 357
 358 inline TemplateName::TemplateName(SubstTemplateTemplateParmStorage *Storage)
 359   : Storage(Storage) { }
 360
 361 inline TemplateName TemplateName::getUnderlying() const {
 362   if (SubstTemplateTemplateParmStorage *subst
 363         = getAsSubstTemplateTemplateParm())
 364     return subst->getReplacement().getUnderlying();
 365   return *this;
 366 }
 367
 368 /// \brief Represents a template name that was expressed as a
 369 /// qualified name.
 370 ///
 371 /// This kind of template name refers to a template name that was
 372 /// preceded by a nested name specifier, e.g., \c std::vector. Here,
 373 /// the nested name specifier is "std::" and the template name is the
 374 /// declaration for "vector". The QualifiedTemplateName class is only
 375 /// used to provide "sugar" for template names that were expressed
 376 /// with a qualified name, and has no semantic meaning. In this
 377 /// manner, it is to TemplateName what ElaboratedType is to Type,
 378 /// providing extra syntactic sugar for downstream clients.
 379 class QualifiedTemplateName : public llvm::FoldingSetNode {
 380   /// \brief The nested name specifier that qualifies the template name.
 381   ///
 382   /// The bit is used to indicate whether the "template" keyword was
 383   /// present before the template name itself. Note that the
 384   /// "template" keyword is always redundant in this case (otherwise,
 385   /// the template name would be a dependent name and we would express
 386   /// this name with DependentTemplateName).
 387   llvm::PointerIntPair<NestedNameSpecifier *, 1> Qualifier;
 388
 389   /// \brief The template declaration or set of overloaded function templates
 390   /// that this qualified name refers to.
 391   TemplateDecl *Template;
 392
 393   friend class ASTContext;
 394
 395   QualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword,
 396                         TemplateDecl *Template)
 397     : Qualifier(NNS, TemplateKeyword? 1 : 0),
 398       Template(Template) { }
 399
 400 public:
 401   /// \brief Return the nested name specifier that qualifies this name.
 402   NestedNameSpecifier *getQualifier() const { return Qualifier.getPointer(); }
 403
 404   /// \brief Whether the template name was prefixed by the "template"
 405   /// keyword.
 406   bool hasTemplateKeyword() const { return Qualifier.getInt(); }
 407
 408   /// \brief The template declaration that this qualified name refers
 409   /// to.
 410   TemplateDecl *getDecl() const { return Template; }
 411
 412   /// \brief The template declaration to which this qualified name
 413   /// refers.
 414   TemplateDecl *getTemplateDecl() const { return Template; }
 415
 416   void Profile(llvm::FoldingSetNodeID &ID) {
 417     Profile(ID, getQualifier(), hasTemplateKeyword(), getTemplateDecl());
 418   }
 419
 420   static void Profile(llvm::FoldingSetNodeID &ID, NestedNameSpecifier *NNS,
 421                       bool TemplateKeyword, TemplateDecl *Template) {
 422     ID.AddPointer(NNS);
 423     ID.AddBoolean(TemplateKeyword);
 424     ID.AddPointer(Template);
 425   }
 426 };
 427
 428 /// \brief Represents a dependent template name that cannot be
 429 /// resolved prior to template instantiation.
 430 ///
 431 /// This kind of template name refers to a dependent template name,
 432 /// including its nested name specifier (if any). For example,
 433 /// DependentTemplateName can refer to "MetaFun::template apply",
 434 /// where "MetaFun::" is the nested name specifier and "apply" is the
 435 /// template name referenced. The "template" keyword is implied.
 436 class DependentTemplateName : public llvm::FoldingSetNode {
 437   /// \brief The nested name specifier that qualifies the template
 438   /// name.
 439   ///
 440   /// The bit stored in this qualifier describes whether the \c Name field
 441   /// is interpreted as an IdentifierInfo pointer (when clear) or as an
 442   /// overloaded operator kind (when set).
 443   llvm::PointerIntPair<NestedNameSpecifier *, 1, bool> Qualifier;
 444
 445   /// \brief The dependent template name.
 446   union {
 447     /// \brief The identifier template name.
 448     ///
 449     /// Only valid when the bit on \c Qualifier is clear.
 450     const IdentifierInfo *Identifier;
 451
 452     /// \brief The overloaded operator name.
 453     ///
 454     /// Only valid when the bit on \c Qualifier is set.
 455     OverloadedOperatorKind Operator;
 456   };
 457
 458   /// \brief The canonical template name to which this dependent
 459   /// template name refers.
 460   ///
 461   /// The canonical template name for a dependent template name is
 462   /// another dependent template name whose nested name specifier is
 463   /// canonical.
 464   TemplateName CanonicalTemplateName;
 465
 466   friend class ASTContext;
 467
 468   DependentTemplateName(NestedNameSpecifier *Qualifier,
 469                         const IdentifierInfo *Identifier)
 470     : Qualifier(Qualifier, false), Identifier(Identifier),
 471       CanonicalTemplateName(this) { }
 472
 473   DependentTemplateName(NestedNameSpecifier *Qualifier,
 474                         const IdentifierInfo *Identifier,
 475                         TemplateName Canon)
 476     : Qualifier(Qualifier, false), Identifier(Identifier),
 477       CanonicalTemplateName(Canon) { }
 478
 479   DependentTemplateName(NestedNameSpecifier *Qualifier,
 480                         OverloadedOperatorKind Operator)
 481   : Qualifier(Qualifier, true), Operator(Operator),
 482     CanonicalTemplateName(this) { }
 483
 484   DependentTemplateName(NestedNameSpecifier *Qualifier,
 485                         OverloadedOperatorKind Operator,
 486                         TemplateName Canon)
 487   : Qualifier(Qualifier, true), Operator(Operator),
 488     CanonicalTemplateName(Canon) { }
 489
 490 public:
 491   /// \brief Return the nested name specifier that qualifies this name.
 492   NestedNameSpecifier *getQualifier() const { return Qualifier.getPointer(); }
 493
 494   /// \brief Determine whether this template name refers to an identifier.
 495   bool isIdentifier() const { return !Qualifier.getInt(); }
 496
 497   /// \brief Returns the identifier to which this template name refers.
 498   const IdentifierInfo *getIdentifier() const {
 499     assert(isIdentifier() && "Template name isn't an identifier?");
 500     return Identifier;
 501   }
 502
 503   /// \brief Determine whether this template name refers to an overloaded
 504   /// operator.
 505   bool isOverloadedOperator() const { return Qualifier.getInt(); }
 506
 507   /// \brief Return the overloaded operator to which this template name refers.
 508   OverloadedOperatorKind getOperator() const {
 509     assert(isOverloadedOperator() &&
 510            "Template name isn't an overloaded operator?");
 511     return Operator;
 512   }
 513
 514   void Profile(llvm::FoldingSetNodeID &ID) {
 515     if (isIdentifier())
 516       Profile(ID, getQualifier(), getIdentifier());
 517     else
 518       Profile(ID, getQualifier(), getOperator());
 519   }
 520
 521   static void Profile(llvm::FoldingSetNodeID &ID, NestedNameSpecifier *NNS,
 522                       const IdentifierInfo *Identifier) {
 523     ID.AddPointer(NNS);
 524     ID.AddBoolean(false);
 525     ID.AddPointer(Identifier);
 526   }
 527
 528   static void Profile(llvm::FoldingSetNodeID &ID, NestedNameSpecifier *NNS,
 529                       OverloadedOperatorKind Operator) {
 530     ID.AddPointer(NNS);
 531     ID.AddBoolean(true);
 532     ID.AddInteger(Operator);
 533   }
 534 };
 535
 536 } // end namespace clang.
 537
 538 namespace llvm {
 539
 540 /// \brief The clang::TemplateName class is effectively a pointer.
 541 template<>
 542 class PointerLikeTypeTraits<clang::TemplateName> {
 543 public:
 544   static inline void *getAsVoidPointer(clang::TemplateName TN) {
 545     return TN.getAsVoidPointer();
 546   }
 547
 548   static inline clang::TemplateName getFromVoidPointer(void *Ptr) {
 549     return clang::TemplateName::getFromVoidPointer(Ptr);
 550   }
 551
 552   // No bits are available!
 553   enum { NumLowBitsAvailable = 0 };
 554 };
 555
 556 } // end namespace llvm.
 557
 558 #endif