TemplateName.cpp

Go to the documentation of this file.

//===- TemplateName.cpp - C++ Template Name Representation ----------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
//  This file defines the TemplateName interface and subclasses.
//
//===----------------------------------------------------------------------===//
 
#include "clang/AST/TemplateName.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DependenceFlags.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/TemplateBase.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OperatorKinds.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
#include <cassert>
#include <optional>
#include <string>
 
using namespace clang;
 
DeducedTemplateStorage::DeducedTemplateStorage(TemplateName Underlying,
                                               const DefaultArguments &DefArgs)
    : UncommonTemplateNameStorage(Deduced, /*Index=*/DefArgs.StartPos,
                                  DefArgs.Args.size()),
      Underlying(Underlying) {
  llvm::copy(DefArgs.Args, reinterpret_cast<TemplateArgument *>(this + 1));
}
 
void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &Context) const {
  Profile(ID, Context, Underlying, getDefaultArguments());
}
 
void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &Context,
                                     TemplateName Underlying,
                                     const DefaultArguments &DefArgs) {
  Underlying.Profile(ID);
  ID.AddInteger(DefArgs.StartPos);
  ID.AddInteger(DefArgs.Args.size());
  for (const TemplateArgument &Arg : DefArgs.Args)
    Arg.Profile(ID, Context);
}
 
TemplateArgument
SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
  return TemplateArgument(ArrayRef(Arguments, Bits.Data));
}
 
TemplateTemplateParmDecl *
SubstTemplateTemplateParmPackStorage::getParameterPack() const {
  return cast<TemplateTemplateParmDecl>(std::get<0>(
      getReplacedTemplateParameter(getAssociatedDecl(), Bits.Index)));
}
 
TemplateTemplateParmDecl *
SubstTemplateTemplateParmStorage::getParameter() const {
  return cast<TemplateTemplateParmDecl>(std::get<0>(
      getReplacedTemplateParameter(getAssociatedDecl(), Bits.Index)));
}
 
void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex(),
          getFinal());
}
 
void SubstTemplateTemplateParmStorage::Profile(
    llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
    unsigned Index, UnsignedOrNone PackIndex, bool Final) {
  Replacement.Profile(ID);
  ID.AddPointer(AssociatedDecl);
  ID.AddInteger(Index);
  ID.AddInteger(PackIndex.toInternalRepresentation());
  ID.AddBoolean(Final);
}
 
SubstTemplateTemplateParmPackStorage::SubstTemplateTemplateParmPackStorage(
    ArrayRef<TemplateArgument> ArgPack, Decl *AssociatedDecl, unsigned Index,
    bool Final)
    : UncommonTemplateNameStorage(SubstTemplateTemplateParmPack, Index,
                                  ArgPack.size()),
      Arguments(ArgPack.data()), AssociatedDeclAndFinal(AssociatedDecl, Final) {
  assert(AssociatedDecl != nullptr);
}
 
void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
                                                   ASTContext &Context) {
  Profile(ID, Context, getArgumentPack(), getAssociatedDecl(), getIndex(),
          getFinal());
}
 
Decl *SubstTemplateTemplateParmPackStorage::getAssociatedDecl() const {
  return AssociatedDeclAndFinal.getPointer();
}
 
bool SubstTemplateTemplateParmPackStorage::getFinal() const {
  return AssociatedDeclAndFinal.getInt();
}
 
void SubstTemplateTemplateParmPackStorage::Profile(
    llvm::FoldingSetNodeID &ID, ASTContext &Context,
    const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index,
    bool Final) {
  ArgPack.Profile(ID, Context);
  ID.AddPointer(AssociatedDecl);
  ID.AddInteger(Index);
  ID.AddBoolean(Final);
}
 
IdentifierOrOverloadedOperator::IdentifierOrOverloadedOperator(
    const IdentifierInfo *II)
    : PtrOrOp(reinterpret_cast<uintptr_t>(II)) {
  static_assert(NUM_OVERLOADED_OPERATORS <= 4096,
                "NUM_OVERLOADED_OPERATORS is too large");
  assert(II);
  assert(getIdentifier() == II);
}
IdentifierOrOverloadedOperator::IdentifierOrOverloadedOperator(
    OverloadedOperatorKind OOK)
    : PtrOrOp(-uintptr_t(OOK)) {
  assert(OOK != OO_None);
  assert(getOperator() == OOK);
}
 
void IdentifierOrOverloadedOperator::Profile(llvm::FoldingSetNodeID &ID) const {
  if (auto *Identifier = getIdentifier()) {
    ID.AddBoolean(false);
    ID.AddPointer(Identifier);
  } else {
    ID.AddBoolean(true);
    ID.AddInteger(getOperator());
  }
}
 
TemplateName::TemplateName(void *Ptr) {
  Storage = StorageType::getFromOpaqueValue(Ptr);
}
 
TemplateName::TemplateName(TemplateDecl *Template) : Storage(Template) {}
TemplateName::TemplateName(OverloadedTemplateStorage *Storage)
    : Storage(Storage) {}
TemplateName::TemplateName(AssumedTemplateStorage *Storage)
    : Storage(Storage) {}
TemplateName::TemplateName(SubstTemplateTemplateParmStorage *Storage)
    : Storage(Storage) {}
TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
    : Storage(Storage) {}
TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {}
TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {}
TemplateName::TemplateName(UsingShadowDecl *Using) : Storage(Using) {}
TemplateName::TemplateName(DeducedTemplateStorage *Deduced)
    : Storage(Deduced) {}
 
bool TemplateName::isNull() const { return Storage.isNull(); }
 
TemplateName::NameKind TemplateName::getKind() const {
  if (auto *ND = dyn_cast<Decl *>(Storage)) {
    if (isa<UsingShadowDecl>(ND))
      return UsingTemplate;
    assert(isa<TemplateDecl>(ND));
    return Template;
  }
 
  if (isa<DependentTemplateName *>(Storage))
    return DependentTemplate;
  if (isa<QualifiedTemplateName *>(Storage))
    return QualifiedTemplate;
 
  UncommonTemplateNameStorage *uncommon =
      cast<UncommonTemplateNameStorage *>(Storage);
  if (uncommon->getAsOverloadedStorage())
    return OverloadedTemplate;
  if (uncommon->getAsAssumedTemplateName())
    return AssumedTemplate;
  if (uncommon->getAsSubstTemplateTemplateParm())
    return SubstTemplateTemplateParm;
  if (uncommon->getAsDeducedTemplateName())
    return DeducedTemplate;
 
  assert(uncommon->getAsSubstTemplateTemplateParmPack() != nullptr);
  return SubstTemplateTemplateParmPack;
}
 
TemplateDecl *TemplateName::getAsTemplateDecl(bool IgnoreDeduced) const {
  TemplateName Name = *this;
  while (std::optional<TemplateName> UnderlyingOrNone =
             Name.desugar(IgnoreDeduced))
    Name = *UnderlyingOrNone;
 
  if (!IgnoreDeduced)
    assert(Name.getAsDeducedTemplateName() == nullptr &&
           "Unexpected canonical DeducedTemplateName; Did you mean to use "
           "getTemplateDeclAndDefaultArgs instead?");
 
  return cast_if_present<TemplateDecl>(
      dyn_cast_if_present<Decl *>(Name.Storage));
}
 
std::pair<TemplateName, DefaultArguments>
TemplateName::getTemplateDeclAndDefaultArgs() const {
  DefaultArguments DefArgs;
  for (TemplateName Name = *this; /**/; /**/) {
    if (DeducedTemplateStorage *DTS = Name.getAsDeducedTemplateName()) {
      assert(!DefArgs && "multiple default args?");
      DefArgs = DTS->getDefaultArguments();
      if (TemplateDecl *TD = DTS->getUnderlying().getAsTemplateDecl();
          TD && DefArgs)
        assert(DefArgs.StartPos + DefArgs.Args.size() <=
               TD->getTemplateParameters()->size());
      Name = DTS->getUnderlying();
    }
    if (std::optional<TemplateName> UnderlyingOrNone =
            Name.desugar(/*IgnoreDeduced=*/false)) {
      Name = *UnderlyingOrNone;
      continue;
    }
    return {Name, DefArgs};
  }
}
 
std::optional<TemplateName> TemplateName::desugar(bool IgnoreDeduced) const {
  if (Decl *D = dyn_cast_if_present<Decl *>(Storage)) {
    if (auto *USD = dyn_cast<UsingShadowDecl>(D))
      return TemplateName(USD->getTargetDecl());
    return std::nullopt;
  }
  if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
    return QTN->getUnderlyingTemplate();
  if (SubstTemplateTemplateParmStorage *S = getAsSubstTemplateTemplateParm())
    return S->getReplacement();
  if (IgnoreDeduced)
    if (DeducedTemplateStorage *S = getAsDeducedTemplateName())
      return S->getUnderlying();
  return std::nullopt;
}
 
OverloadedTemplateStorage *TemplateName::getAsOverloadedTemplate() const {
  if (UncommonTemplateNameStorage *Uncommon =
          Storage.dyn_cast<UncommonTemplateNameStorage *>())
    return Uncommon->getAsOverloadedStorage();
 
  return nullptr;
}
 
AssumedTemplateStorage *TemplateName::getAsAssumedTemplateName() const {
  if (UncommonTemplateNameStorage *Uncommon =
          Storage.dyn_cast<UncommonTemplateNameStorage *>())
    return Uncommon->getAsAssumedTemplateName();
 
  return nullptr;
}
 
SubstTemplateTemplateParmStorage *
TemplateName::getAsSubstTemplateTemplateParm() const {
  if (UncommonTemplateNameStorage *uncommon =
          dyn_cast_if_present<UncommonTemplateNameStorage *>(Storage))
    return uncommon->getAsSubstTemplateTemplateParm();
 
  return nullptr;
}
 
SubstTemplateTemplateParmPackStorage *
TemplateName::getAsSubstTemplateTemplateParmPack() const {
  if (UncommonTemplateNameStorage *Uncommon =
          Storage.dyn_cast<UncommonTemplateNameStorage *>())
    return Uncommon->getAsSubstTemplateTemplateParmPack();
 
  return nullptr;
}
 
QualifiedTemplateName *TemplateName::getAsQualifiedTemplateName() const {
  return dyn_cast_if_present<QualifiedTemplateName *>(Storage);
}
 
DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
  return Storage.dyn_cast<DependentTemplateName *>();
}
 
std::tuple<NestedNameSpecifier, bool>
TemplateName::getQualifierAndTemplateKeyword() const {
  for (std::optional<TemplateName> Cur = *this; Cur;
       Cur = Cur->desugar(/*IgnoreDeduced=*/true)) {
    if (DependentTemplateName *N = Cur->getAsDependentTemplateName())
      return {N->getQualifier(), N->hasTemplateKeyword()};
    if (QualifiedTemplateName *N = Cur->getAsQualifiedTemplateName())
      return {N->getQualifier(), N->hasTemplateKeyword()};
    if (Cur->getAsSubstTemplateTemplateParm() ||
        Cur->getAsSubstTemplateTemplateParmPack())
      break;
  }
  return {std::nullopt, false};
}
 
UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const {
  if (Decl *D = Storage.dyn_cast<Decl *>())
    if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
      return USD;
  if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
    return QTN->getUnderlyingTemplate().getAsUsingShadowDecl();
  return nullptr;
}
 
DependentTemplateStorage::DependentTemplateStorage(
    NestedNameSpecifier Qualifier, IdentifierOrOverloadedOperator Name,
    bool HasTemplateKeyword)
    : Qualifier(Qualifier, HasTemplateKeyword), Name(Name) {
  assert((!Qualifier || Qualifier.isDependent()) &&
         "Qualifier must be dependent");
}
 
TemplateNameDependence DependentTemplateStorage::getDependence() const {
  return toTemplateNameDependence(getQualifier().getDependence()) |
         TemplateNameDependence::DependentInstantiation;
}
 
void DependentTemplateStorage::print(raw_ostream &OS,
                                     const PrintingPolicy &Policy) const {
  getQualifier().print(OS, Policy);
 
  if (hasTemplateKeyword())
    OS << "template ";
 
  IdentifierOrOverloadedOperator Name = getName();
  if (const IdentifierInfo *II = Name.getIdentifier())
    OS << II->getName();
  else
    OS << "operator " << getOperatorSpelling(Name.getOperator());
}
 
DeducedTemplateStorage *TemplateName::getAsDeducedTemplateName() const {
  if (UncommonTemplateNameStorage *Uncommon =
          dyn_cast_if_present<UncommonTemplateNameStorage *>(Storage))
    return Uncommon->getAsDeducedTemplateName();
 
  return nullptr;
}
 
TemplateNameDependence TemplateName::getDependence() const {
  switch (getKind()) {
  case NameKind::Template:
  case NameKind::UsingTemplate: {
    TemplateDecl *Template = getAsTemplateDecl();
    auto D = TemplateNameDependence::None;
    if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template)) {
      D |= TemplateNameDependence::DependentInstantiation;
      if (TTP->isParameterPack())
        D |= TemplateNameDependence::UnexpandedPack;
    }
    // FIXME: Hack, getDeclContext() can be null if Template is still
    // initializing due to PCH reading, so we check it before using it.
    // Should probably modify TemplateSpecializationType to allow constructing
    // it without the isDependent() checking.
    if (Template->getDeclContext() &&
        Template->getDeclContext()->isDependentContext())
      D |= TemplateNameDependence::DependentInstantiation;
    return D;
  }
  case NameKind::QualifiedTemplate: {
    QualifiedTemplateName *S = getAsQualifiedTemplateName();
    TemplateNameDependence D = S->getUnderlyingTemplate().getDependence();
    D |= toTemplateNameDependence(S->getQualifier().getDependence());
    return D;
  }
  case NameKind::DependentTemplate: {
    DependentTemplateName *S = getAsDependentTemplateName();
    return toTemplateNameDependence(S->getQualifier().getDependence()) |
           TemplateNameDependence::DependentInstantiation;
  }
  case NameKind::SubstTemplateTemplateParm: {
    auto *S = getAsSubstTemplateTemplateParm();
    return S->getReplacement().getDependence();
  }
  case NameKind::SubstTemplateTemplateParmPack:
    return TemplateNameDependence::UnexpandedPack |
           TemplateNameDependence::DependentInstantiation;
  case NameKind::DeducedTemplate: {
    DeducedTemplateStorage *DTS = getAsDeducedTemplateName();
    TemplateNameDependence D = DTS->getUnderlying().getDependence();
    for (const TemplateArgument &Arg : DTS->getDefaultArguments().Args)
      D |= toTemplateNameDependence(Arg.getDependence());
    return D;
  }
  case NameKind::AssumedTemplate:
    return TemplateNameDependence::DependentInstantiation;
  case NameKind::OverloadedTemplate:
    llvm_unreachable("overloaded templates shouldn't survive to here.");
  }
  llvm_unreachable("Unknown TemplateName kind");
}
 
bool TemplateName::isDependent() const {
  return getDependence() & TemplateNameDependence::Dependent;
}
 
bool TemplateName::isInstantiationDependent() const {
  return getDependence() & TemplateNameDependence::Instantiation;
}
 
bool TemplateName::containsUnexpandedParameterPack() const {
  return getDependence() & TemplateNameDependence::UnexpandedPack;
}
 
void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
                         Qualified Qual) const {
  auto handleAnonymousTTP = [&](TemplateDecl *TD, raw_ostream &OS) {
    if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(TD);
        TTP && (Policy.PrintAsCanonical || TTP->getIdentifier() == nullptr)) {
      OS << "template-parameter-" << TTP->getDepth() << "-" << TTP->getIndex();
      return true;
    }
    return false;
  };
  if (NameKind Kind = getKind();
      Kind == TemplateName::Template || Kind == TemplateName::UsingTemplate) {
    // After `namespace ns { using std::vector }`, what is the fully-qualified
    // name of the UsingTemplateName `vector` within ns?
    //
    // - ns::vector (the qualified name of the using-shadow decl)
    // - std::vector (the qualified name of the underlying template decl)
    //
    // Similar to the UsingType behavior, using declarations are used to import
    // names more often than to export them, thus using the original name is
    // most useful in this case.
    TemplateDecl *Template = getAsTemplateDecl();
    if (Policy.PrintAsCanonical)
      Template = cast<TemplateDecl>(Template->getCanonicalDecl());
    if (handleAnonymousTTP(Template, OS))
      return;
    if (Qual == Qualified::None || isa<TemplateTemplateParmDecl>(Template) ||
        Policy.SuppressScope) {
      if (IdentifierInfo *II = Template->getIdentifier();
          Policy.CleanUglifiedParameters && II &&
          isa<TemplateTemplateParmDecl>(Template))
        OS << II->deuglifiedName();
      else
        OS << *Template;
    } else {
      PrintingPolicy NestedNamePolicy = Policy;
      NestedNamePolicy.SuppressUnwrittenScope = true;
      Template->printQualifiedName(OS, NestedNamePolicy);
    }
  } else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
    if (Policy.PrintAsCanonical) {
      QTN->getUnderlyingTemplate().print(OS, Policy, Qual);
      return;
    }
    if (Qual != Qualified::None)
      QTN->getQualifier().print(OS, Policy);
    if (QTN->hasTemplateKeyword())
      OS << "template ";
 
    TemplateName Underlying = QTN->getUnderlyingTemplate();
    assert(Underlying.getKind() == TemplateName::Template ||
           Underlying.getKind() == TemplateName::UsingTemplate);
 
    TemplateDecl *UTD = Underlying.getAsTemplateDecl();
 
    if (handleAnonymousTTP(UTD, OS))
      return;
 
    OS << *UTD;
  } else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
    DTN->print(OS, Policy);
  } else if (SubstTemplateTemplateParmStorage *subst =
                 getAsSubstTemplateTemplateParm()) {
    subst->getReplacement().print(OS, Policy, Qual);
  } else if (SubstTemplateTemplateParmPackStorage *SubstPack =
                 getAsSubstTemplateTemplateParmPack())
    OS << *SubstPack->getParameterPack();
  else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) {
    Assumed->getDeclName().print(OS, Policy);
  } else if (DeducedTemplateStorage *Deduced = getAsDeducedTemplateName()) {
    Deduced->getUnderlying().print(OS, Policy);
    DefaultArguments DefArgs = Deduced->getDefaultArguments();
    OS << ":" << DefArgs.StartPos;
    printTemplateArgumentList(OS, DefArgs.Args, Policy);
  } else {
    assert(getKind() == TemplateName::OverloadedTemplate);
    OverloadedTemplateStorage *OTS = getAsOverloadedTemplate();
    (*OTS->begin())->printName(OS, Policy);
  }
}
 
const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
                                             TemplateName N) {
  std::string NameStr;
  llvm::raw_string_ostream OS(NameStr);
  LangOptions LO;
  LO.CPlusPlus = true;
  LO.Bool = true;
  OS << '\'';
  N.print(OS, PrintingPolicy(LO));
  OS << '\'';
  return DB << NameStr;
}