lib/AST/TemplateName.cpp - llvm-project/clang - Git at Google

 //===- 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/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <optional>
 #include <string>

 using namespace clang;

 TemplateArgument
 SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
   return TemplateArgument(llvm::ArrayRef(Arguments, Bits.Data));
 }

 TemplateTemplateParmDecl *
 SubstTemplateTemplateParmPackStorage::getParameterPack() const {
   return cast<TemplateTemplateParmDecl>(
       getReplacedTemplateParameterList(getAssociatedDecl())
           ->asArray()[Bits.Index]);
 }

 TemplateTemplateParmDecl *
 SubstTemplateTemplateParmStorage::getParameter() const {
   return cast<TemplateTemplateParmDecl>(
       getReplacedTemplateParameterList(getAssociatedDecl())
           ->asArray()[Bits.Index]);
 }

 void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
   Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex());
 }

 void SubstTemplateTemplateParmStorage::Profile(
     llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
     unsigned Index, std::optional<unsigned> PackIndex) {
   Replacement.Profile(ID);
   ID.AddPointer(AssociatedDecl);
   ID.AddInteger(Index);
   ID.AddInteger(PackIndex ? *PackIndex + 1 : 0);
 }

 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);
 }

 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) {}

 bool TemplateName::isNull() const { return Storage.isNull(); }

 TemplateName::NameKind TemplateName::getKind() const {
   if (auto *ND = Storage.dyn_cast<Decl *>()) {
     if (isa<UsingShadowDecl>(ND))
       return UsingTemplate;
     assert(isa<TemplateDecl>(ND));
     return Template;
   }

   if (Storage.is<DependentTemplateName *>())
     return DependentTemplate;
   if (Storage.is<QualifiedTemplateName *>())
     return QualifiedTemplate;

   UncommonTemplateNameStorage *uncommon
     = Storage.get<UncommonTemplateNameStorage*>();
   if (uncommon->getAsOverloadedStorage())
     return OverloadedTemplate;
   if (uncommon->getAsAssumedTemplateName())
     return AssumedTemplate;
   if (uncommon->getAsSubstTemplateTemplateParm())
     return SubstTemplateTemplateParm;
   return SubstTemplateTemplateParmPack;
 }

 TemplateDecl *TemplateName::getAsTemplateDecl() const {
   if (Decl *TemplateOrUsing = Storage.dyn_cast<Decl *>()) {
     if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(TemplateOrUsing))
       return cast<TemplateDecl>(USD->getTargetDecl());

     assert(isa<TemplateDecl>(TemplateOrUsing));
     return cast<TemplateDecl>(TemplateOrUsing);
   }

   if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
     return QTN->getUnderlyingTemplate().getAsTemplateDecl();

   if (SubstTemplateTemplateParmStorage *sub = getAsSubstTemplateTemplateParm())
     return sub->getReplacement().getAsTemplateDecl();

   if (UsingShadowDecl *USD = getAsUsingShadowDecl())
     return cast<TemplateDecl>(USD->getTargetDecl());

   return nullptr;
 }

 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 =
           Storage.dyn_cast<UncommonTemplateNameStorage *>())
     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 Storage.dyn_cast<QualifiedTemplateName *>();
 }

 DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
   return Storage.dyn_cast<DependentTemplateName *>();
 }

 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;
 }

 TemplateName TemplateName::getNameToSubstitute() const {
   TemplateDecl *Decl = getAsTemplateDecl();

   // Substituting a dependent template name: preserve it as written.
   if (!Decl)
     return *this;

   // If we have a template declaration, use the most recent non-friend
   // declaration of that template.
   Decl = cast<TemplateDecl>(Decl->getMostRecentDecl());
   while (Decl->getFriendObjectKind()) {
     Decl = cast<TemplateDecl>(Decl->getPreviousDecl());
     assert(Decl && "all declarations of template are friends");
   }
   return TemplateName(Decl);
 }

 TemplateNameDependence TemplateName::getDependence() const {
   auto D = TemplateNameDependence::None;
   switch (getKind()) {
   case TemplateName::NameKind::QualifiedTemplate:
     D |= toTemplateNameDependence(
         getAsQualifiedTemplateName()->getQualifier()->getDependence());
     break;
   case TemplateName::NameKind::DependentTemplate:
     D |= toTemplateNameDependence(
         getAsDependentTemplateName()->getQualifier()->getDependence());
     break;
   case TemplateName::NameKind::SubstTemplateTemplateParmPack:
     D |= TemplateNameDependence::UnexpandedPack;
     break;
   case TemplateName::NameKind::OverloadedTemplate:
     llvm_unreachable("overloaded templates shouldn't survive to here.");
   default:
     break;
   }
   if (TemplateDecl *Template = getAsTemplateDecl()) {
     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;
   } else {
     D |= TemplateNameDependence::DependentInstantiation;
   }
   return D;
 }

 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::Profile(llvm::FoldingSetNodeID &ID) {
   if (const auto* USD = getAsUsingShadowDecl())
     ID.AddPointer(USD->getCanonicalDecl());
   else if (const auto *TD = getAsTemplateDecl())
     ID.AddPointer(TD->getCanonicalDecl());
   else
     ID.AddPointer(Storage.getOpaqueValue());
 }

 void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
                          Qualified Qual) const {
   auto Kind = getKind();
   TemplateDecl *Template = nullptr;
   if (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.
     Template = getAsTemplateDecl();
   }

   if (Template)
     if (Policy.CleanUglifiedParameters &&
         isa<TemplateTemplateParmDecl>(Template) && Template->getIdentifier())
       OS << Template->getIdentifier()->deuglifiedName();
     else if (Qual == Qualified::Fully &&
              getDependence() !=
                  TemplateNameDependenceScope::DependentInstantiation)
       Template->printQualifiedName(OS, Policy);
     else
       OS << *Template;
   else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
     if (Qual == Qualified::Fully &&
         getDependence() !=
             TemplateNameDependenceScope::DependentInstantiation) {
       QTN->getUnderlyingTemplate().getAsTemplateDecl()->printQualifiedName(
           OS, Policy);
       return;
     }
     if (Qual == Qualified::AsWritten)
       QTN->getQualifier()->print(OS, Policy);
     if (QTN->hasTemplateKeyword())
       OS << "template ";
     OS << *QTN->getUnderlyingTemplate().getAsTemplateDecl();
   } else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
     if (Qual == Qualified::AsWritten && DTN->getQualifier())
       DTN->getQualifier()->print(OS, Policy);
     OS << "template ";

     if (DTN->isIdentifier())
       OS << DTN->getIdentifier()->getName();
     else
       OS << "operator " << getOperatorSpelling(DTN->getOperator());
   } 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 {
     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 << '\'';
   OS.flush();
   return DB << NameStr;
 }

 void TemplateName::dump(raw_ostream &OS) const {
   LangOptions LO;  // FIXME!
   LO.CPlusPlus = true;
   LO.Bool = true;
   print(OS, PrintingPolicy(LO));
 }

 LLVM_DUMP_METHOD void TemplateName::dump() const {
   dump(llvm::errs());
 }
	//===- 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/Casting.h"
	#include "llvm/Support/Compiler.h"
	#include "llvm/Support/raw_ostream.h"
	#include <cassert>
	#include <optional>
	#include <string>

	using namespace clang;

	TemplateArgument
	SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
	return TemplateArgument(llvm::ArrayRef(Arguments, Bits.Data));
	}

	TemplateTemplateParmDecl *
	SubstTemplateTemplateParmPackStorage::getParameterPack() const {
	return cast<TemplateTemplateParmDecl>(
	getReplacedTemplateParameterList(getAssociatedDecl())
	->asArray()[Bits.Index]);
	}

	TemplateTemplateParmDecl *
	SubstTemplateTemplateParmStorage::getParameter() const {
	return cast<TemplateTemplateParmDecl>(
	getReplacedTemplateParameterList(getAssociatedDecl())
	->asArray()[Bits.Index]);
	}

	void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID) {
	Profile(ID, Replacement, getAssociatedDecl(), getIndex(), getPackIndex());
	}

	void SubstTemplateTemplateParmStorage::Profile(
	llvm::FoldingSetNodeID &ID, TemplateName Replacement, Decl *AssociatedDecl,
	unsigned Index, std::optional<unsigned> PackIndex) {
	Replacement.Profile(ID);
	ID.AddPointer(AssociatedDecl);
	ID.AddInteger(Index);
	ID.AddInteger(PackIndex ? *PackIndex + 1 : 0);
	}

	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);
	}

	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) {}

	bool TemplateName::isNull() const { return Storage.isNull(); }

	TemplateName::NameKind TemplateName::getKind() const {
	if (auto ND = Storage.dyn_cast<Decl >()) {
	if (isa<UsingShadowDecl>(ND))
	return UsingTemplate;
	assert(isa<TemplateDecl>(ND));
	return Template;
	}

	if (Storage.is<DependentTemplateName *>())
	return DependentTemplate;
	if (Storage.is<QualifiedTemplateName *>())
	return QualifiedTemplate;

	UncommonTemplateNameStorage *uncommon
	= Storage.get<UncommonTemplateNameStorage*>();
	if (uncommon->getAsOverloadedStorage())
	return OverloadedTemplate;
	if (uncommon->getAsAssumedTemplateName())
	return AssumedTemplate;
	if (uncommon->getAsSubstTemplateTemplateParm())
	return SubstTemplateTemplateParm;
	return SubstTemplateTemplateParmPack;
	}

	TemplateDecl *TemplateName::getAsTemplateDecl() const {
	if (Decl TemplateOrUsing = Storage.dyn_cast<Decl >()) {
	if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(TemplateOrUsing))
	return cast<TemplateDecl>(USD->getTargetDecl());

	assert(isa<TemplateDecl>(TemplateOrUsing));
	return cast<TemplateDecl>(TemplateOrUsing);
	}

	if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
	return QTN->getUnderlyingTemplate().getAsTemplateDecl();

	if (SubstTemplateTemplateParmStorage *sub = getAsSubstTemplateTemplateParm())
	return sub->getReplacement().getAsTemplateDecl();

	if (UsingShadowDecl *USD = getAsUsingShadowDecl())
	return cast<TemplateDecl>(USD->getTargetDecl());

	return nullptr;
	}

	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 =
	Storage.dyn_cast<UncommonTemplateNameStorage *>())
	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 Storage.dyn_cast<QualifiedTemplateName *>();
	}

	DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
	return Storage.dyn_cast<DependentTemplateName *>();
	}

	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;
	}

	TemplateName TemplateName::getNameToSubstitute() const {
	TemplateDecl *Decl = getAsTemplateDecl();

	// Substituting a dependent template name: preserve it as written.
	if (!Decl)
	return *this;

	// If we have a template declaration, use the most recent non-friend
	// declaration of that template.
	Decl = cast<TemplateDecl>(Decl->getMostRecentDecl());
	while (Decl->getFriendObjectKind()) {
	Decl = cast<TemplateDecl>(Decl->getPreviousDecl());
	assert(Decl && "all declarations of template are friends");
	}
	return TemplateName(Decl);
	}

	TemplateNameDependence TemplateName::getDependence() const {
	auto D = TemplateNameDependence::None;
	switch (getKind()) {
	case TemplateName::NameKind::QualifiedTemplate:
	D \|= toTemplateNameDependence(
	getAsQualifiedTemplateName()->getQualifier()->getDependence());
	break;
	case TemplateName::NameKind::DependentTemplate:
	D \|= toTemplateNameDependence(
	getAsDependentTemplateName()->getQualifier()->getDependence());
	break;
	case TemplateName::NameKind::SubstTemplateTemplateParmPack:
	D \|= TemplateNameDependence::UnexpandedPack;
	break;
	case TemplateName::NameKind::OverloadedTemplate:
	llvm_unreachable("overloaded templates shouldn't survive to here.");
	default:
	break;
	}
	if (TemplateDecl *Template = getAsTemplateDecl()) {
	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;
	} else {
	D \|= TemplateNameDependence::DependentInstantiation;
	}
	return D;
	}

	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::Profile(llvm::FoldingSetNodeID &ID) {
	if (const auto* USD = getAsUsingShadowDecl())
	ID.AddPointer(USD->getCanonicalDecl());
	else if (const auto *TD = getAsTemplateDecl())
	ID.AddPointer(TD->getCanonicalDecl());
	else
	ID.AddPointer(Storage.getOpaqueValue());
	}

	void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
	Qualified Qual) const {
	auto Kind = getKind();
	TemplateDecl *Template = nullptr;
	if (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.
	Template = getAsTemplateDecl();
	}

	if (Template)
	if (Policy.CleanUglifiedParameters &&
	isa<TemplateTemplateParmDecl>(Template) && Template->getIdentifier())
	OS << Template->getIdentifier()->deuglifiedName();
	else if (Qual == Qualified::Fully &&
	getDependence() !=
	TemplateNameDependenceScope::DependentInstantiation)
	Template->printQualifiedName(OS, Policy);
	else
	OS << *Template;
	else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
	if (Qual == Qualified::Fully &&
	getDependence() !=
	TemplateNameDependenceScope::DependentInstantiation) {
	QTN->getUnderlyingTemplate().getAsTemplateDecl()->printQualifiedName(
	OS, Policy);
	return;
	}
	if (Qual == Qualified::AsWritten)
	QTN->getQualifier()->print(OS, Policy);
	if (QTN->hasTemplateKeyword())
	OS << "template ";
	OS << *QTN->getUnderlyingTemplate().getAsTemplateDecl();
	} else if (DependentTemplateName *DTN = getAsDependentTemplateName()) {
	if (Qual == Qualified::AsWritten && DTN->getQualifier())
	DTN->getQualifier()->print(OS, Policy);
	OS << "template ";

	if (DTN->isIdentifier())
	OS << DTN->getIdentifier()->getName();
	else
	OS << "operator " << getOperatorSpelling(DTN->getOperator());
	} 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 {
	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 << '\'';
	OS.flush();
	return DB << NameStr;
	}

	void TemplateName::dump(raw_ostream &OS) const {
	LangOptions LO; // FIXME!
	LO.CPlusPlus = true;
	LO.Bool = true;
	print(OS, PrintingPolicy(LO));
	}

	LLVM_DUMP_METHOD void TemplateName::dump() const {
	dump(llvm::errs());
	}