[lldb] Remove all the 'current_id' logging counters from the lookup code.

[teemperor]

Summary

We have a lot of code in our lookup code to pass around current_id counters which end up in our logs like this:

AOCTV::FT [234] Found XYZ

This patch removes all of this code because:

• I'm splitting up all humongous functions, so I need to write more and more boilerplate to pass around these ids.
• I never saw any similar counters in the LLDB/LLVM code base.
• They're essentially globals and the last thing we need in LLDB is even more global state.
• They're not really useful when readings logs. It doesn't help that there isn't just 1 or 2 counters, but 12 (!) unique counters. I always thought that if I see two identical counter values in those brackets it's the same lookup request, but it seems that's only true by accident (and you can't know which of the 12 counters is actually printed without reading the code). The only time I know I can trust the counters is when it's obvious from the log that it's the same counter like in the log below, but then why have the counters in the first place?

LayoutRecordType[28] on (ASTContext*)0x00007FFA1C840200 'scratch ASTContext' for (RecordDecl*)0x00007FFA0AAE8CF0 [name = '__tree']
LRT[28] returned:
LRT[28]   Original = (RecordDecl*)%p
LRT[28]   Size = %lld
LRT[28]   Alignment = %lld
LRT[28]   Fields:
LRT[28]     (FieldDecl*)0x00007FFA1A13B1D0, Name = '__begin_node_', Offset = 0 bits
LRT[28]     (FieldDecl*)0x00007FFA1C08FD30, Name = '__pair1_', Offset = 64 bits
LRT[28]     (FieldDecl*)0x00007FFA1C061210, Name = '__pair3_', Offset = 128 bits
LRT[28]   Bases:

[grandinj]

Just a drive-by suggestion: Logging the pointer value of the relevant root object in the callees would provide similar benefit to anyone needing to do log tracing

[shafik]

I have struggled to understand the real use of those counters, they may have been helpful to someone at one point but the rationale is lost in the sands of time.

LGTM but lets see if someone else has an insight.

[labath]

I rarely visit this part of the code, but on the few occasions that I had to debug it, I did not find the ID numbers useful..

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

protected:
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///
   /// \param[in] module
   ///     If non-NULL, the module to query.
   ///
   /// \param[in] namespace_decl
   ///     If valid and module is non-NULL, the parent namespace.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
   void FindExternalVisibleDecls(NameSearchContext &context,
                                 lldb::ModuleSP module,
-                                CompilerDeclContext &namespace_decl,
-                                unsigned int current_id);
+                                CompilerDeclContext &namespace_decl);
 
   /// Find all Objective-C methods matching a given selector.
   ///
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///     Its m_decl_name contains the selector and its m_decl_context
   ///     is the containing object.
   void FindObjCMethodDecls(NameSearchContext &context);
public:
   ClangASTImporter::DeclOrigin GetDeclOrigin(const clang::Decl *decl);
 
   /// Returns the TypeSystem that uses this ClangASTSource instance as it's
   /// ExternalASTSource.
   TypeSystemClang *GetTypeSystem() const { return m_clang_ast_context; }
 
 protected:
   bool FindObjCMethodDeclsWithOrigin(
-      unsigned int current_id, NameSearchContext &context,
+      NameSearchContext &context,
       clang::ObjCInterfaceDecl *original_interface_decl, const char *log_info);
 
-  void FindDeclInModules(NameSearchContext &context, ConstString name,
-                         unsigned current_id);
-  void FindDeclInObjCRuntime(NameSearchContext &context, ConstString name,
-                             unsigned current_id);
+  void FindDeclInModules(NameSearchContext &context, ConstString name);
+  void FindDeclInObjCRuntime(NameSearchContext &context, ConstString name);
 
   friend struct NameSearchContext;
 
   bool m_import_in_progress;
   bool m_lookups_enabled;
 
   /// The target to use in finding variables and types.
   const lldb::TargetSP m_target;

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

bool ClangASTSource::FindExternalVisibleDeclsByName(
   //  --g_depth;
   m_active_lookups.erase(uniqued_const_decl_name);
   return (name_decls.size() != 0);
 }
 
 void ClangASTSource::CompleteType(TagDecl *tag_decl) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  static unsigned int invocation_id = 0;
-  unsigned int current_id = invocation_id++;
-
   if (log) {
     LLDB_LOG(log,
-             "    CompleteTagDecl[{0}] on (ASTContext*){1} Completing "
+             "    CompleteTagDecl on (ASTContext*){1} Completing "
              "(TagDecl*){2} named {3}",
-             current_id, m_clang_ast_context->getDisplayName(), tag_decl,
+             m_clang_ast_context->getDisplayName(), tag_decl,
              tag_decl->getName());
 
-    LLDB_LOG(log, "      CTD[%u] Before:\n{0}", current_id,
-             ClangUtil::DumpDecl(tag_decl));
+    LLDB_LOG(log, "      CTD Before:\n{0}", 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 (!m_ast_importer_sp->CompleteTagDecl(tag_decl)) {
     // We couldn't complete the type.  Maybe there's a definition somewhere
     // else that can be completed.
 
-    LLDB_LOG(log,
-             "      CTD[{0}] Type could not be completed in the module in "
-             "which it was first found.",
-             current_id);
+    LLDB_LOG(log, "      CTD Type could not be completed in the module in "
+                  "which it was first found.");
 
     bool found = false;
 
     DeclContext *decl_ctx = tag_decl->getDeclContext();
 
     if (const NamespaceDecl *namespace_context =
             dyn_cast<NamespaceDecl>(decl_ctx)) {
       ClangASTImporter::NamespaceMapSP namespace_map =
           m_ast_importer_sp->GetNamespaceMap(namespace_context);
 
       if (log && log->GetVerbose())
-        LLDB_LOG(log,
-                 "      CTD[{0}] Inspecting namespace map{1} ({2} entries)",
-                 current_id, namespace_map.get(), namespace_map->size());
+        LLDB_LOG(log, "      CTD Inspecting namespace map{1} ({2} entries)",
+                 namespace_map.get(), namespace_map->size());
 
       if (!namespace_map)
         return;
 
       for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
                                                     e = namespace_map->end();
            i != e && !found; ++i) {
-        LLDB_LOG(log, "      CTD[{0}] Searching namespace {1} in module {2}",
-                 current_id, i->second.GetName(),
-                 i->first->GetFileSpec().GetFilename());
+        LLDB_LOG(log, "      CTD Searching namespace {1} in module {2}",
+                 i->second.GetName(), i->first->GetFileSpec().GetFilename());
 
         TypeList types;
 
         ConstString name(tag_decl->getName().str().c_str());
 
         i->first->FindTypesInNamespace(name, i->second, UINT32_MAX, types);
 
         for (uint32_t ti = 0, te = types.GetSize(); ti != te && !found; ++ti) {
if (!context_decl)
     return;
 
   auto iter = m_active_lexical_decls.find(context_decl);
   if (iter != m_active_lexical_decls.end())
     return;
   m_active_lexical_decls.insert(context_decl);
   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} '{2}' in "
+               "FindExternalLexicalDecls on (ASTContext*){1} '{2}' in "
                "'{3}' (%sDecl*){4}",
-               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               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} '{2}' in "
+               "FindExternalLexicalDecls on (ASTContext*){1} '{2}' in "
                "({3}Decl*){4}",
-               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+               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} '{2}' in a "
+               "FindExternalLexicalDecls on (ASTContext*){1} '{2}' in a "
                "NULL context",
-               current_id, m_ast_context,
-               m_clang_ast_context->getDisplayName());
+               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 {1} (Decl*){2:x}:\n{3}", current_id,
+  LLDB_LOG(log, "  FELD Original decl {1} (Decl*){2:x}:\n{3}",
            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);
for (DeclContext::decl_iterator iter = original_decl_context->decls_begin();
     // 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) {
         std::string ast_dump = ClangUtil::DumpDecl(decl);
         if (const NamedDecl *context_named_decl =
                 dyn_cast<NamedDecl>(context_decl))
-          LLDB_LOG(
-              log, "  FELD[{0}] Adding [to {1}Decl {2}] lexical {3}Decl {4}",
-              current_id, context_named_decl->getDeclKindName(),
-              context_named_decl->getName(), decl->getDeclKindName(), ast_dump);
+          LLDB_LOG(log, "  FELD Adding [to {1}Decl {2}] lexical {3}Decl {4}",
+                   context_named_decl->getDeclKindName(),
+                   context_named_decl->getName(), decl->getDeclKindName(),
+                   ast_dump);
         else
-          LLDB_LOG(log, "  FELD[{0}] Adding lexical {1}Decl {2}", current_id,
+          LLDB_LOG(log, "  FELD Adding lexical {1}Decl {2}",
                    decl->getDeclKindName(), ast_dump);
       }
 
       Decl *copied_decl = CopyDecl(decl);
 
       if (!copied_decl)
         continue;
 

 
 void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) {
   assert(m_ast_context);
 
   const ConstString name(context.m_decl_name.getAsString().c_str());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  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 "
+               "ClangASTSource::FindExternalVisibleDecls on "
                "(ASTContext*){1} '{2}' for '{3}' in a NULL DeclContext",
-               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
-               name);
+               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 "
+               "ClangASTSource::FindExternalVisibleDecls on "
                "(ASTContext*){1} '{2}' for '{3}' in '{4}'",
-               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
-               name, context_named_decl->getName());
+               m_ast_context, m_clang_ast_context->getDisplayName(), name,
+               context_named_decl->getName());
     else
       LLDB_LOG(log,
-               "ClangASTSource::FindExternalVisibleDecls[{0}] on "
+               "ClangASTSource::FindExternalVisibleDecls on "
                "(ASTContext*){1} '{2}' for '{3}' in a '{4}'",
-               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
-               name, context.m_decl_context->getDeclKindName());
+               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->GetNamespaceMap(namespace_context);
 
     if (log && log->GetVerbose())
-      LLDB_LOG(log,
-               "  CAS::FEVD[{0}] Inspecting namespace map {1} ({2} entries)",
-               current_id, namespace_map.get(), namespace_map->size());
+      LLDB_LOG(log, "  CAS::FEVD Inspecting namespace map {1} ({2} entries)",
+               namespace_map.get(), namespace_map->size());
 
     if (!namespace_map)
       return;
 
     for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
                                                   e = namespace_map->end();
          i != e; ++i) {
-      LLDB_LOG(log, "  CAS::FEVD[{0}] Searching namespace {1} in module {2}",
-               current_id, i->second.GetName(),
-               i->first->GetFileSpec().GetFilename());
+      LLDB_LOG(log, "  CAS::FEVD Searching namespace {1} in module {2}",
+               i->second.GetName(), i->first->GetFileSpec().GetFilename());
 
-      FindExternalVisibleDecls(context, i->first, i->second, current_id);
+      FindExternalVisibleDecls(context, i->first, i->second);
     }
   } else if (isa<ObjCInterfaceDecl>(context.m_decl_context)) {
     FindObjCPropertyAndIvarDecls(context);
   } else if (!isa<TranslationUnitDecl>(context.m_decl_context)) {
     // we shouldn't be getting FindExternalVisibleDecls calls for these
     return;
   } else {
     CompilerDeclContext namespace_decl;
 
-    LLDB_LOG(log, "  CAS::FEVD[{0}] Searching the root namespace", current_id);
+    LLDB_LOG(log, "  CAS::FEVD Searching the root namespace");
 
-    FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl,
-                             current_id);
+    FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
   }
 
   if (!context.m_namespace_map->empty()) {
     if (log && log->GetVerbose())
-      LLDB_LOG(log,
-               "  CAS::FEVD[{0}] Registering namespace map {1} ({2} entries)",
-               current_id, context.m_namespace_map.get(),
-               context.m_namespace_map->size());
+      LLDB_LOG(log, "  CAS::FEVD Registering namespace map {1} ({2} entries)",
+               context.m_namespace_map.get(), context.m_namespace_map->size());
 
     NamespaceDecl *clang_namespace_decl =
         AddNamespace(context, context.m_namespace_map);
 
     if (clang_namespace_decl)
       clang_namespace_decl->setHasExternalVisibleStorage();
   }
 }
bool ClangASTSource::IgnoreName(const ConstString name,
   // The ClangASTSource is not responsible for finding $-names.
   return name_string_ref.empty() ||
          (ignore_all_dollar_names && name_string_ref.startswith("$")) ||
          name_string_ref.startswith("_$");
 }
 
 void ClangASTSource::FindExternalVisibleDecls(
     NameSearchContext &context, lldb::ModuleSP module_sp,
-    CompilerDeclContext &namespace_decl, unsigned int current_id) {
+    CompilerDeclContext &namespace_decl) {
   assert(m_ast_context);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   SymbolContextList sc_list;
 
   const ConstString name(context.m_decl_name.getAsString().c_str());
   if (IgnoreName(name, true))
     return;
 
   if (!m_target)
     return;
 
   if (module_sp && namespace_decl) {
     CompilerDeclContext found_namespace_decl;
 
     if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) {
       found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl);
 
       if (found_namespace_decl) {
         context.m_namespace_map->push_back(
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 module_sp, found_namespace_decl));
 
-        LLDB_LOG(log, "  CAS::FEVD[{0}] Found namespace {1} in module {2}",
-                 current_id, name, module_sp->GetFileSpec().GetFilename());
+        LLDB_LOG(log, "  CAS::FEVD Found namespace {1} in module {2}", name,
+                 module_sp->GetFileSpec().GetFilename());
       }
     }
   } else {
     const ModuleList &target_images = m_target->GetImages();
     std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
 
     for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
       lldb::ModuleSP image = target_images.GetModuleAtIndexUnlocked(i);
for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
 
       found_namespace_decl = symbol_file->FindNamespace(name, namespace_decl);
 
       if (found_namespace_decl) {
         context.m_namespace_map->push_back(
             std::pair<lldb::ModuleSP, CompilerDeclContext>(
                 image, found_namespace_decl));
 
-        LLDB_LOG(log, "  CAS::FEVD[{0}] Found namespace {1} in module {2}",
-                 current_id, name, image->GetFileSpec().GetFilename());
+        LLDB_LOG(log, "  CAS::FEVD Found namespace {1} in module {2}", name,
+                 image->GetFileSpec().GetFilename());
       }
     }
   }
 
   if (context.m_found.type)
     return;
 
   TypeList types;
   const bool exact_match = true;
   llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
   if (module_sp && namespace_decl)
     module_sp->FindTypesInNamespace(name, namespace_decl, 1, types);
   else {
     m_target->GetImages().FindTypes(module_sp.get(), name, exact_match, 1,
                                     searched_symbol_files, types);
   }
 
   if (size_t num_types = types.GetSize()) {
     for (size_t ti = 0; ti < num_types; ++ti) {
       lldb::TypeSP type_sp = types.GetTypeAtIndex(ti);
 
       if (log) {
         const char *name_string = type_sp->GetName().GetCString();
 
-        LLDB_LOG(log, "  CAS::FEVD[{0}] Matching type found for \"{1}\": {2}",
-                 current_id, name,
+        LLDB_LOG(log, "  CAS::FEVD Matching type found for \"{1}\": {2}", name,
                  (name_string ? name_string : "<anonymous>"));
       }
 
       CompilerType full_type = type_sp->GetFullCompilerType();
 
       CompilerType copied_clang_type(GuardedCopyType(full_type));
 
       if (!copied_clang_type) {
-        LLDB_LOG(log, "  CAS::FEVD[{0}] - Couldn't export a type",
-                 current_id);
+        LLDB_LOG(log, "  CAS::FEVD - Couldn't export a type");
 
         continue;
       }
 
       context.AddTypeDecl(copied_clang_type);
 
       context.m_found.type = true;
       break;
     }
   }
 
   if (!context.m_found.type) {
     // Try the modules next.
-    FindDeclInModules(context, name, current_id);
+    FindDeclInModules(context, name);
   }
 
   if (!context.m_found.type) {
-    FindDeclInObjCRuntime(context, name, current_id);
+    FindDeclInObjCRuntime(context, name);
   }
 }
 
 template <class D> class TaggedASTDecl {
 public:
   TaggedASTDecl() : decl(nullptr) {}
   TaggedASTDecl(D *_decl) : decl(_decl) {}
   bool IsValid() const { return (decl != nullptr); }

 DeclFromParser<D> DeclFromUser<D>::Import(ClangASTSource &source) {
   DeclFromParser<> parser_generic_decl(source.CopyDecl(this->decl));
   if (parser_generic_decl.IsInvalid())
     return DeclFromParser<D>();
   return DeclFromParser<D>(dyn_cast<D>(parser_generic_decl.decl));
 }
 
 bool ClangASTSource::FindObjCMethodDeclsWithOrigin(
-    unsigned int current_id, NameSearchContext &context,
-    ObjCInterfaceDecl *original_interface_decl, const char *log_info) {
+    NameSearchContext &context, ObjCInterfaceDecl *original_interface_decl,
+    const char *log_info) {
   const DeclarationName &decl_name(context.m_decl_name);
   clang::ASTContext *original_ctx = &original_interface_decl->getASTContext();
 
   Selector original_selector;
 
   if (decl_name.isObjCZeroArgSelector()) {
     IdentifierInfo *ident = &original_ctx->Idents.get(decl_name.getAsString());
     original_selector = original_ctx->Selectors.getSelector(0, &ident);
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));
 
-    LLDB_LOG(log, "  CAS::FOMD[{0}] found ({1}) {2}", current_id, log_info,
+    LLDB_LOG(log, "  CAS::FOMD found ({1}) {2}", log_info,
              ClangUtil::DumpDecl(copied_method_decl));
 
     context.AddNamedDecl(copied_method_decl);
   }
 
   return true;
 }
 
 void ClangASTSource::FindDeclInModules(NameSearchContext &context,
-                                       ConstString name, unsigned current_id) {
+                                       ConstString name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   ClangModulesDeclVendor *modules_decl_vendor =
       m_target->GetClangModulesDeclVendor();
   if (!modules_decl_vendor)
     return;
 
   bool append = false;
   uint32_t max_matches = 1;
   std::vector<clang::NamedDecl *> decls;
 
   if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
     return;
 
   if (log) {
     LLDB_LOG(log,
-             "  CAS::FEVD[{0}] Matching entity found for \"{1}\" in "
+             "  CAS::FEVD Matching entity found for \"{1}\" in "
              "the modules",
-             current_id, name);
+             name);
   }
 
   clang::NamedDecl *const decl_from_modules = decls[0];
 
   if (llvm::isa<clang::TypeDecl>(decl_from_modules) ||
       llvm::isa<clang::ObjCContainerDecl>(decl_from_modules) ||
       llvm::isa<clang::EnumConstantDecl>(decl_from_modules)) {
     clang::Decl *copied_decl = CopyDecl(decl_from_modules);
     clang::NamedDecl *copied_named_decl =
         copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
 
     if (!copied_named_decl) {
-      LLDB_LOG(log,
-               "  CAS::FEVD[{0}] - Couldn't export a type from the modules",
-               current_id);
+      LLDB_LOG(log, "  CAS::FEVD - Couldn't export a type from the modules");
 
       return;
     }
 
     context.AddNamedDecl(copied_named_decl);
 
     context.m_found.type = true;
   }
 }
 
 void ClangASTSource::FindDeclInObjCRuntime(NameSearchContext &context,
-                                           ConstString name,
-                                           unsigned current_id) {
+                                           ConstString name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   lldb::ProcessSP process(m_target->GetProcessSP());
 
   if (!process)
     return;
 
   ObjCLanguageRuntime *language_runtime(ObjCLanguageRuntime::Get(*process));
void ClangASTSource::FindDeclInObjCRuntime(NameSearchContext &context,
   uint32_t max_matches = 1;
   std::vector<clang::NamedDecl *> decls;
 
   auto *clang_decl_vendor = llvm::cast<ClangDeclVendor>(decl_vendor);
   if (!clang_decl_vendor->FindDecls(name, append, max_matches, decls))
     return;
 
   if (log) {
-    LLDB_LOG(log,
-             "  CAS::FEVD[{0}] Matching type found for \"{0}\" in the runtime",
-             current_id, name);
+    LLDB_LOG(log, "  CAS::FEVD Matching type found for \"{0}\" in the runtime",
+             name);
   }
 
   clang::Decl *copied_decl = CopyDecl(decls[0]);
   clang::NamedDecl *copied_named_decl =
       copied_decl ? dyn_cast<clang::NamedDecl>(copied_decl) : nullptr;
 
   if (!copied_named_decl) {
-    LLDB_LOG(log, "  CAS::FEVD[{0}] - Couldn't export a type from the runtime",
-             current_id);
+    LLDB_LOG(log, "  CAS::FEVD - Couldn't export a type from the runtime");
 
     return;
   }
 
   context.AddNamedDecl(copied_named_decl);
 }
 
 void ClangASTSource::FindObjCMethodDecls(NameSearchContext &context) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  static unsigned int invocation_id = 0;
-  unsigned int current_id = invocation_id++;
-
   const DeclarationName &decl_name(context.m_decl_name);
   const DeclContext *decl_ctx(context.m_decl_context);
 
   const ObjCInterfaceDecl *interface_decl =
       dyn_cast<ObjCInterfaceDecl>(decl_ctx);
 
   if (!interface_decl)
     return;
 
   do {
     ClangASTImporter::DeclOrigin original = m_ast_importer_sp->GetDeclOrigin(interface_decl);
 
     if (!original.Valid())
       break;
 
     ObjCInterfaceDecl *original_interface_decl =
         dyn_cast<ObjCInterfaceDecl>(original.decl);
 
-    if (FindObjCMethodDeclsWithOrigin(current_id, context,
-                                      original_interface_decl, "at origin"))
+    if (FindObjCMethodDeclsWithOrigin(context, original_interface_decl,
+                                      "at origin"))
       return; // found it, no need to look any further
   } while (false);
 
   StreamString ss;
 
   if (decl_name.isObjCZeroArgSelector()) {
     ss.Printf("%s", decl_name.getAsString().c_str());
   } else if (decl_name.isObjCOneArgSelector()) {
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} '{2}' "
+           "ClangASTSource::FindObjCMethodDecls on (ASTContext*){1} '{2}' "
            "for selector [{3} {4}]",
-           current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+           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();
 
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;
 
-        LLDB_LOG(log, "  CAS::FOMD[{0}] found (in symbols)\n{1}", current_id,
+        LLDB_LOG(log, "  CAS::FOMD found (in symbols)\n{1}",
                  ClangUtil::DumpDecl(copied_method_decl));
 
         context.AddNamedDecl(copied_method_decl);
       }
     }
 
     return;
   }
do {
 
     DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
         complete_interface_decl);
 
     if (complete_interface_decl == interface_decl)
       break; // already checked this one
 
     LLDB_LOG(log,
-             "CAS::FOPD[{0}] trying origin "
+             "CAS::FOPD trying origin "
              "(ObjCInterfaceDecl*){1}/(ASTContext*){2}...",
-             current_id, complete_interface_decl,
-             &complete_iface_decl->getASTContext());
+             complete_interface_decl, &complete_iface_decl->getASTContext());
 
-    FindObjCMethodDeclsWithOrigin(current_id, context, complete_interface_decl,
+    FindObjCMethodDeclsWithOrigin(context, complete_interface_decl,
                                   "in debug info");
 
     return;
   } while (false);
 
   do {
     // Check the modules only if the debug information didn't have a complete
     // interface.
if (ClangModulesDeclVendor *modules_decl_vendor =
         break;
 
       ObjCInterfaceDecl *interface_decl_from_modules =
           dyn_cast<ObjCInterfaceDecl>(decls[0]);
 
       if (!interface_decl_from_modules)
         break;
 
-      if (FindObjCMethodDeclsWithOrigin(
-              current_id, context, interface_decl_from_modules, "in modules"))
+      if (FindObjCMethodDeclsWithOrigin(context, interface_decl_from_modules,
+                                        "in modules"))
         return;
     }
   } while (false);
 
   do {
     // Check the runtime only if the debug information didn't have a complete
     // interface and the modules don't get us anywhere.
 
if (!clang_decl_vendor->FindDecls(interface_name, append, max_matches,
       break;
 
     ObjCInterfaceDecl *runtime_interface_decl =
         dyn_cast<ObjCInterfaceDecl>(decls[0]);
 
     if (!runtime_interface_decl)
       break;
 
-    FindObjCMethodDeclsWithOrigin(current_id, context, runtime_interface_decl,
+    FindObjCMethodDeclsWithOrigin(context, runtime_interface_decl,
                                   "in runtime");
   } while (false);
 }
 
 static bool FindObjCPropertyAndIvarDeclsWithOrigin(
-    unsigned int current_id, NameSearchContext &context, ClangASTSource &source,
+    NameSearchContext &context, ClangASTSource &source,
     DeclFromUser<const ObjCInterfaceDecl> &origin_iface_decl) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (origin_iface_decl.IsInvalid())
     return false;
 
   std::string name_str = context.m_decl_name.getAsString();
   StringRef name(name_str);
   IdentifierInfo &name_identifier(
       origin_iface_decl->getASTContext().Idents.get(name));
 
   DeclFromUser<ObjCPropertyDecl> origin_property_decl(
       origin_iface_decl->FindPropertyDeclaration(
           &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()) {
-      LLDB_LOG(log, "  CAS::FOPD[{0}] found\n{1}", current_id,
+      LLDB_LOG(log, "  CAS::FOPD found\n{1}",
                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) {
-        LLDB_LOG(log, "  CAS::FOPD[{0}] found\n{1}", current_id,
+        LLDB_LOG(log, "  CAS::FOPD found\n{1}",
                  ClangUtil::DumpDecl(parser_ivar_decl.decl));
       }
 
       context.AddNamedDecl(parser_ivar_decl.decl);
       found = true;
     }
   }
 
   return found;
 }
 
 void ClangASTSource::FindObjCPropertyAndIvarDecls(NameSearchContext &context) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
-  static unsigned int invocation_id = 0;
-  unsigned int current_id = invocation_id++;
-
   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 "
+           "ClangASTSource::FindObjCPropertyAndIvarDecls on "
            "(ASTContext*){1} '{2}' for '{3}.{4}'",
-           current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
+           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))
+  if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, origin_iface_decl))
     return;
 
   LLDB_LOG(log,
-           "CAS::FOPD[{0}] couldn't find the property on origin "
+           "CAS::FOPD couldn't find the property on origin "
            "(ObjCInterfaceDecl*){1}/(ASTContext*){2}, searching "
            "elsewhere...",
-           current_id, origin_iface_decl.decl,
-           &origin_iface_decl->getASTContext());
+           origin_iface_decl.decl, &origin_iface_decl->getASTContext());
 
   SymbolContext null_sc;
   TypeList type_list;
 
   do {
     ObjCInterfaceDecl *complete_interface_decl = GetCompleteObjCInterface(
         const_cast<ObjCInterfaceDecl *>(parser_iface_decl.decl));
 
     if (!complete_interface_decl)
       break;
 
     // We found the complete interface.  The runtime never needs to be queried
     // in this scenario.
 
     DeclFromUser<const ObjCInterfaceDecl> complete_iface_decl(
         complete_interface_decl);
 
     if (complete_iface_decl.decl == origin_iface_decl.decl)
       break; // already checked this one
 
     LLDB_LOG(log,
-             "CAS::FOPD[{0}] trying origin "
+             "CAS::FOPD trying origin "
              "(ObjCInterfaceDecl*){1}/(ASTContext*){2}...",
-             current_id, complete_iface_decl.decl,
-             &complete_iface_decl->getASTContext());
+             complete_iface_decl.decl, &complete_iface_decl->getASTContext());
 
-    FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this,
-                                           complete_iface_decl);
+    FindObjCPropertyAndIvarDeclsWithOrigin(context, *this, complete_iface_decl);
 
     return;
   } while (false);
 
   do {
     // Check the modules only if the debug information didn't have a complete
     // interface.
 
DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_modules(
         dyn_cast<ObjCInterfaceDecl>(decls[0]));
 
     if (!interface_decl_from_modules.IsValid())
       break;
 
     LLDB_LOG(log,
              "CAS::FOPD[{0}] trying module "
              "(ObjCInterfaceDecl*){1}/(ASTContext*){2}...",
-             current_id, interface_decl_from_modules.decl,
+             interface_decl_from_modules.decl,
              &interface_decl_from_modules->getASTContext());
 
-    if (FindObjCPropertyAndIvarDeclsWithOrigin(current_id, context, *this,
+    if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this,
                                                interface_decl_from_modules))
       return;
   } while (false);
 
   do {
     // Check the runtime only if the debug information didn't have a complete
     // interface and nothing was in the modules.
 
DeclFromUser<const ObjCInterfaceDecl> interface_decl_from_runtime(
         dyn_cast<ObjCInterfaceDecl>(decls[0]));
 
     if (!interface_decl_from_runtime.IsValid())
       break;
 
     LLDB_LOG(log,
              "CAS::FOPD[{0}] trying runtime "
              "(ObjCInterfaceDecl*){1}/(ASTContext*){2}...",
-             current_id, interface_decl_from_runtime.decl,
+             interface_decl_from_runtime.decl,
              &interface_decl_from_runtime->getASTContext());
 
-    if (FindObjCPropertyAndIvarDeclsWithOrigin(
-            current_id, context, *this, interface_decl_from_runtime))
+    if (FindObjCPropertyAndIvarDeclsWithOrigin(context, *this,
+                                               interface_decl_from_runtime))
       return;
   } while (false);
 }
 
 typedef llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsetMap;
 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap;
 
 template <class D, class O>
bool ExtractBaseOffsets(const ASTRecordLayout &record_layout,
   return true;
 }
 
 bool ClangASTSource::layoutRecordType(const RecordDecl *record, uint64_t &size,
                                       uint64_t &alignment,
                                       FieldOffsetMap &field_offsets,
                                       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} '{2}' for (RecordDecl*)"
+           "LayoutRecordType on (ASTContext*){1} '{2}' for (RecordDecl*)"
            "{3} [name = '{4}']",
-           current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
-           record, record->getName());
+           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;
 
if (!ImportOffsetMap(field_offsets, origin_field_offsets, *this) ||
                        *this))
     return false;
 
   size = record_layout.getSize().getQuantity() * m_ast_context->getCharWidth();
   alignment = record_layout.getAlignment().getQuantity() *
               m_ast_context->getCharWidth();
 
   if (log) {
-    LLDB_LOG(log, "LRT[{0}] returned:", current_id);
-    LLDB_LOG(log, "LRT[{0}]   Original = (RecordDecl*)%p", current_id,
+    LLDB_LOG(log, "LRT returned:");
+    LLDB_LOG(log, "LRT   Original = (RecordDecl*)%p",
              static_cast<const void *>(origin_record.decl));
-    LLDB_LOG(log, "LRT[{0}]   Size = %" PRId64, current_id, size);
-    LLDB_LOG(log, "LRT[{0}]   Alignment = %" PRId64, current_id, alignment);
-    LLDB_LOG(log, "LRT[{0}]   Fields:", current_id);
+    LLDB_LOG(log, "LRT   Size = %" PRId64, size);
+    LLDB_LOG(log, "LRT   Alignment = %" PRId64, alignment);
+    LLDB_LOG(log, "LRT   Fields:");
     for (RecordDecl::field_iterator fi = record->field_begin(),
                                     fe = record->field_end();
          fi != fe; ++fi) {
       LLDB_LOG(log,
                "LRT[{0}]     (FieldDecl*){1}, Name = '{2}', Offset = {3} bits",
-               current_id, *fi, fi->getName(), field_offsets[*fi]);
+               *fi, fi->getName(), field_offsets[*fi]);
     }
     DeclFromParser<const CXXRecordDecl> parser_cxx_record =
         DynCast<const CXXRecordDecl>(parser_record);
     if (parser_cxx_record.IsValid()) {
-      LLDB_LOG(log, "LRT[{0}]   Bases:", current_id);
+      LLDB_LOG(log, "LRT   Bases:");
       for (CXXRecordDecl::base_class_const_iterator
                bi = parser_cxx_record->bases_begin(),
                be = parser_cxx_record->bases_end();
            bi != be; ++bi) {
         bool is_virtual = bi->isVirtual();
 
         QualType base_type = bi->getType();
         const RecordType *base_record_type = base_type->getAs<RecordType>();
         DeclFromParser<RecordDecl> base_record(base_record_type->getDecl());
         DeclFromParser<CXXRecordDecl> base_cxx_record =
             DynCast<CXXRecordDecl>(base_record);
 
         LLDB_LOG(log,
-                 "LRT[{0}]     {1}(CXXRecordDecl*){2}, Name = '{3}', Offset = "
+                 "LRT     {1}(CXXRecordDecl*){2}, Name = '{3}', Offset = "
                  "{4} chars",
-                 current_id, (is_virtual ? "Virtual " : ""),
-                 base_cxx_record.decl, base_cxx_record.decl->getName(),
+                 (is_virtual ? "Virtual " : ""), base_cxx_record.decl,
+                 base_cxx_record.decl->getName(),
                  (is_virtual
                       ? virtual_base_offsets[base_cxx_record.decl].getQuantity()
                       : base_offsets[base_cxx_record.decl].getQuantity()));
       }
     } else {
-      LLDB_LOG(log, "LRD[{0}]   Not a CXXRecord, so no bases", current_id);
+      LLDB_LOG(log, "LRD   Not a CXXRecord, so no bases");
     }
   }
 
   return true;
 }
 
 void ClangASTSource::CompleteNamespaceMap(
     ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
     ClangASTImporter::NamespaceMapSP &parent_map) const {
-  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} '{2}' Searching "
+               "CompleteNamespaceMap 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());
+               m_ast_context, m_clang_ast_context->getDisplayName(), name,
+               parent_map->begin()->second.GetName());
     else
       LLDB_LOG(log,
-               "CompleteNamespaceMap[{0}] on (ASTContext*){1} '{2}' Searching "
+               "CompleteNamespaceMap on (ASTContext*){1} '{2}' Searching "
                "for namespace {3}",
-               current_id, m_ast_context, m_clang_ast_context->getDisplayName(),
-               name);
+               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;
 
for (ClangASTImporter::NamespaceMap::iterator i = parent_map->begin(),
           symbol_file->FindNamespace(name, module_parent_namespace_decl);
 
       if (!found_namespace_decl)
         continue;
 
       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
           module_sp, found_namespace_decl));
 
-      LLDB_LOG(log, "  CMN[{0}] Found namespace {1} in module {2}", current_id,
-               name, module_sp->GetFileSpec().GetFilename());
+      LLDB_LOG(log, "  CMN Found namespace {1} in module {2}", name,
+               module_sp->GetFileSpec().GetFilename());
     }
   } else {
     const ModuleList &target_images = m_target->GetImages();
     std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
 
     CompilerDeclContext null_namespace_decl;
 
     for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
for (size_t i = 0, e = target_images.GetSize(); i < e; ++i) {
           symbol_file->FindNamespace(name, null_namespace_decl);
 
       if (!found_namespace_decl)
         continue;
 
       namespace_map->push_back(std::pair<lldb::ModuleSP, CompilerDeclContext>(
           image, found_namespace_decl));
 
-      LLDB_LOG(log, "  CMN[{0}] Found namespace {1} in module {2}", current_id,
-               name, image->GetFileSpec().GetFilename());
+      LLDB_LOG(log, "  CMN[{0}] Found namespace {1} in module {2}", name,
+               image->GetFileSpec().GetFilename());
     }
   }
 }
 
 NamespaceDecl *ClangASTSource::AddNamespace(
     NameSearchContext &context,
     ClangASTImporter::NamespaceMapSP &namespace_decls) {
   if (!namespace_decls)

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

public:
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///
   /// \param[in] module
   ///     If non-NULL, the module to query.
   ///
   /// \param[in] namespace_decl
   ///     If valid and module is non-NULL, the parent namespace.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
   void FindExternalVisibleDecls(NameSearchContext &context,
                                 lldb::ModuleSP module,
-                                const CompilerDeclContext &namespace_decl,
-                                unsigned int current_id);
+                                const CompilerDeclContext &namespace_decl);
 
 protected:
   /// Retrieves the declaration with the given name from the storage of
   /// persistent declarations.
   ///
   /// \return
   ///     A persistent decl with the given name or a nullptr.
   virtual clang::NamedDecl *GetPersistentDecl(ConstString name);
private:
   /// Searches the persistent decls of the target for entities with the
   /// given name.
   ///
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///
   /// \param[in] name
   ///     The name of the entities that need to be found.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
-  void SearchPersistenDecls(NameSearchContext &context, const ConstString name,
-                            unsigned int current_id);
+  void SearchPersistenDecls(NameSearchContext &context, const ConstString name);
 
   /// Handles looking up $__lldb_class which requires special treatment.
   ///
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
-  void LookUpLldbClass(NameSearchContext &context, unsigned int current_id);
+  void LookUpLldbClass(NameSearchContext &context);
 
   /// Handles looking up $__lldb_objc_class which requires special treatment.
   ///
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
-  void LookUpLldbObjCClass(NameSearchContext &context, unsigned int current_id);
+  void LookUpLldbObjCClass(NameSearchContext &context);
 
   /// Handles looking up the synthetic namespace that contains our local
   /// variables for the current frame.
   ///
   /// \param[in] sym_ctx
   ///     The current SymbolContext of this frame.
   ///
   /// \param[in] name_context
   ///     The NameSearchContext that can construct Decls for this name.
   void LookupLocalVarNamespace(SymbolContext &sym_ctx,
                                NameSearchContext &name_context);
 
   /// Lookup entities in the ClangModulesDeclVendor.
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///
   /// \param[in] name
   ///     The name of the entities that need to be found.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
-  void LookupInModulesDeclVendor(NameSearchContext &context, ConstString name,
-                                 unsigned current_id);
+  void LookupInModulesDeclVendor(NameSearchContext &context, ConstString name);
 
   /// Looks up a local variable.
   ///
   /// \param[in] context
   ///     The NameSearchContext that can construct Decls for this name.
   ///
   /// \param[in] name
   ///     The name of the entities that need to be found.
   ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
-  ///
   /// \param[in] sym_ctx
   ///     The current SymbolContext of this frame.
   ///
   /// \param[in] namespace_decl
   ///     The parent namespace if there is one.
   ///
   /// \return
   ///    True iff a local variable was found.
   bool LookupLocalVariable(NameSearchContext &context, ConstString name,
-                           unsigned current_id, SymbolContext &sym_ctx,
+                           SymbolContext &sym_ctx,
                            const CompilerDeclContext &namespace_decl);
 
   /// Searches for functions in the given SymbolContextList.
   ///
   /// \param[in] sc_list
   ///     The SymbolContextList to search.
   ///
   /// \param[in] frame_decl_context
private:
   /// \param[in] module_sp
   ///     If non-NULL, the module to query.
   ///
   /// \param[in] name
   ///     The name of the function that should be find.
   ///
   /// \param[in] namespace_decl
   ///     If valid and module is non-NULL, the parent namespace.
-  ///
-  /// \param[in] current_id
-  ///     The ID for the current FindExternalVisibleDecls invocation,
-  ///     for logging purposes.
   void LookupFunction(NameSearchContext &context, lldb::ModuleSP module_sp,
                       ConstString name,
-                      const CompilerDeclContext &namespace_decl,
-                      unsigned current_id);
+                      const CompilerDeclContext &namespace_decl);
 
   /// Given a target, find a variable that matches the given name and type.
   ///
   /// \param[in] target
   ///     The target to use as a basis for finding the variable.
   ///
   /// \param[in] module
   ///     If non-NULL, the module to search.
private:
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] var
   ///     The LLDB Variable that needs a Decl.
   ///
   /// \param[in] valobj
   ///     The LLDB ValueObject for that variable.
   void AddOneVariable(NameSearchContext &context, lldb::VariableSP var,
-                      lldb::ValueObjectSP valobj, unsigned int current_id);
+                      lldb::ValueObjectSP valobj);
 
   /// Use the NameSearchContext to generate a Decl for the given persistent
   /// variable, and put it in the list of found entities.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] pvar_sp
   ///     The persistent variable that needs a Decl.
-  ///
-  /// \param[in] current_id
-  ///     The ID of the current invocation of FindExternalVisibleDecls
-  ///     for logging purposes.
   void AddOneVariable(NameSearchContext &context,
-                      lldb::ExpressionVariableSP &pvar_sp,
-                      unsigned int current_id);
+                      lldb::ExpressionVariableSP &pvar_sp);
 
   /// Use the NameSearchContext to generate a Decl for the given LLDB symbol
   /// (treated as a variable), and put it in the list of found entities.
-  void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol,
-                             unsigned int current_id);
+  void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol);
 
   /// Use the NameSearchContext to generate a Decl for the given function.
   /// (Functions are not placed in the Tuple list.)  Can handle both fully
   /// typed functions and generic functions.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] fun
   ///     The Function that needs to be created.  If non-NULL, this is
   ///     a fully-typed function.
   ///
   /// \param[in] sym
   ///     The Symbol that corresponds to a function that needs to be
   ///     created with generic type (unitptr_t foo(...)).
-  void AddOneFunction(NameSearchContext &context, Function *fun, Symbol *sym,
-                      unsigned int current_id);
+  void AddOneFunction(NameSearchContext &context, Function *fun, Symbol *sym);
 
   /// Use the NameSearchContext to generate a Decl for the given register.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] reg_info
   ///     The information corresponding to that register.
-  void AddOneRegister(NameSearchContext &context, const RegisterInfo *reg_info,
-                      unsigned int current_id);
+  void AddOneRegister(NameSearchContext &context, const RegisterInfo *reg_info);
 
   /// Use the NameSearchContext to generate a Decl for the given type.  (Types
   /// are not placed in the Tuple list.)
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] type
   ///     The type that needs to be created.
-  void AddOneType(NameSearchContext &context, const TypeFromUser &type,
-                  unsigned int current_id);
+  void AddOneType(NameSearchContext &context, const TypeFromUser &type);
 
   /// Generate a Decl for "*this" and add a member function declaration to it
   /// for the expression, then report it.
   ///
   /// \param[in] context
   ///     The NameSearchContext to use when constructing the Decl.
   ///
   /// \param[in] type
   ///     The type for *this.
-  void AddThisType(NameSearchContext &context, const TypeFromUser &type,
-                   unsigned int current_id);
+  void AddThisType(NameSearchContext &context, const TypeFromUser &type);
 
   /// Move a type out of the current ASTContext into another, but make sure to
   /// export all components of the type also.
   ///
   /// \param[in] target
   ///     The TypeSystemClang to move to.
   /// \param[in] source
   ///     The TypeSystemClang to move from.  This is assumed to be going away.

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

void ClangExpressionDeclMap::FindExternalVisibleDecls(
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (GetImportInProgress()) {
     if (log && log->GetVerbose())
       LLDB_LOGF(log, "Ignoring a query during an import");
     return;
   }
 
-  static unsigned int invocation_id = 0;
-  unsigned int current_id = invocation_id++;
-
   if (log) {
     if (!context.m_decl_context)
       LLDB_LOGF(log,
-                "ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for "
+                "ClangExpressionDeclMap::FindExternalVisibleDecls for "
                 "'%s' in a NULL DeclContext",
-                current_id, name.GetCString());
+                name.GetCString());
     else if (const NamedDecl *context_named_decl =
                  dyn_cast<NamedDecl>(context.m_decl_context))
       LLDB_LOGF(log,
-                "ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for "
+                "ClangExpressionDeclMap::FindExternalVisibleDecls for "
                 "'%s' in '%s'",
-                current_id, name.GetCString(),
+                name.GetCString(),
                 context_named_decl->getNameAsString().c_str());
     else
       LLDB_LOGF(log,
-                "ClangExpressionDeclMap::FindExternalVisibleDecls[%u] for "
+                "ClangExpressionDeclMap::FindExternalVisibleDecls for "
                 "'%s' in a '%s'",
-                current_id, name.GetCString(),
-                context.m_decl_context->getDeclKindName());
+                name.GetCString(), context.m_decl_context->getDeclKindName());
   }
 
   if (const NamespaceDecl *namespace_context =
           dyn_cast<NamespaceDecl>(context.m_decl_context)) {
     if (namespace_context->getName().str() ==
         std::string(g_lldb_local_vars_namespace_cstr)) {
       CompilerDeclContext compiler_decl_ctx =
           m_clang_ast_context->CreateDeclContext(
               const_cast<clang::DeclContext *>(context.m_decl_context));
-      FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx,
-                               current_id);
+      FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx);
       return;
     }
 
     ClangASTImporter::NamespaceMapSP namespace_map =
         m_ast_importer_sp->GetNamespaceMap(namespace_context);
 
     if (!namespace_map)
       return;
 
     if (log && log->GetVerbose())
-      log->Printf("  CEDM::FEVD[%u] Inspecting (NamespaceMap*)%p (%d entries)",
-                  current_id, static_cast<void *>(namespace_map.get()),
+      log->Printf("  CEDM::FEVD Inspecting (NamespaceMap*)%p (%d entries)",
+                  static_cast<void *>(namespace_map.get()),
                   (int)namespace_map->size());
 
     for (ClangASTImporter::NamespaceMap::iterator i = namespace_map->begin(),
                                                   e = namespace_map->end();
          i != e; ++i) {
       if (log)
-        log->Printf("  CEDM::FEVD[%u] Searching namespace %s in module %s",
-                    current_id, i->second.GetName().AsCString(),
+        log->Printf("  CEDM::FEVD Searching namespace %s in module %s",
+                    i->second.GetName().AsCString(),
                     i->first->GetFileSpec().GetFilename().GetCString());
 
-      FindExternalVisibleDecls(context, i->first, i->second, current_id);
+      FindExternalVisibleDecls(context, i->first, i->second);
     }
   } else if (isa<TranslationUnitDecl>(context.m_decl_context)) {
     CompilerDeclContext namespace_decl;
 
     if (log)
-      log->Printf("  CEDM::FEVD[%u] Searching the root namespace", current_id);
+      log->Printf("  CEDM::FEVD Searching the root namespace");
 
-    FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl,
-                             current_id);
+    FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
   }
 
   ClangASTSource::FindExternalVisibleDecls(context);
 }
 
 void ClangExpressionDeclMap::MaybeRegisterFunctionBody(
     FunctionDecl *copied_function_decl) {
   if (copied_function_decl->getBody() && m_parser_vars->m_code_gen) {
clang::NamedDecl *ClangExpressionDeclMap::GetPersistentDecl(ConstString name) {
   TypeSystemClang::GetScratch(*target);
 
   if (!m_parser_vars->m_persistent_vars)
     return nullptr;
   return m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
 }
 
 void ClangExpressionDeclMap::SearchPersistenDecls(NameSearchContext &context,
-                                                  const ConstString name,
-                                                  unsigned int current_id) {
+                                                  const ConstString name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   NamedDecl *persistent_decl = GetPersistentDecl(name);
 
   if (!persistent_decl)
     return;
 
   Decl *parser_persistent_decl = CopyDecl(persistent_decl);
 
   if (!parser_persistent_decl)
     return;
 
   NamedDecl *parser_named_decl = dyn_cast<NamedDecl>(parser_persistent_decl);
 
   if (!parser_named_decl)
     return;
 
   if (clang::FunctionDecl *parser_function_decl =
           llvm::dyn_cast<clang::FunctionDecl>(parser_named_decl)) {
     MaybeRegisterFunctionBody(parser_function_decl);
   }
 
-  LLDB_LOGF(log, "  CEDM::FEVD[%u] Found persistent decl %s", current_id,
-            name.GetCString());
+  LLDB_LOG(log, "  CEDM::FEVD Found persistent decl %s", name);
 
   context.AddNamedDecl(parser_named_decl);
 }
 
-void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context,
-                                             unsigned int current_id) {
+void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
   SymbolContext sym_ctx;
   if (frame != nullptr)
     sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                       lldb::eSymbolContextBlock);
 
   if (m_ctx_obj) {
     Status status;
     lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
     if (!ctx_obj_ptr || status.Fail())
       return;
 
-    AddThisType(context, TypeFromUser(m_ctx_obj->GetCompilerType()),
-                current_id);
+    AddThisType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));
 
     m_struct_vars->m_object_pointer_type =
         TypeFromUser(ctx_obj_ptr->GetCompilerType());
 
     return;
   }
 
   // Clang is looking for the type of "this"
void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
   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(),
                                  function_decl_ctx.GetTypeSystem());
 
-    LLDB_LOG(log, "  CEDM::FEVD[{0}] Adding type for $__lldb_class: {1}",
-             current_id, class_qual_type.getAsString());
+    LLDB_LOG(log, "  CEDM::FEVD Adding type for $__lldb_class: {1}",
+             class_qual_type.getAsString());
 
-    AddThisType(context, class_user_type, current_id);
+    AddThisType(context, class_user_type);
 
     if (method_decl->isInstance()) {
       // self is a pointer to the object
 
       QualType class_pointer_type =
           method_decl->getASTContext().getPointerType(class_qual_type);
 
       TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
if (this_var && this_var->IsInScope(frame) &&
     Type *this_type = this_var->GetType();
 
     if (!this_type)
       return;
 
     TypeFromUser pointee_type =
         this_type->GetForwardCompilerType().GetPointeeType();
 
-    LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_class: {1}", current_id,
+    LLDB_LOG(log, "  FEVD Adding type for $__lldb_class: {1}",
              ClangUtil::GetQualType(pointee_type).getAsString());
 
-    AddThisType(context, pointee_type, current_id);
+    AddThisType(context, pointee_type);
     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) {
+void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
 
   if (m_ctx_obj) {
     Status status;
     lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
     if (!ctx_obj_ptr || status.Fail())
       return;
 
-    AddOneType(context, TypeFromUser(m_ctx_obj->GetCompilerType()), current_id);
+    AddOneType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));
 
     m_struct_vars->m_object_pointer_type =
         TypeFromUser(ctx_obj_ptr->GetCompilerType());
 
     return;
   }
 
   // Clang is looking for the type of "*self"
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(),
                                  function_decl_ctx.GetTypeSystem());
 
     LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
-             current_id, ClangUtil::ToString(interface_type));
+             ClangUtil::ToString(interface_type));
 
-    AddOneType(context, class_user_type, current_id);
+    AddOneType(context, class_user_type);
 
     if (method_decl->isInstanceMethod()) {
       // self is a pointer to the object
 
       QualType class_pointer_type =
           method_decl->getASTContext().getObjCObjectPointerType(
               QualType(interface_type, 0));
 
void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context) {
   if (!TypeSystemClang::IsObjCObjectPointerType(self_clang_type))
     return;
   self_clang_type = self_clang_type.GetPointeeType();
 
   if (!self_clang_type)
     return;
 
   LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
-           current_id, ClangUtil::ToString(self_type->GetFullCompilerType()));
+           ClangUtil::ToString(self_type->GetFullCompilerType()));
 
   TypeFromUser class_user_type(self_clang_type);
 
-  AddOneType(context, class_user_type, current_id);
+  AddOneType(context, class_user_type);
 
   TypeFromUser self_user_type(self_type->GetFullCompilerType());
 
   m_struct_vars->m_object_pointer_type = self_user_type;
 }
 
 void ClangExpressionDeclMap::LookupLocalVarNamespace(
     SymbolContext &sym_ctx, NameSearchContext &name_context) {
void ClangExpressionDeclMap::LookupLocalVarNamespace(
 
   name_context.AddNamedDecl(namespace_decl);
   clang::DeclContext *ctxt = clang::Decl::castToDeclContext(namespace_decl);
   ctxt->setHasExternalVisibleStorage(true);
   name_context.m_found.local_vars_nsp = true;
 }
 
 void ClangExpressionDeclMap::LookupInModulesDeclVendor(
-    NameSearchContext &context, ConstString name, unsigned current_id) {
+    NameSearchContext &context, ConstString name) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (!m_target)
     return;
 
   auto *modules_decl_vendor = m_target->GetClangModulesDeclVendor();
   if (!modules_decl_vendor)
     return;
 
   bool append = false;
   uint32_t max_matches = 1;
   std::vector<clang::NamedDecl *> decls;
 
   if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
     return;
 
   assert(!decls.empty() && "FindDecls returned true but no decls?");
   clang::NamedDecl *const decl_from_modules = decls[0];
 
   LLDB_LOG(log,
-           "  CAS::FEVD[{0}] Matching decl found for "
+           "  CAS::FEVD Matching decl found for "
            "\"{1}\" in the modules",
-           current_id, name);
+           name);
 
   clang::Decl *copied_decl = CopyDecl(decl_from_modules);
   if (!copied_decl) {
-    LLDB_LOG(log,
-             "  CAS::FEVD[{0}] - Couldn't export a "
-             "declaration from the modules",
-             current_id);
+    LLDB_LOG(log, "  CAS::FEVD - Couldn't export a "
+                  "declaration from the modules");
     return;
   }
 
   if (auto copied_function = dyn_cast<clang::FunctionDecl>(copied_decl)) {
     MaybeRegisterFunctionBody(copied_function);
 
     context.AddNamedDecl(copied_function);
 
     context.m_found.function_with_type_info = true;
     context.m_found.function = true;
   } else if (auto copied_var = dyn_cast<clang::VarDecl>(copied_decl)) {
     context.AddNamedDecl(copied_var);
     context.m_found.variable = true;
   }
 }
 
 bool ClangExpressionDeclMap::LookupLocalVariable(
-    NameSearchContext &context, ConstString name, unsigned current_id,
-    SymbolContext &sym_ctx, const CompilerDeclContext &namespace_decl) {
+    NameSearchContext &context, ConstString name, SymbolContext &sym_ctx,
+    const CompilerDeclContext &namespace_decl) {
   if (sym_ctx.block == nullptr)
     return false;
 
   CompilerDeclContext decl_context = sym_ctx.block->GetDeclContext();
   if (!decl_context)
     return false;
 
   // Make sure that the variables are parsed so that we have the
for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi) {
         var = candidate_var;
         break;
       }
     }
 
     if (var && !variable_found) {
       variable_found = true;
       ValueObjectSP valobj = ValueObjectVariable::Create(frame, var);
-      AddOneVariable(context, var, valobj, current_id);
+      AddOneVariable(context, var, valobj);
       context.m_found.variable = true;
     }
   }
   return variable_found;
 }
 
 /// Structure to hold the info needed when comparing function
 /// declarations.
SymbolContextList ClangExpressionDeclMap::SearchFunctionsInSymbolContexts(
 
   // Rejoin the lists with the functions in front.
   sc_func_list.Append(sc_sym_list);
   return sc_func_list;
 }
 
 void ClangExpressionDeclMap::LookupFunction(
     NameSearchContext &context, lldb::ModuleSP module_sp, ConstString name,
-    const CompilerDeclContext &namespace_decl, unsigned current_id) {
+    const CompilerDeclContext &namespace_decl) {
   if (!m_parser_vars)
     return;
 
   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
 
   std::vector<clang::NamedDecl *> decls_from_modules;
 
   if (target) {
for (uint32_t index = 0, num_indices = sc_list.GetSize();
 
         if (!decl_ctx)
           continue;
 
         // Filter out class/instance methods.
         if (decl_ctx.IsClassMethod(nullptr, nullptr, nullptr))
           continue;
 
-        AddOneFunction(context, sym_ctx.function, nullptr, current_id);
+        AddOneFunction(context, sym_ctx.function, nullptr);
         context.m_found.function_with_type_info = true;
         context.m_found.function = true;
       } else if (sym_ctx.symbol) {
         if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target) {
           sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
           if (sym_ctx.symbol == nullptr)
             continue;
         }
if (!context.m_found.function_with_type_info) {
             context.m_found.function_with_type_info = true;
           }
         }
       }
     }
 
     if (!context.m_found.function_with_type_info) {
       if (extern_symbol) {
-        AddOneFunction(context, nullptr, extern_symbol, current_id);
+        AddOneFunction(context, nullptr, extern_symbol);
         context.m_found.function = true;
       } else if (non_extern_symbol) {
-        AddOneFunction(context, nullptr, non_extern_symbol, current_id);
+        AddOneFunction(context, nullptr, non_extern_symbol);
         context.m_found.function = true;
       }
     }
   }
 }
 
 void ClangExpressionDeclMap::FindExternalVisibleDecls(
     NameSearchContext &context, lldb::ModuleSP module_sp,
-    const CompilerDeclContext &namespace_decl, unsigned int current_id) {
+    const CompilerDeclContext &namespace_decl) {
   assert(m_ast_context);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   const ConstString name(context.m_decl_name.getAsString().c_str());
   if (IgnoreName(name, false))
     return;
 
   // Only look for functions by name out in our symbols if the function doesn't
   // start with our phony prefix of '$'
 
   Target *target = nullptr;
   StackFrame *frame = nullptr;
   SymbolContext sym_ctx;
   if (m_parser_vars) {
     target = m_parser_vars->m_exe_ctx.GetTargetPtr();
     frame = m_parser_vars->m_exe_ctx.GetFramePtr();
   }
   if (frame != nullptr)
     sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                       lldb::eSymbolContextBlock);
 
   // Try the persistent decls, which take precedence over all else.
   if (!namespace_decl)
-    SearchPersistenDecls(context, name, current_id);
+    SearchPersistenDecls(context, name);
 
   if (name.GetStringRef().startswith("$") && !namespace_decl) {
     if (name == "$__lldb_class") {
-      LookUpLldbClass(context, current_id);
+      LookUpLldbClass(context);
       return;
     }
 
     if (name == "$__lldb_objc_class") {
-      LookUpLldbObjCClass(context, current_id);
+      LookUpLldbObjCClass(context);
       return;
     }
     if (name == g_lldb_local_vars_namespace_cstr) {
       LookupLocalVarNamespace(sym_ctx, context);
       return;
     }
 
     // any other $__lldb names should be weeded out now
     if (name.GetStringRef().startswith("$__lldb"))
       return;
 
     // No ParserVars means we can't do register or variable lookup.
     if (!m_parser_vars || !m_parser_vars->m_persistent_vars)
       return;
 
     ExpressionVariableSP pvar_sp(
         m_parser_vars->m_persistent_vars->GetVariable(name));
 
     if (pvar_sp) {
-      AddOneVariable(context, pvar_sp, current_id);
+      AddOneVariable(context, pvar_sp);
       return;
     }
 
     assert(name.GetStringRef().startswith("$"));
     llvm::StringRef reg_name = name.GetStringRef().substr(1);
 
     if (m_parser_vars->m_exe_ctx.GetRegisterContext()) {
       const RegisterInfo *reg_info(
           m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(
               reg_name));
 
       if (reg_info) {
-        LLDB_LOGF(log, "  CEDM::FEVD[%u] Found register %s", current_id,
-                  reg_info->name);
+        LLDB_LOGF(log, "  CEDM::FEVD Found register %s", reg_info->name);
 
-        AddOneRegister(context, reg_info, current_id);
+        AddOneRegister(context, reg_info);
       }
     }
     return;
   }
 
   bool local_var_lookup = !namespace_decl || (namespace_decl.GetName() ==
                                               g_lldb_local_vars_namespace_cstr);
   if (frame && local_var_lookup)
-    if (LookupLocalVariable(context, name, current_id, sym_ctx, namespace_decl))
+    if (LookupLocalVariable(context, name, sym_ctx, namespace_decl))
       return;
 
   if (target) {
     ValueObjectSP valobj;
     VariableSP var;
     var = FindGlobalVariable(*target, module_sp, name, namespace_decl);
 
     if (var) {
       valobj = ValueObjectVariable::Create(target, var);
-      AddOneVariable(context, var, valobj, current_id);
+      AddOneVariable(context, var, valobj);
       context.m_found.variable = true;
       return;
     }
   }
 
-  LookupFunction(context, module_sp, name, namespace_decl, current_id);
+  LookupFunction(context, module_sp, name, namespace_decl);
 
   // Try the modules next.
   if (!context.m_found.function_with_type_info)
-    LookupInModulesDeclVendor(context, name, current_id);
+    LookupInModulesDeclVendor(context, name);
 
   if (target && !context.m_found.variable && !namespace_decl) {
     // We couldn't find a non-symbol variable for this.  Now we'll hunt for a
     // generic data symbol, and -- if it is found -- treat it as a variable.
     Status error;
 
     const Symbol *data_symbol =
         m_parser_vars->m_sym_ctx.FindBestGlobalDataSymbol(name, error);
 
     if (!error.Success()) {
       const unsigned diag_id =
           m_ast_context->getDiagnostics().getCustomDiagID(
               clang::DiagnosticsEngine::Level::Error, "%0");
       m_ast_context->getDiagnostics().Report(diag_id) << error.AsCString();
     }
 
     if (data_symbol) {
       std::string warning("got name from symbols: ");
       warning.append(name.AsCString());
       const unsigned diag_id =
           m_ast_context->getDiagnostics().getCustomDiagID(
               clang::DiagnosticsEngine::Level::Warning, "%0");
       m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
-      AddOneGenericVariable(context, *data_symbol, current_id);
+      AddOneGenericVariable(context, *data_symbol);
       context.m_found.variable = true;
     }
   }
 }
 
 bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
                                               lldb_private::Value &var_location,
                                               TypeFromUser *user_type,
bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
   if (user_type)
     *user_type = TypeFromUser(var_clang_type);
 
   return true;
 }
 
 void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
                                             VariableSP var,
-                                            ValueObjectSP valobj,
-                                            unsigned int current_id) {
+                                            ValueObjectSP valobj) {
   assert(m_parser_vars.get());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   TypeFromUser ut;
   TypeFromParser pt;
   Value var_location;
 
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;
 
-  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));
+  LLDB_LOG(log, "  CEDM::FEVD Found variable {1}, returned\n{2} (original {3})",
+           decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString(ut));
 }
 
 void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
-                                            ExpressionVariableSP &pvar_sp,
-                                            unsigned int current_id) {
+                                            ExpressionVariableSP &pvar_sp) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   TypeFromUser user_type(
       llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
 
   TypeFromParser parser_type(GuardedCopyType(user_type));
 
   if (!parser_type.GetOpaqueQualType()) {
-    LLDB_LOGF(log, "  CEDM::FEVD[%u] Couldn't import type for pvar %s",
-              current_id, pvar_sp->GetName().GetCString());
+    LLDB_LOGF(log, "  CEDM::FEVD Couldn't import type for pvar %s",
+              pvar_sp->GetName().GetCString());
     return;
   }
 
   NamedDecl *var_decl =
       context.AddVarDecl(parser_type.GetLValueReferenceType());
 
   llvm::cast<ClangExpressionVariable>(pvar_sp.get())
       ->EnableParserVars(GetParserID());
   ClangExpressionVariable::ParserVars *parser_vars =
       llvm::cast<ClangExpressionVariable>(pvar_sp.get())
           ->GetParserVars(GetParserID());
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_value.Clear();
 
-  LLDB_LOG(log, "  CEDM::FEVD[{0}] Added pvar {1}, returned\n{2}", current_id,
+  LLDB_LOG(log, "  CEDM::FEVD Added pvar {1}, returned\n{2}",
            pvar_sp->GetName(), ClangUtil::DumpDecl(var_decl));
 }
 
 void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
-                                                   const Symbol &symbol,
-                                                   unsigned int current_id) {
+                                                   const Symbol &symbol) {
   assert(m_parser_vars.get());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
 
   if (target == nullptr)
     return;
void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
   parser_vars->m_lldb_value.SetCompilerType(user_type);
   parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
   parser_vars->m_lldb_value.SetValueType(Value::eValueTypeLoadAddress);
 
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_sym = &symbol;
 
-  LLDB_LOG(log, "  CEDM::FEVD[{0}] Found variable {1}, returned\n{2}",
-           current_id, decl_name, ClangUtil::DumpDecl(var_decl));
+  LLDB_LOG(log, "  CEDM::FEVD Found variable {1}, returned\n{2}", decl_name,
+           ClangUtil::DumpDecl(var_decl));
 }
 
 void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
-                                            const RegisterInfo *reg_info,
-                                            unsigned int current_id) {
+                                            const RegisterInfo *reg_info) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   CompilerType clang_type =
       m_clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
           reg_info->encoding, reg_info->byte_size * 8);
 
   if (!clang_type) {
     LLDB_LOGF(log, "  Tried to add a type for %s, but couldn't get one",
void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
   entity->EnableParserVars(GetParserID());
   ClangExpressionVariable::ParserVars *parser_vars =
       entity->GetParserVars(GetParserID());
   parser_vars->m_named_decl = var_decl;
   parser_vars->m_llvm_value = nullptr;
   parser_vars->m_lldb_value.Clear();
   entity->m_flags |= ClangExpressionVariable::EVBareRegister;
 
-  LLDB_LOG(log, "  CEDM::FEVD[{0}] Added register {1}, returned\n{2}",
-           current_id, context.m_decl_name.getAsString(),
-           ClangUtil::DumpDecl(var_decl));
+  LLDB_LOG(log, "  CEDM::FEVD Added register {1}, returned\n{2}",
+           context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl));
 }
 
 void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
-                                            Function *function, Symbol *symbol,
-                                            unsigned int current_id) {
+                                            Function *function,
+                                            Symbol *symbol) {
   assert(m_parser_vars.get());
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   NamedDecl *function_decl = nullptr;
   Address fun_address;
   CompilerType function_clang_type;
 
if (!extern_c) {
                   CopyDecl(function_template));
           if (copied_function_template) {
             if (log) {
               StreamString ss;
 
               function->DumpSymbolContext(&ss);
 
               LLDB_LOG(log,
-                       "  CEDM::FEVD[{0}] Imported decl for function template"
+                       "  CEDM::FEVD Imported decl for function template"
                        " {1} (description {2}), returned\n{3}",
-                       current_id, copied_function_template->getNameAsString(),
+                       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) {
               StreamString ss;
 
               function->DumpSymbolContext(&ss);
 
               LLDB_LOG(log,
-                       "  CEDM::FEVD[{0}]] Imported decl for function {1} "
+                       "  CEDM::FEVD Imported decl for function {1} "
                        "(description {2}), returned\n{3}",
-                       current_id, copied_function_decl->getNameAsString(),
-                       ss.GetData(), ClangUtil::DumpDecl(copied_function_decl));
+                       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());
void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
   if (log) {
     StreamString ss;
 
     fun_address.Dump(&ss,
                      m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
                      Address::DumpStyleResolvedDescription);
 
     LLDB_LOG(log,
-             "  CEDM::FEVD[{0}] Found {1} function {2} (description {3}), "
+             "  CEDM::FEVD Found {1} function {2} (description {3}), "
              "returned\n{4}",
-             current_id, (function ? "specific" : "generic"), decl_name,
-             ss.GetData(), ClangUtil::DumpDecl(function_decl));
+             (function ? "specific" : "generic"), decl_name, ss.GetData(),
+             ClangUtil::DumpDecl(function_decl));
   }
 }
 
 void ClangExpressionDeclMap::AddThisType(NameSearchContext &context,
-                                         const TypeFromUser &ut,
-                                         unsigned int current_id) {
+                                         const TypeFromUser &ut) {
   CompilerType copied_clang_type = GuardedCopyType(ut);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
   if (!copied_clang_type) {
     if (log)
       LLDB_LOGF(
           log,
if (!typedef_decl)
     return;
 
   context.AddNamedDecl(typedef_decl);
 
   return;
 }
 
 void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
-                                        const TypeFromUser &ut,
-                                        unsigned int current_id) {
+                                        const TypeFromUser &ut) {
   CompilerType copied_clang_type = GuardedCopyType(ut);
 
   if (!copied_clang_type) {
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
     if (log)
       LLDB_LOGF(
           log, "ClangExpressionDeclMap::AddOneType - Couldn't import the type");
 
     return;
   }
 
   context.AddTypeDecl(copied_clang_type);
 }

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

 class lldb_private::AppleObjCExternalASTSource
     : public clang::ExternalASTSource {
 public:
   AppleObjCExternalASTSource(AppleObjCDeclVendor &decl_vendor)
       : m_decl_vendor(decl_vendor) {}
 
   bool FindExternalVisibleDeclsByName(const clang::DeclContext *decl_ctx,
                                       clang::DeclarationName name) 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::FindExternalVisibleDeclsByName[%"
-                "u] on (ASTContext*)%p Looking for %s in (%sDecl*)%p",
-                current_id,
+                "AppleObjCExternalASTSource::FindExternalVisibleDeclsByName"
+                " on (ASTContext*)%p Looking for %s in (%sDecl*)%p",
                 static_cast<void *>(&decl_ctx->getParentASTContext()),
                 name.getAsString().c_str(), decl_ctx->getDeclKindName(),
                 static_cast<const void *>(decl_ctx));
     }
 
     do {
       const clang::ObjCInterfaceDecl *interface_decl =
           llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx);
do {
       return (result.size() != 0);
     } while (false);
 
     SetNoExternalVisibleDeclsForName(decl_ctx, name);
     return false;
   }
 
   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?
 
     LLDB_LOGF(log,
-              "AppleObjCExternalASTSource::CompleteType[%u] on "
+              "AppleObjCExternalASTSource::CompleteType on "
               "(ASTContext*)%p Completing (TagDecl*)%p named %s",
-              current_id, static_cast<void *>(&tag_decl->getASTContext()),
+              static_cast<void *>(&tag_decl->getASTContext()),
               static_cast<void *>(tag_decl), tag_decl->getName().str().c_str());
 
-    LLDB_LOG(log, "  AOEAS::CT[{0}] Before:\n{1}", current_id,
-             ClangUtil::DumpDecl(tag_decl));
+    LLDB_LOG(log, "  AOEAS::CT Before:\n{1}", ClangUtil::DumpDecl(tag_decl));
 
-    LLDB_LOG(log, "  AOEAS::CT[{1}] After:{1}", current_id,
-             ClangUtil::DumpDecl(tag_decl));
+    LLDB_LOG(log, "  AOEAS::CT After:{1}", ClangUtil::DumpDecl(tag_decl));
 
     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 "
+                "AppleObjCExternalASTSource::CompleteType 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);
+      LLDB_LOGF(log, "  AOEAS::CT Before:");
       LLDB_LOG(log, "    [CT] {0}", ClangUtil::DumpDecl(interface_decl));
     }
 
     m_decl_vendor.FinishDecl(interface_decl);
 
     if (log) {
       LLDB_LOGF(log, "  [CT] After:");
       LLDB_LOG(log, "    [CT] {0}", ClangUtil::DumpDecl(interface_decl));
bool AppleObjCDeclVendor::FinishDecl(clang::ObjCInterfaceDecl *interface_decl) {
   }
 
   return true;
 }
 
 uint32_t AppleObjCDeclVendor::FindDecls(ConstString name, bool append,
                                         uint32_t max_matches,
                                         std::vector<CompilerDecl> &decls) {
-  static unsigned int invocation_id = 0;
-  unsigned int current_id = invocation_id++;
 
   Log *log(GetLogIfAllCategoriesSet(
       LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
 
-  LLDB_LOGF(log, "AppleObjCDeclVendor::FindDecls [%u] ('%s', %s, %u, )",
-            current_id, (const char *)name.AsCString(),
-            append ? "true" : "false", max_matches);
+  LLDB_LOGF(log, "AppleObjCDeclVendor::FindDecls ('%s', %s, %u, )",
+            (const char *)name.AsCString(), append ? "true" : "false",
+            max_matches);
 
   if (!append)
     decls.clear();
 
   uint32_t ret = 0;
 
   do {
     // See if the type is already in our ASTContext.
if (!lookup_result.empty()) {
               ast_ctx.getObjCInterfaceType(result_iface_decl);
 
           uint64_t isa_value = LLDB_INVALID_ADDRESS;
           ClangASTMetadata *metadata = m_ast_ctx.GetMetadata(result_iface_decl);
           if (metadata)
             isa_value = metadata->GetISAPtr();
 
           LLDB_LOG(log,
-                   "AOCTV::FT [%u] Found %s (isa 0x%" PRIx64
-                   ") in the ASTContext",
-                   current_id, result_iface_type.getAsString(), isa_value);
+                   "AOCTV::FT Found %s (isa 0x%" PRIx64 ") in the ASTContext",
+                   result_iface_type.getAsString(), isa_value);
         }
 
         decls.push_back(m_ast_ctx.GetCompilerDecl(result_iface_decl));
         ret++;
         break;
       } else {
-        LLDB_LOGF(log,
-                  "AOCTV::FT [%u] There's something in the ASTContext, but "
-                  "it's not something we know about",
-                  current_id);
+        LLDB_LOGF(log, "AOCTV::FT There's something in the ASTContext, but "
+                       "it's not something we know about");
         break;
       }
     } else if (log) {
-      LLDB_LOGF(log, "AOCTV::FT [%u] Couldn't find %s in the ASTContext",
-                current_id, name.AsCString());
+      LLDB_LOGF(log, "AOCTV::FT Couldn't find %s in the ASTContext",
+                name.AsCString());
     }
 
     // It's not.  If it exists, we have to put it into our ASTContext.
 
     ObjCLanguageRuntime::ObjCISA isa = m_runtime.GetISA(name);
 
     if (!isa) {
-      LLDB_LOGF(log, "AOCTV::FT [%u] Couldn't find the isa", current_id);
+      LLDB_LOGF(log, "AOCTV::FT Couldn't find the isa");
 
       break;
     }
 
     clang::ObjCInterfaceDecl *iface_decl = GetDeclForISA(isa);
 
     if (!iface_decl) {
       LLDB_LOGF(log,
-                "AOCTV::FT [%u] Couldn't get the Objective-C interface for "
+                "AOCTV::FT Couldn't get the Objective-C interface for "
                 "isa 0x%" PRIx64,
-                current_id, (uint64_t)isa);
+                (uint64_t)isa);
 
       break;
     }
 
     if (log) {
       clang::QualType new_iface_type = ast_ctx.getObjCInterfaceType(iface_decl);
 
-      LLDB_LOG(log, "AOCTV::FT [{0}] Created {1} (isa 0x{2:x})", current_id,
+      LLDB_LOG(log, "AOCTV::FT Created {1} (isa 0x{2:x})",
                new_iface_type.getAsString(), (uint64_t)isa);
     }
 
     decls.push_back(m_ast_ctx.GetCompilerDecl(iface_decl));
     ret++;
     break;
   } while (false);
 
   return ret;
 }