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

   1 //===-- TemplateBase.h - Core classes for C++ templates ---------*- 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 definitions which are common for all kinds of
  11 //  template representation.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_AST_TEMPLATEBASE_H
  16 #define LLVM_CLANG_AST_TEMPLATEBASE_H
  17
  18 #include "llvm/ADT/APSInt.h"
  19 #include "llvm/ADT/SmallVector.h"
  20 #include "llvm/Support/ErrorHandling.h"
  21 #include "clang/AST/Type.h"
  22 #include "clang/AST/TemplateName.h"
  23
  24 namespace llvm {
  25   class FoldingSetNodeID;
  26   class raw_ostream;
  27 }
  28
  29 namespace clang {
  30
  31 class Decl;
  32 class DiagnosticBuilder;
  33 class Expr;
  34 struct PrintingPolicy;
  35 class TypeSourceInfo;
  36
  37 /// \brief Represents a template argument within a class template
  38 /// specialization.
  39 class TemplateArgument {
  40 public:
  41   /// \brief The kind of template argument we're storing.
  42   enum ArgKind {
  43     /// \brief Represents an empty template argument, e.g., one that has not
  44     /// been deduced.
  45     Null = 0,
  46     /// The template argument is a type. Its value is stored in the
  47     /// TypeOrValue field.
  48     Type,
  49     /// The template argument is a declaration that was provided for a pointer
  50     /// or reference non-type template parameter.
  51     Declaration,
  52     /// The template argument is an integral value stored in an llvm::APSInt
  53     /// that was provided for an integral non-type template parameter.
  54     Integral,
  55     /// The template argument is a template name that was provided for a
  56     /// template template parameter.
  57     Template,
  58     /// The template argument is a pack expansion of a template name that was
  59     /// provided for a template template parameter.
  60     TemplateExpansion,
  61     /// The template argument is a value- or type-dependent expression
  62     /// stored in an Expr*.
  63     Expression,
  64     /// The template argument is actually a parameter pack. Arguments are stored
  65     /// in the Args struct.
  66     Pack
  67   };
  68
  69 private:
  70   /// \brief The kind of template argument we're storing.
  71   unsigned Kind;
  72
  73   union {
  74     uintptr_t TypeOrValue;
  75     struct {
  76       char Value[sizeof(llvm::APSInt)];
  77       void *Type;
  78     } Integer;
  79     struct {
  80       const TemplateArgument *Args;
  81       unsigned NumArgs;
  82     } Args;
  83     struct {
  84       void *Name;
  85       unsigned NumExpansions;
  86     } TemplateArg;
  87   };
  88
  89   TemplateArgument(TemplateName, bool); // DO NOT USE
  90
  91 public:
  92   /// \brief Construct an empty, invalid template argument.
  93   TemplateArgument() : Kind(Null), TypeOrValue(0) { }
  94
  95   /// \brief Construct a template type argument.
  96   TemplateArgument(QualType T) : Kind(Type) {
  97     TypeOrValue = reinterpret_cast<uintptr_t>(T.getAsOpaquePtr());
  98   }
  99
 100   /// \brief Construct a template argument that refers to a
 101   /// declaration, which is either an external declaration or a
 102   /// template declaration.
 103   TemplateArgument(Decl *D) : Kind(Declaration) {
 104     // FIXME: Need to be sure we have the "canonical" declaration!
 105     TypeOrValue = reinterpret_cast<uintptr_t>(D);
 106   }
 107
 108   /// \brief Construct an integral constant template argument.
 109   TemplateArgument(const llvm::APSInt &Value, QualType Type) : Kind(Integral) {
 110     // FIXME: Large integral values will get leaked. Do something
 111     // similar to what we did with IntegerLiteral.
 112     new (Integer.Value) llvm::APSInt(Value);
 113     Integer.Type = Type.getAsOpaquePtr();
 114   }
 115
 116   /// \brief Construct a template argument that is a template.
 117   ///
 118   /// This form of template argument is generally used for template template
 119   /// parameters. However, the template name could be a dependent template
 120   /// name that ends up being instantiated to a function template whose address
 121   /// is taken.
 122   ///
 123   /// \param Name The template name.
 124   TemplateArgument(TemplateName Name) : Kind(Template)
 125   {
 126     TemplateArg.Name = Name.getAsVoidPointer();
 127     TemplateArg.NumExpansions = 0;
 128   }
 129
 130   /// \brief Construct a template argument that is a template pack expansion.
 131   ///
 132   /// This form of template argument is generally used for template template
 133   /// parameters. However, the template name could be a dependent template
 134   /// name that ends up being instantiated to a function template whose address
 135   /// is taken.
 136   ///
 137   /// \param Name The template name.
 138   ///
 139   /// \param NumExpansions The number of expansions that will be generated by
 140   /// instantiating
 141   TemplateArgument(TemplateName Name, llvm::Optional<unsigned> NumExpansions)
 142     : Kind(TemplateExpansion)
 143   {
 144     TemplateArg.Name = Name.getAsVoidPointer();
 145     if (NumExpansions)
 146       TemplateArg.NumExpansions = *NumExpansions + 1;
 147     else
 148       TemplateArg.NumExpansions = 0;
 149   }
 150
 151   /// \brief Construct a template argument that is an expression.
 152   ///
 153   /// This form of template argument only occurs in template argument
 154   /// lists used for dependent types and for expression; it will not
 155   /// occur in a non-dependent, canonical template argument list.
 156   TemplateArgument(Expr *E) : Kind(Expression) {
 157     TypeOrValue = reinterpret_cast<uintptr_t>(E);
 158   }
 159
 160   /// \brief Construct a template argument that is a template argument pack.
 161   ///
 162   /// We assume that storage for the template arguments provided
 163   /// outlives the TemplateArgument itself.
 164   TemplateArgument(const TemplateArgument *Args, unsigned NumArgs) : Kind(Pack){
 165     this->Args.Args = Args;
 166     this->Args.NumArgs = NumArgs;
 167   }
 168
 169   /// \brief Copy constructor for a template argument.
 170   TemplateArgument(const TemplateArgument &Other) : Kind(Other.Kind) {
 171     // FIXME: Large integral values will get leaked. Do something
 172     // similar to what we did with IntegerLiteral.
 173     if (Kind == Integral) {
 174       new (Integer.Value) llvm::APSInt(*Other.getAsIntegral());
 175       Integer.Type = Other.Integer.Type;
 176     } else if (Kind == Pack) {
 177       Args.NumArgs = Other.Args.NumArgs;
 178       Args.Args = Other.Args.Args;
 179     } else if (Kind == Template || Kind == TemplateExpansion) {
 180       TemplateArg.Name = Other.TemplateArg.Name;
 181       TemplateArg.NumExpansions = Other.TemplateArg.NumExpansions;
 182     } else
 183       TypeOrValue = Other.TypeOrValue;
 184   }
 185
 186   TemplateArgument& operator=(const TemplateArgument& Other) {
 187     using llvm::APSInt;
 188
 189     if (Kind == Other.Kind && Kind == Integral) {
 190       // Copy integral values.
 191       *this->getAsIntegral() = *Other.getAsIntegral();
 192       Integer.Type = Other.Integer.Type;
 193       return *this;
 194     }
 195
 196     // Destroy the current integral value, if that's what we're holding.
 197     if (Kind == Integral)
 198       getAsIntegral()->~APSInt();
 199
 200     Kind = Other.Kind;
 201
 202     if (Other.Kind == Integral) {
 203       new (Integer.Value) llvm::APSInt(*Other.getAsIntegral());
 204       Integer.Type = Other.Integer.Type;
 205     } else if (Other.Kind == Pack) {
 206       Args.NumArgs = Other.Args.NumArgs;
 207       Args.Args = Other.Args.Args;
 208     } else if (Kind == Template || Kind == TemplateExpansion) {
 209       TemplateArg.Name = Other.TemplateArg.Name;
 210       TemplateArg.NumExpansions = Other.TemplateArg.NumExpansions;
 211     } else {
 212       TypeOrValue = Other.TypeOrValue;
 213     }
 214
 215     return *this;
 216   }
 217
 218   ~TemplateArgument() {
 219     using llvm::APSInt;
 220
 221     if (Kind == Integral)
 222       getAsIntegral()->~APSInt();
 223   }
 224
 225   /// \brief Create a new template argument pack by copying the given set of
 226   /// template arguments.
 227   static TemplateArgument CreatePackCopy(ASTContext &Context,
 228                                          const TemplateArgument *Args,
 229                                          unsigned NumArgs);
 230
 231   /// \brief Return the kind of stored template argument.
 232   ArgKind getKind() const { return (ArgKind)Kind; }
 233
 234   /// \brief Determine whether this template argument has no value.
 235   bool isNull() const { return Kind == Null; }
 236
 237   /// \brief Whether this template argument is dependent on a template
 238   /// parameter such that its result can change from one instantiation to
 239   /// another.
 240   bool isDependent() const;
 241
 242   /// \brief Whether this template argument is dependent on a template
 243   /// parameter.
 244   bool isInstantiationDependent() const;
 245
 246   /// \brief Whether this template argument contains an unexpanded
 247   /// parameter pack.
 248   bool containsUnexpandedParameterPack() const;
 249
 250   /// \brief Determine whether this template argument is a pack expansion.
 251   bool isPackExpansion() const;
 252
 253   /// \brief Retrieve the template argument as a type.
 254   QualType getAsType() const {
 255     if (Kind != Type)
 256       return QualType();
 257
 258     return QualType::getFromOpaquePtr(reinterpret_cast<void*>(TypeOrValue));
 259   }
 260
 261   /// \brief Retrieve the template argument as a declaration.
 262   Decl *getAsDecl() const {
 263     if (Kind != Declaration)
 264       return 0;
 265     return reinterpret_cast<Decl *>(TypeOrValue);
 266   }
 267
 268   /// \brief Retrieve the template argument as a template name.
 269   TemplateName getAsTemplate() const {
 270     if (Kind != Template)
 271       return TemplateName();
 272
 273     return TemplateName::getFromVoidPointer(TemplateArg.Name);
 274   }
 275
 276   /// \brief Retrieve the template argument as a template name; if the argument
 277   /// is a pack expansion, return the pattern as a template name.
 278   TemplateName getAsTemplateOrTemplatePattern() const {
 279     if (Kind != Template && Kind != TemplateExpansion)
 280       return TemplateName();
 281
 282     return TemplateName::getFromVoidPointer(TemplateArg.Name);
 283   }
 284
 285   /// \brief Retrieve the number of expansions that a template template argument
 286   /// expansion will produce, if known.
 287   llvm::Optional<unsigned> getNumTemplateExpansions() const;
 288
 289   /// \brief Retrieve the template argument as an integral value.
 290   llvm::APSInt *getAsIntegral() {
 291     if (Kind != Integral)
 292       return 0;
 293     return reinterpret_cast<llvm::APSInt*>(&Integer.Value[0]);
 294   }
 295
 296   const llvm::APSInt *getAsIntegral() const {
 297     return const_cast<TemplateArgument*>(this)->getAsIntegral();
 298   }
 299
 300   /// \brief Retrieve the type of the integral value.
 301   QualType getIntegralType() const {
 302     if (Kind != Integral)
 303       return QualType();
 304
 305     return QualType::getFromOpaquePtr(Integer.Type);
 306   }
 307
 308   void setIntegralType(QualType T) {
 309     assert(Kind == Integral &&
 310            "Cannot set the integral type of a non-integral template argument");
 311     Integer.Type = T.getAsOpaquePtr();
 312   }
 313
 314   /// \brief Retrieve the template argument as an expression.
 315   Expr *getAsExpr() const {
 316     if (Kind != Expression)
 317       return 0;
 318
 319     return reinterpret_cast<Expr *>(TypeOrValue);
 320   }
 321
 322   /// \brief Iterator that traverses the elements of a template argument pack.
 323   typedef const TemplateArgument * pack_iterator;
 324
 325   /// \brief Iterator referencing the first argument of a template argument
 326   /// pack.
 327   pack_iterator pack_begin() const {
 328     assert(Kind == Pack);
 329     return Args.Args;
 330   }
 331
 332   /// \brief Iterator referencing one past the last argument of a template
 333   /// argument pack.
 334   pack_iterator pack_end() const {
 335     assert(Kind == Pack);
 336     return Args.Args + Args.NumArgs;
 337   }
 338
 339   /// \brief The number of template arguments in the given template argument
 340   /// pack.
 341   unsigned pack_size() const {
 342     assert(Kind == Pack);
 343     return Args.NumArgs;
 344   }
 345
 346   /// Determines whether two template arguments are superficially the
 347   /// same.
 348   bool structurallyEquals(const TemplateArgument &Other) const;
 349
 350   /// \brief When the template argument is a pack expansion, returns
 351   /// the pattern of the pack expansion.
 352   ///
 353   /// \param Ellipsis Will be set to the location of the ellipsis.
 354   TemplateArgument getPackExpansionPattern() const;
 355
 356   /// \brief Print this template argument to the given output stream.
 357   void print(const PrintingPolicy &Policy, llvm::raw_ostream &Out) const;
 358
 359   /// \brief Used to insert TemplateArguments into FoldingSets.
 360   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const;
 361 };
 362
 363 /// Location information for a TemplateArgument.
 364 struct TemplateArgumentLocInfo {
 365 private:
 366   union {
 367     Expr *Expression;
 368     TypeSourceInfo *Declarator;
 369     struct {
 370       // FIXME: We'd like to just use the qualifier in the TemplateName,
 371       // but template arguments get canonicalized too quickly.
 372       NestedNameSpecifier *Qualifier;
 373       void *QualifierLocData;
 374       unsigned TemplateNameLoc;
 375       unsigned EllipsisLoc;
 376     } Template;
 377   };
 378
 379 public:
 380   TemplateArgumentLocInfo();
 381
 382   TemplateArgumentLocInfo(TypeSourceInfo *TInfo) : Declarator(TInfo) {}
 383
 384   TemplateArgumentLocInfo(Expr *E) : Expression(E) {}
 385
 386   TemplateArgumentLocInfo(NestedNameSpecifierLoc QualifierLoc,
 387                           SourceLocation TemplateNameLoc,
 388                           SourceLocation EllipsisLoc)
 389   {
 390     Template.Qualifier = QualifierLoc.getNestedNameSpecifier();
 391     Template.QualifierLocData = QualifierLoc.getOpaqueData();
 392     Template.TemplateNameLoc = TemplateNameLoc.getRawEncoding();
 393     Template.EllipsisLoc = EllipsisLoc.getRawEncoding();
 394   }
 395
 396   TypeSourceInfo *getAsTypeSourceInfo() const {
 397     return Declarator;
 398   }
 399
 400   Expr *getAsExpr() const {
 401     return Expression;
 402   }
 403
 404   NestedNameSpecifierLoc getTemplateQualifierLoc() const {
 405     return NestedNameSpecifierLoc(Template.Qualifier,
 406                                   Template.QualifierLocData);
 407   }
 408
 409   SourceLocation getTemplateNameLoc() const {
 410     return SourceLocation::getFromRawEncoding(Template.TemplateNameLoc);
 411   }
 412
 413   SourceLocation getTemplateEllipsisLoc() const {
 414     return SourceLocation::getFromRawEncoding(Template.EllipsisLoc);
 415   }
 416 };
 417
 418 /// Location wrapper for a TemplateArgument.  TemplateArgument is to
 419 /// TemplateArgumentLoc as Type is to TypeLoc.
 420 class TemplateArgumentLoc {
 421   TemplateArgument Argument;
 422   TemplateArgumentLocInfo LocInfo;
 423
 424 public:
 425   TemplateArgumentLoc() {}
 426
 427   TemplateArgumentLoc(const TemplateArgument &Argument,
 428                       TemplateArgumentLocInfo Opaque)
 429     : Argument(Argument), LocInfo(Opaque) {
 430   }
 431
 432   TemplateArgumentLoc(const TemplateArgument &Argument, TypeSourceInfo *TInfo)
 433     : Argument(Argument), LocInfo(TInfo) {
 434     assert(Argument.getKind() == TemplateArgument::Type);
 435   }
 436
 437   TemplateArgumentLoc(const TemplateArgument &Argument, Expr *E)
 438     : Argument(Argument), LocInfo(E) {
 439     assert(Argument.getKind() == TemplateArgument::Expression);
 440   }
 441
 442   TemplateArgumentLoc(const TemplateArgument &Argument,
 443                       NestedNameSpecifierLoc QualifierLoc,
 444                       SourceLocation TemplateNameLoc,
 445                       SourceLocation EllipsisLoc = SourceLocation())
 446     : Argument(Argument), LocInfo(QualifierLoc, TemplateNameLoc, EllipsisLoc) {
 447     assert(Argument.getKind() == TemplateArgument::Template ||
 448            Argument.getKind() == TemplateArgument::TemplateExpansion);
 449   }
 450
 451   /// \brief - Fetches the primary location of the argument.
 452   SourceLocation getLocation() const {
 453     if (Argument.getKind() == TemplateArgument::Template ||
 454         Argument.getKind() == TemplateArgument::TemplateExpansion)
 455       return getTemplateNameLoc();
 456
 457     return getSourceRange().getBegin();
 458   }
 459
 460   /// \brief - Fetches the full source range of the argument.
 461   SourceRange getSourceRange() const;
 462
 463   const TemplateArgument &getArgument() const {
 464     return Argument;
 465   }
 466
 467   TemplateArgumentLocInfo getLocInfo() const {
 468     return LocInfo;
 469   }
 470
 471   TypeSourceInfo *getTypeSourceInfo() const {
 472     assert(Argument.getKind() == TemplateArgument::Type);
 473     return LocInfo.getAsTypeSourceInfo();
 474   }
 475
 476   Expr *getSourceExpression() const {
 477     assert(Argument.getKind() == TemplateArgument::Expression);
 478     return LocInfo.getAsExpr();
 479   }
 480
 481   Expr *getSourceDeclExpression() const {
 482     assert(Argument.getKind() == TemplateArgument::Declaration);
 483     return LocInfo.getAsExpr();
 484   }
 485
 486   NestedNameSpecifierLoc getTemplateQualifierLoc() const {
 487     assert(Argument.getKind() == TemplateArgument::Template ||
 488            Argument.getKind() == TemplateArgument::TemplateExpansion);
 489     return LocInfo.getTemplateQualifierLoc();
 490   }
 491
 492   SourceLocation getTemplateNameLoc() const {
 493     assert(Argument.getKind() == TemplateArgument::Template ||
 494            Argument.getKind() == TemplateArgument::TemplateExpansion);
 495     return LocInfo.getTemplateNameLoc();
 496   }
 497
 498   SourceLocation getTemplateEllipsisLoc() const {
 499     assert(Argument.getKind() == TemplateArgument::TemplateExpansion);
 500     return LocInfo.getTemplateEllipsisLoc();
 501   }
 502
 503   /// \brief When the template argument is a pack expansion, returns
 504   /// the pattern of the pack expansion.
 505   ///
 506   /// \param Ellipsis Will be set to the location of the ellipsis.
 507   ///
 508   /// \param NumExpansions Will be set to the number of expansions that will
 509   /// be generated from this pack expansion, if known a priori.
 510   TemplateArgumentLoc getPackExpansionPattern(SourceLocation &Ellipsis,
 511                                         llvm::Optional<unsigned> &NumExpansions,
 512                                               ASTContext &Context) const;
 513 };
 514
 515 /// A convenient class for passing around template argument
 516 /// information.  Designed to be passed by reference.
 517 class TemplateArgumentListInfo {
 518   llvm::SmallVector<TemplateArgumentLoc, 8> Arguments;
 519   SourceLocation LAngleLoc;
 520   SourceLocation RAngleLoc;
 521
 522 public:
 523   TemplateArgumentListInfo() {}
 524
 525   TemplateArgumentListInfo(SourceLocation LAngleLoc,
 526                            SourceLocation RAngleLoc)
 527     : LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc) {}
 528
 529   SourceLocation getLAngleLoc() const { return LAngleLoc; }
 530   SourceLocation getRAngleLoc() const { return RAngleLoc; }
 531
 532   void setLAngleLoc(SourceLocation Loc) { LAngleLoc = Loc; }
 533   void setRAngleLoc(SourceLocation Loc) { RAngleLoc = Loc; }
 534
 535   unsigned size() const { return Arguments.size(); }
 536
 537   const TemplateArgumentLoc *getArgumentArray() const {
 538     return Arguments.data();
 539   }
 540
 541   const TemplateArgumentLoc &operator[](unsigned I) const {
 542     return Arguments[I];
 543   }
 544
 545   void addArgument(const TemplateArgumentLoc &Loc) {
 546     Arguments.push_back(Loc);
 547   }
 548 };
 549
 550 const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
 551                                     const TemplateArgument &Arg);
 552
 553 inline TemplateSpecializationType::iterator
 554     TemplateSpecializationType::end() const {
 555   return getArgs() + getNumArgs();
 556 }
 557
 558 inline DependentTemplateSpecializationType::iterator
 559     DependentTemplateSpecializationType::end() const {
 560   return getArgs() + getNumArgs();
 561 }
 562
 563 inline const TemplateArgument &
 564     TemplateSpecializationType::getArg(unsigned Idx) const {
 565   assert(Idx < getNumArgs() && "Template argument out of range");
 566   return getArgs()[Idx];
 567 }
 568
 569 inline const TemplateArgument &
 570     DependentTemplateSpecializationType::getArg(unsigned Idx) const {
 571   assert(Idx < getNumArgs() && "Template argument out of range");
 572   return getArgs()[Idx];
 573 }
 574
 575 } // end namespace clang
 576
 577 #endif