[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

struct ParsedDWARFTypeAttributes {
   size_t calling_convention = llvm::dwarf::DW_CC_normal;
   uint32_t bit_stride = 0;
   uint32_t byte_stride = 0;
   uint32_t encoding = 0;
   clang::RefQualifierKind ref_qual =
       clang::RQ_None; ///< Indicates ref-qualifier of
                       ///< C++ member function if present.
                       ///< Is RQ_None otherwise.
+  DWARFFormValue preferred_name;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H

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

case DW_AT_export_symbols:
       exports_symbols = form_value.Boolean();
       break;
     case DW_AT_rvalue_reference:
       ref_qual = clang::RQ_RValue;
       break;
     case DW_AT_reference:
       ref_qual = clang::RQ_LValue;
       break;
+
+    // TODO: Could check this in ParseStructureLikeDIE since it's specific
+    // to DW_TAG_structure_type
+    case DW_AT_LLVM_preferred_name:
+      preferred_name = form_value;
+      break;
     }
   }
 }
 
 static std::string GetUnitName(const DWARFDIE &die) {
   if (DWARFUnit *unit = die.GetCU())
     return unit->GetAbsolutePath().GetPath();
   return "<missing DWARF unit path>";
if (layout_info.bit_size == 0)
           die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;
 
     clang::CXXRecordDecl *record_decl =
         m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
     if (record_decl)
       GetClangASTImporter().SetRecordLayout(record_decl, layout_info);
   }
 
+  // TODO: only gets resolved after second call to 'v'.
+  // TODO: doesn't work for 'p'.
+  //
+  // Need to set preferred name here since the type that
+  // the typedef links back to is probably in the process
+  // of being created.
+  ParsedDWARFTypeAttributes attrs(die);
+  if (attrs.preferred_name.IsValid()) {
+    Type *lldb_type = die.ResolveTypeUID(attrs.preferred_name.Reference());
+    if (lldb_type) {
+      CompilerType pref_name = lldb_type->GetFullCompilerType();
+
+      clang::CXXRecordDecl *record_decl =
+          m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
+      if (record_decl && pref_name.IsValid()) {
+        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)));
+      }
+    }
+  }
+
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteEnumType(const DWARFDIE &die,
                                            lldb_private::Type *type,
                                            CompilerType &clang_type) {
   if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {

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

TypeSystemClang::CreateClassTemplateSpecializationDecl(
   class_template_specialization_decl->setDeclContext(decl_ctx);
   class_template_specialization_decl->setInstantiationOf(class_template_decl);
   class_template_specialization_decl->setTemplateArgs(
       TemplateArgumentList::CreateCopy(ast, args));
   ast.getTypeDeclType(class_template_specialization_decl, nullptr);
   class_template_specialization_decl->setDeclName(
       class_template_decl->getDeclName());
   SetOwningModule(class_template_specialization_decl, owning_module);
+
   decl_ctx->addDecl(class_template_specialization_decl);
 
   class_template_specialization_decl->setSpecializationKind(
       TSK_ExplicitSpecialization);
 
   return class_template_specialization_decl;
 }
 
ConstString TypeSystemClang::GetTypeName(lldb::opaque_compiler_type_t type,
   // act as their own types from the user's perspective (e.g., formatter
   // shouldn't format a variable differently depending on how the ser has
   // specified the type. '::Type' and 'Type' should behave the same).
   // Typedefs and atomic derived types are not removed as they are actually
   // useful for identifiying specific types.
   qual_type = RemoveWrappingTypes(qual_type,
                                   {clang::Type::Typedef, clang::Type::Atomic});
 
+  GetCompleteQualType(&getASTContext(), qual_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));
   }
 
   // For consistency, this follows the same code path that clang uses to emit
   // debug info. This also handles when we don't want any scopes preceding the