Rename child_* variables and arguments to deref_*

kuilpd · kuilpd · commit ba08e51bfdfc · 2025-05-09T22:29:44.000+05:00
diff --git a/lldb/include/lldb/Symbol/CompilerType.h b/lldb/include/lldb/Symbol/CompilerType.h
@@ -434,8 +434,8 @@ class CompilerType {
   CompilerDecl GetStaticFieldWithName(llvm::StringRef name) const;
 
   llvm::Expected<CompilerType>
-  GetDereferencedType(ExecutionContext *exe_ctx, std::string &child_name,
-                      uint32_t &child_byte_size, int32_t &child_byte_offset,
+  GetDereferencedType(ExecutionContext *exe_ctx, std::string &deref_name,
+                      uint32_t &deref_byte_size, int32_t &deref_byte_offset,
                       ValueObject *valobj, uint64_t &language_flags) const;
 
   llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(
diff --git a/lldb/include/lldb/Symbol/TypeSystem.h b/lldb/include/lldb/Symbol/TypeSystem.h
@@ -366,8 +366,8 @@ class TypeSystem : public PluginInterface,
 
   virtual llvm::Expected<CompilerType>
   GetDereferencedType(lldb::opaque_compiler_type_t type,
-                      ExecutionContext *exe_ctx, std::string &child_name,
-                      uint32_t &child_byte_size, int32_t &child_byte_offset,
+                      ExecutionContext *exe_ctx, std::string &deref_name,
+                      uint32_t &deref_byte_size, int32_t &deref_byte_offset,
                       ValueObject *valobj, uint64_t &language_flags) = 0;
 
   virtual llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(
diff --git a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp
@@ -6186,8 +6186,8 @@ uint32_t TypeSystemClang::GetNumPointeeChildren(clang::QualType type) {
 
 llvm::Expected<CompilerType> TypeSystemClang::GetDereferencedType(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-    std::string &child_name, uint32_t &child_byte_size,
-    int32_t &child_byte_offset, ValueObject *valobj, uint64_t &language_flags) {
+    std::string &deref_name, uint32_t &deref_byte_size,
+    int32_t &deref_byte_offset, ValueObject *valobj, uint64_t &language_flags) {
   bool type_valid = IsPointerOrReferenceType(type, nullptr) ||
                     IsArrayType(type, nullptr, nullptr, nullptr);
   if (!type_valid)
@@ -6197,8 +6197,8 @@ llvm::Expected<CompilerType> TypeSystemClang::GetDereferencedType(
   bool child_is_base_class;
   bool child_is_deref_of_parent;
   return GetChildCompilerTypeAtIndex(
-      type, exe_ctx, 0, false, true, false, child_name, child_byte_size,
-      child_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
+      type, exe_ctx, 0, false, true, false, deref_name, deref_byte_size,
+      deref_byte_offset, child_bitfield_bit_size, child_bitfield_bit_offset,
       child_is_base_class, child_is_deref_of_parent, valobj, language_flags);
 }
 
diff --git a/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h b/lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h
@@ -891,8 +891,8 @@ class TypeSystemClang : public TypeSystem {
 
   llvm::Expected<CompilerType>
   GetDereferencedType(lldb::opaque_compiler_type_t type,
-                      ExecutionContext *exe_ctx, std::string &child_name,
-                      uint32_t &child_byte_size, int32_t &child_byte_offset,
+                      ExecutionContext *exe_ctx, std::string &deref_name,
+                      uint32_t &deref_byte_size, int32_t &deref_byte_offset,
                       ValueObject *valobj, uint64_t &language_flags) override;
 
   llvm::Expected<CompilerType> GetChildCompilerTypeAtIndex(
diff --git a/lldb/source/Symbol/CompilerType.cpp b/lldb/source/Symbol/CompilerType.cpp
@@ -894,13 +894,13 @@ CompilerDecl CompilerType::GetStaticFieldWithName(llvm::StringRef name) const {
 }
 
 llvm::Expected<CompilerType> CompilerType::GetDereferencedType(
-    ExecutionContext *exe_ctx, std::string &child_name,
-    uint32_t &child_byte_size, int32_t &child_byte_offset, ValueObject *valobj,
+    ExecutionContext *exe_ctx, std::string &deref_name,
+    uint32_t &deref_byte_size, int32_t &deref_byte_offset, ValueObject *valobj,
     uint64_t &language_flags) const {
   if (IsValid())
     if (auto type_system_sp = GetTypeSystem())
       return type_system_sp->GetDereferencedType(
-          m_type, exe_ctx, child_name, child_byte_size, child_byte_offset,
+          m_type, exe_ctx, deref_name, deref_byte_size, deref_byte_offset,
           valobj, language_flags);
   return CompilerType();
 }
diff --git a/lldb/source/ValueObject/ValueObject.cpp b/lldb/source/ValueObject/ValueObject.cpp
@@ -2794,56 +2794,56 @@ ValueObjectSP ValueObject::Dereference(Status &error) {
   if (m_deref_valobj)
     return m_deref_valobj->GetSP();
 
-  std::string child_name_str;
-  uint32_t child_byte_size = 0;
-  int32_t child_byte_offset = 0;
+  std::string deref_name_str;
+  uint32_t deref_byte_size = 0;
+  int32_t deref_byte_offset = 0;
   CompilerType compiler_type = GetCompilerType();
   uint64_t language_flags = 0;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
 
-  CompilerType child_compiler_type;
-  auto child_compiler_type_or_err = compiler_type.GetDereferencedType(
-      &exe_ctx, child_name_str, child_byte_size, child_byte_offset, this,
+  CompilerType deref_compiler_type;
+  auto deref_compiler_type_or_err = compiler_type.GetDereferencedType(
+      &exe_ctx, deref_name_str, deref_byte_size, deref_byte_offset, this,
       language_flags);
 
   std::string deref_error;
-  if (child_compiler_type_or_err) {
-    child_compiler_type = *child_compiler_type_or_err;
-    if (child_compiler_type && child_byte_size) {
-      ConstString child_name;
-      if (!child_name_str.empty())
-        child_name.SetCString(child_name_str.c_str());
+  if (deref_compiler_type_or_err) {
+    deref_compiler_type = *deref_compiler_type_or_err;
+    if (deref_compiler_type && deref_byte_size) {
+      ConstString deref_name;
+      if (!deref_name_str.empty())
+        deref_name.SetCString(deref_name_str.c_str());
 
       m_deref_valobj =
-          new ValueObjectChild(*this, child_compiler_type, child_name,
-                               child_byte_size, child_byte_offset, 0, 0, false,
+          new ValueObjectChild(*this, deref_compiler_type, deref_name,
+                               deref_byte_size, deref_byte_offset, 0, 0, false,
                                true, eAddressTypeInvalid, language_flags);
     }
 
-    // In case of incomplete child compiler type, use the pointee type and try
+    // In case of incomplete deref compiler type, use the pointee type and try
     // to recreate a new ValueObjectChild using it.
     if (!m_deref_valobj) {
       // FIXME(#59012): C++ stdlib formatters break with incomplete types (e.g.
       // `std::vector<int> &`). Remove ObjC restriction once that's resolved.
       if (Language::LanguageIsObjC(GetPreferredDisplayLanguage()) &&
           HasSyntheticValue()) {
-        child_compiler_type = compiler_type.GetPointeeType();
+        deref_compiler_type = compiler_type.GetPointeeType();
 
-        if (child_compiler_type) {
-          ConstString child_name;
-          if (!child_name_str.empty())
-            child_name.SetCString(child_name_str.c_str());
+        if (deref_compiler_type) {
+          ConstString deref_name;
+          if (!deref_name_str.empty())
+            deref_name.SetCString(deref_name_str.c_str());
 
           m_deref_valobj = new ValueObjectChild(
-              *this, child_compiler_type, child_name, child_byte_size,
-              child_byte_offset, 0, 0, false, true, eAddressTypeInvalid,
+              *this, deref_compiler_type, deref_name, deref_byte_size,
+              deref_byte_offset, 0, 0, false, true, eAddressTypeInvalid,
               language_flags);
         }
       }
     }
   } else {
-    deref_error = llvm::toString(child_compiler_type_or_err.takeError());
+    deref_error = llvm::toString(deref_compiler_type_or_err.takeError());
     LLDB_LOG(GetLog(LLDBLog::Types), "could not find child: {0}", deref_error);
     if (IsSynthetic()) {
       m_deref_valobj = GetChildMemberWithName("$$dereference$$").get();
