[WIP][lldb][DWARFASTParserClang] Support DW_AT_LLVM_preferred_name attribute

[Michael137]

• Add tests

[Michael137]

• Revert redundant change

[Michael137]

• Clean up patch

[Michael137]

• Update variable names in test

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

private:
   /// base classes with the base offset.
   void ParseInheritance(
       const DWARFDIE &die, const DWARFDIE &parent_die,
       const lldb_private::CompilerType class_clang_type,
       const lldb::AccessType default_accessibility,
       const lldb::ModuleSP &module_sp,
       std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
       lldb_private::ClangASTImporter::LayoutInfo &layout_info);
+
+  /// Add to 'record_decl' a 'clang::PreferredNameAttr' pointing to the type
+  /// represented by 'pref_die'.
+  void AttachPreferredNameAttr(DWARFDIE pref_die,
+                               clang::CXXRecordDecl *record_decl);
 };
 
 /// Parsed form of all attributes that are relevant for type reconstruction.
 /// Some attributes are relevant for all kinds of types (declaration), while
 /// others are only meaningful to a specific type (is_virtual)
 struct ParsedDWARFTypeAttributes {
   explicit ParsedDWARFTypeAttributes(const DWARFDIE &die);
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

dwarf->GetObjectFile()->GetModule()->ReportError(
         "attach the file at the start of this error message",
         die.GetOffset(), tag, DW_TAG_value_to_name(tag));
     break;
   }
 
   // TODO: We should consider making the switch above exhaustive to simplify
   // control flow in ParseTypeFromDWARF. Then, we could simply replace this
   // return statement with a call to llvm_unreachable.
-  return UpdateSymbolContextScopeForType(sc, die, type_sp);
+  auto parsed_type = UpdateSymbolContextScopeForType(sc, die, type_sp);
+
+  // Set clang::PreferredNameAttr on forward declaration in case LLDB
+  // wants to format a structure without having completed it.
+  if (DWARFDIE pref_name_die =
+          die.GetAttributeValueAsReferenceDIE(DW_AT_LLVM_preferred_name))
+    if (clang::CXXRecordDecl *record_decl =
+            m_ast.GetAsCXXRecordDecl(type_sp->GetForwardCompilerType().GetOpaqueQualType()))
+      AttachPreferredNameAttr(pref_name_die, record_decl);
+
+  return parsed_type;
 }
 
 lldb::TypeSP
 DWARFASTParserClang::ParseTypeModifier(const SymbolContext &sc,
                                        const DWARFDIE &die,
                                        ParsedDWARFTypeAttributes &attrs) {
   Log *log = GetLog(DWARFLog::TypeCompletion | DWARFLog::Lookups);
   SymbolFileDWARF *dwarf = die.GetDWARF();
if (dst_size_artificial) {
     for (idx = 0; idx < dst_size_artificial; ++idx) {
       failures.push_back(
           dst_name_to_die_artificial.GetValueAtIndexUnchecked(idx));
     }
   }
 
   return !failures.empty();
 }
+
+void DWARFASTParserClang::AttachPreferredNameAttr(
+    DWARFDIE pref_die, clang::CXXRecordDecl *record_decl) {
+  assert(record_decl != nullptr);
+
+  Type *lldb_type = pref_die.ResolveType();
+  if (!lldb_type)
+    return;
+
+  CompilerType pref_name = lldb_type->GetForwardCompilerType();
+  if (!pref_name)
+    return;
+
+  clang::QualType pref_name_type = ClangUtil::GetQualType(pref_name);
+  if (!pref_name_type.isNull())
+    record_decl->addAttr(clang::PreferredNameAttr::CreateImplicit(
+        m_ast.getASTContext(),
+        m_ast.getASTContext().getTrivialTypeSourceInfo(pref_name_type)));
+}

lldb/source/Symbol/Type.cpp

bool Type::WriteToMemory(ExecutionContext *exe_ctx, lldb::addr_t addr,
   return false;
 }
 
 const Declaration &Type::GetDeclaration() const { return m_decl; }
 
 bool Type::ResolveCompilerType(ResolveState compiler_type_resolve_state) {
   // TODO: This needs to consider the correct type system to use.
   Type *encoding_type = nullptr;
-  if (!m_compiler_type.IsValid()) {
+  if (!m_compiler_type.IsValid())
     encoding_type = GetEncodingType();
+
+  // Check m_compiler_type again in case
+  // GetEncodingType above resolved this
+  // type.
+  if (!m_compiler_type.IsValid()) {
     if (encoding_type) {
       switch (m_encoding_uid_type) {
       case eEncodingIsUID: {
         CompilerType encoding_compiler_type =
             encoding_type->GetForwardCompilerType();
         if (encoding_compiler_type.IsValid()) {
           m_compiler_type = encoding_compiler_type;
           m_compiler_type_resolve_state =

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/shared_ptr/TestDataFormatterLibcxxSharedPtr.py

def test_shared_ptr_variables(self):
             "sp_int_ref_ref",
             type="std::shared_ptr<int> &&",
             children=[ValueCheck(name="__ptr_")],
         )
         self.assertRegex(valobj.summary, r"^10( strong=1)? weak=1$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
-            string_type = "std::basic_string<char>"
+            string_type = "std::string"
         else:
-            string_type = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
+            string_type = "std::basic_string<char, std::char_traits<char>, std::allocator<char> > "
 
         valobj = self.expect_var_path(
             "sp_str",
-            type="std::shared_ptr<" + string_type + " >",
+            type="std::shared_ptr<" + string_type + ">",
             children=[ValueCheck(name="__ptr_", summary='"hello"')],
         )
         self.assertRegex(valobj.summary, r'^"hello"( strong=1)? weak=1$')
 
         valobj = self.expect_var_path("sp_user", type="std::shared_ptr<User>")
         self.assertRegex(
             valobj.summary,
             "^std(::__[^:]*)?::shared_ptr<User>::element_type @ 0x0*[1-9a-f][0-9a-f]+( strong=1)? weak=1",

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unique_ptr/TestDataFormatterLibcxxUniquePtr.py

def make_expected_type(self, pointee_type: str, qualifiers: str = "") -> str:
 
         if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             return f'std::unique_ptr<{pointee_type}>{qualifiers}'
         else:
             return f'std::unique_ptr<{pointee_type}, std::default_delete<{pointee_type}> >{qualifiers}'
 
     def make_expected_basic_string_ptr(self) -> str:
         if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
-            return f'std::unique_ptr<std::basic_string<char> >'
+            return f'std::unique_ptr<std::string>'
         else:
             return 'std::unique_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, ' \
                    'std::default_delete<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >'
 
     @add_test_categories(["libc++"])
     def test_unique_ptr_variables(self):
         """Test `frame variable` output for `std::unique_ptr` types."""
         self.build()

lldb/test/API/lang/cpp/preferred_name/Makefile

+CXX_SOURCES := main.cpp
+CXXFLAGS_EXTRAS := -std=c++20 -glldb
+include Makefile.rules

lldb/test/API/lang/cpp/preferred_name/TestPreferredName.py

+"""
+Test formatting of types annotated with
+[[clang::preferred_name]] attributes.
+"""
+
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import decorators
+
+
+class TestPreferredName(TestBase):
+
+    def test_frame_var(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "return", lldb.SBFileSpec("main.cpp"))
+
+        self.expect("frame variable barInt", substrs=["BarInt"])
+        self.expect("frame variable barDouble", substrs=["BarDouble"])
+        self.expect("frame variable barShort", substrs=["Bar<short>"])
+        self.expect("frame variable barChar", substrs=["Bar<char>"])
+
+        self.expect("frame variable varInt", substrs=["BarInt"])
+        self.expect("frame variable varDouble", substrs=["BarDouble"])
+        self.expect("frame variable varShort", substrs=["Bar<short>"])
+        self.expect("frame variable varChar", substrs=["Bar<char>"])
+
+    def test_expr(self):
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "return", lldb.SBFileSpec("main.cpp"))
+
+        self.expect_expr("barInt", result_type="BarInt")
+        self.expect_expr("barDouble", result_type="BarDouble")
+        self.expect_expr("barShort", result_type="Bar<short>")
+        self.expect_expr("barChar", result_type="Bar<char>")
+
+        self.expect_expr("varInt", result_type="BarInt")
+        self.expect_expr("varDouble", result_type="BarDouble")
+        self.expect_expr("varShort", result_type="Bar<short>")
+        self.expect_expr("varChar", result_type="Bar<char>")

lldb/test/API/lang/cpp/preferred_name/main.cpp

+template <typename T> struct Foo;
+
+typedef Foo<int> BarInt;
+typedef Foo<double> BarDouble;
+
+template <typename T> using Bar = Foo<T>;
+
+template <typename T>
+struct [[clang::preferred_name(BarInt), clang::preferred_name(BarDouble),
+         clang::preferred_name(Bar<short>), clang::preferred_name(Bar<short>),
+         clang::preferred_name(Bar<double>),
+         clang::preferred_name(Bar<char>)]] Foo{};
+
+int main() {
+  BarInt varInt;
+  BarDouble varDouble;
+  Bar<short> varShort;
+  Bar<char> varChar;
+
+  Foo<int> varInt;
+  Foo<double> varDouble;
+  Foo<short> varShort;
+  Foo<char> varChar;
+  return 0;
+}