[AST] Add a new TemplateName for templates found via a using declaration.

[hokein]

Summary

This is template version of https://reviews.llvm.org/D114251.

This patch introduces a new template name kind (UsingTemplateName). The
UsingTemplateName stores the found using-shadow decl (and underlying
template can be retrieved from the using-shadow decl). With the new
template name, we can be able to find the using decl that a template
typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template,
which is useful for tooling use cases (include cleaner etc).

This patch merely focuses on adding the node to the AST.

Next steps:

• support using-decl in qualified template name;
• update the clangd and other tools to use this new node;
• add ast matchers for matching different kinds of template names;

[sammccall]

This looks pretty good!
The tests in clang are sadly indirect.
I think adding support to clangd's FindTarget would be a small change and would allow a fairly direct test, but maybe it will affect a bunch of existing tests or possibly have a blast radius. Up to you.

clang/include/clang/AST/ASTContext.h

2184 ↗

(On Diff #420485)

nit: there's something of a canonical order in TemplateName::NameKind, I think it's useful to follow this as much as possible for consistency when navigating in these huge files.
This mostly means placing UsingTemplate code at the bottom of lists of template name cases.

clang/include/clang/AST/TemplateName.h

30

this list is alpha sorted, please preserve (and below)

415

docs on getUsingShadowDecl and getUnderlying

415

getFoundDecl() would be consistent with UsingType, and would describe the relation between this and the UsingShadowDecl, rather than echoing its type

416

maybe getUnderlyingTemplate? "underlying" acts as an adjective so this feels a little ungrammatical

417

nit: separate the public API from implementation details with a blank line at least

419

It seems really unfortunate that this is a TemplateDecl* instead of a TemplateName.

for:

template <int> class x;
namespace a { using ::x; }
a::x<0>;

we want a::x to include both a QualifiedTemplateName (modelling the a:: qualifier) and a UsingTemplateName (modelling the UsingShadowDecl that was found).

I'd guess we can change Template to be a TemplateName internally, and add getTemplate() while keeping the existing get[Template]Decl APIs on top of TemplateName::getAsTemplateDecl().
I suppose this could be a separate change (though it'd be nice to know whether it's going to work...)

Of course if that changed there's a natural followon to take the qualifier out of DependentTemplateName and turn it into a QualifiedTemplateName wrapping a DependentTemplateName. (Definitely out of scope for this patch, not sure if it's reasonable to expect you to do it at all)

clang/lib/AST/ASTContext.cpp

6175

you could also handle this in the QualifiedTemplate/Template case, since the decl is guaranteed to be present.

[sammccall]

clang/lib/AST/ItaniumMangle.cpp

2389

this seems pretty scary: we have to use a goto here rather than extract a function, because the target code also uses goto...

The nontrivial TemplateTemplateParmDecl case isn't possible here. So I suggest just calling mangleSourceNameWithAbiTags directly without trying to reuse logic.

clang/lib/AST/TemplateName.cpp

116

= getAsUsingTemplateName()

302

Why is this correct, rather than potentially printing the wrong sugar?

If the reasoning is that that the underlying TemplateName has the same name and can't have any unwanted sugar, that seems subtle and deserves a comment.

I think just printing the unqualified name directly would be clearer.

clang/lib/Sema/SemaDecl.cpp

507–511

nit: just Template(TD) or = TD?

clang/lib/Sema/SemaDeclCXX.cpp

11028

I don't think it can be valid to find the template name via a usingshadowdecl, because the deduction guide must be declared in the same scope as the template. (err_deduction_guide_wrong_scope).

Is this to prevent an unneccesary second diagnostic? (And if so, I wonder whether we should also include QualifiedTemplate, maybe as a separate change). It may deserve a comment

clang/lib/Tooling/CMakeLists.txt

62 ↗

(On Diff #420485)

revert?

(though yes, this is annoying)

clang/test/AST/ast-dump-using-template.cpp

2

Maybe a comment here:
TemplateNames are not dumped, so the sugar here isn't obvious. However the "using" on the TemplateSpecializationTypes shows that the UsingTemplateName is present.

[hokein]

address review comments;
rename methods;
fix templatename::print and add a test;
add a fixme for qualified template name;

[hokein]

In D123127#3429589, @sammccall wrote:

This looks pretty good!
The tests in clang are sadly indirect.

This is mostly due to the fact that TemplateName is not dumped. This patch extend the NodeDumper to print a using indicator, I think it is relatively obvious in the AST.

I think adding support to clangd's FindTarget would be a small change and would allow a fairly direct test, but maybe it will affect a bunch of existing tests or possibly have a blast radius. Up to you.

Adding support in clangd FindTarget is my next step, it would be a followup patch. I feel like the FindTarget tests are more related to the application logic of the new TemplateName, and are less direct compared with the tests in this patch.

clang/include/clang/AST/TemplateName.h

419

we want a::x to include both a QualifiedTemplateName (modelling the a:: qualifier) and a UsingTemplateName (modelling the UsingShadowDecl that was found).

I'd guess we can change Template to be a TemplateName internally, and add getTemplate() while keeping the existing get[Template]Decl APIs on top of TemplateName::getAsTemplateDecl().
I suppose this could be a separate change (though it'd be nice to know whether it's going to work...)

Agree, I think this is the right solution, but would require more work (a followup patch).

There are two options, 1) leave the qualified template name out, and support it in a followup patch, 2) workaround it -- we wrap the qualified template name with a using template name, though it doesn't quite match our mental model, I think it is probably ok. (I added a FIXME in SemaTemplate.cpp).

Let me know what you think, also happy to switch to 1).

clang/lib/AST/ASTContext.cpp

6175

yeah, but I think the current version is clearer.

clang/lib/AST/TemplateName.cpp

302

good point, you're right, this will print duplicated nested specifiers. Change it to print unqualified name only, and added a test.

clang/lib/Sema/SemaDeclCXX.cpp

11028

yeah, it prevents a bogus diagnostic introduced by this patch.

namespace N {
   template<typename T> struct NamedNS1 {}; // expected-note {{here}}
 }
 using N::NamedNS1;
 NamedNS1(int) -> NamedNS1<int>; // expected-error {{deduction guide must be declared in the same scope as template}}

With this patch without the change here, we emit an extra diagnostic deduced type 'NamedNS1<int>' of deduction guide is not written as a specialization of template 'NamedNS1'.

And this part of code might have another issue where it emits a wrong err_deduction_guide_defines_function for a correct code, (this is something I plan to take a look but not in this patch) .

clang/lib/Tooling/CMakeLists.txt

62 ↗

(On Diff #420485)

oops, an accident change, reverted.

[sammccall]

Thanks, I think this is just about ready to go.
Only substantive issue is I think we should address the QualifiedTemplate/UsingTemplate interaction in a more principled way.

clang/include/clang/AST/PropertiesBase.td

625

rename these properties too?

clang/include/clang/AST/TemplateName.h

419

I don't like 2), it adds code in order to introduce an incorrect "inside-out" AST in a surprising way that will lead to subtle bugs, and we'll need to undo this later. To me this seems probably worse than dropping one of the sugar nodes and never fixing it, which is already pretty bad.

I think we should do 1) instead - I think it's actually simpler to land the QualifiedTemplate-holds-TemplateName patch *first*, but either order seems fine.

clang/lib/Sema/SemaDeclCXX.cpp

11028

That makes sense, though it seems to me inconsistent to suppress the secondary diagnostic for UsingTemplate but emit it for QualifiedTemplate - it's equally bogus/valid in both cases.

Can we either suppress both, or suppress neither for now and suppress them in a subsequent patch?

[hokein]

address remaining comments.

clang/include/clang/AST/TemplateName.h

419

ok, faire enough, switched to 1).

clang/lib/Sema/SemaDeclCXX.cpp

11028

ok, let's not do it for now, and add a FIXME for the newly-introduced diagnostic in the existing test.

[sammccall]

clang/include/clang/AST/TemplateName.h

408

(Per offline discussion)

The UnderlyingTN here seems like it would refer to the TemplateDecl pointed to by the UsingShadowDecl, with sugar from the RHS of the UsingDecl.

The only sugar possible is a namespace [alias] qualifier, so the only TemplateNames possible are Qualified and Ordinary. And the code isn't actually creating Qualified names here when it would be applicable.

So we should either:

• change this to be a TemplateDecl* instead
• start creating the Qualified names where appropriate

Arguments in favor of having the sugar qualified names:

• it's a more complete AST
• it's more consistent with sugar types

Arguments against the sugar qualified names

• performance: it avoids adding a second level of indirection, extra storage etc
• it avoids confusing callers into handling *all* TemplateName cases here
• the sugar is still available: USD->getUsingDecl()->getQualifier()

I think we should not provide sugared names here, and change the type to TemplateDecl*

408

If we change the type to TemplateDecl, do we actually need to store it? Or can we just cast<TemplateDecl>(USD->getTargetDecl())?

[hokein]

A revised iteration: store UsingShadowDecl directly in TemplateName::Storage,
UsingTemplateName class is no longer needed.

[hokein]

some tweaks.

[sammccall]

Storing the UsingShadowDecl directly is much nicer :-)

clang/include/clang/AST/TemplateName.h

235

nit: declaration *found* through

306

getAsUsingShadowDecl!

clang/lib/AST/ASTContext.cpp

6129

nit: no braces (other cases only use them where variables are declared)

clang/lib/AST/ASTImporter.cpp

9244

remove commented code

9251

This doesn't look right at all, you're returning an ordinary template name, not a using...

clang/lib/AST/TemplateName.cpp

80

assert(isa<TemplateDecl>(Using->getTargetDecl()))

(better to crash upfront than in getAsTemplateDecl() or so)

269

this is going to print the wrong qualifier: qualifier of the underlying rather than of the usingdecl

clang/lib/Sema/SemaTemplate.cpp

294

it would be really nice to have a test verifying that if we are ambiguous here and form an Overloaded TemplateName, then when it's later resolved it turns into a Using TemplateName where appropriate...

[hokein]

address some comments, and cleanups.

[hokein]

clang/lib/AST/TemplateName.cpp

80

There is already a stricter assertion TD == Using->getUnderlyingDecl() in every construct side.

269

I think this is a good argument -- after the code namespace ns { using std::vector; }, what's the fully-qualified name of the vector UsingTemplateName within ns?

1. ns::vector -- the qualified name of using-decl.
2. or std::vector- the qualified name of the underlying template decl.

after a second thought, I'm leaning towards 2). AFAIK, the major place to print fully-qualified name is TemplateArgument::print (for template template parameters). 2) is providing more useful information for users to locate the actual template class. Imaging a case where we have a using long::long::long::abc in a global namespace, printing abc seems less useful.

This is also consistent with UsingType.

clang/lib/Sema/SemaTemplate.cpp

294

then when it's later resolved it turns into a Using TemplateName where appropriate...

clang doesn't seem to work like this -- it does form an Overloaded TemplateName during parsing, but a call to these overloaded function templates is a UnresolvedLookupExpr which stores all function candidates. After the template instantiation, the UnresolvedLookupExpr is resolved to a normal DeclRefExpr (that said there is no Using TemplateName being built).

The reason I added the isAmbiguous guard here was to ensure the Using->getUnderlyingDecl() == TD invariant, it is always true for correct cases. However, we pickup an *arbitrary* template for error-recovery (see line 231). Now I have figured out a better way to handle it (by storing the corresponding FoundUsingDecl) without needing this isAmbiguous guard. Removed.

[hokein]

add a unittest for template name.

[sammccall]

clang/lib/AST/TemplateName.cpp

123

= getAsUsingShadowDecl

269

OK, that makes sense, but deserves a serious comment - it *looks* like a bug.

(I'd forgotten about the UsingType behavior. It has a 9-line comment!)

clang/lib/Sema/SemaDecl.cpp

1112–1116

FIXME here for qualified using case?

[hokein]

address remaining comments.

[hokein]

Fix a use-after-free in the unittest, TemplateArgumentLoc is a local storage of
MatchCallback.

[hokein]

reopening it for the reland version.

[hokein]

reland version: there is no freebit in the TemplateName's PointerUnion to store
5 different pointer types in 32-bit build, instead we change the TemplateDecl to
NamedDecl, which can be used to hold the TemplateDecl and UsingShadowDecl.

[sammccall]

Nice fix! Just nits

clang/include/clang/AST/TemplateName.h

198

nit: I'd use Decl here instead of NamedDecl.

Sure, the lowest common type is NamedDecl, but that's not really important and we don't use any of the NamedDecl interface.

304

I think this second sentence is confusing rather than helpful to understanding to use this class (as opposed to its implementation).

The main way to get the underlying declaration is with getAsTemplateDecl(). From a public POV, a Using name has a using shadow decl *and* a template decl, the fact that we only store one of these is an implementation detail.

306

If (after followup patches) you have a qualified name Q wrapping a using name U, I'd expect Q.getAsUsingShadowDecl() to extract the pointer from U.storage.

I'd expect this based on the first sentence of the comment here, and also consistent with getAsTemplateDecl() which does this sort of unwrapping.

So no changes needed if you're OK with adding that unwrapping behavior in the next patch, otherwise I think we need to think a bit about how to set expectations with this API.

clang/lib/AST/TemplateName.cpp

90

nit: invert this so that UsingShadowDecl is the special case and TemplateDecl the general one?

112

and again here

256

I don't understand what "std::vector is much more common" there's no ground truth for us to observe.
Rather maybe "using declarations are used to import names more often than to export them, and using the original name is most useful in this case"?

[hokein]

address comments.

clang-tools-extra/clangd/DumpAST.cpp

case TemplateName::X:                                                        \
     return #X;
       TEMPLATE_KIND(Template);
       TEMPLATE_KIND(OverloadedTemplate);
       TEMPLATE_KIND(AssumedTemplate);
       TEMPLATE_KIND(QualifiedTemplate);
       TEMPLATE_KIND(DependentTemplate);
       TEMPLATE_KIND(SubstTemplateTemplateParm);
       TEMPLATE_KIND(SubstTemplateTemplateParmPack);
+      TEMPLATE_KIND(UsingTemplate);
 #undef TEMPLATE_KIND
     }
     llvm_unreachable("Unhandled NameKind enum");
   }
   std::string getKind(const Attr *A) {
     switch (A->getKind()) {
 #define ATTR(X)                                                                \
   case attr::X:                                                                \

clang-tools-extra/clangd/SemanticHighlighting.cpp

bool TraverseTemplateArgumentLoc(TemplateArgumentLoc L) {
     case TemplateName::AssumedTemplate:
       H.addToken(L.getTemplateNameLoc(), HighlightingKind::Class)
           .addModifier(HighlightingModifier::DependentName);
       break;
     case TemplateName::Template:
     case TemplateName::QualifiedTemplate:
     case TemplateName::SubstTemplateTemplateParm:
     case TemplateName::SubstTemplateTemplateParmPack:
+    case TemplateName::UsingTemplate:
       // Names that could be resolved to a TemplateDecl are handled elsewhere.
       break;
     }
     return RecursiveASTVisitor::TraverseTemplateArgumentLoc(L);
   }
 
   // findExplicitReferences will walk nested-name-specifiers and
   // find anything that can be resolved to a Decl. However, non-leaf

clang/include/clang/AST/PropertiesBase.td

 let Class = PropertyTypeCase<TemplateName, "Template"> in {
   def : Property<"declaration", TemplateDeclRef> {
     let Read = [{ node.getAsTemplateDecl() }];
   }
   def : Creator<[{
     return TemplateName(declaration);
   }]>;
 }
+
+let Class = PropertyTypeCase<TemplateName, "UsingTemplate"> in {
+  def : Property<"foundDecl", UsingShadowDeclRef> {
+    let Read = [{ node.getAsUsingShadowDecl() }];
+  }
+  def : Creator<[{
+    return TemplateName(foundDecl);
+  }]>;
+}
+
 let Class = PropertyTypeCase<TemplateName, "OverloadedTemplate"> in {
   def : Property<"overloads", Array<NamedDeclRef>> {
     let Read = [{ node.getAsOverloadedTemplate()->decls() }];
   }
   def : Creator<[{
     // Copy into an UnresolvedSet to satisfy the interface.
     UnresolvedSet<8> overloadSet;
     for (auto overload : overloads) {

clang/include/clang/AST/TemplateName.h

 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <cassert>
 
 namespace clang {
 
 class ASTContext;
+class Decl;
 class DependentTemplateName;
 class IdentifierInfo;
 class NamedDecl;
 class NestedNameSpecifier;
 enum OverloadedOperatorKind : int;
 class OverloadedTemplateStorage;
 class AssumedTemplateStorage;
 struct PrintingPolicy;
 class QualifiedTemplateName;
 class SubstTemplateTemplateParmPackStorage;
 class SubstTemplateTemplateParmStorage;
 class TemplateArgument;
 class TemplateDecl;
 class TemplateTemplateParmDecl;
+class UsingShadowDecl;
 
 /// Implementation class used to describe either a set of overloaded
 /// template names or an already-substituted template template parameter pack.
 class UncommonTemplateNameStorage {
 protected:
   enum Kind {
     Overloaded,
     Assumed, // defined in DeclarationName.h

 ///   typedef typename MetaFun::template apply<T1, T2>::type type;
 /// };
 /// \endcode
 ///
 /// Here, "apply" is treated as a template name within the typename
 /// specifier in the typedef. "apply" is a nested template, and can
 /// only be understood in the context of
 class TemplateName {
+  // NameDecl is either a TemplateDecl or a UsingShadowDecl depending on the
+  // NameKind.
+  // !! There is no free low bits in 32-bit builds to discriminate more than 4
+  // pointer types in PointerUnion.
   using StorageType =
-      llvm::PointerUnion<TemplateDecl *, UncommonTemplateNameStorage *,
+      llvm::PointerUnion<Decl *, UncommonTemplateNameStorage *,
                          QualifiedTemplateName *, DependentTemplateName *>;
 
   StorageType Storage;
 
   explicit TemplateName(void *Ptr);
 
 public:
   // Kind of name that is actually stored.
enum NameKind {
 
     /// A template template parameter that has been substituted
     /// for some other template name.
     SubstTemplateTemplateParm,
 
     /// A template template parameter pack that has been substituted for
     /// a template template argument pack, but has not yet been expanded into
     /// individual arguments.
-    SubstTemplateTemplateParmPack
+    SubstTemplateTemplateParmPack,
+
+    /// A template name that refers to a template declaration found through a
+    /// specific using shadow declaration.
+    UsingTemplate,
   };
 
   TemplateName() = default;
   explicit TemplateName(TemplateDecl *Template);
   explicit TemplateName(OverloadedTemplateStorage *Storage);
   explicit TemplateName(AssumedTemplateStorage *Storage);
   explicit TemplateName(SubstTemplateTemplateParmStorage *Storage);
   explicit TemplateName(SubstTemplateTemplateParmPackStorage *Storage);
   explicit TemplateName(QualifiedTemplateName *Qual);
   explicit TemplateName(DependentTemplateName *Dep);
+  explicit TemplateName(UsingShadowDecl *Using);
 
   /// Determine whether this template name is NULL.
   bool isNull() const;
 
   // Get the kind of name that is actually stored.
   NameKind getKind() const;
 
   /// Retrieve the underlying template declaration that
public:
   /// Retrieve the underlying qualified template name
   /// structure, if any.
   QualifiedTemplateName *getAsQualifiedTemplateName() const;
 
   /// Retrieve the underlying dependent template name
   /// structure, if any.
   DependentTemplateName *getAsDependentTemplateName() const;
 
+  /// Retrieve the using shadow declaration through which the underlying
+  /// template declaration is introduced, if any.
+  UsingShadowDecl *getAsUsingShadowDecl() const;
+
   TemplateName getUnderlying() const;
 
   /// Get the template name to substitute when this template name is used as a
   /// template template argument. This refers to the most recent declaration of
   /// the template, including any default template arguments.
   TemplateName getNameToSubstitute() const;
 
   TemplateNameDependence getDependence() const;
 
   /// Determines whether this is a dependent template name.

 /// declaration for "vector". The QualifiedTemplateName class is only
 /// used to provide "sugar" for template names that were expressed
 /// with a qualified name, and has no semantic meaning. In this
 /// manner, it is to TemplateName what ElaboratedType is to Type,
 /// providing extra syntactic sugar for downstream clients.
 class QualifiedTemplateName : public llvm::FoldingSetNode {
   friend class ASTContext;
 
   /// The nested name specifier that qualifies the template name.
   ///
   /// The bit is used to indicate whether the "template" keyword was
   /// present before the template name itself. Note that the
   /// "template" keyword is always redundant in this case (otherwise,
   /// the template name would be a dependent name and we would express
   /// this name with DependentTemplateName).
   llvm::PointerIntPair<NestedNameSpecifier *, 1> Qualifier;
 
   /// The template declaration or set of overloaded function templates
   /// that this qualified name refers to.
   TemplateDecl *Template;
 
   QualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword,
                         TemplateDecl *Template)
       : Qualifier(NNS, TemplateKeyword? 1 : 0), Template(Template) {}
 
 public:
   /// Return the nested name specifier that qualifies this name.
   NestedNameSpecifier *getQualifier() const { return Qualifier.getPointer(); }

clang/include/clang/AST/TextNodeDumper.h

#include "clang/AST/AttrTextNodeDump.inc"
   void VisitFunctionProtoType(const FunctionProtoType *T);
   void VisitUnresolvedUsingType(const UnresolvedUsingType *T);
   void VisitUsingType(const UsingType *T);
   void VisitTypedefType(const TypedefType *T);
   void VisitUnaryTransformType(const UnaryTransformType *T);
   void VisitTagType(const TagType *T);
   void VisitTemplateTypeParmType(const TemplateTypeParmType *T);
   void VisitAutoType(const AutoType *T);
+  void VisitDeducedTemplateSpecializationType(
+      const DeducedTemplateSpecializationType *T);
   void VisitTemplateSpecializationType(const TemplateSpecializationType *T);
   void VisitInjectedClassNameType(const InjectedClassNameType *T);
   void VisitObjCInterfaceType(const ObjCInterfaceType *T);
   void VisitPackExpansionType(const PackExpansionType *T);
 
   void VisitLabelDecl(const LabelDecl *D);
   void VisitTypedefDecl(const TypedefDecl *D);
   void VisitEnumDecl(const EnumDecl *D);

clang/lib/AST/ASTContext.cpp

ASTContext::getNameForTemplate(TemplateName Name,
   }
 
   case TemplateName::SubstTemplateTemplateParmPack: {
     SubstTemplateTemplateParmPackStorage *subst
       = Name.getAsSubstTemplateTemplateParmPack();
     return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
                                NameLoc);
   }
+  case TemplateName::UsingTemplate:
+    return DeclarationNameInfo(Name.getAsUsingShadowDecl()->getDeclName(),
+                               NameLoc);
   }
 
   llvm_unreachable("bad template name kind!");
 }
 
 TemplateName
 ASTContext::getCanonicalTemplateName(const TemplateName &Name) const {
   switch (Name.getKind()) {
+  case TemplateName::UsingTemplate:
   case TemplateName::QualifiedTemplate:
   case TemplateName::Template: {
     TemplateDecl *Template = Name.getAsTemplateDecl();
     if (auto *TTP  = dyn_cast<TemplateTemplateParmDecl>(Template))
       Template = getCanonicalTemplateTemplateParmDecl(TTP);
 
     // The canonical template name is the canonical template declaration.
     return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
case TemplateName::SubstTemplateTemplateParmPack: {
     SubstTemplateTemplateParmPackStorage *subst
                                   = Name.getAsSubstTemplateTemplateParmPack();
     TemplateTemplateParmDecl *canonParameter
       = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
     TemplateArgument canonArgPack
       = getCanonicalTemplateArgument(subst->getArgumentPack());
     return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
   }
   }
 
   llvm_unreachable("bad template name!");
 }
 
 bool ASTContext::hasSameTemplateName(const TemplateName &X,
                                      const TemplateName &Y) const {
   return getCanonicalTemplateName(X).getAsVoidPointer() ==
          getCanonicalTemplateName(Y).getAsVoidPointer();

clang/lib/AST/ASTImporter.cpp

case TemplateName::SubstTemplateTemplateParmPack: {
     auto ArgPackOrErr =
         Importer.ImportTemplateArgument(SubstPack->getArgumentPack());
     if (!ArgPackOrErr)
       return ArgPackOrErr.takeError();
 
     return ToContext.getSubstTemplateTemplateParmPack(
         cast<TemplateTemplateParmDecl>(*ParamOrErr), *ArgPackOrErr);
   }
+  case TemplateName::UsingTemplate: {
+    auto UsingOrError = Import(From.getAsUsingShadowDecl());
+    if (!UsingOrError)
+      return UsingOrError.takeError();
+    return TemplateName(cast<UsingShadowDecl>(*UsingOrError));
+  }
   }
 
   llvm_unreachable("Invalid template name kind");
 }
 
 Expected<SourceLocation> ASTImporter::Import(SourceLocation FromLoc) {
   if (FromLoc.isInvalid())
     return SourceLocation{};
 
   SourceManager &FromSM = FromContext.getSourceManager();
   bool IsBuiltin = FromSM.isWrittenInBuiltinFile(FromLoc);

clang/lib/AST/ASTStructuralEquivalence.cpp

return IsStructurallyEquivalent(Context, P1->getArgumentPack(),
                                     P2->getArgumentPack()) &&
            IsStructurallyEquivalent(Context, P1->getParameterPack(),
                                     P2->getParameterPack());
   }
 
    case TemplateName::Template:
    case TemplateName::QualifiedTemplate:
    case TemplateName::SubstTemplateTemplateParm:
+   case TemplateName::UsingTemplate:
      // It is sufficient to check value of getAsTemplateDecl.
      break;
 
   }
 
   return true;
 }
 

clang/lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleType(TemplateName TN) {
 
   TemplateDecl *TD = nullptr;
 
   switch (TN.getKind()) {
   case TemplateName::QualifiedTemplate:
     TD = TN.getAsQualifiedTemplateName()->getTemplateDecl();
     goto HaveDecl;
 
+  case TemplateName::UsingTemplate:
   case TemplateName::Template:
     TD = TN.getAsTemplateDecl();
     goto HaveDecl;
 
   HaveDecl:
     if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TD))
       mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
     else
case Type::TemplateSpecialization: {
     case TemplateName::SubstTemplateTemplateParmPack: {
       // FIXME: not clear how to mangle this!
       // template <template <class U> class T...> class A {
       //   template <class U...> void foo(decltype(T<U>::foo) x...);
       // };
       Out << "_SUBSTPACK_";
       break;
     }
+    case TemplateName::UsingTemplate: {
+      TemplateDecl *TD = TN.getAsTemplateDecl();
+      assert(TD && !isa<TemplateTemplateParmDecl>(TD));
+      mangleSourceNameWithAbiTags(TD);
+      break;
+    }
     }
 
     // Note: we don't pass in the template name here. We are mangling the
     // original source-level template arguments, so we shouldn't consider
     // conversions to the corresponding template parameter.
     // FIXME: Other compilers mangle partially-resolved template arguments in
     // unresolved-qualifier-levels.
     mangleTemplateArgs(TemplateName(), TST->getArgs(), TST->getNumArgs());

clang/lib/AST/ODRHash.cpp

case TemplateName::Template:
     break;
   // TODO: Support these cases.
   case TemplateName::OverloadedTemplate:
   case TemplateName::AssumedTemplate:
   case TemplateName::QualifiedTemplate:
   case TemplateName::DependentTemplate:
   case TemplateName::SubstTemplateTemplateParm:
   case TemplateName::SubstTemplateTemplateParmPack:
+  case TemplateName::UsingTemplate:
     break;
   }
 }
 
 void ODRHash::AddTemplateArgument(TemplateArgument TA) {
   const auto Kind = TA.getKind();
   ID.AddInteger(Kind);
 

clang/lib/AST/TemplateName.cpp

 //===- 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"

 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 (Storage.is<TemplateDecl *>())
+  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 (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
-    return Template;
+  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->getTemplateDecl();
 
   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();
 

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

 }
 
 bool TemplateName::containsUnexpandedParameterPack() const {
   return getDependence() & TemplateNameDependence::UnexpandedPack;
 }
 
 void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
                          Qualified Qual) const {
-  if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
+  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->getTemplateDecl()->printQualifiedName(OS, Policy);
       return;
else
                = 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);
   }
 }
 
 const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
                                              TemplateName N) {
   std::string NameStr;

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
   OS << " nullptr";
 }
 
 void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
   OS << " integral " << TA.getAsIntegral();
 }
 
 void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
+  if (TA.getAsTemplate().getKind() == TemplateName::UsingTemplate)
+    OS << " using";
   OS << " template ";
   TA.getAsTemplate().dump(OS);
 }
 
 void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
     const TemplateArgument &TA) {
+  if (TA.getAsTemplateOrTemplatePattern().getKind() ==
+      TemplateName::UsingTemplate)
+    OS << " using";
   OS << " template expansion ";
   TA.getAsTemplateOrTemplatePattern().dump(OS);
 }
 
 void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
   OS << " expr";
 }
 
if (!T->isDeduced())
     OS << " undeduced";
   if (T->isConstrained()) {
     dumpDeclRef(T->getTypeConstraintConcept());
     for (const auto &Arg : T->getTypeConstraintArguments())
       VisitTemplateArgument(Arg);
   }
 }
 
+void TextNodeDumper::VisitDeducedTemplateSpecializationType(
+    const DeducedTemplateSpecializationType *T) {
+  if (T->getTemplateName().getKind() == TemplateName::UsingTemplate)
+    OS << " using";
+}
+
 void TextNodeDumper::VisitTemplateSpecializationType(
     const TemplateSpecializationType *T) {
   if (T->isTypeAlias())
     OS << " alias";
+  if (T->getTemplateName().getKind() == TemplateName::UsingTemplate)
+    OS << " using";
   OS << " ";
   T->getTemplateName().dump(OS);
 }
 
 void TextNodeDumper::VisitInjectedClassNameType(
     const InjectedClassNameType *T) {
   dumpDeclRef(T->getDecl());
 }

clang/lib/AST/Type.cpp

: Type(TemplateSpecialization, Canon.isNull() ? QualType(this, 0) : Canon,
       Template(T) {
   TemplateSpecializationTypeBits.NumArgs = Args.size();
   TemplateSpecializationTypeBits.TypeAlias = !AliasedType.isNull();
 
   assert(!T.getAsDependentTemplateName() &&
          "Use DependentTemplateSpecializationType for dependent template-name");
   assert((T.getKind() == TemplateName::Template ||
           T.getKind() == TemplateName::SubstTemplateTemplateParm ||
-          T.getKind() == TemplateName::SubstTemplateTemplateParmPack) &&
+          T.getKind() == TemplateName::SubstTemplateTemplateParmPack ||
+          T.getKind() == TemplateName::UsingTemplate) &&
          "Unexpected template name for TemplateSpecializationType");
 
   auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
   for (const TemplateArgument &Arg : Args) {
     // Update instantiation-dependent, variably-modified, and error bits.
     // If the canonical type exists and is non-dependent, the template
     // specialization type can be non-dependent even if one of the type
     // arguments is. Given:

clang/lib/Sema/SemaDecl.cpp

if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
     FoundUsingShadow = nullptr; // FIXME: Target must be a TypeDecl.
   } else if (auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
     (void)DiagnoseUseOfDecl(UD, NameLoc);
     // Recover with 'int'
     T = Context.IntTy;
     FoundUsingShadow = nullptr;
   } else if (AllowDeducedTemplate) {
     if (auto *TD = getAsTypeTemplateDecl(IIDecl)) {
-      // FIXME: TemplateName should include FoundUsingShadow sugar.
-      T = Context.getDeducedTemplateSpecializationType(TemplateName(TD),
-                                                       QualType(), false);
+      assert(!FoundUsingShadow || FoundUsingShadow->getTargetDecl() == TD);
+      TemplateName Template =
+          FoundUsingShadow ? TemplateName(FoundUsingShadow) : TemplateName(TD);
+      T = Context.getDeducedTemplateSpecializationType(Template, QualType(),
+                                                       false);
       // Don't wrap in a further UsingType.
       FoundUsingShadow = nullptr;
     }
   }
 
   if (T.isNull()) {
     // If it's not plausibly a type, suppress diagnostics.
     Result.suppressDiagnostics();
if (Result.end() - Result.begin() > 1) {
                                                    Result.end());
     } else if (!Result.empty()) {
       auto *TD = cast<TemplateDecl>(getAsTemplateNameDecl(
           *Result.begin(), /*AllowFunctionTemplates=*/true,
           /*AllowDependent=*/false));
       IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
       IsVarTemplate = isa<VarTemplateDecl>(TD);
 
-      if (SS.isNotEmpty())
+      UsingShadowDecl *FoundUsingShadow =
+          dyn_cast<UsingShadowDecl>(*Result.begin());
+
+      if (SS.isNotEmpty()) {
+        // FIXME: support using shadow-declaration in qualified template name.
         Template =
             Context.getQualifiedTemplateName(SS.getScopeRep(),
                                              /*TemplateKeyword=*/false, TD);
-      else
-        Template = TemplateName(TD);
+      } else {
+        assert(!FoundUsingShadow ||
+               TD == cast<TemplateDecl>(FoundUsingShadow->getTargetDecl()));
+        Template = FoundUsingShadow ? TemplateName(FoundUsingShadow)
+                                    : TemplateName(TD);
+      }
     } else {
       // All results were non-template functions. This is a function template
       // name.
       IsFunctionTemplate = true;
       Template = Context.getAssumedTemplateName(NameInfo.getName());
     }
 
     if (IsFunctionTemplate) {

clang/lib/Sema/SemaDeclCXX.cpp

for (const DeclaratorChunk &Chunk : llvm::reverse(D.type_objects())) {
     assert(TSI && "deduction guide has valid type but invalid return type?");
     bool AcceptableReturnType = false;
     bool MightInstantiateToSpecialization = false;
     if (auto RetTST =
             TSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>()) {
       TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
       bool TemplateMatches =
           Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
+      // FIXME: We should consider other template kinds (using, qualified),
+      // otherwise we will emit bogus diagnostics.
       if (SpecifiedName.getKind() == TemplateName::Template && TemplateMatches)
         AcceptableReturnType = true;
       else {
         // This could still instantiate to the right type, unless we know it
         // names the wrong class template.
         auto *TD = SpecifiedName.getAsTemplateDecl();
         MightInstantiateToSpecialization = !(TD && isa<ClassTemplateDecl>(TD) &&
                                              !TemplateMatches);
       }

clang/lib/Sema/SemaTemplate.cpp

 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
 //
 // 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 implements semantic analysis for C++ templates.
 //===----------------------------------------------------------------------===//
 
 #include "TreeTransform.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/AST/TemplateName.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/Stack.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
return AssumedTemplate == AssumedTemplateKind::FoundNothing
                ? TNK_Undeclared_template
                : TNK_Function_template;
   }
 
   if (R.empty())
     return TNK_Non_template;
 
   NamedDecl *D = nullptr;
+  UsingShadowDecl *FoundUsingShadow = dyn_cast<UsingShadowDecl>(*R.begin());
   if (R.isAmbiguous()) {
     // If we got an ambiguity involving a non-function template, treat this
     // as a template name, and pick an arbitrary template for error recovery.
     bool AnyFunctionTemplates = false;
     for (NamedDecl *FoundD : R) {
       if (NamedDecl *FoundTemplate = getAsTemplateNameDecl(FoundD)) {
         if (isa<FunctionTemplateDecl>(FoundTemplate))
           AnyFunctionTemplates = true;
         else {
           D = FoundTemplate;
+          FoundUsingShadow = dyn_cast<UsingShadowDecl>(FoundD);
           break;
         }
       }
     }
 
     // If we didn't find any templates at all, this isn't a template name.
     // Leave the ambiguity for a later lookup to diagnose.
     if (!D && !AnyFunctionTemplates) {
if (isa<UnresolvedUsingValueDecl>(D)) {
       MemberOfUnknownSpecialization = true;
       return TNK_Non_template;
     }
 
     TemplateDecl *TD = cast<TemplateDecl>(D);
 
     if (SS.isSet() && !SS.isInvalid()) {
       NestedNameSpecifier *Qualifier = SS.getScopeRep();
-      Template = Context.getQualifiedTemplateName(Qualifier,
-                                                  hasTemplateKeyword, TD);
-    } else {
-      Template = TemplateName(TD);
+      // FIXME: store the using TemplateName in QualifiedTemplateName if
+      // the TD is referred via a using-declaration.
+      Template =
+          Context.getQualifiedTemplateName(Qualifier, hasTemplateKeyword, TD);
+    } else {
+      Template =
+          FoundUsingShadow ? TemplateName(FoundUsingShadow) : TemplateName(TD);
+      assert(!FoundUsingShadow || FoundUsingShadow->getTargetDecl() == TD);
     }
 
     if (isa<FunctionTemplateDecl>(TD)) {
       TemplateKind = TNK_Function_template;
 
       // We'll do this lookup again later.
       R.suppressDiagnostics();
     } else {

clang/test/AST/ast-dump-using-template.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -std=c++17 -ast-dump %s | FileCheck -strict-whitespace %s
+
+// Tests to verify we construct correct using template names.
+// TemplateNames are not dumped, so the sugar here isn't obvious. However
+// the "using" on the TemplateSpecializationTypes shows that the
+// UsingTemplateName is present.
+namespace ns {
+template<typename T> class S {
+ public:
+   S(T);
+};
+}
+using ns::S;
+
+// TemplateName in TemplateSpecializationType.
+template<typename T>
+using A = S<T>;
+// CHECK:      TypeAliasDecl
+// CHECK-NEXT: `-TemplateSpecializationType {{.*}} 'S<T>' dependent using S
+
+// TemplateName in TemplateArgument.
+template <template <typename> class T> class X {};
+using B = X<S>;
+// CHECK:      TypeAliasDecl
+// CHECK-NEXT: `-TemplateSpecializationType {{.*}} 'X<ns::S>' sugar X
+// CHECK-NEXT:   |-TemplateArgument using template S
+// CHECK-NEXT:     `-RecordType {{.*}} 'X<ns::S>'
+// CHECK-NEXT:       `-ClassTemplateSpecialization {{.*}} 'X'
+
+// TemplateName in DeducedTemplateSpecializationType.
+S DeducedTemplateSpecializationT(123);
+using C = decltype(DeducedTemplateSpecializationT);
+// CHECK:      DecltypeType {{.*}}
+// CHECK-NEXT:  |-DeclRefExpr {{.*}}
+// CHECK-NEXT:  `-DeducedTemplateSpecializationType {{.*}} 'ns::S<int>' sugar using

clang/test/CXX/temp/temp.deduct.guide/p3.cpp

namespace {
     AnonNS2(int) -> AnonNS2<int>; // expected-error {{deduction guide must be declared in the same scope as template 'WrongScope::AnonNS2'}}
   }
   namespace N {
     template<typename T> struct NamedNS1 {}; // expected-note {{here}}
     template<typename T> struct NamedNS2 {}; // expected-note {{here}}
   }
   using N::NamedNS1;
   NamedNS1(int) -> NamedNS1<int>; // expected-error {{deduction guide must be declared in the same scope as template}}
+  // FIXME: remove the following bogus diagnostic
+  // expected-error@-2{{deduction guide is not written as a specialization of template 'NamedNS1'}}
+
   using namespace N;
   NamedNS2(int) -> NamedNS2<int>; // expected-error {{deduction guide must be declared in the same scope as template}}
   struct ClassMemberA {
     template<typename T> struct X {}; // expected-note {{here}}
   };
   struct ClassMemberB : ClassMemberA {
     X(int) -> X<int>; // expected-error {{deduction guide must be declared in the same scope as template 'WrongScope::ClassMemberA::X'}}
   };
   template<typename T> struct Local {};
   void f() {
     Local(int) -> Local<int>; // expected-error {{expected}}
     using WrongScope::Local;
     Local(int) -> Local<int>; // expected-error {{expected}}
   }
 }

clang/tools/libclang/CIndex.cpp

bool CursorVisitor::VisitTemplateParameters(
   }
 
   return false;
 }
 
 bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
   switch (Name.getKind()) {
   case TemplateName::Template:
+  case TemplateName::UsingTemplate:
     return Visit(MakeCursorTemplateRef(Name.getAsTemplateDecl(), Loc, TU));
 
   case TemplateName::OverloadedTemplate:
     // Visit the overloaded template set.
     if (Visit(MakeCursorOverloadedDeclRef(Name, Loc, TU)))
       return true;
 
     return false;

clang/unittests/AST/ASTImporterTest.cpp

 TEST_P(ImportDecl, ImportUsingDecl) {
   MatchVerifier<Decl> Verifier;
   testImport("namespace foo { int bar; }"
              "void declToImport() { using foo::bar; }",
              Lang_CXX03, "", Lang_CXX03, Verifier,
              functionDecl(hasDescendant(usingDecl(hasName("bar")))));
 }
 
+TEST_P(ImportDecl, ImportUsingTemplate) {
+  MatchVerifier<Decl> Verifier;
+  testImport("namespace ns { template <typename T> struct S {}; }"
+             "template <template <typename> class T> class X {};"
+             "void declToImport() {"
+             "using ns::S;  X<S> xi; }",
+             Lang_CXX11, "", Lang_CXX11, Verifier,
+             functionDecl(
+                 hasDescendant(varDecl(hasTypeLoc(templateSpecializationTypeLoc(
+                     hasAnyTemplateArgumentLoc(templateArgumentLoc())))))));
+}
+
 TEST_P(ImportDecl, ImportUsingEnumDecl) {
   MatchVerifier<Decl> Verifier;
   testImport("namespace foo { enum bar { baz, toto, quux }; }"
              "void declToImport() { using enum foo::bar; }",
              Lang_CXX20, "", Lang_CXX20, Verifier,
              functionDecl(hasDescendant(usingEnumDecl(hasName("bar")))));
 }
 

clang/unittests/AST/CMakeLists.txt

add_clang_unittest(ASTTests
   ExternalASTSourceTest.cpp
   NamedDeclPrinterTest.cpp
   RandstructTest.cpp
   RecursiveASTVisitorTest.cpp
   SizelessTypesTest.cpp
   SourceLocationTest.cpp
   StmtPrinterTest.cpp
   StructuralEquivalenceTest.cpp
+  TemplateNameTest.cpp
   TypePrinterTest.cpp
   )
 
 clang_target_link_libraries(ASTTests
   PRIVATE
   clangAST
   clangASTMatchers
   clangBasic

clang/unittests/AST/TemplateNameTest.cpp

+//===- unittests/AST/TemplateNameTest.cpp --- Tests for TemplateName ------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "ASTPrint.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace {
+using namespace ast_matchers;
+
+std::string printTemplateName(TemplateName TN, const PrintingPolicy &Policy,
+                              TemplateName::Qualified Qual) {
+  std::string Result;
+  llvm::raw_string_ostream Out(Result);
+  TN.print(Out, Policy, Qual);
+  return Out.str();
+}
+
+TEST(TemplateName, PrintUsingTemplate) {
+  std::string Code = R"cpp(
+    namespace std {
+      template <typename> struct vector {};
+    }
+    namespace absl { using std::vector; }
+
+    template<template <typename> class T> class X;
+
+    using absl::vector;
+    using A = X<vector>;
+  )cpp";
+  auto AST = tooling::buildASTFromCode(Code);
+  ASTContext &Ctx = AST->getASTContext();
+  // Match the template argument vector in X<vector>.
+  auto MatchResults = match(templateArgumentLoc().bind("id"), Ctx);
+  const auto *Template = selectFirst<TemplateArgumentLoc>("id", MatchResults);
+  ASSERT_TRUE(Template);
+
+  TemplateName TN = Template->getArgument().getAsTemplate();
+  EXPECT_EQ(TN.getKind(), TemplateName::UsingTemplate);
+  EXPECT_EQ(TN.getAsUsingShadowDecl()->getTargetDecl(), TN.getAsTemplateDecl());
+
+  EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
+                              TemplateName::Qualified::Fully),
+            "std::vector");
+  EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
+                              TemplateName::Qualified::AsWritten),
+            "vector");
+  EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
+                              TemplateName::Qualified::None),
+            "vector");
+}
+
+} // namespace
+} // namespace clang