[lldb] Fix simple template names and template params with scope qualifiers

[aeubanks]

Summary

Followup to D134378.

With PrintingPolicy::SuppressScope, we'd also not print the scope in template params. The intention was only to skip the scope for the class because we expect template params to be fully qualified when comparing them for simple template names.

Instead, use NamedDecl::getNameForDiagnostic if we're dealing with a tag, which is what we actually use when emitting debug info in clang. That already has an option to suppress the scope on the base name.

[dblaikie]

@aaron.ballman does this seem OK? (this was based on my suggestion in the related review linked in the description)

It probably needs tests in clang too - not sure if there's an opportunity to use a unit test to simplify access to the printing policy & exercise this?

[aaron.ballman]

...we expect template params to be fully qualified when comparing them for simple template names

So lldb is not inspecting the AST, they're doing reflection (of a sort) on the pretty printed names? Or am I misunderstanding something?

clang/include/clang/AST/PrettyPrinter.h

134

I think this should be expressed in the positive rather than in the negative (SuppressTemplateParamScope) so it's consistent with the rest of the options.

[dblaikie]

In D137583#3917706, @aaron.ballman wrote:

...we expect template params to be fully qualified when comparing them for simple template names

So lldb is not inspecting the AST, they're doing reflection (of a sort) on the pretty printed names? Or am I misunderstanding something?

Not reflection as such - but building names for the user, but partly from the AST - basically LLDB wants to be able to produce the same name that CGDebugInfo produces - so, maybe it should produce it the same way as CGDebugInfo, which isn't to use the pretty printer from scratch.

@aeubanks would this work for lldb's use case? https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/CGDebugInfo.cpp#L5229 it'd be identical to the original debug info generation, and looks like it doesn't require a printing policy change/feature. Sorry I didn't think of that earlier. I guess since Qualified would be false for lldb's use case, you could go down into the implementation and just call the unqualified side directly: NamedDecl::printName(OS, Policy); should print it unqualified for this name, but respect the qualified printing policy flag for any nested names, parameters, etc.

[aaron.ballman]

In D137583#3917735, @dblaikie wrote:

In D137583#3917706, @aaron.ballman wrote:

...we expect template params to be fully qualified when comparing them for simple template names

So lldb is not inspecting the AST, they're doing reflection (of a sort) on the pretty printed names? Or am I misunderstanding something?

Not reflection as such - but building names for the user, but partly from the AST - basically LLDB wants to be able to produce the same name that CGDebugInfo produces - so, maybe it should produce it the same way as CGDebugInfo, which isn't to use the pretty printer from scratch.

Ah thank you for the clarification, that makes more sense to me.

@aeubanks would this work for lldb's use case? https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/CGDebugInfo.cpp#L5229 it'd be identical to the original debug info generation, and looks like it doesn't require a printing policy change/feature. Sorry I didn't think of that earlier. I guess since Qualified would be false for lldb's use case, you could go down into the implementation and just call the unqualified side directly: NamedDecl::printName(OS, Policy); should print it unqualified for this name, but respect the qualified printing policy flag for any nested names, parameters, etc.

I agree that it seems pretty sensible for the debugger to use the same mechanisms as debug info in terms of what names to display for users.

[aeubanks]

use getNameForDiagnostics

[aeubanks]

add comment

[aeubanks]

In D137583#3917735, @dblaikie wrote:

In D137583#3917706, @aaron.ballman wrote:

...we expect template params to be fully qualified when comparing them for simple template names

So lldb is not inspecting the AST, they're doing reflection (of a sort) on the pretty printed names? Or am I misunderstanding something?

Not reflection as such - but building names for the user, but partly from the AST - basically LLDB wants to be able to produce the same name that CGDebugInfo produces - so, maybe it should produce it the same way as CGDebugInfo, which isn't to use the pretty printer from scratch.

@aeubanks would this work for lldb's use case? https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/CGDebugInfo.cpp#L5229 it'd be identical to the original debug info generation, and looks like it doesn't require a printing policy change/feature. Sorry I didn't think of that earlier. I guess since Qualified would be false for lldb's use case, you could go down into the implementation and just call the unqualified side directly: NamedDecl::printName(OS, Policy); should print it unqualified for this name, but respect the qualified printing policy flag for any nested names, parameters, etc.

much better, thanks!

[dblaikie]

Awesome!

clang/include/clang/AST/PrettyPrinter.h

struct PrintingPolicy {
   /// \code
   /// typedef struct { int x, y; } Point;
   /// \endcode
   unsigned IncludeTagDefinition : 1;
 
   /// Suppresses printing of scope specifiers.
   unsigned SuppressScope : 1;
 
+  /// When SuppressScope is true, do not apply it to template parameters.
+  unsigned NoSuppressTemplateParamsScope : 1;
+
   /// Suppress printing parts of scope specifiers that are never
   /// written, e.g., for anonymous namespaces.
   unsigned SuppressUnwrittenScope : 1;
 
   /// Suppress printing parts of scope specifiers that correspond
   /// to inline namespaces, where the name is unambiguous with the specifier
   /// removed.
   unsigned SuppressInlineNamespace : 1;

clang/lib/AST/TypePrinter.cpp

public:
   }
 
   ~ElaboratedTypePolicyRAII() {
     Policy.SuppressTagKeyword = SuppressTagKeyword;
     Policy.SuppressScope = SuppressScope;
   }
 };
 
+class NoSuppressTemplateParamsScopeRAII {
+  PrintingPolicy &Policy;
+  bool OldSuppressScope;
+
+public:
+  explicit NoSuppressTemplateParamsScopeRAII(PrintingPolicy &Policy)
+      : Policy(Policy) {
+    OldSuppressScope = Policy.SuppressScope;
+    if (Policy.NoSuppressTemplateParamsScope)
+      Policy.SuppressScope = false;
+  }
+
+  ~NoSuppressTemplateParamsScopeRAII() {
+    Policy.SuppressScope = OldSuppressScope;
+  }
+};
+
 class TypePrinter {
   PrintingPolicy Policy;
   unsigned Indentation;
   bool HasEmptyPlaceHolder = false;
   bool InsideCCAttribute = false;
 
 public:
   explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0)
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)) {
+    NoSuppressTemplateParamsScopeRAII SuppressScopeRAII(Policy);
     ArrayRef<TemplateArgument> Args;
     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();

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type,
   // For a typedef just return the qualified name.
   if (const auto *typedef_type = qual_type->getAs<clang::TypedefType>()) {
     const clang::TypedefNameDecl *typedef_decl = typedef_type->getDecl();
     return ConstString(GetTypeNameForDecl(typedef_decl));
   }
 
   clang::PrintingPolicy printing_policy(GetTypePrintingPolicy());
   printing_policy.SuppressScope = BaseOnly;
+  printing_policy.NoSuppressTemplateParamsScope = BaseOnly;
   return ConstString(qual_type.getAsString(printing_policy));
 }
 
 ConstString
 TypeSystemClang::GetDisplayTypeName(lldb::opaque_compiler_type_t type) {
   if (!type)
     return ConstString();
 

lldb/test/API/lang/cpp/unique-types2/TestUniqueTypes.py

def do_test(self, debug_flags):
         self.expect("image lookup -A -t 'FooPack<float, int>'", DATA_TYPES_DISPLAYED_CORRECTLY, error=True)
 
         self.expect("image lookup -A -t '::Foo<int>::Nested<char>'", DATA_TYPES_DISPLAYED_CORRECTLY, substrs=["1 match found"])
         self.expect("image lookup -A -t 'Foo<int>::Nested<char>'", DATA_TYPES_DISPLAYED_CORRECTLY, substrs=["1 match found"])
         self.expect("image lookup -A -t 'Foo<char>::Nested<char>'", DATA_TYPES_DISPLAYED_CORRECTLY, error=True)
         self.expect("image lookup -A -t 'Foo<int>::Nested<int>'", DATA_TYPES_DISPLAYED_CORRECTLY, error=True)
         self.expect("image lookup -A -t 'Nested<char>'", DATA_TYPES_DISPLAYED_CORRECTLY, substrs=["1 match found"])
         self.expect("image lookup -A -t '::Nested<char>'", DATA_TYPES_DISPLAYED_CORRECTLY, error=True)
+        self.expect("image lookup -A -t 'Foo<int>::Nested<ns::Bar>'", DATA_TYPES_DISPLAYED_CORRECTLY, substrs=["1 match found"])
 
         self.expect_expr("t1", result_type="Foo<char>")
         self.expect_expr("t1", result_type="Foo<char>")
         self.expect_expr("t2", result_type="Foo<int>")
         self.expect_expr("t3", result_type="Foo<Foo<int> >")
         self.expect_expr("p1", result_type="FooPack<char>")
         self.expect_expr("p2", result_type="FooPack<int>")
         self.expect_expr("p3", result_type="FooPack<Foo<int> >")
         self.expect_expr("p4", result_type="FooPack<char, int>")
         self.expect_expr("p5", result_type="FooPack<char, float>")
         self.expect_expr("p6", result_type="FooPack<int, int>")
         self.expect_expr("p7", result_type="FooPack<int, int, int>")
         self.expect_expr("n1", result_type="Foo<int>::Nested<char>")
+        self.expect_expr("n2", result_type="Foo<int>::Nested<ns::Bar>")
 
     @skipIf(compiler=no_match("clang"))
     @skipIf(compiler_version=["<", "15.0"])
     def test_simple_template_names(self):
         self.do_test(dict(CFLAGS_EXTRAS="-gsimple-template-names"))
 
     @skipIf(compiler=no_match("clang"))
     @skipIf(compiler_version=["<", "15.0"])
     def test_no_simple_template_names(self):
         self.do_test(dict(CFLAGS_EXTRAS="-gno-simple-template-names"))

lldb/test/API/lang/cpp/unique-types2/main.cpp

+namespace ns {
+struct Bar {};
+} // namespace ns
+
 template <class T> struct Foo {
   T t;
   template <class U> class Nested {
     U u;
   };
 };
 
 template <class T, class... Ss> class FooPack {
int main() {
   FooPack<int> p2;
   FooPack<Foo<int>> p3;
   FooPack<char, int> p4;
   FooPack<char, float> p5;
   FooPack<int, int> p6;
   FooPack<int, int, int> p7;
 
   Foo<int>::Nested<char> n1;
+  Foo<int>::Nested<ns::Bar> n2;
   // Set breakpoint here
 }