DebugInfo: Render the canonical name of a class template specialization, even when nested in another class template specialization

[dblaikie]

Ping (just curious about the change to the canonicalization printing policy - making sure I don't break something important)

[dblaikie]

Ping

[dblaikie]

Some more ping (:

clang/lib/AST/TypePrinter.cpp

else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
 
     OS << (Policy.MSVCFormatting ? '\'' : ')');
   }
 
   // If this is a class template specialization, print the template
   // arguments.
   if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     ArrayRef<TemplateArgument> Args;
-    if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
+    TypeSourceInfo *TAW = Spec->getTypeAsWritten();
+    if (!Policy.PrintCanonicalTypes && TAW) {
       const TemplateSpecializationType *TST =
         cast<TemplateSpecializationType>(TAW->getType());
       Args = TST->template_arguments();
     } else {
       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
       Args = TemplateArgs.asArray();
     }
     IncludeStrongLifetimeRAII Strong(Policy);

clang/lib/CodeGen/CGDebugInfo.cpp

 StringRef CGDebugInfo::getSelectorName(Selector S) {
   return internString(S.getAsString());
 }
 
 StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
   if (isa<ClassTemplateSpecializationDecl>(RD)) {
     SmallString<128> Name;
     llvm::raw_svector_ostream OS(Name);
-    RD->getNameForDiagnostic(OS, getPrintingPolicy(),
+    PrintingPolicy PP = getPrintingPolicy();
+    PP.PrintCanonicalTypes = true;
+    RD->getNameForDiagnostic(OS, PP,
                              /*Qualified*/ false);
 
     // Copy this name on the side and use its reference.
     return internString(Name);
   }
 
   // quick optimization to avoid having to intern strings that are already
   // stored reliably elsewhere

clang/test/CodeGenCXX/debug-info-template-explicit-specialization.cpp

 // CHECK-NOT: DIFlagFwdDecl
 // CHECK-SAME: ){{$}}
 
 template <typename T1, typename T2 = T1>
 struct j {
 };
 extern template class j<int>;
 j<int> jj;
+template <typename T>
+struct j_wrap {
+};
+j_wrap<j<int>> j_wrap_j;
 // CHECK: DICompositeType(tag: DW_TAG_structure_type, name: "j<int, int>"
+// CHECK: DICompositeType(tag: DW_TAG_structure_type, name: "j_wrap<j<int, int> >"
 
 template <typename T>
 struct k {
 };
 template <>
 struct k<int>;
 template struct k<int>;
 // CHECK-NOT: !DICompositeType(tag: DW_TAG_structure_type, name: "k<int>"
 
 // CHECK: DICompositeType(tag: DW_TAG_structure_type, name: "b<int>"
 // CHECK-NOT: DIFlagFwdDecl
 // CHECK-SAME: ){{$}}