[lldb] Remove lldb's own ASTDumper

[teemperor]

Summary

LLDB's ASTDumper is just a clone of Clang's ASTDumper but with some scary code and
some unrelated functionality (like dumping name/attributes of types). This removes LLDB's ASTDumper
and replaces its uses with the ClangUtils::DumpDecl method that just calls Clang's ASTDumper
and returns the result as a string.

The few uses where we just want a textual representation of a type (which will print their name/attributes but not
dump any AST) are now also in ClangUtil under a ToString name until we find a better home for them.

[labath]

Yay

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

1675

drop .c_str()

1709

drop .GetCString()

1762

drop .c_str()

[teemperor]

• Address feedback (Thanks Pavel)

[shafik]

Yeah, there was indeed some ugly code there, nice work!

lldb/include/lldb/Symbol/ClangUtil.h

 //===-- ClangUtil.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // A collection of helper methods and data structures for manipulating clang
 // types and decls.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_CLANGUTIL_H
 #define LLDB_SYMBOL_CLANGUTIL_H
 
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/Type.h"
 
 #include "lldb/Symbol/CompilerType.h"
 
 namespace clang {
 class TagDecl;
 }
 
 namespace lldb_private {
 struct ClangUtil {
   static bool IsClangType(const CompilerType &ct);
 
   static clang::QualType GetQualType(const CompilerType &ct);
 
   static clang::QualType GetCanonicalQualType(const CompilerType &ct);
 
   static CompilerType RemoveFastQualifiers(const CompilerType &ct);
 
   static clang::TagDecl *GetAsTagDecl(const CompilerType &type);
+
+  /// Returns a textual representation of the given Decl's AST. Does not
+  /// deserialize any child nodes.
+  static std::string DumpDecl(const clang::Decl *d);
+  /// Returns a textual representation of the given type.
+  static std::string ToString(const clang::Type *t);
+  /// Returns a textual representation of the given CompilerType (assuming
+  /// its underlying type is a Clang type).
+  static std::string ToString(const CompilerType &c);
 };
 }
 
 #endif

lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.h

-//===-- ASTDumper.h ---------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_ASTDumper_h_
-#define liblldb_ASTDumper_h_
-
-#include "clang/AST/DeclVisitor.h"
-#include "clang/AST/TypeVisitor.h"
-
-#include "lldb/Utility/Stream.h"
-#include "llvm/ADT/DenseSet.h"
-
-namespace lldb_private {
-
-class ASTDumper {
-public:
-  ASTDumper(clang::Decl *decl);
-  ASTDumper(clang::DeclContext *decl_ctx);
-  ASTDumper(const clang::Type *type);
-  ASTDumper(clang::QualType type);
-  ASTDumper(lldb::opaque_compiler_type_t type);
-  ASTDumper(const CompilerType &compiler_type);
-
-  const char *GetCString();
-  void ToSTDERR();
-  void ToLog(Log *log, const char *prefix);
-  void ToStream(lldb::StreamSP &stream);
-
-private:
-  std::string m_dump;
-};
-
-} // namespace lldb_private
-
-#endif

lldb/source/Plugins/ExpressionParser/Clang/ASTDumper.cpp

-//===-- ASTDumper.cpp -------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "ASTDumper.h"
-
-#include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Symbol/ClangUtil.h"
-#include "lldb/Symbol/CompilerType.h"
-#include "lldb/Utility/Log.h"
-
-#include "llvm/Support/raw_ostream.h"
-
-using namespace lldb_private;
-
-ASTDumper::ASTDumper(clang::Decl *decl) {
-  clang::DeclContext *decl_ctx = llvm::dyn_cast<clang::DeclContext>(decl);
-
-  bool has_external_lexical_storage;
-  bool has_external_visible_storage;
-
-  if (decl_ctx) {
-    has_external_lexical_storage = decl_ctx->hasExternalLexicalStorage();
-    has_external_visible_storage = decl_ctx->hasExternalVisibleStorage();
-    decl_ctx->setHasExternalLexicalStorage(false);
-    decl_ctx->setHasExternalVisibleStorage(false);
-  }
-
-  llvm::raw_string_ostream os(m_dump);
-  decl->print(os);
-  os.flush();
-
-  if (decl_ctx) {
-    decl_ctx->setHasExternalLexicalStorage(has_external_lexical_storage);
-    decl_ctx->setHasExternalVisibleStorage(has_external_visible_storage);
-  }
-}
-
-ASTDumper::ASTDumper(clang::DeclContext *decl_ctx) {
-  bool has_external_lexical_storage = decl_ctx->hasExternalLexicalStorage();
-  bool has_external_visible_storage = decl_ctx->hasExternalVisibleStorage();
-
-  decl_ctx->setHasExternalLexicalStorage(false);
-  decl_ctx->setHasExternalVisibleStorage(false);
-
-  if (clang::Decl *decl = llvm::dyn_cast<clang::Decl>(decl_ctx)) {
-    llvm::raw_string_ostream os(m_dump);
-    decl->print(os);
-    os.flush();
-  } else {
-    m_dump.assign("<DeclContext is not a Decl>");
-  }
-
-  decl_ctx->setHasExternalLexicalStorage(has_external_lexical_storage);
-  decl_ctx->setHasExternalVisibleStorage(has_external_visible_storage);
-}
-
-ASTDumper::ASTDumper(const clang::Type *type) {
-  m_dump = clang::QualType(type, 0).getAsString();
-}
-
-ASTDumper::ASTDumper(clang::QualType type) { m_dump = type.getAsString(); }
-
-ASTDumper::ASTDumper(lldb::opaque_compiler_type_t type) {
-  m_dump = clang::QualType::getFromOpaquePtr(type).getAsString();
-}
-
-ASTDumper::ASTDumper(const CompilerType &compiler_type) {
-  m_dump = ClangUtil::GetQualType(compiler_type).getAsString();
-}
-
-const char *ASTDumper::GetCString() { return m_dump.c_str(); }
-
-void ASTDumper::ToLog(Log *log, const char *prefix) {
-  size_t len = m_dump.length() + 1;
-
-  char *alloc = (char *)malloc(len);
-  char *str = alloc;
-
-  memcpy(str, m_dump.c_str(), len);
-
-  char *end = nullptr;
-
-  end = strchr(str, '\n');
-
-  while (end) {
-    *end = '\0';
-
-    LLDB_LOGF(log, "%s%s", prefix, str);
-
-    *end = '\n';
-
-    str = end + 1;
-    end = strchr(str, '\n');
-  }
-
-  LLDB_LOGF(log, "%s%s", prefix, str);
-
-  free(alloc);
-}

lldb/source/Plugins/ExpressionParser/Clang/CMakeLists.txt

 if(NOT LLDB_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lldb_library(lldbPluginExpressionParserClang PLUGIN
-  ASTDumper.cpp
   ASTResultSynthesizer.cpp
   ASTStructExtractor.cpp
   ASTUtils.cpp
   ClangASTSource.cpp
   ClangDeclVendor.cpp
   ClangExpressionDeclMap.cpp
   ClangExpressionParser.cpp
   ClangExpressionSourceCode.cpp

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

 //===-- ClangASTSource.cpp ---------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangASTSource.h"
 
-#include "ASTDumper.h"
 #include "ClangDeclVendor.h"
 #include "ClangModulesDeclVendor.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
void ClangASTSource::CompleteType(TagDecl *tag_decl) {
 
   if (log) {
     LLDB_LOGF(log,
               "    CompleteTagDecl[%u] on (ASTContext*)%p Completing "
               "(TagDecl*)%p named %s",
               current_id, static_cast<void *>(m_ast_context),
               static_cast<void *>(tag_decl), tag_decl->getName().str().c_str());
 
-    LLDB_LOGF(log, "      CTD[%u] Before:", current_id);
-    ASTDumper dumper((Decl *)tag_decl);
-    dumper.ToLog(log, "      [CTD] ");
+    LLDB_LOG(log, "      CTD[%u] Before:\n{0}", current_id,
+             ClangUtil::DumpDecl(tag_decl));
   }
 
   auto iter = m_active_lexical_decls.find(tag_decl);
   if (iter != m_active_lexical_decls.end())
     return;
   m_active_lexical_decls.insert(tag_decl);
   ScopedLexicalDeclEraser eraser(m_active_lexical_decls, tag_decl);
 
if (const NamespaceDecl *namespace_context =
 
         if (m_ast_importer_sp->CompleteTagDeclWithOrigin(tag_decl,
                                                          candidate_tag_decl))
           found = true;
       }
     }
   }
 
-  if (log) {
-    LLDB_LOGF(log, "      [CTD] After:");
-    ASTDumper dumper((Decl *)tag_decl);
-    dumper.ToLog(log, "      [CTD] ");
-  }
+  LLDB_LOG(log, "      [CTD] After:\n{0}", ClangUtil::DumpDecl(tag_decl));
 }
 
 void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  if (log) {
-    LLDB_LOGF(log,
-              "    [CompleteObjCInterfaceDecl] on (ASTContext*)%p Completing "
-              "an ObjCInterfaceDecl named %s",
-              static_cast<void *>(m_ast_context),
-              interface_decl->getName().str().c_str());
-    LLDB_LOGF(log, "      [COID] Before:");
-    ASTDumper dumper((Decl *)interface_decl);
-    dumper.ToLog(log, "      [COID] ");
-  }
+  LLDB_LOG(log, "      [COID] Before:\n{0}",
+           ClangUtil::DumpDecl(interface_decl));
 
   if (!m_ast_importer_sp) {
     if (HasMerger()) {
       ObjCInterfaceDecl *complete_iface_decl =
         GetCompleteObjCInterface(interface_decl);
 
       if (complete_iface_decl && (complete_iface_decl != interface_decl)) {
         m_merger_up->ForceRecordOrigin(interface_decl, {complete_iface_decl, &complete_iface_decl->getASTContext()});
void ClangASTSource::CompleteType(clang::ObjCInterfaceDecl *interface_decl) {
   m_ast_importer_sp->CompleteObjCInterfaceDecl(interface_decl);
 
   if (interface_decl->getSuperClass() &&
       interface_decl->getSuperClass() != interface_decl)
     CompleteType(interface_decl->getSuperClass());
 
   if (log) {
     LLDB_LOGF(log, "      [COID] After:");
-    ASTDumper dumper((Decl *)interface_decl);
-    dumper.ToLog(log, "      [COID] ");
+    LLDB_LOG(log, "      [COID] {0}", ClangUtil::DumpDecl(interface_decl));
   }
 }
 
 clang::ObjCInterfaceDecl *ClangASTSource::GetCompleteObjCInterface(
     const clang::ObjCInterfaceDecl *interface_decl) {
   lldb::ProcessSP process(m_target->GetProcessSP());
 
   if (!process)
void ClangASTSource::FindExternalLexicalDecls(
 
   Decl *original_decl = nullptr;
   ASTContext *original_ctx = nullptr;
 
   if (!m_ast_importer_sp->ResolveDeclOrigin(context_decl, &original_decl,
                                             &original_ctx))
     return;
 
-  if (log) {
-    LLDB_LOGF(
-        log, "  FELD[%u] Original decl (ASTContext*)%p (Decl*)%p:", current_id,
-        static_cast<void *>(original_ctx), static_cast<void *>(original_decl));
-    ASTDumper(original_decl).ToLog(log, "    ");
-  }
+  LLDB_LOG(
+      log, "  FELD[{0}] Original decl (ASTContext*){1:x} (Decl*){2:x}:\n{3}",
+      current_id, static_cast<void *>(original_ctx),
+      static_cast<void *>(original_decl), ClangUtil::DumpDecl(original_decl));
 
   if (ObjCInterfaceDecl *original_iface_decl =
           dyn_cast<ObjCInterfaceDecl>(original_decl)) {
     ObjCInterfaceDecl *complete_iface_decl =
         GetCompleteObjCInterface(original_iface_decl);
 
     if (complete_iface_decl && (complete_iface_decl != original_iface_decl)) {
       original_decl = complete_iface_decl;
for (TagDecl::decl_iterator iter = original_decl_context->decls_begin();
        iter != original_decl_context->decls_end(); ++iter) {
     Decl *decl = *iter;
 
     // The predicate function returns true if the passed declaration kind is
     // the one we are looking for.
     // See clang::ExternalASTSource::FindExternalLexicalDecls()
     if (predicate(decl->getKind())) {
       if (log) {
-        ASTDumper ast_dumper(decl);
+        std::string ast_dump = ClangUtil::DumpDecl(decl);
         if (const NamedDecl *context_named_decl =
                 dyn_cast<NamedDecl>(context_decl))
           LLDB_LOGF(log, "  FELD[%d] Adding [to %sDecl %s] lexical %sDecl %s",
                     current_id, context_named_decl->getDeclKindName(),
                     context_named_decl->getNameAsString().c_str(),
-                    decl->getDeclKindName(), ast_dumper.GetCString());
+                    decl->getDeclKindName(), ast_dump.c_str());
         else
           LLDB_LOGF(log, "  FELD[%d] Adding lexical %sDecl %s", current_id,
-                    decl->getDeclKindName(), ast_dumper.GetCString());
+                    decl->getDeclKindName(), ast_dump.c_str());
       }
 
       Decl *copied_decl = CopyDecl(decl);
 
       if (!copied_decl)
         continue;
 
       if (FieldDecl *copied_field = dyn_cast<FieldDecl>(copied_decl)) {
for (NamedDecl *named_decl : methods) {
 
     ObjCMethodDecl *copied_method_decl = dyn_cast<ObjCMethodDecl>(copied_decl);
 
     if (!copied_method_decl)
       continue;
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-    if (log) {
-      ASTDumper dumper((Decl *)copied_method_decl);
-      LLDB_LOGF(log, "  CAS::FOMD[%d] found (%s) %s", current_id, log_info,
-                dumper.GetCString());
-    }
+    LLDB_LOG(log, "  CAS::FOMD[{0}] found ({1}) {2}", current_id, log_info,
+             ClangUtil::DumpDecl(copied_method_decl));
 
     context.AddNamedDecl(copied_method_decl);
   }
 
   return true;
 }
 
 void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) {
for (uint32_t i = 0, e = sc_list.GetSize(); i != e; ++i) {
           continue;
 
         ObjCMethodDecl *copied_method_decl =
             dyn_cast<ObjCMethodDecl>(copied_decl);
 
         if (!copied_method_decl)
           continue;
 
-        if (log) {
-          ASTDumper dumper((Decl *)copied_method_decl);
-          LLDB_LOGF(log, "  CAS::FOMD[%d] found (in symbols) %s", current_id,
-                    dumper.GetCString());
-        }
+        LLDB_LOG(log, "  CAS::FOMD[{0}] found (in symbols)\n{1}", current_id,
+                 ClangUtil::DumpDecl(copied_method_decl));
 
         context.AddNamedDecl(copied_method_decl);
       }
     }
 
     return;
   }
 
DeclFromUser<ObjCPropertyDecl> origin_property_decl(
           &name_identifier, ObjCPropertyQueryKind::OBJC_PR_query_instance));
 
   bool found = false;
 
   if (origin_property_decl.IsValid()) {
     DeclFromParser<ObjCPropertyDecl> parser_property_decl(
         origin_property_decl.Import(source));
     if (parser_property_decl.IsValid()) {
-      if (log) {
-        ASTDumper dumper((Decl *)parser_property_decl.decl);
-        LLDB_LOGF(log, "  CAS::FOPD[%d] found %s", current_id,
-                  dumper.GetCString());
-      }
+      LLDB_LOG(log, "  CAS::FOPD[{0}] found\n{1}", current_id,
+               ClangUtil::DumpDecl(parser_property_decl.decl));
 
       context.AddNamedDecl(parser_property_decl.decl);
       found = true;
     }
   }
 
   DeclFromUser<ObjCIvarDecl> origin_ivar_decl(
       origin_iface_decl->getIvarDecl(&name_identifier));
 
   if (origin_ivar_decl.IsValid()) {
     DeclFromParser<ObjCIvarDecl> parser_ivar_decl(
         origin_ivar_decl.Import(source));
     if (parser_ivar_decl.IsValid()) {
       if (log) {
-        ASTDumper dumper((Decl *)parser_ivar_decl.decl);
-        LLDB_LOGF(log, "  CAS::FOPD[%d] found %s", current_id,
-                  dumper.GetCString());
+        LLDB_LOG(log, "  CAS::FOPD[{0}] found\n{1}", current_id,
+                 ClangUtil::DumpDecl(parser_ivar_decl.decl));
       }
 
       context.AddNamedDecl(parser_ivar_decl.decl);
       found = true;
     }
   }
 
   return found;

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

 //===-- ClangExpressionDeclMap.cpp -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangExpressionDeclMap.h"
 
-#include "ASTDumper.h"
 #include "ClangASTSource.h"
 #include "ClangModulesDeclVendor.h"
 #include "ClangPersistentVariables.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/Materializer.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
if (method_decl) {
     clang::CXXRecordDecl *class_decl = method_decl->getParent();
 
     QualType class_qual_type(class_decl->getTypeForDecl(), 0);
 
     TypeFromUser class_user_type(
         class_qual_type.getAsOpaquePtr(),
         ClangASTContext::GetASTContext(&class_decl->getASTContext()));
 
-    if (log) {
-      ASTDumper ast_dumper(class_qual_type);
-      LLDB_LOGF(log, "  CEDM::FEVD[%u] Adding type for $__lldb_class: %s",
-                current_id, ast_dumper.GetCString());
-    }
+    LLDB_LOG(log, "  CEDM::FEVD[{0}] Adding type for $__lldb_class: {1}",
+             current_id, class_qual_type.getAsString());
 
     AddThisType(context, class_user_type, current_id);
 
     if (method_decl->isInstance()) {
       // self is a pointer to the object
 
       QualType class_pointer_type =
           method_decl->getASTContext().getPointerType(class_qual_type);
if (this_var && this_var->IsInScope(frame) &&
     Type *this_type = this_var->GetType();
 
     if (!this_type)
       return;
 
     TypeFromUser pointee_type =
         this_type->GetForwardCompilerType().GetPointeeType();
 
-    if (pointee_type.IsValid()) {
-      if (log) {
-        ASTDumper ast_dumper(pointee_type);
-        LLDB_LOGF(log, "  FEVD[%u] Adding type for $__lldb_class: %s",
-                  current_id, ast_dumper.GetCString());
-      }
+    LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_class: {1}", current_id,
+             ClangUtil::GetQualType(pointee_type).getAsString());
 
-      AddThisType(context, pointee_type, current_id);
-      TypeFromUser this_user_type(this_type->GetFullCompilerType());
-      m_struct_vars->m_object_pointer_type = this_user_type;
-    }
-  }
-}
 
 void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context,
                                                  unsigned int current_id) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
 
   if (m_ctx_obj) {
if (method_decl) {
     if (!interface_type)
       return; // This is unlikely, but we have seen crashes where this
               // occurred
 
     TypeFromUser class_user_type(
         QualType(interface_type, 0).getAsOpaquePtr(),
         ClangASTContext::GetASTContext(&method_decl->getASTContext()));
 
-    if (log) {
-      ASTDumper ast_dumper(interface_type);
-      LLDB_LOGF(log, "  FEVD[%u] Adding type for $__lldb_objc_class: %s",
-                current_id, ast_dumper.GetCString());
-    }
+    LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
+             current_id, ClangUtil::ToString(interface_type));
 
     AddOneType(context, class_user_type, current_id);
 
     if (method_decl->isInstanceMethod()) {
       // self is a pointer to the object
 
       QualType class_pointer_type =
           method_decl->getASTContext().getObjCObjectPointerType(
void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context,
   }
   if (!ClangASTContext::IsObjCObjectPointerType(self_clang_type))
     return;
   self_clang_type = self_clang_type.GetPointeeType();
 
   if (!self_clang_type)
     return;
 
-  if (log) {
-    ASTDumper ast_dumper(self_type->GetFullCompilerType());
-    LLDB_LOGF(log, "  FEVD[%u] Adding type for $__lldb_objc_class: %s",
-              current_id, ast_dumper.GetCString());
-  }
+  LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
+           current_id, ClangUtil::ToString(self_type->GetFullCompilerType()));
 
   TypeFromUser class_user_type(self_clang_type);
 
   AddOneType(context, class_user_type, current_id);
 
   TypeFromUser self_user_type(self_type->GetFullCompilerType());
 
   m_struct_vars->m_object_pointer_type = self_user_type;
void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_value = var_location;
   parser_vars->m_lldb_var = var;
 
   if (is_reference)
     entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
 
-  if (log) {
-    ASTDumper orig_dumper(ut.GetOpaqueQualType());
-    ASTDumper ast_dumper(var_decl);
-    LLDB_LOGF(log,
-              "  CEDM::FEVD[%u] Found variable %s, returned %s (original %s)",
-              current_id, decl_name.c_str(), ast_dumper.GetCString(),
-              orig_dumper.GetCString());
-  }
+  LLDB_LOG(log,
+           "  CEDM::FEVD[{0}] Found variable {1}, returned\n{2} (original {3})",
+           current_id, decl_name, ClangUtil::DumpDecl(var_decl),
+           ClangUtil::ToString(ut));
 }
 
 void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
                                             ExpressionVariableSP &pvar_sp,
                                             unsigned int current_id) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   TypeFromUser user_type(
void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
   ClangExpressionVariable::ParserVars *parser_vars =
       llvm::cast<ClangExpressionVariable>(pvar_sp.get())
           ->GetParserVars(GetParserID());
   parser_vars->m_parser_type = parser_type;
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_value.Clear();
 
-  if (log) {
-    ASTDumper ast_dumper(var_decl);
-    LLDB_LOGF(log, "  CEDM::FEVD[%u] Added pvar %s, returned %s", current_id,
-              pvar_sp->GetName().GetCString(), ast_dumper.GetCString());
-  }
+  LLDB_LOG(log, "  CEDM::FEVD[{0}] Added pvar {1}, returned\n{2}", current_id,
+           pvar_sp->GetName(), ClangUtil::DumpDecl(var_decl));
 }
 
 void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
                                                    const Symbol &symbol,
                                                    unsigned int current_id) {
   assert(m_parser_vars.get());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
   parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
   parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
 
   parser_vars->m_parser_type = parser_type;
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_sym = &symbol;
 
-  if (log) {
-    ASTDumper ast_dumper(var_decl);
-
-    LLDB_LOGF(log, "  CEDM::FEVD[%u] Found variable %s, returned %s",
-              current_id, decl_name.c_str(), ast_dumper.GetCString());
-  }
+  LLDB_LOG(log, "  CEDM::FEVD[{0}] Found variable {1}, returned\n{2}",
+           current_id, decl_name, ClangUtil::DumpDecl(var_decl));
 }
 
 void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
                                             const RegisterInfo *reg_info,
                                             unsigned int current_id) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   CompilerType clang_type =
void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
   parser_vars->m_parser_type = parser_clang_type;
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_value.Clear();
   entity->m_flags |= ClangExpressionVariable::EVBareRegister;
 
-  if (log) {
-    ASTDumper ast_dumper(var_decl);
-    LLDB_LOGF(log, "  CEDM::FEVD[%d] Added register %s, returned %s",
-              current_id, context.m_decl_name.getAsString().c_str(),
-              ast_dumper.GetCString());
-  }
+  LLDB_LOG(log, "  CEDM::FEVD[{0}] Added register {1}, returned\n{2}",
+           current_id, context.m_decl_name.getAsString(),
+           ClangUtil::DumpDecl(var_decl));
 }
 
 void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
                                             Function *function, Symbol *symbol,
                                             unsigned int current_id) {
   assert(m_parser_vars.get());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (!extern_c) {
             src_function_decl->getTemplateSpecializationInfo()) {
           clang::FunctionTemplateDecl *function_template =
               src_function_decl->getTemplateSpecializationInfo()->getTemplate();
           clang::FunctionTemplateDecl *copied_function_template =
               llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(
                   CopyDecl(function_template));
           if (copied_function_template) {
             if (log) {
-              ASTDumper ast_dumper((clang::Decl *)copied_function_template);
-
               StreamString ss;
 
               function->DumpSymbolContext(&ss);
 
-              log->Printf("  CEDM::FEVD[%u] Imported decl for function template"
-                          " %s (description %s), returned %s",
-                          current_id,
-                          copied_function_template->getNameAsString().c_str(),
-                          ss.GetData(), ast_dumper.GetCString());
+              LLDB_LOG(log,
+                       "  CEDM::FEVD[{0}] Imported decl for function template"
+                       " {1} (description {2}), returned\n{3}",
+                       current_id, copied_function_template->getNameAsString(),
+                       ss.GetData(),
+                       ClangUtil::DumpDecl(copied_function_template));
             }
 
             context.AddNamedDecl(copied_function_template);
           }
         } else if (src_function_decl) {
           if (clang::FunctionDecl *copied_function_decl =
                   llvm::dyn_cast_or_null<clang::FunctionDecl>(
                       CopyDecl(src_function_decl))) {
             if (log) {
-              ASTDumper ast_dumper((clang::Decl *)copied_function_decl);
-
               StreamString ss;
 
               function->DumpSymbolContext(&ss);
 
-              LLDB_LOGF(log,
-                        "  CEDM::FEVD[%u] Imported decl for function %s "
-                        "(description %s), returned %s",
-                        current_id,
-                        copied_function_decl->getNameAsString().c_str(),
-                        ss.GetData(), ast_dumper.GetCString());
+              LLDB_LOG(log,
+                       "  CEDM::FEVD[{0}]] Imported decl for function {1} "
+                       "(description {2}), returned\n{3}",
+                       current_id, copied_function_decl->getNameAsString(),
+                       ss.GetData(), ClangUtil::DumpDecl(copied_function_decl));
             }
 
             context.AddNamedDecl(copied_function_decl);
             return;
           } else {
             if (log) {
               LLDB_LOGF(log, "  Failed to import the function decl for '%s'",
                         src_function_decl->getName().str().c_str());
if (load_addr != LLDB_INVALID_ADDRESS) {
     parser_vars->m_lldb_value.SetValueType(Value::eValueTypeFileAddress);
     parser_vars->m_lldb_value.GetScalar() = file_addr;
   }
 
   parser_vars->m_named_decl = function_decl;
   parser_vars->m_llvm_value = nullptr;
 
   if (log) {
-    std::string function_str =
-        function_decl ? ASTDumper(function_decl).GetCString() : "nullptr";
-
     StreamString ss;
 
     fun_address.Dump(&ss,
                      m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
                      Address::DumpStyleResolvedDescription);
 
-    LLDB_LOGF(
-        log,
-        "  CEDM::FEVD[%u] Found %s function %s (description %s), returned %s",
-        current_id, (function ? "specific" : "generic"), decl_name.c_str(),
-        ss.GetData(), function_str.c_str());
+    LLDB_LOG(log,
+             "  CEDM::FEVD[{0}] Found {1} function {2} (description {3}), "
+             "returned\n{4}",
+             current_id, (function ? "specific" : "generic"), decl_name,
+             ss.GetData(), ClangUtil::DumpDecl(function_decl));
   }
 }
 
 void ClangExpressionDeclMap::AddThisType(NameSearchContext &context,
                                          const TypeFromUser &ut,
                                          unsigned int current_id) {
   CompilerType copied_clang_type = GuardedCopyType(ut);
 
if (copied_clang_type.IsAggregateType() &&
 
     CXXMethodDecl *method_decl =
         ClangASTContext::GetASTContext(m_ast_context)
             ->AddMethodToCXXRecordType(
                 copied_clang_type.GetOpaqueQualType(), "$__lldb_expr", nullptr,
                 method_type, lldb::eAccessPublic, is_virtual, is_static,
                 is_inline, is_explicit, is_attr_used, is_artificial);
 
-    if (log) {
-      ASTDumper method_ast_dumper((clang::Decl *)method_decl);
-      ASTDumper type_ast_dumper(copied_clang_type);
-
-      LLDB_LOGF(log,
-                "  CEDM::AddThisType Added function $__lldb_expr "
-                "(description %s) for this type %s",
-                method_ast_dumper.GetCString(), type_ast_dumper.GetCString());
-    }
+    LLDB_LOG(log,
+             "(description {0}) for this type\n{1}",
+             ClangUtil::ToString(copied_clang_type),
+             ClangUtil::DumpDecl(method_decl));
   }
 
   if (!copied_clang_type.IsValid())
     return;
 
   TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(
       QualType::getFromOpaquePtr(copied_clang_type.GetOpaqueQualType()));
 

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

 //===-- AppleObjCDeclVendor.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleObjCDeclVendor.h"
 
-#include "Plugins/ExpressionParser/Clang/ASTDumper.h"
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 
public:
 
   void CompleteType(clang::TagDecl *tag_decl) override {
     static unsigned int invocation_id = 0;
     unsigned int current_id = invocation_id++;
 
     Log *log(GetLogIfAllCategoriesSet(
         LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
 
-    if (log) {
-      LLDB_LOGF(log,
-                "AppleObjCExternalASTSource::CompleteType[%u] on "
-                "(ASTContext*)%p Completing (TagDecl*)%p named %s",
-                current_id, static_cast<void *>(&tag_decl->getASTContext()),
-                static_cast<void *>(tag_decl),
-                tag_decl->getName().str().c_str());
+              static_cast<void *>(tag_decl), tag_decl->getName().str().c_str());
 
-      LLDB_LOGF(log, "  AOEAS::CT[%u] Before:", current_id);
-      ASTDumper dumper((clang::Decl *)tag_decl);
-      dumper.ToLog(log, "    [CT] ");
-    }
+    LLDB_LOG(log, "  AOEAS::CT[{0}] Before:\n{1}", current_id,
+             ClangUtil::DumpDecl(tag_decl));
+
+    LLDB_LOG(log, "  AOEAS::CT[{1}] After:{1}", current_id,
+             ClangUtil::DumpDecl(tag_decl));
 
-    if (log) {
-      LLDB_LOGF(log, "  AOEAS::CT[%u] After:", current_id);
-      ASTDumper dumper((clang::Decl *)tag_decl);
-      dumper.ToLog(log, "    [CT] ");
-    }
     return;
   }
 
   void CompleteType(clang::ObjCInterfaceDecl *interface_decl) override {
     static unsigned int invocation_id = 0;
     unsigned int current_id = invocation_id++;
 
     Log *log(GetLogIfAllCategoriesSet(
         LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
 
     if (log) {
       LLDB_LOGF(log,
                 "AppleObjCExternalASTSource::CompleteType[%u] on "
                 "(ASTContext*)%p Completing (ObjCInterfaceDecl*)%p named %s",
                 current_id,
                 static_cast<void *>(&interface_decl->getASTContext()),
                 static_cast<void *>(interface_decl),
                 interface_decl->getName().str().c_str());
 
       LLDB_LOGF(log, "  AOEAS::CT[%u] Before:", current_id);
-      ASTDumper dumper((clang::Decl *)interface_decl);
-      dumper.ToLog(log, "    [CT] ");
+      LLDB_LOG(log, "    [CT] {0}", ClangUtil::DumpDecl(interface_decl));
     }
 
     m_decl_vendor.FinishDecl(interface_decl);
 
     if (log) {
       LLDB_LOGF(log, "  [CT] After:");
-      ASTDumper dumper((clang::Decl *)interface_decl);
-      dumper.ToLog(log, "    [CT] ");
+      LLDB_LOG(log, "    [CT] {0}", ClangUtil::DumpDecl(interface_decl));
     }
     return;
   }
 
   bool layoutRecordType(
       const clang::RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
       llvm::DenseMap<const clang::FieldDecl *, uint64_t> &FieldOffsets,
       llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
if (ivar_type.IsValid()) {
       if (ivar_decl) {
         interface_decl->addDecl(ivar_decl);
       }
     }
 
     return false;
   };
 
-  if (log) {
-    ASTDumper method_dumper((clang::Decl *)interface_decl);
-
-    LLDB_LOGF(log,
-              "[AppleObjCDeclVendor::FinishDecl] Finishing Objective-C "
-              "interface for %s",
-              descriptor->GetClassName().AsCString());
-  }
+  LLDB_LOG(log,
 
   if (!descriptor->Describe(superclass_func, instance_method_func,
                             class_method_func, ivar_func))
     return false;
 
   if (log) {
-    ASTDumper method_dumper((clang::Decl *)interface_decl);
-
     LLDB_LOGF(
         log,
         "[AppleObjCDeclVendor::FinishDecl] Finished Objective-C interface");
 
-    method_dumper.ToLog(log, "  [AOTV::FD] ");
+    LLDB_LOG(log, "  [AOTV::FD] {0}", ClangUtil::DumpDecl(interface_decl));
   }
 
   return true;
 }
 
 uint32_t
 AppleObjCDeclVendor::FindDecls(ConstString name, bool append,
                                uint32_t max_matches,
clang::DeclContext::lookup_result lookup_result =
         ast_ctx->getTranslationUnitDecl()->lookup(decl_name);
 
     if (!lookup_result.empty()) {
       if (clang::ObjCInterfaceDecl *result_iface_decl =
               llvm::dyn_cast<clang::ObjCInterfaceDecl>(lookup_result[0])) {
         if (log) {
           clang::QualType result_iface_type =
               ast_ctx->getObjCInterfaceType(result_iface_decl);
-          ASTDumper dumper(result_iface_type);
 
           uint64_t isa_value = LLDB_INVALID_ADDRESS;
           ClangASTMetadata *metadata =
               m_external_source->GetMetadata(result_iface_decl);
           if (metadata)
             isa_value = metadata->GetISAPtr();
 
-          LLDB_LOGF(log,
-                    "AOCTV::FT [%u] Found %s (isa 0x%" PRIx64
-                    ") in the ASTContext",
-                    current_id, dumper.GetCString(), isa_value);
+          LLDB_LOG(log,
+                   current_id, result_iface_type.getAsString(), isa_value);
         }
 
         decls.push_back(result_iface_decl);
         ret++;
         break;
       } else {
         LLDB_LOGF(log,
                   "AOCTV::FT [%u] There's something in the ASTContext, but "
if (!iface_decl) {
                 current_id, (uint64_t)isa);
 
       break;
     }
 
     if (log) {
       clang::QualType new_iface_type =
           ast_ctx->getObjCInterfaceType(iface_decl);
-      ASTDumper dumper(new_iface_type);
-      LLDB_LOGF(log, "AOCTV::FT [%u] Created %s (isa 0x%" PRIx64 ")",
-                current_id, dumper.GetCString(), (uint64_t)isa);
+
+      LLDB_LOG(log, "AOCTV::FT [{0}] Created {1} (isa 0x{2:x})", current_id,
+               new_iface_type.getAsString(), (uint64_t)isa);
     }
 
     decls.push_back(iface_decl);
     ret++;
     break;
   } while (false);
 
   return ret;
 }
 
 clang::ExternalASTMerger::ImporterSource
 AppleObjCDeclVendor::GetImporterSource() {
   return clang::ExternalASTMerger::ImporterSource(*m_ast_ctx.getASTContext(),
                                                   *m_ast_ctx.getFileManager(),
                                                   m_ast_ctx.GetOriginMap());
 }

lldb/source/Symbol/ClangUtil.cpp

 
 clang::TagDecl *ClangUtil::GetAsTagDecl(const CompilerType &type) {
   clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
   if (qual_type.isNull())
     return nullptr;
 
   return qual_type->getAsTagDecl();
 }
+
+std::string ClangUtil::DumpDecl(const clang::Decl *d) {
+  if (!d)
+    return "nullptr";
+
+  std::string result;
+  llvm::raw_string_ostream stream(result);
+  bool deserialize = false;
+  d->dump(stream, deserialize);
+
+  stream.flush();
+  return result;
+}
+
+std::string ClangUtil::ToString(const clang::Type *t) {
+  return clang::QualType(t, 0).getAsString();
+}
+
+std::string ClangUtil::ToString(const CompilerType &c) {
+  return ClangUtil::GetQualType(c).getAsString();
+}