[lldb] Add a display name to ClangASTContext instances

[teemperor]

Summary

I often struggle to understand what exactly LLDB is doing by looking at our expression evaluation logging as our messages look like this:

CompleteTagDecl[2] on (ASTContext*)0x7ff31f01d240 Completing (TagDecl*)0x7ff31f01d568 named DeclName1

From the log messages it's unclear what this ASTContext is. Is it the scratch context, the expression context, some decl vendor context or a context from a module?
The pointer value isn't helpful for anyone unless I'm in a debugger where I could inspect the memory at the address. But even with a debugger it's not easy to
figure out what this ASTContext is without having deeper understanding about all the different ASTContext instances in LLDB (e.g., valid SourceLocation
from the file system usually means that this is the Objective-C decl vendor, a file name from multiple expressions is probably the scratch context, etc.).

This patch adds a name field to ClangASTContext instances that we can use to store a name which can be used for logging and debugging. With this
our log messages now look like this:

CompleteTagDecl[2] on scratch ASTContext. Completing (TagDecl*)0x7ff31f01d568 named Foo

We can now also just print a ClangASTContext from the debugger and see a useful name in the m_display_name field, e.g.

m_display_name = "AST for /Users/user/test/main.o";

[teemperor]

I don't know if this needs a unit test where we call the constructor and explicitly check the name is the one we passed in. Let me know if you think this would make sense.

[labath]

Seems reasonable to me, some other important object already have names (e.g. broadcasters&listeners).

[clayborg]

I don't mess with the expression parser all that much, but do we still want to see the pointer value in the log output?

current:

CompleteTagDecl[2] on (ASTContext*)0x7ff31f01d240 Completing (TagDecl*)0x7ff31f01d568 named DeclName1

Should the new one be

CompleteTagDecl[2] on scratch ASTContext. Completing (TagDecl*)0x7ff31f01d568 named Foo

Or include the pointer value and the name:

CompleteTagDecl[2] on scratch (ASTContext*)0x7ff31f01d240. Completing (TagDecl*)0x7ff31f01d568 named DeclName1

Might be nice to still see the pointer value in case there are multiple ASTContexts with the same name?

[teemperor]

@clayborg We can easily append the ptr value to the display name. All names should always be unique as long as there is one target, but in the off-chance that one isn't unique it might be useful.

[shafik]

Perhaps it makes sense to modify the dump() method to also display the new name?

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

610

AST -> ASTContext?

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

164

AST -> ASTContext?

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

147

AST -> ASTContext?

Below you use "scratch ASTContext"

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

27

AST -> ASTContext?

lldb/unittests/Symbol/TestClangASTContext.cpp

29–30

AST -> ASTContext?

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

42

dummy -> dummy ASTContext

lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h

25–26

AST -> ASTContext?

[shafik]

In D72391#1811589, @teemperor wrote:

@clayborg We can easily append the ptr value to the display name. All names should always be unique as long as there is one target, but in the off-chance that one isn't unique it might be useful.

I think the pointer values would be useful to have.

[shafik]

In D72391#1809751, @teemperor wrote:

I don't know if this needs a unit test where we call the constructor and explicitly check the name is the one we passed in. Let me know if you think this would make sense.

I think we should.

lldb/include/lldb/Symbol/ClangASTContext.h

typedef void (*CompleteObjCInterfaceDeclCallback)(void *baton,
                                                     clang::ObjCInterfaceDecl *);
 
   // llvm casting support
   bool isA(const void *ClassID) const override { return ClassID == &ID; }
   static bool classof(const TypeSystem *ts) { return ts->isA(&ID); }
 
   /// Constructs a ClangASTContext with an ASTContext using the given triple.
   ///
+  /// \param name The name for the ClangASTContext (for logging purposes)
   /// \param triple The llvm::Triple used for the ASTContext. The triple defines
   ///               certain characteristics of the ASTContext and its types
   ///               (e.g., whether certain primitive types exist or what their
   ///               signedness is).
-  explicit ClangASTContext(llvm::Triple triple);
+  explicit ClangASTContext(llvm::StringRef name, llvm::Triple triple);
 
   /// Constructs a ClangASTContext that uses an existing ASTContext internally.
   /// Useful when having an existing ASTContext created by Clang.
   ///
+  /// \param name The name for the ClangASTContext (for logging purposes)
   /// \param existing_ctxt An existing ASTContext.
-  explicit ClangASTContext(clang::ASTContext &existing_ctxt);
+  explicit ClangASTContext(llvm::StringRef name,
+                           clang::ASTContext &existing_ctxt);
 
   ~ClangASTContext() override;
 
   void Finalize() override;
 
   // PluginInterface functions
   ConstString GetPluginName() override;
 
static ClangASTContext *GetScratch(Target &target,
     if (auto err = type_system_or_err.takeError()) {
       LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
                      std::move(err), "Couldn't get scratch ClangASTContext");
       return nullptr;
     }
     return llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
   }
 
+  /// Returns the display name of this ClangASTContext that indicates what
+  /// purpose it serves in LLDB. Used for example in logs.
+  llvm::StringRef getDisplayName() const { return m_display_name; }
+
   clang::ASTContext &getASTContext();
 
   clang::MangleContext *getMangleContext();
 
   std::shared_ptr<clang::TargetOptions> &getTargetOptions();
 
   clang::TargetInfo *getTargetInfo();
 
private:
   std::unique_ptr<clang::IdentifierTable> m_identifier_table_up;
   std::unique_ptr<clang::SelectorTable> m_selector_table_up;
   std::unique_ptr<clang::Builtin::Context> m_builtins_up;
   std::unique_ptr<DWARFASTParserClang> m_dwarf_ast_parser_up;
   std::unique_ptr<PDBASTParser> m_pdb_ast_parser_up;
   std::unique_ptr<clang::MangleContext> m_mangle_ctx_up;
   uint32_t m_pointer_byte_size = 0;
   bool m_ast_owned = false;
+  /// A string describing what this ClangASTContext represents (e.g.,
+  /// AST for debug information, an expression, some other utility ClangAST).
+  /// Useful for logging and debugging.
+  std::string m_display_name;
 
   typedef llvm::DenseMap<const clang::Decl *, ClangASTMetadata> DeclMetadataMap;
   /// Maps Decls to their associated ClangASTMetadata.
   DeclMetadataMap m_decl_metadata;
 
   typedef llvm::DenseMap<const clang::Type *, ClangASTMetadata> TypeMetadataMap;
   /// Maps Types to their associated ClangASTMetadata.
   TypeMetadataMap m_type_metadata;

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

void ClangASTSource::CompleteType(TagDecl *tag_decl) {
 
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   if (log) {
     LLDB_LOG(log,
              "    CompleteTagDecl[{0}] on (ASTContext*){1} Completing "
              "(TagDecl*){2} named {3}",
-             current_id, static_cast<void *>(m_ast_context),
-             static_cast<void *>(tag_decl), tag_decl->getName());
+             current_id, m_clang_ast_context->getDisplayName(), tag_decl,
+             tag_decl->getName());
 
     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;
void ClangASTSource::CompleteType(TagDecl *tag_decl) {
 
   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));
 
   LLDB_LOG(log,
-           "    [CompleteObjCInterfaceDecl] on (ASTContext*){0} Completing "
-           "an ObjCInterfaceDecl named {1}",
-           m_ast_context, interface_decl->getName());
+           "    [CompleteObjCInterfaceDecl] on (ASTContext*){0} '{1}' "
+           "Completing an ObjCInterfaceDecl named {1}",
+           m_ast_context, m_clang_ast_context->getDisplayName(),
+           interface_decl->getName());
   LLDB_LOG(log, "      [COID] Before:\n{0}",
            ClangUtil::DumpDecl(interface_decl));
 
   if (!m_ast_importer_sp) {
     lldbassert(0 && "No mechanism for completing a type!");
     return;
   }
 
void ClangASTSource::FindExternalLexicalDecls(
   ScopedLexicalDeclEraser eraser(m_active_lexical_decls, context_decl);
 
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   if (log) {
     if (const NamedDecl *context_named_decl = dyn_cast<NamedDecl>(context_decl))
       LLDB_LOG(log,
-               "FindExternalLexicalDecls[{0}] on (ASTContext*){1} in '{2}' "
-               "(%sDecl*){3}",
-               current_id, static_cast<void *>(m_ast_context),
+               "FindExternalLexicalDecls[{0}] on (ASTContext*){1} '{2}' in "
+               "'{3}' (%sDecl*){4}",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
                context_named_decl->getNameAsString().c_str(),
                context_decl->getDeclKindName(),
                static_cast<const void *>(context_decl));
     else if (context_decl)
-      LLDB_LOG(
-          log,
-          "FindExternalLexicalDecls[{0}] on (ASTContext*){1} in ({2}Decl*){3}",
-          current_id, static_cast<void *>(m_ast_context),
+      LLDB_LOG(log,
+               "FindExternalLexicalDecls[{0}] on (ASTContext*){1} '{2}' in "
+               "({3}Decl*){4}",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
                context_decl->getDeclKindName(),
                static_cast<const void *>(context_decl));
     else
-      LLDB_LOG(
-          log,
-          "FindExternalLexicalDecls[{0}] on (ASTContext*){1} in a NULL context",
-          current_id, static_cast<const void *>(m_ast_context));
+      LLDB_LOG(log,
+               "FindExternalLexicalDecls[{0}] on (ASTContext*){1} '{2}' in a "
+               "NULL context",
+               current_id, m_ast_context,
+               m_clang_ast_context->getDisplayName());
   }
 
   ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(context_decl);
 
   if (!original.Valid())
     return;
 
-  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));
+  LLDB_LOG(log, "  FELD[{0}] Original decl {1} (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;
void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) {
 
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   if (log) {
     if (!context.m_decl_context)
       LLDB_LOG(log,
                "ClangASTSource::FindExternalVisibleDecls[{0}] on "
-               "(ASTContext*){1} for '{2}' in a NULL DeclContext",
-               current_id, m_ast_context, name);
+               "(ASTContext*){1} '{2}' for '{3}' in a NULL DeclContext",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               name);
     else if (const NamedDecl *context_named_decl =
                  dyn_cast<NamedDecl>(context.m_decl_context))
       LLDB_LOG(log,
                "ClangASTSource::FindExternalVisibleDecls[{0}] on "
-               "(ASTContext*){1} for '{2}' in '{3}'",
-               current_id, m_ast_context, name, context_named_decl->getName());
+               "(ASTContext*){1} '{2}' for '{3}' in '{4}'",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               name, context_named_decl->getName());
     else
       LLDB_LOG(log,
                "ClangASTSource::FindExternalVisibleDecls[{0}] on "
-               "(ASTContext*){1} for '{2}' in a '{3}'",
-               current_id, m_ast_context, name,
-               context.m_decl_context->getDeclKindName());
+               "(ASTContext*){1} '{2}' for '{3}' in a '{4}'",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               name, context.m_decl_context->getDeclKindName());
   }
 
   context.m_namespace_map = std::make_shared<ClangASTImporter::NamespaceMap>();
 
   if (const NamespaceDecl *namespace_context =
           dyn_cast<NamespaceDecl>(context.m_decl_context)) {
     ClangASTImporter::NamespaceMapSP namespace_map =  m_ast_importer_sp ?
         m_ast_importer_sp->GetNamespaceMap(namespace_context) : nullptr;
void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) {
   ss.Flush();
 
   if (ss.GetString().contains("$__lldb"))
     return; // we don't need any results
 
   ConstString selector_name(ss.GetString());
 
   LLDB_LOG(log,
-           "ClangASTSource::FindObjCMethodDecls[{0}] on (ASTContext*){1} "
-           "for selector [{2} {3}]",
-           current_id, m_ast_context, interface_decl->getName(), selector_name);
+           "ClangASTSource::FindObjCMethodDecls[{0}] on (ASTContext*){1} '{2}' "
+           "for selector [{3} {4}]",
+           current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+           interface_decl->getName(), selector_name);
   SymbolContextList sc_list;
 
   const bool include_symbols = false;
   const bool include_inlines = false;
 
   std::string interface_name = interface_decl->getNameAsString();
 
   do {
DeclFromParser<const ObjCInterfaceDecl> parser_iface_decl(
       cast<ObjCInterfaceDecl>(context.m_decl_context));
   DeclFromUser<const ObjCInterfaceDecl> origin_iface_decl(
       parser_iface_decl.GetOrigin(*this));
 
   ConstString class_name(parser_iface_decl->getNameAsString().c_str());
 
   LLDB_LOG(log,
            "ClangASTSource::FindObjCPropertyAndIvarDecls[{0}] on "
-           "(ASTContext*){1} for '{2}.{3}'",
-           current_id, m_ast_context, parser_iface_decl->getName(),
-           context.m_decl_name.getAsString());
+           "(ASTContext*){1} '{2}' for '{3}.{4}'",
+           current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+           parser_iface_decl->getName(), context.m_decl_name.getAsString());
 
   if (FindObjCPropertyAndIvarDeclsWithOrigin(
           current_id, context, *this, origin_iface_decl))
     return;
 
   LLDB_LOG(log,
            "CAS::FOPD[{0}] couldn't find the property on origin "
            "(ObjCInterfaceDecl*){1}/(ASTContext*){2}, searching "
bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
                                       BaseOffsetMap &base_offsets,
                                       BaseOffsetMap &virtual_base_offsets) {
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   LLDB_LOG(log,
-           "LayoutRecordType[{0}] on (ASTContext*){1} for (RecordDecl*){2} "
-           "[name = '{3}']",
-           current_id, m_ast_context, record, record->getName());
+           "LayoutRecordType[{0}] on (ASTContext*){1} '{2}' for (RecordDecl*)"
+           "{3} [name = '{4}']",
+           current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+           record, record->getName());
 
   DeclFromParser<const RecordDecl> parser_record(record);
   DeclFromUser<const RecordDecl> origin_record(
       parser_record.GetOrigin(*this));
 
   if (origin_record.IsInvalid())
     return false;
 
void ClangASTSource::CompleteNamespaceMap(
   static unsigned int invocation_id = 0;
   unsigned int current_id = invocation_id++;
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (log) {
     if (parent_map && parent_map->size())
       LLDB_LOG(log,
-               "CompleteNamespaceMap[{0}] on (ASTContext*){1} Searching for "
-               "namespace {2} in namespace {3}",
-               current_id, m_ast_context, name,
-               parent_map->begin()->second.GetName());
+               "CompleteNamespaceMap[{0}] on (ASTContext*){1} '{2}' Searching "
+               "for namespace {3} in namespace {4}",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               name, parent_map->begin()->second.GetName());
     else
       LLDB_LOG(log,
-               "CompleteNamespaceMap[{0}] on (ASTContext*){1} Searching for "
-               "namespace {2}",
-               current_id, m_ast_context, name);
+               "CompleteNamespaceMap[{0}] on (ASTContext*){1} '{2}' Searching "
+               "for namespace {3}",
+               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               name);
   }
 
   if (parent_map) {
     for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
                                                   e = parent_map->end();
          i != e; ++i) {
       CompilerDeclContext found_namespace_decl;
 

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

ClangExpressionParser::ClangExpressionParser(
   auto &PP = m_compiler->getPreprocessor();
   auto &builtin_context = PP.getBuiltinInfo();
   builtin_context.initializeBuiltins(PP.getIdentifierTable(),
                                      m_compiler->getLangOpts());
 
   m_compiler->createASTContext();
   clang::ASTContext &ast_context = m_compiler->getASTContext();
 
-  m_ast_context.reset(new ClangASTContext(ast_context));
+  m_ast_context.reset(new ClangASTContext(
+      "Expression ASTContext for '" + m_filename + "'", ast_context));
 
   std::string module_name("$__lldb_module");
 
   m_llvm_context.reset(new LLVMContext());
   m_code_generator.reset(CreateLLVMCodeGen(
       m_compiler->getDiagnostics(), module_name,
       m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(),
       m_compiler->getCodeGenOpts(), *m_llvm_context));

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

ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
     std::unique_ptr<clang::CompilerInstance> compiler_instance,
     std::unique_ptr<clang::Parser> parser)
     : m_diagnostics_engine(std::move(diagnostics_engine)),
       m_compiler_invocation(std::move(compiler_invocation)),
       m_compiler_instance(std::move(compiler_instance)),
       m_parser(std::move(parser)) {
 
   // Initialize our ClangASTContext.
-  m_ast_context.reset(new ClangASTContext(m_compiler_instance->getASTContext()));
+  m_ast_context.reset(
+      new ClangASTContext("ClangModulesDeclVendor ASTContext",
+                          m_compiler_instance->getASTContext()));
 }
 
 void ClangModulesDeclVendorImpl::ReportModuleExportsHelper(
     std::set<ClangModulesDeclVendor::ModuleID> &exports,
     clang::Module *module) {
   if (exports.count(reinterpret_cast<ClangModulesDeclVendor::ModuleID>(module)))
     return;
 

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

public:
   }
 
 private:
   AppleObjCDeclVendor &m_decl_vendor;
 };
 
 AppleObjCDeclVendor::AppleObjCDeclVendor(ObjCLanguageRuntime &runtime)
     : ClangDeclVendor(eAppleObjCDeclVendor), m_runtime(runtime),
-      m_ast_ctx(runtime.GetProcess()
-                    ->GetTarget()
-                    .GetArchitecture()
-                    .GetTriple()),
+      m_ast_ctx(
+          "AppleObjCDeclVendor AST",
+          runtime.GetProcess()->GetTarget().GetArchitecture().GetTriple()),
       m_type_realizer_sp(m_runtime.GetEncodingToType()) {
   m_external_source = new AppleObjCExternalASTSource(*this);
   llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> external_source_owning_ptr(
       m_external_source);
   m_ast_ctx.getASTContext().setExternalSource(external_source_owning_ptr);
 }
 
 clang::ObjCInterfaceDecl *

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

 #include <vector>
 
 using namespace lldb_private;
 
 AppleObjCTypeEncodingParser::AppleObjCTypeEncodingParser(
     ObjCLanguageRuntime &runtime)
     : ObjCLanguageRuntime::EncodingToType(), m_runtime(runtime) {
   if (!m_scratch_ast_ctx_up)
-    m_scratch_ast_ctx_up.reset(new ClangASTContext(runtime.GetProcess()
-                                                       ->GetTarget()
-                                                       .GetArchitecture()
-                                                       .GetTriple()));
+    m_scratch_ast_ctx_up.reset(new ClangASTContext(
+        "AppleObjCTypeEncodingParser ASTContext",
+        runtime.GetProcess()->GetTarget().GetArchitecture().GetTriple()));
 }
 
 std::string AppleObjCTypeEncodingParser::ReadStructName(StringLexer &type) {
   StreamString buffer;
   while (type.HasAtLeast(1) && type.Peek() != '=')
     buffer.Printf("%c", type.Next());
   return buffer.GetString();
 }

lldb/source/Symbol/ClangASTContext.cpp

static void ParseLangArgs(LangOptions &Opts, InputKind IK, const char *triple) {
   // This is the __NO_INLINE__ define, which just depends on things like the
   // optimization level and -fno-inline, not actually whether the backend has
   // inlining enabled.
   //
   // FIXME: This is affected by other options (-fno-inline).
   Opts.NoInlineDefine = !Opt;
 }
 
-ClangASTContext::ClangASTContext(llvm::Triple target_triple) {
+ClangASTContext::ClangASTContext(llvm::StringRef name,
+                                 llvm::Triple target_triple) {
+  m_display_name = name.str();
   if (!target_triple.str().empty())
     SetTargetTriple(target_triple.str());
   // The caller didn't pass an ASTContext so create a new one for this
   // ClangASTContext.
   CreateASTContext();
 }
 
-ClangASTContext::ClangASTContext(ASTContext &existing_ctxt) {
+ClangASTContext::ClangASTContext(llvm::StringRef name,
+                                 ASTContext &existing_ctxt) {
+  m_display_name = name.str();
   SetTargetTriple(existing_ctxt.getTargetInfo().getTriple().str());
 
   m_ast_up.reset(&existing_ctxt);
   GetASTMap().Insert(&existing_ctxt, this);
 }
 
 // Destructor
 ClangASTContext::~ClangASTContext() { Finalize(); }
if (triple.getArch() == llvm::Triple::arm ||
         triple.getArch() == llvm::Triple::aarch64_32 ||
         triple.getArch() == llvm::Triple::thumb) {
       triple.setOS(llvm::Triple::IOS);
     } else {
       triple.setOS(llvm::Triple::MacOSX);
     }
   }
 
-  if (module)
-    return std::make_shared<ClangASTContext>(triple);
-  else if (target && target->IsValid())
+  if (module) {
+    std::string ast_name =
+        "ASTContext for '" + module->GetFileSpec().GetPath() + "'";
+    return std::make_shared<ClangASTContext>(ast_name, triple);
+  } else if (target && target->IsValid())
     return std::make_shared<ClangASTContextForExpressions>(*target, triple);
   return lldb::TypeSystemSP();
 }
 
 LanguageSet ClangASTContext::GetSupportedLanguagesForTypes() {
   LanguageSet languages;
   languages.Insert(lldb::eLanguageTypeC89);
   languages.Insert(lldb::eLanguageTypeC);
ClangASTContext *ast =
       llvm::dyn_cast_or_null<ClangASTContext>(dc.GetTypeSystem());
   if (ast)
     return &ast->getASTContext();
   return nullptr;
 }
 
 ClangASTContextForExpressions::ClangASTContextForExpressions(
     Target &target, llvm::Triple triple)
-    : ClangASTContext(triple), m_target_wp(target.shared_from_this()),
+    : ClangASTContext("scratch ASTContext", triple),
+      m_target_wp(target.shared_from_this()),
       m_persistent_variables(new ClangPersistentVariables) {
   m_scratch_ast_source_up.reset(new ClangASTSource(
       target.shared_from_this(), target.GetClangASTImporter()));
   m_scratch_ast_source_up->InstallASTContext(*this);
   llvm::IntrusiveRefCntPtr<clang::ExternalASTSource> proxy_ast_source(
       m_scratch_ast_source_up->CreateProxy());
   SetExternalSource(proxy_ast_source);
 }

lldb/unittests/Symbol/TestClangASTContext.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 class TestClangASTContext : public testing::Test {
 public:
   SubsystemRAII<FileSystem, HostInfo> subsystems;
 
   void SetUp() override {
-    m_ast.reset(new ClangASTContext(HostInfo::GetTargetTriple()));
+    m_ast.reset(
+        new ClangASTContext("test ASTContext", HostInfo::GetTargetTriple()));
   }
 
   void TearDown() override { m_ast.reset(); }
 
 protected:
   std::unique_ptr<ClangASTContext> m_ast;
 
   QualType GetBasicQualType(BasicType type) const {
TEST_F(TestClangASTContext, TestBuiltinTypeForEncodingAndBitSize) {
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 32);
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 64);
   VerifyEncodingAndBitSize(*m_ast, eEncodingUint, 128);
 
   VerifyEncodingAndBitSize(*m_ast, eEncodingIEEE754, 32);
   VerifyEncodingAndBitSize(*m_ast, eEncodingIEEE754, 64);
 }
 
+TEST_F(TestClangASTContext, TestDisplayName) {
+  ClangASTContext ast("some name", llvm::Triple());
+  EXPECT_EQ("some name", ast.getDisplayName());
+}
+
+TEST_F(TestClangASTContext, TestDisplayNameEmpty) {
+  ClangASTContext ast("", llvm::Triple());
+  EXPECT_EQ("", ast.getDisplayName());
+}
+
 TEST_F(TestClangASTContext, TestIsClangType) {
   clang::ASTContext &context = m_ast->getASTContext();
   lldb::opaque_compiler_type_t bool_ctype =
       ClangASTContext::GetOpaqueCompilerType(&context, lldb::eBasicTypeBool);
   CompilerType bool_type(m_ast.get(), bool_ctype);
   CompilerType record_type = m_ast->CreateRecordType(
       nullptr, lldb::eAccessPublic, "FooRecord", clang::TTK_Struct,
       lldb::eLanguageTypeC_plus_plus, nullptr);

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

public:
   }
 };
 } // namespace
 
 // If your implementation needs to dereference the dummy pointers we are
 // defining here, causing this test to fail, feel free to delete it.
 TEST_F(DWARFASTParserClangTests,
        EnsureAllDIEsInDeclContextHaveBeenParsedParsesOnlyMatchingEntries) {
-  ClangASTContext ast_ctx(HostInfoBase::GetTargetTriple());
+  ClangASTContext ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
   DWARFASTParserClangStub ast_parser(ast_ctx);
 
   DWARFUnit *unit = nullptr;
   std::vector<DWARFDIE> dies = {DWARFDIE(unit, (DWARFDebugInfoEntry *)1LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)2LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)3LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)4LL)};
   std::vector<clang::DeclContext *> decl_ctxs = {

lldb/unittests/TestingSupport/Symbol/ClangTestUtils.h

 namespace clang_utils {
 inline clang::DeclarationName getDeclarationName(ClangASTContext &ast,
                                                  llvm::StringRef name) {
   clang::IdentifierInfo &II = ast.getASTContext().Idents.get(name);
   return ast.getASTContext().DeclarationNames.getIdentifier(&II);
 }
 
 inline std::unique_ptr<ClangASTContext> createAST() {
-  return std::make_unique<ClangASTContext>(HostInfo::GetTargetTriple());
+  return std::make_unique<ClangASTContext>("test ASTContext",
+                                           HostInfo::GetTargetTriple());
 }
 
 inline CompilerType createRecord(ClangASTContext &ast, llvm::StringRef name) {
   return ast.CreateRecordType(ast.getASTContext().getTranslationUnitDecl(),
                               lldb::AccessType::eAccessPublic, name, 0,
                               lldb::LanguageType::eLanguageTypeC);
 }