Replace use of double underscore in identifiers

[shafik]

Summary

Identifiers with __ anywhere are reserved. I picked this up via the bugprone-reserved-identifier clang-tidy check but -Wreserved-identifier will also flag these uses as well.

[labath]

Yeah, we shouldn't be using these. Personally, I think the names are now unnecessarily long, and I'd go with something shorter. E.g. replacing the double underscore (btw, in python land they abbreviate that to "dunder", so that would be another option) with a single (g_double_underscore_kCFBooleanFalse -> g_kCFBooleanFalse), but I don't think this is worth bikeshedding over.

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

370

this line is now way above the length limit.

[shafik]

Used shorter options for renaming based on feedback.

[aprantl]

Nice.

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

261

This one also contains a double __?

[JDevlieghere]

Assuming all issues have been fixed, can you add this clang-tidy check to the .clang-tidy file in the root of the repository? That should make it less likely this regresses again in the future.

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

bool lldb_private::formatters::LibcxxFunctionSummaryProvider(
   if (!cpp_runtime)
     return false;
 
   CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info =
       cpp_runtime->FindLibCppStdFunctionCallableInfo(valobj_sp);
 
   switch (callable_info.callable_case) {
   case CPPLanguageRuntime::LibCppStdFunctionCallableCase::Invalid:
-    stream.Printf(" __f_ = %" PRIu64, callable_info.member__f_pointer_value);
+    stream.Printf(" __f_ = %" PRIu64, callable_info.member_f_pointer_value);
     return false;
     break;
   case CPPLanguageRuntime::LibCppStdFunctionCallableCase::Lambda:
     stream.Printf(
         " Lambda in File %s at Line %u",
         callable_info.callable_line_entry.file.GetFilename().GetCString(),
         callable_info.callable_line_entry.line);
     break;
bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() {
   TargetSP target_sp(valobj_sp->GetTargetSP());
 
   if (!target_sp)
     return false;
 
   if (!valobj_sp)
     return false;
 
-  static ConstString g___i_("__i_");
+  static ConstString g_i_("__i_");
 
   // this must be a ValueObject* because it is a child of the ValueObject we
   // are producing children for it if were a ValueObjectSP, we would end up
   // with a loop (iterator -> synthetic -> child -> parent == iterator) and
   // that would in turn leak memory by never allowing the ValueObjects to die
   // and free their memory
   m_pair_ptr = valobj_sp
                    ->GetValueForExpressionPath(
m_pair_ptr = valobj_sp
                          ValueObject::GetValueForExpressionPathOptions()
                              .DontCheckDotVsArrowSyntax()
                              .SetSyntheticChildrenTraversal(
                                  ValueObject::GetValueForExpressionPathOptions::
                                      SyntheticChildrenTraversal::None),
                          nullptr)
                      .get();
     if (m_pair_ptr) {
-      auto __i_(valobj_sp->GetChildMemberWithName(g___i_, true));
+      auto __i_(valobj_sp->GetChildMemberWithName(g_i_, true));
       if (!__i_) {
         m_pair_ptr = nullptr;
         return false;
       }
       CompilerType pair_type(
           __i_->GetCompilerType().GetTypeTemplateArgument(0));
       std::string name;
       uint64_t bit_offset_ptr;

lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     ~LibcxxInitializerListSyntheticFrontEnd() {
   // this needs to stay around because it's a child object who will follow its
   // parent's life cycle
   // delete m_start;
 }
 
 size_t lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     CalculateNumChildren() {
-  static ConstString g___size_("__size_");
+  static ConstString g_size_("__size_");
   m_num_elements = 0;
-  ValueObjectSP size_sp(m_backend.GetChildMemberWithName(g___size_, true));
+  ValueObjectSP size_sp(m_backend.GetChildMemberWithName(g_size_, true));
   if (size_sp)
     m_num_elements = size_sp->GetValueAsUnsigned(0);
   return m_num_elements;
 }
 
 lldb::ValueObjectSP lldb_private::formatters::
     LibcxxInitializerListSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
   if (!m_start)
     return lldb::ValueObjectSP();
 
   uint64_t offset = idx * m_element_size;
   offset = offset + m_start->GetValueAsUnsigned(0);
   StreamString name;
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   return CreateValueObjectFromAddress(name.GetString(), offset,
                                       m_backend.GetExecutionContextRef(),
                                       m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     Update() {
-  static ConstString g___begin_("__begin_");
+  static ConstString g_begin_("__begin_");
 
   m_start = nullptr;
   m_num_elements = 0;
   m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
   if (!m_element_type.IsValid())
     return false;
 
   if (llvm::Optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
     m_element_size = *size;
     // Store raw pointers or end up with a circular dependency.
-    m_start = m_backend.GetChildMemberWithName(g___begin_, true).get();
+    m_start = m_backend.GetChildMemberWithName(g_begin_, true).get();
   }
 
   return false;
 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     MightHaveChildren() {
   return true;

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

: SyntheticChildrenFrontEnd(*valobj_sp), m_tree(nullptr),
       m_root_node(nullptr), m_element_type(), m_skip_size(UINT32_MAX),
       m_count(UINT32_MAX), m_iterators() {
   if (valobj_sp)
     Update();
 }
 
 size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     CalculateNumChildren() {
-  static ConstString g___pair3_("__pair3_");
-  static ConstString g___first_("__first_");
-  static ConstString g___value_("__value_");
+  static ConstString g_pair3_("__pair3_");
+  static ConstString g_first_("__first_");
+  static ConstString g_value_("__value_");
 
   if (m_count != UINT32_MAX)
     return m_count;
   if (m_tree == nullptr)
     return 0;
-  ValueObjectSP m_item(m_tree->GetChildMemberWithName(g___pair3_, true));
+  ValueObjectSP m_item(m_tree->GetChildMemberWithName(g_pair3_, true));
   if (!m_item)
     return 0;
 
   switch (m_item->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
-    m_item = m_item->GetChildMemberWithName(g___first_, true);
+    m_item = m_item->GetChildMemberWithName(g_first_, true);
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent = m_item->GetChildAtIndex(0, true);
-    m_item = first_elem_parent->GetChildMemberWithName(g___value_, true);
+    m_item = first_elem_parent->GetChildMemberWithName(g_value_, true);
     break;
   }
   default:
     return false;
   }
 
   if (!m_item)
     return 0;
   m_count = m_item->GetValueAsUnsigned(0);
   return m_count;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() {
-  static ConstString g___value_("__value_");
+  static ConstString g_value_("__value_");
   static ConstString g_tree_("__tree_");
   static ConstString g_pair3("__pair3_");
 
   if (m_element_type.GetOpaqueQualType() && m_element_type.GetTypeSystem())
     return true;
   m_element_type.Clear();
   ValueObjectSP deref;
   Status error;
   deref = m_root_node->Dereference(error);
   if (!deref || error.Fail())
     return false;
-  deref = deref->GetChildMemberWithName(g___value_, true);
+  deref = deref->GetChildMemberWithName(g_value_, true);
   if (deref) {
     m_element_type = deref->GetCompilerType();
     return true;
   }
   deref = m_backend.GetChildAtNamePath({g_tree_, g_pair3});
   if (!deref)
     return false;
   m_element_type = deref->GetCompilerType()
if (tree_node_type
             .IsValid())
       m_skip_size = (uint32_t)child_byte_offset;
   }
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
     size_t idx) {
-  static ConstString g___cc("__cc");
-  static ConstString g___nc("__nc");
-  static ConstString g___value_("__value_");
+  static ConstString g_cc("__cc");
+  static ConstString g_nc("__nc");
+  static ConstString g_value_("__value_");
 
   if (idx >= CalculateNumChildren())
     return lldb::ValueObjectSP();
   if (m_tree == nullptr || m_root_node == nullptr)
     return lldb::ValueObjectSP();
 
   MapIterator iterator(m_root_node, CalculateNumChildren());
 
if (GetDataType()) {
     if (!need_to_skip) {
       Status error;
       iterated_sp = iterated_sp->Dereference(error);
       if (!iterated_sp || error.Fail()) {
         m_tree = nullptr;
         return lldb::ValueObjectSP();
       }
       GetValueOffset(iterated_sp);
-      auto child_sp = iterated_sp->GetChildMemberWithName(g___value_, true);
+      auto child_sp = iterated_sp->GetChildMemberWithName(g_value_, true);
       if (child_sp)
         iterated_sp = child_sp;
       else
         iterated_sp = iterated_sp->GetSyntheticChildAtOffset(
             m_skip_size, m_element_type, true);
       if (!iterated_sp) {
         m_tree = nullptr;
         return lldb::ValueObjectSP();
lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetChildAtIndex(
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   auto potential_child_sp = CreateValueObjectFromData(
       name.GetString(), data, m_backend.GetExecutionContextRef(),
       m_element_type);
   if (potential_child_sp) {
     switch (potential_child_sp->GetNumChildren()) {
     case 1: {
       auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
-      if (child0_sp && child0_sp->GetName() == g___cc)
+      if (child0_sp && child0_sp->GetName() == g_cc)
         potential_child_sp = child0_sp->Clone(ConstString(name.GetString()));
       break;
     }
     case 2: {
       auto child0_sp = potential_child_sp->GetChildAtIndex(0, true);
       auto child1_sp = potential_child_sp->GetChildAtIndex(1, true);
-      if (child0_sp && child0_sp->GetName() == g___cc && child1_sp &&
-          child1_sp->GetName() == g___nc)
+      if (child0_sp && child0_sp->GetName() == g_cc && child1_sp &&
+          child1_sp->GetName() == g_nc)
         potential_child_sp = child0_sp->Clone(ConstString(name.GetString()));
       break;
     }
     }
   }
   m_iterators[idx] = iterator;
   return potential_child_sp;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() {
-  static ConstString g___tree_("__tree_");
-  static ConstString g___begin_node_("__begin_node_");
+  static ConstString g_tree_("__tree_");
+  static ConstString g_begin_node_("__begin_node_");
   m_count = UINT32_MAX;
   m_tree = m_root_node = nullptr;
   m_iterators.clear();
-  m_tree = m_backend.GetChildMemberWithName(g___tree_, true).get();
+  m_tree = m_backend.GetChildMemberWithName(g_tree_, true).get();
   if (!m_tree)
     return false;
-  m_root_node = m_tree->GetChildMemberWithName(g___begin_node_, true).get();
+  m_root_node = m_tree->GetChildMemberWithName(g_begin_node_, true).get();
   return false;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 

lldb/source/Plugins/Language/ObjC/CF.cpp

if (!valobj_addr)
     return false;
 
   uint32_t count = 0;
 
   bool is_type_ok = false; // check to see if this is a CFBag we know about
   if (descriptor->IsCFType()) {
     ConstString type_name(valobj.GetTypeName());
 
-    static ConstString g___CFBag("__CFBag");
+    static ConstString g_CFBag("__CFBag");
     static ConstString g_conststruct__CFBag("const struct __CFBag");
 
-    if (type_name == g___CFBag || type_name == g_conststruct__CFBag) {
+    if (type_name == g_CFBag || type_name == g_conststruct__CFBag) {
       if (valobj.IsPointerType())
         is_type_ok = true;
     }
   }
 
   if (is_type_ok) {
     lldb::addr_t offset = 2 * ptr_size + 4 + valobj_addr;
     Status error;
bool lldb_private::formatters::CFBinaryHeapSummaryProvider(
 
   uint32_t count = 0;
 
   bool is_type_ok =
       false; // check to see if this is a CFBinaryHeap we know about
   if (descriptor->IsCFType()) {
     ConstString type_name(valobj.GetTypeName());
 
-    static ConstString g___CFBinaryHeap("__CFBinaryHeap");
+    static ConstString g_CFBinaryHeap("__CFBinaryHeap");
     static ConstString g_conststruct__CFBinaryHeap(
         "const struct __CFBinaryHeap");
     static ConstString g_CFBinaryHeapRef("CFBinaryHeapRef");
 
-    if (type_name == g___CFBinaryHeap ||
+    if (type_name == g_CFBinaryHeap ||
         type_name == g_conststruct__CFBinaryHeap ||
         type_name == g_CFBinaryHeapRef) {
       if (valobj.IsPointerType())
         is_type_ok = true;
     }
   }
 
   if (is_type_ok) {

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

if (!valobj_addr)
     return false;
 
   uint64_t date_value_bits = 0;
   double date_value = 0.0;
 
   ConstString class_name = descriptor->GetClassName();
 
   static const ConstString g_NSDate("NSDate");
-  static const ConstString g___NSDate("__NSDate");
-  static const ConstString g___NSTaggedDate("__NSTaggedDate");
+  static const ConstString g_dunder_NSDate("__NSDate");
+  static const ConstString g_NSTaggedDate("__NSTaggedDate");
   static const ConstString g_NSCalendarDate("NSCalendarDate");
   static const ConstString g_NSConstantDate("NSConstantDate");
 
   if (class_name.IsEmpty())
     return false;
 
   uint64_t info_bits = 0, value_bits = 0;
-  if ((class_name == g_NSDate) || (class_name == g___NSDate) ||
-      (class_name == g___NSTaggedDate) || (class_name == g_NSConstantDate)) {
+  if ((class_name == g_NSDate) || (class_name == g_dunder_NSDate) ||
+      (class_name == g_NSTaggedDate) || (class_name == g_NSConstantDate)) {
     if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits)) {
       date_value_bits = ((value_bits << 8) | (info_bits << 4));
       memcpy(&date_value, &date_value_bits, sizeof(date_value_bits));
     } else {
       llvm::Triple triple(
           process_sp->GetTarget().GetArchitecture().GetTriple());
       uint32_t delta =
           (triple.isWatchOS() && triple.isWatchABI()) ? 8 : ptr_size;
bool lldb_private::formatters::NSDateSummaryProvider(
   // The relative time in seconds from Cocoa Epoch to [NSDate distantPast].
   const double RelSecondsFromCocoaEpochToNSDateDistantPast = -63114076800;
   if (date_value == RelSecondsFromCocoaEpochToNSDateDistantPast) {
     stream.Printf("0001-01-01 00:00:00 UTC");
     return true;
   }
 
   // Accomodate for the __NSTaggedDate format introduced in Foundation 1600.
-  if (class_name == g___NSTaggedDate) {
+  if (class_name == g_NSTaggedDate) {
     auto *runtime = llvm::dyn_cast_or_null<AppleObjCRuntime>(
         ObjCLanguageRuntime::Get(*process_sp));
     if (runtime && runtime->GetFoundationVersion() >= 1600)
       date_value = decodeTaggedTimeInterval(value_bits << 4);
   }
 
   // this snippet of code assumes that time_t == seconds since Jan-1-1970 this
   // is generally true and POSIXly happy, but might break if a library vendor

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

 
 static CompilerType GetLLDBNSPairType(TargetSP target_sp) {
   CompilerType compiler_type;
 
   TypeSystemClang *target_ast_context =
       ScratchTypeSystemClang::GetForTarget(*target_sp);
 
   if (target_ast_context) {
-    ConstString g___lldb_autogen_nspair("__lldb_autogen_nspair");
+    ConstString g_lldb_autogen_nspair("__lldb_autogen_nspair");
 
     compiler_type =
         target_ast_context->GetTypeForIdentifier<clang::CXXRecordDecl>(
-            g___lldb_autogen_nspair);
+            g_lldb_autogen_nspair);
 
     if (!compiler_type) {
       compiler_type = target_ast_context->CreateRecordType(
           nullptr, OptionalClangModuleID(), lldb::eAccessPublic,
-          g___lldb_autogen_nspair.GetCString(), clang::TTK_Struct,
+          g_lldb_autogen_nspair.GetCString(), clang::TTK_Struct,
           lldb::eLanguageTypeC);
 
       if (compiler_type) {
         TypeSystemClang::StartTagDeclarationDefinition(compiler_type);
         CompilerType id_compiler_type =
             target_ast_context->GetBasicType(eBasicTypeObjCID);
         TypeSystemClang::AddFieldToRecordType(
             compiler_type, "key", id_compiler_type, lldb::eAccessPublic, 0);

lldb/source/Plugins/Language/ObjC/NSError.cpp

m_child_sp = CreateValueObjectFromData(
         ScratchTypeSystemClang::GetForTarget(process_sp->GetTarget())
             ->GetBasicType(lldb::eBasicTypeObjCID));
     return false;
   }
 
   bool MightHaveChildren() override { return true; }
 
   size_t GetIndexOfChildWithName(ConstString name) override {
-    static ConstString g___userInfo("_userInfo");
-    if (name == g___userInfo)
+    static ConstString g_userInfo("_userInfo");
+    if (name == g_userInfo)
       return 0;
     return UINT32_MAX;
   }
 
 private:
   // the child here can be "real" (i.e. an actual child of the root) or
   // synthetized from raw memory if the former, I need to store a plain pointer
   // to it - or else a loop of references will cause this entire hierarchy of

lldb/source/Plugins/Language/ObjC/NSException.cpp

public:
   bool MightHaveChildren() override { return true; }
 
   size_t GetIndexOfChildWithName(ConstString name) override {
     // NSException has 4 members:
     //   NSString *name;
     //   NSString *reason;
     //   NSDictionary *userInfo;
     //   id reserved;
-    static ConstString g___name("name");
-    static ConstString g___reason("reason");
-    static ConstString g___userInfo("userInfo");
-    static ConstString g___reserved("reserved");
-    if (name == g___name) return 0;
-    if (name == g___reason) return 1;
-    if (name == g___userInfo) return 2;
-    if (name == g___reserved) return 3;
+    static ConstString g_name("name");
+    static ConstString g_reason("reason");
+    static ConstString g_userInfo("userInfo");
+    static ConstString g_reserved("reserved");
+    if (name == g_name) return 0;
+    if (name == g_reason) return 1;
+    if (name == g_userInfo) return 2;
+    if (name == g_reserved) return 3;
     return UINT32_MAX;
   }
 
 private:
   ValueObjectSP m_name_sp;
   ValueObjectSP m_reason_sp;
   ValueObjectSP m_userinfo_sp;
   ValueObjectSP m_reserved_sp;

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h

enum class LibCppStdFunctionCallableCase {
     FreeOrMemberFunction,
     Invalid
   };
 
   struct LibCppStdFunctionCallableInfo {
     Symbol callable_symbol;
     Address callable_address;
     LineEntry callable_line_entry;
-    lldb::addr_t member__f_pointer_value = 0u;
+    lldb::addr_t member_f_pointer_value = 0u;
     LibCppStdFunctionCallableCase callable_case =
         LibCppStdFunctionCallableCase::Invalid;
   };
 
   LibCppStdFunctionCallableInfo
   FindLibCppStdFunctionCallableInfo(lldb::ValueObjectSP &valobj_sp);
 
   static char ID;

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.cpp

 
 bool contains_lambda_identifier(llvm::StringRef &str_ref) {
   return str_ref.contains("$_") || str_ref.contains("'lambda'");
 }
 
 CPPLanguageRuntime::LibCppStdFunctionCallableInfo
 line_entry_helper(Target &target, const SymbolContext &sc, Symbol *symbol,
                   llvm::StringRef first_template_param_sref,
-                  bool has___invoke) {
+                  bool has_invoke) {
 
   CPPLanguageRuntime::LibCppStdFunctionCallableInfo optional_info;
 
   AddressRange range;
   sc.GetAddressRange(eSymbolContextEverything, 0, false, range);
 
   Address address = range.GetBaseAddress();
 
   Address addr;
   if (target.ResolveLoadAddress(address.GetCallableLoadAddress(&target),
                                 addr)) {
     LineEntry line_entry;
     addr.CalculateSymbolContextLineEntry(line_entry);
 
-    if (contains_lambda_identifier(first_template_param_sref) || has___invoke) {
+    if (contains_lambda_identifier(first_template_param_sref) || has_invoke) {
       // Case 1 and 2
       optional_info.callable_case = lldb_private::CPPLanguageRuntime::
           LibCppStdFunctionCallableCase::Lambda;
     } else {
       // Case 3
       optional_info.callable_case = lldb_private::CPPLanguageRuntime::
           LibCppStdFunctionCallableCase::CallableObject;
     }
CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
   //    this entry and lookup operator()() and obtain the line table entry.
   // 3) a callable object via operator()(). We will obtain the name of the
   //    object from the first template parameter from __func's vtable. We will
   //    look up the objects operator()() and obtain the line table entry.
   // 4) a member function. A pointer to the function will stored after the
   //    we will obtain the name from this pointer.
   // 5) a free function. A pointer to the function will stored after the vtable
   //    we will obtain the name from this pointer.
-  ValueObjectSP member__f_(
+  ValueObjectSP member_f_(
       valobj_sp->GetChildMemberWithName(ConstString("__f_"), true));
 
-  if (member__f_) {
-    ValueObjectSP sub_member__f_(
-       member__f_->GetChildMemberWithName(ConstString("__f_"), true));
+  if (member_f_) {
+    ValueObjectSP sub_member_f_(
+       member_f_->GetChildMemberWithName(ConstString("__f_"), true));
 
-    if (sub_member__f_)
-        member__f_ = sub_member__f_;
+    if (sub_member_f_)
+        member_f_ = sub_member_f_;
   }
 
-  if (!member__f_)
+  if (!member_f_)
     return optional_info;
 
-  lldb::addr_t member__f_pointer_value = member__f_->GetValueAsUnsigned(0);
+  lldb::addr_t member_f_pointer_value = member_f_->GetValueAsUnsigned(0);
 
-  optional_info.member__f_pointer_value = member__f_pointer_value;
+  optional_info.member_f_pointer_value = member_f_pointer_value;
 
-  if (!member__f_pointer_value)
+  if (!member_f_pointer_value)
     return optional_info;
 
   ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef());
   Process *process = exe_ctx.GetProcessPtr();
 
   if (process == nullptr)
     return optional_info;
 
   uint32_t address_size = process->GetAddressByteSize();
   Status status;
 
   // First item pointed to by __f_ should be the pointer to the vtable for
   // a __base object.
   lldb::addr_t vtable_address =
-      process->ReadPointerFromMemory(member__f_pointer_value, status);
+      process->ReadPointerFromMemory(member_f_pointer_value, status);
 
   if (status.Fail())
     return optional_info;
 
   lldb::addr_t vtable_address_first_entry =
       process->ReadPointerFromMemory(vtable_address + address_size, status);
 
   if (status.Fail())
     return optional_info;
 
-  lldb::addr_t address_after_vtable = member__f_pointer_value + address_size;
+  lldb::addr_t address_after_vtable = member_f_pointer_value + address_size;
   // As commented above we may not have a function pointer but if we do we will
   // need it.
   lldb::addr_t possible_function_address =
       process->ReadPointerFromMemory(address_after_vtable, status);
 
   if (status.Fail())
     return optional_info;
 
CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
   if (target.GetSectionLoadList().ResolveLoadAddress(
           possible_function_address, function_address_resolved)) {
     target.GetImages().ResolveSymbolContextForAddress(
         function_address_resolved, eSymbolContextEverything, sc);
     symbol = sc.symbol;
   }
 
   // These conditions are used several times to simplify statements later on.
-  bool has___invoke =
+  bool has_invoke =
       (symbol ? symbol->GetName().GetStringRef().contains("__invoke") : false);
   auto calculate_symbol_context_helper = [](auto &t,
                                             SymbolContextList &sc_list) {
     SymbolContext sc;
     t->CalculateSymbolContext(&sc);
     sc_list.Append(sc);
   };
 
   // Case 2
-  if (has___invoke) {
+  if (has_invoke) {
     SymbolContextList scl;
     calculate_symbol_context_helper(symbol, scl);
 
     return line_entry_helper(target, scl[0], symbol, first_template_parameter,
-                             has___invoke);
+                             has_invoke);
   }
 
   // Case 4 or 5
   if (symbol && !symbol->GetName().GetStringRef().startswith("vtable for") &&
-      !contains_lambda_identifier(first_template_parameter) && !has___invoke) {
+      !contains_lambda_identifier(first_template_parameter) && !has_invoke) {
     optional_info.callable_case =
         LibCppStdFunctionCallableCase::FreeOrMemberFunction;
     optional_info.callable_address = function_address_resolved;
     optional_info.callable_symbol = *symbol;
 
     return optional_info;
   }
 
CPPLanguageRuntime::FindLibCppStdFunctionCallableInfo(
   //
   // TODO
   // We currently don't support this case a callable object may have multiple
   // operator()() varying on const/non-const and number of arguments and we
   // don't have a way to currently distinguish them so we will bail out now.
   if (!contains_lambda_identifier(name_to_use))
     return optional_info;
 
-  if (vtable_cu && !has___invoke) {
+  if (vtable_cu && !has_invoke) {
     lldb::FunctionSP func_sp =
         vtable_cu->FindFunction([name_to_use](const FunctionSP &f) {
           auto name = f->GetName().GetStringRef();
           if (name.startswith(name_to_use) && name.contains("operator"))
             return true;
 
           return false;
         });
 
     if (func_sp) {
       calculate_symbol_context_helper(func_sp, scl);
     }
   }
 
   if (symbol == nullptr)
     return optional_info;
 
   // Case 1 or 3
   if (scl.GetSize() >= 1) {
     optional_info = line_entry_helper(target, scl[0], symbol,
-                                      first_template_parameter, has___invoke);
+                                      first_template_parameter, has_invoke);
   }
 
   CallableLookupCache[func_to_match] = optional_info;
 
   return optional_info;
 }
 
 lldb::ThreadPlanSP

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

AppleObjCRuntimeV2::GetPointerISA(ObjCISA isa) {
 
   return ret;
 }
 
 bool AppleObjCRuntimeV2::GetCFBooleanValuesIfNeeded() {
   if (m_CFBoolean_values)
     return true;
 
-  static ConstString g___kCFBooleanFalse("__kCFBooleanFalse");
-  static ConstString g___kCFBooleanTrue("__kCFBooleanTrue");
+  static ConstString g_dunder_kCFBooleanFalse("__kCFBooleanFalse");
+  static ConstString g_dunder_kCFBooleanTrue("__kCFBooleanTrue");
   static ConstString g_kCFBooleanFalse("kCFBooleanFalse");
   static ConstString g_kCFBooleanTrue("kCFBooleanTrue");
 
   std::function<lldb::addr_t(ConstString, ConstString)> get_symbol =
       [this](ConstString sym, ConstString real_sym) -> lldb::addr_t {
     SymbolContextList sc_list;
     GetProcess()->GetTarget().GetImages().FindSymbolsWithNameAndType(
         sym, lldb::eSymbolTypeData, sc_list);
std::function<lldb::addr_t(ConstString, ConstString)> get_symbol =
     lldb::addr_t addr = sc.symbol->GetLoadAddress(&GetProcess()->GetTarget());
     Status error;
     addr = GetProcess()->ReadPointerFromMemory(addr, error);
     if (error.Fail())
       return LLDB_INVALID_ADDRESS;
     return addr;
   };
 
-  lldb::addr_t false_addr = get_symbol(g___kCFBooleanFalse, g_kCFBooleanFalse);
-  lldb::addr_t true_addr = get_symbol(g___kCFBooleanTrue, g_kCFBooleanTrue);
+  lldb::addr_t false_addr = get_symbol(g_dunder_kCFBooleanFalse, g_kCFBooleanFalse);
+  lldb::addr_t true_addr = get_symbol(g_dunder_kCFBooleanTrue, g_kCFBooleanTrue);
 
   return (m_CFBoolean_values = {false_addr, true_addr}).operator bool();
 }
 
 void AppleObjCRuntimeV2::GetValuesForGlobalCFBooleans(lldb::addr_t &cf_true,
                                                       lldb::addr_t &cf_false) {
   if (GetCFBooleanValuesIfNeeded()) {
     cf_true = m_CFBoolean_values->second;