[AST] Support template declaration found through using-decl for QualifiedTemplateName.

[hokein]

Summary

This is a followup of https://reviews.llvm.org/D123127, adding support
for the QualifiedTemplateName.

[sammccall]

clang/include/clang/AST/PropertiesBase.td

665–666

this seems to be flattening the TemplateName into its possible attributes.

Is it possible to encode it as a single TemplateName property? are there particular advantages/disadvantages?

clang/include/clang/AST/TemplateName.h

418

I'm confused about the overloaded case: before this patch it was a single TemplateDecl. Have we actually added the possibility that UnderlyingTemplate is an Overload in this patch? Where?

418

nit: "Template TemplateName" reads a little strangely or reminds of TemplateTemplateParm
I think "a Template" is clear in context. (and below)

426

you've documented the invariant above, probably makes sense to assert it here

450

It seems all of the callers of this function ultimately just use it to reconstruct the underlying template name. This makes sense, because you mostly don't look at QualifiedTemplateName unless you're handling every TemplateName case, and normally handle it by recursion.

I think:

• we should definitely expose the underlying TemplateName and many callers should use that
• we should probably remove getUsingShadowDecl() unless there are enough callers that benefit from not getting it via TemplateName
• we should *consider* removing getTemplateDecl(), it makes for a simpler logical model (basically the top TemplateName::getTemplateName() decl does this smart unwrapping of sugar, but the specific representations like QualifiedTemplateName just expose their components). If it's too much of a pain for callers, we don't need to do this of course.

clang/lib/AST/ASTContext.cpp

4855

This seems like an obvious example where we want:

if (QTN = ...)
  Template = QTN->getUnderlyingTemplate();

clang/unittests/AST/TemplateNameTest.cpp

92

absl::vector -> absl::vector<int>

is a TemplateSpecializationType -> is an elaborated TemplateSpecializationType
(I think the TST itself just covers the vector<int> part)

93

the qualifiers are rather part of the ElaboratedTypeLoc

97

Describe more of the structure?

elaboratedTypeLoc(hasNamedTypeLoc(loc(templateSpecializationType())))

[hokein]

expose underlying template name, removed the getUsingShadowDecl;
address comments;

[hokein]

format

clang/include/clang/AST/PropertiesBase.td

665–666

use TemplateName now.

clang/include/clang/AST/TemplateName.h

418

before this patch it was a single TemplateDecl. Have we actually added the possibility that UnderlyingTemplate is an Overload in this patch? Where?

No, this was basically moved from the original comment, but you're right, the comment doesn't reflect the current code, I think it was oversight when we abstracted out a QualifiedTemplateName in https://github.com/llvm/llvm-project/commit/d28ae27d8d2e20672e182710160f27cf821b55fd. Removed it.

450

we should definitely expose the underlying TemplateName and many callers should use that

+1, this sounds good, and it can also simplify some user code.

we should *consider* removing getTemplateDecl()

This is doable, there are not too many callers of this API (~14 in-tree occurrences), but I'd prefer to do it in a follow-up patch.

[sammccall]

clang/lib/AST/ASTImporter.cpp

9189

why not just import(UnderlyingTN) directly, instead of importing its shadowdecl or templatedecl case-by-case?

[hokein]

simplify the code in ASTImporter.

clang/lib/AST/ASTImporter.cpp

9189

good catch, not sure how I missed this.

[shafik]

clang/lib/Sema/SemaTemplate.cpp

1004

nitpick: /*HasTemplateKeyword*/ -> /*HasTemplateKeyword=*/

clang/include/clang/AST/ASTContext.h

DeclarationNameInfo getNameForTemplate(TemplateName Name,
                                          SourceLocation NameLoc) const;
 
   TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin,
                                          UnresolvedSetIterator End) const;
   TemplateName getAssumedTemplateName(DeclarationName Name) const;
 
   TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS,
                                         bool TemplateKeyword,
-                                        TemplateDecl *Template) const;
+                                        TemplateName Template) const;
 
   TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                         const IdentifierInfo *Name) const;
   TemplateName getDependentTemplateName(NestedNameSpecifier *NNS,
                                         OverloadedOperatorKind Operator) const;
   TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
                                             TemplateName replacement) const;
   TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,

clang/include/clang/AST/PropertiesBase.td

let Class = PropertyTypeCase<TemplateName, "QualifiedTemplate"> in {
   def : ReadHelper<[{
     auto qtn = node.getAsQualifiedTemplateName();
   }]>;
   def : Property<"qualifier", NestedNameSpecifier> {
     let Read = [{ qtn->getQualifier() }];
   }
   def : Property<"hasTemplateKeyword", Bool> {
     let Read = [{ qtn->hasTemplateKeyword() }];
   }
-  def : Property<"declaration", TemplateDeclRef> {
-    let Read = [{ qtn->getTemplateDecl() }];
+  def : Property<"underlyingTemplateName", TemplateName> {
+    let Read = [{ qtn->getUnderlyingTemplate() }];
   }
   def : Creator<[{
     return ctx.getQualifiedTemplateName(qualifier, hasTemplateKeyword,
-                                        declaration);
+                                        underlyingTemplateName);
   }]>;
 }
 let Class = PropertyTypeCase<TemplateName, "DependentTemplate"> in {
   def : ReadHelper<[{
     auto dtn = node.getAsDependentTemplateName();
   }]>;
   def : Property<"qualifier", NestedNameSpecifier> {
     let Read = [{ dtn->getQualifier() }];

clang/include/clang/AST/TemplateName.h

class QualifiedTemplateName : public llvm::FoldingSetNode {
   ///
   /// 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;
+  /// The underlying template name, it is either
+  ///  1) a Template -- a template declaration that this qualified name refers
+  ///     to.
+  ///  2) or a UsingTemplate -- a template declaration introduced by a
+  ///     using-shadow declaration.
+  TemplateName UnderlyingTemplate;
 
   QualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword,
-                        TemplateDecl *Template)
-      : Qualifier(NNS, TemplateKeyword? 1 : 0), Template(Template) {}
+                        TemplateName Template)
+      : Qualifier(NNS, TemplateKeyword ? 1 : 0), UnderlyingTemplate(Template) {
+    assert(UnderlyingTemplate.getKind() == TemplateName::Template ||
+           UnderlyingTemplate.getKind() == TemplateName::UsingTemplate);
+  }
 
 public:
   /// Return the nested name specifier that qualifies this name.
   NestedNameSpecifier *getQualifier() const { return Qualifier.getPointer(); }
 
   /// Whether the template name was prefixed by the "template"
   /// keyword.
   bool hasTemplateKeyword() const { return Qualifier.getInt(); }
 
+  /// Return the underlying template name.
+  TemplateName getUnderlyingTemplate() const { return UnderlyingTemplate; }
+
   /// The template declaration to which this qualified name
   /// refers.
-  TemplateDecl *getTemplateDecl() const { return Template; }
+  /// FIXME: remove this and use getUnderlyingTemplate() instead.
+  TemplateDecl *getTemplateDecl() const {
+    return UnderlyingTemplate.getAsTemplateDecl();
+  }
 
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, getQualifier(), hasTemplateKeyword(), getTemplateDecl());
+    Profile(ID, getQualifier(), hasTemplateKeyword(), UnderlyingTemplate);
   }
 
   static void Profile(llvm::FoldingSetNodeID &ID, NestedNameSpecifier *NNS,
-                      bool TemplateKeyword, TemplateDecl *Template) {
+                      bool TemplateKeyword, TemplateName TN) {
     ID.AddPointer(NNS);
     ID.AddBoolean(TemplateKeyword);
-    ID.AddPointer(Template);
+    ID.AddPointer(TN.getAsVoidPointer());
   }
 };
 
 /// Represents a dependent template name that cannot be
 /// resolved prior to template instantiation.
 ///
 /// This kind of template name refers to a dependent template name,
 /// including its nested name specifier (if any). For example,

clang/lib/AST/ASTContext.cpp

 QualType
 ASTContext::getTemplateSpecializationType(TemplateName Template,
                                           ArrayRef<TemplateArgument> Args,
                                           QualType Underlying) const {
   assert(!Template.getAsDependentTemplateName() &&
          "No dependent template names here!");
   // Look through qualified template names.
   if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
-    Template = TemplateName(QTN->getTemplateDecl());
+    Template = QTN->getUnderlyingTemplate();
 
   bool IsTypeAlias =
-    Template.getAsTemplateDecl() &&
-    isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
+      isa_and_nonnull<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
   QualType CanonType;
   if (!Underlying.isNull())
     CanonType = getCanonicalType(Underlying);
   else {
     // We can get here with an alias template when the specialization contains
     // a pack expansion that does not match up with a parameter pack.
     assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&
            "Caller must compute aliased type");

 
 QualType ASTContext::getCanonicalTemplateSpecializationType(
     TemplateName Template, ArrayRef<TemplateArgument> Args) const {
   assert(!Template.getAsDependentTemplateName() &&
          "No dependent template names here!");
 
   // Look through qualified template names.
   if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
-    Template = TemplateName(QTN->getTemplateDecl());
+    Template = TemplateName(QTN->getUnderlyingTemplate());
 
   // Build the canonical template specialization type.
   TemplateName CanonTemplate = getCanonicalTemplateName(Template);
   SmallVector<TemplateArgument, 4> CanonArgs;
   ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
 
   // Determine whether this canonical template specialization type already
   // exists.

 /// assumed to name a template for ADL purposes.
 TemplateName ASTContext::getAssumedTemplateName(DeclarationName Name) const {
   auto *OT = new (*this) AssumedTemplateStorage(Name);
   return TemplateName(OT);
 }
 
 /// Retrieve the template name that represents a qualified
 /// template name such as \c std::vector.
-TemplateName
-ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
+TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
                                                   bool TemplateKeyword,
-                                     TemplateDecl *Template) const {
+                                                  TemplateName Template) const {
   assert(NNS && "Missing nested-name-specifier in qualified template name");
 
   // FIXME: Canonicalization?
   llvm::FoldingSetNodeID ID;
   QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
 
   void *InsertPos = nullptr;
   QualifiedTemplateName *QTN =

clang/lib/AST/ASTImporter.cpp

case TemplateName::AssumedTemplate: {
     return ToContext.getAssumedTemplateName(*DeclNameOrErr);
   }
 
   case TemplateName::QualifiedTemplate: {
     QualifiedTemplateName *QTN = From.getAsQualifiedTemplateName();
     auto QualifierOrErr = Import(QTN->getQualifier());
     if (!QualifierOrErr)
       return QualifierOrErr.takeError();
-
-    if (ExpectedDecl ToTemplateOrErr = Import(From.getAsTemplateDecl()))
-      return ToContext.getQualifiedTemplateName(
-          *QualifierOrErr, QTN->hasTemplateKeyword(),
-          cast<TemplateDecl>(*ToTemplateOrErr));
-    else
-      return ToTemplateOrErr.takeError();
+    auto TNOrErr = Import(QTN->getUnderlyingTemplate());
+    if (!TNOrErr)
+      return TNOrErr.takeError();
+        *QualifierOrErr, QTN->hasTemplateKeyword(), *TNOrErr);
   }
 
   case TemplateName::DependentTemplate: {
     DependentTemplateName *DTN = From.getAsDependentTemplateName();
     auto QualifierOrErr = Import(DTN->getQualifier());
     if (!QualifierOrErr)
       return QualifierOrErr.takeError();
 

clang/lib/AST/QualTypeNames.cpp

if (QTName && !QTName->hasTemplateKeyword()) {
     } else {
       NNS = nullptr;
     }
   } else {
     NNS = createNestedNameSpecifierForScopeOf(
         Ctx, ArgTDecl, true, WithGlobalNsPrefix);
   }
   if (NNS) {
-    TName = Ctx.getQualifiedTemplateName(NNS,
-                                         /*TemplateKeyword=*/false, ArgTDecl);
+    TemplateName UnderlyingTN(ArgTDecl);
+    if (UsingShadowDecl *USD = TName.getAsUsingShadowDecl())
+      UnderlyingTN = TemplateName(USD);
+    TName =
+        Ctx.getQualifiedTemplateName(NNS,
+                                     /*TemplateKeyword=*/false, UnderlyingTN);
     Changed = true;
   }
   return Changed;
 }
 
 static bool getFullyQualifiedTemplateArgument(const ASTContext &Ctx,
                                               TemplateArgument &Arg,
                                               bool WithGlobalNsPrefix) {

clang/lib/Sema/SemaDecl.cpp

if (Result.end() - Result.begin() > 1) {
       auto *TD = cast<TemplateDecl>(getAsTemplateNameDecl(
           *Result.begin(), /*AllowFunctionTemplates=*/true,
           /*AllowDependent=*/false));
       IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
       IsVarTemplate = isa<VarTemplateDecl>(TD);
 
       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 {
-        assert(!FoundUsingShadow ||
-               TD == cast<TemplateDecl>(FoundUsingShadow->getTargetDecl()));
-        Template = FoundUsingShadow ? TemplateName(FoundUsingShadow)
-                                    : TemplateName(TD);
-      }
+      Template =
+          FoundUsingShadow ? TemplateName(FoundUsingShadow) : TemplateName(TD);
+      if (SS.isNotEmpty())
+        Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
+                                                    /*TemplateKeyword=*/false,
+                                                    Template);
     } 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/SemaTemplate.cpp

if (!D && ResultCount > 1) {
 
     if (isa<UnresolvedUsingValueDecl>(D)) {
       // We don't yet know whether this is a template-name or not.
       MemberOfUnknownSpecialization = true;
       return TNK_Non_template;
     }
 
     TemplateDecl *TD = cast<TemplateDecl>(D);
-
-    if (SS.isSet() && !SS.isInvalid()) {
-      NestedNameSpecifier *Qualifier = SS.getScopeRep();
-      // 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 (SS.isSet() && !SS.isInvalid()) {
+      NestedNameSpecifier *Qualifier = SS.getScopeRep();
+      Template = Context.getQualifiedTemplateName(Qualifier, hasTemplateKeyword,
+                                                  Template);
     }
 
     if (isa<FunctionTemplateDecl>(TD)) {
       TemplateKind = TNK_Function_template;
 
       // We'll do this lookup again later.
       R.suppressDiagnostics();
     } else {
if (auto ET = TL.getAs<ElaboratedTypeLoc>()) {
       SS.Adopt(ET.getQualifierLoc());
       TL = ET.getNamedTypeLoc();
     }
 
     if (auto DTST = TL.getAs<DeducedTemplateSpecializationTypeLoc>()) {
       TemplateName Name = DTST.getTypePtr()->getTemplateName();
       if (SS.isSet())
         Name = Context.getQualifiedTemplateName(SS.getScopeRep(),
                                                 /*HasTemplateKeyword*/ false,
-                                                Name.getAsTemplateDecl());
+                                                Name);
       ParsedTemplateArgument Result(SS, TemplateTy::make(Name),
                                     DTST.getTemplateNameLoc());
       if (EllipsisLoc.isValid())
         Result = Result.getTemplatePackExpansion(EllipsisLoc);
       return Result;
     }
   }
 

clang/lib/Sema/TreeTransform.h

 }
 
 template<typename Derived>
 TemplateName
 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                             bool TemplateKW,
                                             TemplateDecl *Template) {
   return SemaRef.Context.getQualifiedTemplateName(SS.getScopeRep(), TemplateKW,
-                                                  Template);
+                                                  TemplateName(Template));
 }
 
 template<typename Derived>
 TemplateName
 TreeTransform<Derived>::RebuildTemplateName(CXXScopeSpec &SS,
                                             SourceLocation TemplateKWLoc,
                                             const IdentifierInfo &Name,
                                             SourceLocation NameLoc,

clang/unittests/AST/TemplateNameTest.cpp

TEST(TemplateName, PrintUsingTemplate) {
   EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
                               TemplateName::Qualified::AsWritten),
             "vector");
   EXPECT_EQ(printTemplateName(TN, Ctx.getPrintingPolicy(),
                               TemplateName::Qualified::None),
             "vector");
 }
 
+TEST(TemplateName, QualifiedUsingTemplate) {
+  std::string Code = R"cpp(
+    namespace std {
+      template <typename> struct vector {};
+    }
+    namespace absl { using std::vector; }
+
+    template<template <typename> class T> class X;
+
+    using A = X<absl::vector>; // QualifiedTemplateName in a template argument.
+  )cpp";
+  auto AST = tooling::buildASTFromCode(Code);
+  // Match the template argument absl::vector in X<absl::vector>.
+  auto Matcher = templateArgumentLoc().bind("id");
+  auto MatchResults = match(Matcher, AST->getASTContext());
+  const auto *TAL = MatchResults.front().getNodeAs<TemplateArgumentLoc>("id");
+  ASSERT_TRUE(TAL);
+  TemplateName TN = TAL->getArgument().getAsTemplate();
+  EXPECT_EQ(TN.getKind(), TemplateName::QualifiedTemplate);
+  const auto *QTN = TN.getAsQualifiedTemplateName();
+  // Verify that we have the Using template name in the QualifiedTemplateName.
+  const auto *USD = QTN->getUnderlyingTemplate().getAsUsingShadowDecl();
+  EXPECT_TRUE(USD);
+  EXPECT_EQ(USD->getTargetDecl(), TN.getAsTemplateDecl());
+}
+
+TEST(TemplateName, UsingTemplate) {
+  auto AST = tooling::buildASTFromCode(R"cpp(
+    namespace std {
+      template <typename T> struct vector { vector(T); };
+    }
+    namespace absl { using std::vector; }
+    // The "absl::vector<int>" is an elaborated TemplateSpecializationType with
+    // an inner Using TemplateName (not a Qualified TemplateName, the qualifiers
+    // are rather part of the ElaboratedType)!
+    absl::vector<int> v(123);
+  )cpp");
+  auto Matcher = elaboratedTypeLoc(
+      hasNamedTypeLoc(loc(templateSpecializationType().bind("id"))));
+  auto MatchResults = match(Matcher, AST->getASTContext());
+  const auto *TST =
+      MatchResults.front().getNodeAs<TemplateSpecializationType>("id");
+  ASSERT_TRUE(TST);
+  EXPECT_EQ(TST->getTemplateName().getKind(), TemplateName::UsingTemplate);
+
+  AST = tooling::buildASTFromCodeWithArgs(R"cpp(
+    namespace std {
+      template <typename T> struct vector { vector(T); };
+    }
+    namespace absl { using std::vector; }
+    // Similiar to the TemplateSpecializationType, absl::vector is an elaborated
+    // DeducedTemplateSpecializationType with an inner Using TemplateName!
+    absl::vector DTST(123);
+    )cpp",
+                                          {"-std=c++17"});
+  Matcher = elaboratedTypeLoc(
+      hasNamedTypeLoc(loc(deducedTemplateSpecializationType().bind("id"))));
+  MatchResults = match(Matcher, AST->getASTContext());
+  const auto *DTST =
+      MatchResults.front().getNodeAs<DeducedTemplateSpecializationType>("id");
+  ASSERT_TRUE(DTST);
+  EXPECT_EQ(DTST->getTemplateName().getKind(), TemplateName::UsingTemplate);
+}
+
 } // namespace
 } // namespace clang