[AST] fully-qualify template args of outer types in getFullyQualifiedType

[victordk]

Summary

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().

[saugustine]

This is a long-standing bug that needed to be fixed. Thank you!

[victordk]

In D103039#2793776, @saugustine wrote:

This is a long-standing bug that needed to be fixed. Thank you!

Could you commit the patch? I don't think I have commit access.

[saugustine]

Committed as 3e55f55048387a8efef01e445d46fc5cf100285d.

Thanks again for the fix.

clang/lib/AST/QualTypeNames.cpp

return NestedNameSpecifier::Create(
       createOuterNNS(Ctx, Namespace, FullyQualified, WithGlobalNsPrefix),
       Namespace);
 }
 
 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
 /// versions of any template parameters.
 QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
                                bool WithGlobalNsPrefix) {
   // In case of myType* we need to strip the pointer first, fully
   // qualify and attach the pointer once again.

clang/unittests/Tooling/QualTypeNamesTest.cpp

TEST(QualTypeNameTest, getFullyQualifiedName) {
   // Anonymous Namespaces nested in named namespaces and vice-versa.
   Visitor.ExpectedQualTypeNames["CheckK"] = "D::aStruct";
   // Namespace alias
   Visitor.ExpectedQualTypeNames["CheckL"] = "A::B::C::MyInt";
   Visitor.ExpectedQualTypeNames["non_dependent_type_var"] =
       "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"
       "   namespace C {\n"
       "     typedef int MyInt;"
       "     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;"
       "   typedef B::Class0 AnotherClass;\n"
       "   void Function1(Template0<C::MyInt,\n"
       "                  AnotherClass> CheckC);\n"
       "   void Function2(Template0<Template1<C::MyInt, AnotherClass>,\n"
       "                            Template0<int, long> > CheckD);\n"
Visitor.runOver(
       "  var.dependent_type_var = 0;\n"
       "var.non_dependent_type_var = 0;\n"
       "}\n"
       "class EnumScopeClass {\n"
       "public:\n"
       "  enum AnEnum { ZERO, ONE };\n"
       "};\n"
       "EnumScopeClass::AnEnum AnEnumVar;\n",
-      TypeNameVisitor::Lang_CXX11
-);
+      TypeNameVisitor::Lang_CXX11);
 
   TypeNameVisitor Complex;
   Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";
   Complex.runOver(
       "namespace A {"
       "  struct X {};"
       "}"
       "using A::X;"