[clang] 3e55f55 - Fully-qualify template args of outer types in getFullyQualifiedType

[Sterling Augustine via cfe-commits]

Author: Victor Kuznetsov
Date: 2021-06-03T10:50:00-07:00
New Revision: 3e55f55048387a8efef01e445d46fc5cf100285d

URL: https://github.com/llvm/llvm-project/commit/3e55f55048387a8efef01e445d46fc5cf100285d
DIFF: https://github.com/llvm/llvm-project/commit/3e55f55048387a8efef01e445d46fc5cf100285d.diff

LOG: Fully-qualify template args of outer types in getFullyQualifiedType

Template args of outer types were not fully-qualified when calling getFullyQualifiedType() for inner types.

For simplicity the patch is a copy-paste of the same call from getFullyQualifiedType().

Reviewed at: https://reviews.llvm.org/D103039

Added: 
    

Modified: 
    clang/lib/AST/QualTypeNames.cpp
    clang/unittests/Tooling/QualTypeNamesTest.cpp

Removed: 
    


################################################################################
diff  --git a/clang/lib/AST/QualTypeNames.cpp b/clang/lib/AST/QualTypeNames.cpp
index 73a33a208233b..9a1b418f5ac1b 100644
--- a/clang/lib/AST/QualTypeNames.cpp
+++ b/clang/lib/AST/QualTypeNames.cpp
@@ -356,11 +356,19 @@ NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,
                                                const TypeDecl *TD,
                                                bool FullyQualify,
                                                bool WithGlobalNsPrefix) {
+  const Type *TypePtr = TD->getTypeForDecl();
+  if (isa<const TemplateSpecializationType>(TypePtr) ||
+      isa<const RecordType>(TypePtr)) {
+    // We are asked to fully qualify and we have a Record Type (which
+    // may point to a template specialization) or Template
+    // Specialization Type. We need to fully qualify their arguments.
+
+    TypePtr = getFullyQualifiedTemplateType(Ctx, TypePtr, WithGlobalNsPrefix);
+  }
+
   return NestedNameSpecifier::Create(
-      Ctx,
-      createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix),
-      false /*No TemplateKeyword*/,
-      TD->getTypeForDecl());
+      Ctx, createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix),
+      false /*No TemplateKeyword*/, TypePtr);
 }
 
 /// Return the fully qualified type, including fully-qualified

diff  --git a/clang/unittests/Tooling/QualTypeNamesTest.cpp b/clang/unittests/Tooling/QualTypeNamesTest.cpp
index c820b61622856..8272edb28c219 100644
--- a/clang/unittests/Tooling/QualTypeNamesTest.cpp
+++ b/clang/unittests/Tooling/QualTypeNamesTest.cpp
@@ -93,12 +93,14 @@ TEST(QualTypeNameTest, getFullyQualifiedName) {
       "Foo<X>::non_dependent_type";
   Visitor.ExpectedQualTypeNames["AnEnumVar"] = "EnumScopeClass::AnEnum";
   Visitor.ExpectedQualTypeNames["AliasTypeVal"] = "A::B::C::InnerAlias<int>";
+  Visitor.ExpectedQualTypeNames["AliasInnerTypeVal"] =
+      "OuterTemplateClass<A::B::Class0>::Inner";
   Visitor.ExpectedQualTypeNames["CheckM"] = "const A::B::Class0 *";
   Visitor.ExpectedQualTypeNames["CheckN"] = "const X *";
   Visitor.runOver(
       "int CheckInt;\n"
       "template <typename T>\n"
-      "class OuterTemplateClass { };\n"
+      "class OuterTemplateClass { public: struct Inner {}; };\n"
       "namespace A {\n"
       " namespace B {\n"
       "   class Class0 { };\n"
@@ -107,6 +109,7 @@ TEST(QualTypeNameTest, getFullyQualifiedName) {
       "     template <typename T>\n"
       "     using InnerAlias = OuterTemplateClass<T>;\n"
       "     InnerAlias<int> AliasTypeVal;\n"
+      "     InnerAlias<Class0>::Inner AliasInnerTypeVal;\n"
       "   }\n"
       "   template<class X, class Y> class Template0;"
       "   template<class X, class Y> class Template1;"
@@ -165,8 +168,7 @@ TEST(QualTypeNameTest, getFullyQualifiedName) {
       "  enum AnEnum { ZERO, ONE };\n"
       "};\n"
       "EnumScopeClass::AnEnum AnEnumVar;\n",
-      TypeNameVisitor::Lang_CXX11
-);
+      TypeNameVisitor::Lang_CXX11);
 
   TypeNameVisitor Complex;
   Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";