[lldb] Default can_create to true in GetChildMemberWithName (NFC)

[kastiglione]

Summary

It turns out all existing callers of GetChildMemberWithName pass true for can_create.
This change makes true the default value, callers don't have to pass an opaque true.

[bulbazord]

If every caller sets this to true, why not remove the argument altogether? It looks like ValueObjectRegister::GetChildMemberWithName doesn't use the argument, ValueObject::GetChildMemberWithName and ValueObjectSynthetic::GetChildMemberWithName just pass it along to GetChildAtIndex.

[kastiglione]

That's an option too, which I considered. I went with this as a more
conservative change. If there's agreement to remove it then I can change it.

[kastiglione]

correction: there's still an overload of GetChildAtNamePath, which takes a can_create value and passes it through to GetChildMemberWithName. However that function isn't used, and could be deleted. To delete the parameter, that overload of GetChildMemberWithName would need to be deleted too. In general, I'm still in favor of the conservative choice of giving it a default. Deleting it altogether is an easy follow up, if so desired.

[kastiglione]

To expand the conversation, I have also opened D152031 which makes the same change to GetChildAtIndex.

[jingham]

It's OK to retain this as the default, and as you say, taking it out would be a trivial patch after this work. The control does allow you to do "Have I already made this child" before setting about to make it, though I can't currently see anywhere where we could use this information.

[bulbazord]

I'm alright with this if Jim is. I think we should remove this parameter since it's never set to anything other than true from what I understand, but that can be done in a follow-up.

lldb/include/lldb/Core/ValueObject.h

public:
   // this will always create the children if necessary
   lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<llvm::StringRef> names);
 
   lldb::ValueObjectSP
   GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names,
                      ConstString *name_of_error = nullptr);
 
   virtual lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
-                                                     bool can_create);
+                                                     bool can_create = true);
 
   virtual size_t GetIndexOfChildWithName(llvm::StringRef name);
 
   size_t GetNumChildren(uint32_t max = UINT32_MAX);
 
   const Value &GetValue() const { return m_value; }
 
   Value &GetValue() { return m_value; }

lldb/include/lldb/Core/ValueObjectRegister.h

public:
   ConstString GetQualifiedTypeName() override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
                                   int32_t synthetic_index) override;
 
   lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
-                                             bool can_create) override;
+                                             bool can_create = true) override;
 
   size_t GetIndexOfChildWithName(llvm::StringRef name) override;
 
 protected:
   bool UpdateValue() override;
 
   CompilerType GetCompilerTypeImpl() override;
 

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

public:
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   lldb::ValueType GetValueType() const override;
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override;
 
   lldb::ValueObjectSP GetChildMemberWithName(llvm::StringRef name,
-                                             bool can_create) override;
+                                             bool can_create = true) override;
 
   size_t GetIndexOfChildWithName(llvm::StringRef name) override;
 
   lldb::ValueObjectSP
   GetDynamicValue(lldb::DynamicValueType valueType) override;
 
   bool IsInScope() override;
 

lldb/source/API/SBValue.cpp

SBValue::GetChildMemberWithName(const char *name,
                                 lldb::DynamicValueType use_dynamic_value) {
   LLDB_INSTRUMENT_VA(this, name, use_dynamic_value);
 
   lldb::ValueObjectSP child_sp;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
-    child_sp = value_sp->GetChildMemberWithName(name, true);
+    child_sp = value_sp->GetChildMemberWithName(name);
   }
 
   SBValue sb_value;
   sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
 
   return sb_value;
 }
 

lldb/source/Core/ValueObject.cpp

 }
 
 lldb::ValueObjectSP
 ValueObject::GetChildAtNamePath(llvm::ArrayRef<llvm::StringRef> names) {
   if (names.size() == 0)
     return GetSP();
   ValueObjectSP root(GetSP());
   for (llvm::StringRef name : names) {
-    root = root->GetChildMemberWithName(name, true);
+    root = root->GetChildMemberWithName(name);
     if (!root) {
       return root;
     }
   }
   return root;
 }
 
 lldb::ValueObjectSP ValueObject::GetChildAtNamePath(
case '.': // or fallthrough from ->
 
       size_t next_sep_pos = temp_expression.find_first_of("-.[", 1);
       ConstString child_name;
       if (next_sep_pos == llvm::StringRef::npos) // if no other separator just
                                                  // expand this last layer
       {
         child_name.SetString(temp_expression);
         ValueObjectSP child_valobj_sp =
-            root->GetChildMemberWithName(child_name, true);
+            root->GetChildMemberWithName(child_name);
 
         if (child_valobj_sp.get()) // we know we are done, so just return
         {
           *reason_to_stop =
               ValueObject::eExpressionPathScanEndReasonEndOfString;
           *final_result = ValueObject::eExpressionPathEndResultTypePlain;
           return child_valobj_sp;
         } else {
           switch (options.m_synthetic_children_traversal) {
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               None:
             break;
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               FromSynthetic:
             if (root->IsSynthetic()) {
               child_valobj_sp = root->GetNonSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             }
             break;
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               ToSynthetic:
             if (!root->IsSynthetic()) {
               child_valobj_sp = root->GetSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             }
             break;
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               Both:
             if (root->IsSynthetic()) {
               child_valobj_sp = root->GetNonSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             } else {
               child_valobj_sp = root->GetSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             }
             break;
           }
         }
 
         // if we are here and options.m_no_synthetic_children is true,
         // child_valobj_sp is going to be a NULL SP, so we hit the "else"
         // branch, and return an error
case '.': // or fallthrough from ->
         }
       } else // other layers do expand
       {
         llvm::StringRef next_separator = temp_expression.substr(next_sep_pos);
 
         child_name.SetString(temp_expression.slice(0, next_sep_pos));
 
         ValueObjectSP child_valobj_sp =
-            root->GetChildMemberWithName(child_name, true);
+            root->GetChildMemberWithName(child_name);
         if (child_valobj_sp.get()) // store the new root and move on
         {
           root = child_valobj_sp;
           remainder = next_separator;
           *final_result = ValueObject::eExpressionPathEndResultTypePlain;
           continue;
         } else {
           switch (options.m_synthetic_children_traversal) {
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               None:
             break;
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               FromSynthetic:
             if (root->IsSynthetic()) {
               child_valobj_sp = root->GetNonSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             }
             break;
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               ToSynthetic:
             if (!root->IsSynthetic()) {
               child_valobj_sp = root->GetSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             }
             break;
           case GetValueForExpressionPathOptions::SyntheticChildrenTraversal::
               Both:
             if (root->IsSynthetic()) {
               child_valobj_sp = root->GetNonSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             } else {
               child_valobj_sp = root->GetSyntheticValue();
               if (child_valobj_sp.get())
                 child_valobj_sp =
-                    child_valobj_sp->GetChildMemberWithName(child_name, true);
+                    child_valobj_sp->GetChildMemberWithName(child_name);
             }
             break;
           }
         }
 
         // if we are here and options.m_no_synthetic_children is true,
         // child_valobj_sp is going to be a NULL SP, so we hit the "else"
         // branch, and return an error
if (!m_deref_valobj) {
               child_byte_offset, child_bitfield_bit_size,
               child_bitfield_bit_offset, child_is_base_class,
               child_is_deref_of_parent, eAddressTypeInvalid, language_flags);
         }
       }
     }
 
   } else if (HasSyntheticValue()) {
-    m_deref_valobj = GetSyntheticValue()
-                         ->GetChildMemberWithName("$$dereference$$", true)
-                         .get();
+    m_deref_valobj =
+        GetSyntheticValue()->GetChildMemberWithName("$$dereference$$").get();
   } else if (IsSynthetic()) {
-    m_deref_valobj = GetChildMemberWithName("$$dereference$$", true).get();
+    m_deref_valobj = GetChildMemberWithName("$$dereference$$").get();
   }
 
   if (m_deref_valobj) {
     error.Clear();
     return m_deref_valobj->GetSP();
   } else {
     StreamString strm;
     GetExpressionPath(strm);

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

 /// members are the lambda captures. If we capture a 'this' pointer,
 /// the artifical class will contain a member variable named 'this'.
 /// The function returns a ValueObject for the captured 'this' if such
 /// member exists. If no 'this' was captured, return a nullptr.
 lldb::ValueObjectSP GetCapturedThisValueObject(StackFrame *frame) {
   assert(frame);
 
   if (auto thisValSP = frame->FindVariable(ConstString("this")))
-    if (auto thisThisValSP = thisValSP->GetChildMemberWithName("this", true))
+    if (auto thisThisValSP = thisValSP->GetChildMemberWithName("this"))
       return thisThisValSP;
 
   return nullptr;
 }
 } // namespace
 
 ClangExpressionDeclMap::ClangExpressionDeclMap(
     bool keep_result_in_memory,
bool ClangExpressionDeclMap::LookupLocalVariable(
   // We're in a local_var_lookup but haven't found any local variables
   // so far. When performing a variable lookup from within the context of
   // a lambda, we count the lambda captures as local variables. Thus,
   // see if we captured any variables with the requested 'name'.
   if (!variable_found) {
     auto find_capture = [](ConstString varname,
                            StackFrame *frame) -> ValueObjectSP {
       if (auto lambda = ClangExpressionUtil::GetLambdaValueObject(frame)) {
-        if (auto capture = lambda->GetChildMemberWithName(varname, true)) {
+        if (auto capture = lambda->GetChildMemberWithName(varname)) {
           return capture;
         }
       }
 
       return nullptr;
     };
 
     if (auto capture = find_capture(name, frame)) {

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

 #include "lldb/Utility/ConstString.h"
 
 namespace lldb_private {
 namespace ClangExpressionUtil {
 lldb::ValueObjectSP GetLambdaValueObject(StackFrame *frame) {
   assert(frame);
 
   if (auto this_val_sp = frame->FindVariable(ConstString("this")))
-    if (this_val_sp->GetChildMemberWithName("this", true))
+    if (this_val_sp->GetChildMemberWithName("this"))
       return this_val_sp;
 
   return nullptr;
 }
 } // namespace ClangExpressionUtil
 } // namespace lldb_private

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

 lldb::addr_t ClangUserExpression::GetCppObjectPointer(
     lldb::StackFrameSP frame_sp, ConstString &object_name, Status &err) {
   auto valobj_sp =
       GetObjectPointerValueObject(std::move(frame_sp), object_name, err);
 
   // We're inside a C++ class method. This could potentially be an unnamed
   // lambda structure. If the lambda captured a "this", that should be
   // the object pointer.
-  if (auto thisChildSP = valobj_sp->GetChildMemberWithName("this", true)) {
+  if (auto thisChildSP = valobj_sp->GetChildMemberWithName("this")) {
     valobj_sp = thisChildSP;
   }
 
   if (!err.Success() || !valobj_sp.get())
     return LLDB_INVALID_ADDRESS;
 
   lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
 

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

if (!target_sp)
     return false;
 
   size_t size = 0;
 
   if (auto arg = m_backend.GetCompilerType().GetIntegralTemplateArgument(0))
     size = arg->value.getLimitedValue();
 
   m_elements.assign(size, ValueObjectSP());
-  m_first = m_backend.GetChildMemberWithName(GetDataContainerMemberName(), true)
-                .get();
+  m_first =
+      m_backend.GetChildMemberWithName(GetDataContainerMemberName()).get();
   return false;
 }
 
 ValueObjectSP GenericBitsetFrontEnd::GetChildAtIndex(size_t idx) {
   if (idx >= m_elements.size() || !m_first)
     return ValueObjectSP();
 
   if (m_elements[idx])

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

if (auto target_sp = m_backend.GetTargetSP()) {
     Update();
   }
 }
 
 bool GenericOptionalFrontend::Update() {
   ValueObjectSP engaged_sp;
 
   if (m_stdlib == StdLib::LibCxx)
-    engaged_sp = m_backend.GetChildMemberWithName("__engaged_", true);
+    engaged_sp = m_backend.GetChildMemberWithName("__engaged_");
   else if (m_stdlib == StdLib::LibStdcpp)
-    engaged_sp = m_backend.GetChildMemberWithName("_M_payload", true)
-                     ->GetChildMemberWithName("_M_engaged", true);
+    engaged_sp = m_backend.GetChildMemberWithName("_M_payload")
+                     ->GetChildMemberWithName("_M_engaged");
 
   if (!engaged_sp)
     return false;
 
   // _M_engaged/__engaged is a bool flag and is true if the optional contains a
   // value. Converting it to unsigned gives us a size of 1 if it contains a
   // value and 0 if not.
   m_has_value = engaged_sp->GetValueAsUnsigned(0) != 0;
 
   return false;
 }
 
 ValueObjectSP GenericOptionalFrontend::GetChildAtIndex(size_t _idx) {
   if (!m_has_value)
     return ValueObjectSP();
 
   ValueObjectSP val_sp;
 
   if (m_stdlib == StdLib::LibCxx)
     // __val_ contains the underlying value of an optional if it has one.
     // Currently because it is part of an anonymous union
     // GetChildMemberWithName() does not peer through and find it unless we are
     // at the parent itself. We can obtain the parent through __engaged_.
-    val_sp = m_backend.GetChildMemberWithName("__engaged_", true)
+    val_sp = m_backend.GetChildMemberWithName("__engaged_")
                  ->GetParent()
                  ->GetChildAtIndex(0, true)
-                 ->GetChildMemberWithName("__val_", true);
+                 ->GetChildMemberWithName("__val_");
   else if (m_stdlib == StdLib::LibStdcpp) {
-    val_sp = m_backend.GetChildMemberWithName("_M_payload", true)
-                 ->GetChildMemberWithName("_M_payload", true);
+    val_sp = m_backend.GetChildMemberWithName("_M_payload")
+                 ->GetChildMemberWithName("_M_payload");
 
     // In some implementations, _M_value contains the underlying value of an
     // optional, and in other versions, it's in the payload member.
-    ValueObjectSP candidate = val_sp->GetChildMemberWithName("_M_value", true);
+    ValueObjectSP candidate = val_sp->GetChildMemberWithName("_M_value");
     if (candidate)
       val_sp = candidate;
   }
 
   if (!val_sp)
     return ValueObjectSP();
 
   CompilerType holder_type = val_sp->GetCompilerType();

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

 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 lldb::ValueObjectSP lldb_private::formatters::GetChildMemberWithName(
     ValueObject &obj, llvm::ArrayRef<ConstString> alternative_names) {
   for (ConstString name : alternative_names) {
-    lldb::ValueObjectSP child_sp = obj.GetChildMemberWithName(name, true);
+    lldb::ValueObjectSP child_sp = obj.GetChildMemberWithName(name);
 
     if (child_sp)
       return child_sp;
   }
   return {};
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::GetFirstValueOfLibCXXCompressedPair(
     ValueObject &pair) {
   ValueObjectSP value;
   ValueObjectSP first_child = pair.GetChildAtIndex(0, true);
   if (first_child)
-    value = first_child->GetChildMemberWithName("__value_", true);
+    value = first_child->GetChildMemberWithName("__value_");
   if (!value) {
     // pre-r300140 member name
-    value = pair.GetChildMemberWithName("__first_", true);
+    value = pair.GetChildMemberWithName("__first_");
   }
   return value;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::GetSecondValueOfLibCXXCompressedPair(
     ValueObject &pair) {
   ValueObjectSP value;
   if (pair.GetNumChildren() > 1) {
     ValueObjectSP second_child = pair.GetChildAtIndex(1, true);
     if (second_child) {
-      value = second_child->GetChildMemberWithName("__value_", true);
+      value = second_child->GetChildMemberWithName("__value_");
     }
   }
   if (!value) {
     // pre-r300140 member name
-    value = pair.GetChildMemberWithName("__second_", true);
+    value = pair.GetChildMemberWithName("__second_");
   }
   return value;
 }
 
 bool lldb_private::formatters::LibcxxOptionalSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
   // An optional either contains a value or not, the member __engaged_ is
   // a bool flag, it is true if the optional has a value and false otherwise.
-  ValueObjectSP engaged_sp(
-      valobj_sp->GetChildMemberWithName("__engaged_", true));
+  ValueObjectSP engaged_sp(valobj_sp->GetChildMemberWithName("__engaged_"));
 
   if (!engaged_sp)
     return false;
 
   llvm::StringRef engaged_as_cstring(
       engaged_sp->GetValueAsUnsigned(0) == 1 ? "true" : "false");
 
   stream.Printf(" Has Value=%s ", engaged_as_cstring.data());
bool lldb_private::formatters::LibcxxFunctionSummaryProvider(
   return true;
 }
 
 bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
-  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_"));
   ValueObjectSP count_sp(
       valobj_sp->GetChildAtNamePath({"__cntrl_", "__shared_owners_"}));
   ValueObjectSP weakcount_sp(
       valobj_sp->GetChildAtNamePath({"__cntrl_", "__shared_weak_owners_"}));
 
   if (!ptr_sp)
     return false;
 

 }
 
 bool lldb_private::formatters::LibcxxUniquePointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_"));
   if (!ptr_sp)
     return false;
 
   ptr_sp = GetFirstValueOfLibCXXCompressedPair(*ptr_sp);
   if (!ptr_sp)
     return false;
 
   if (ptr_sp->GetValueAsUnsigned(0) == 0) {
m_pair_ptr = valobj_sp
                          ValueObject::GetValueForExpressionPathOptions()
                              .DontCheckDotVsArrowSyntax()
                              .SetSyntheticChildrenTraversal(
                                  ValueObject::GetValueForExpressionPathOptions::
                                      SyntheticChildrenTraversal::None),
                          nullptr)
                      .get();
     if (m_pair_ptr) {
-      auto __i_(valobj_sp->GetChildMemberWithName("__i_", true));
+      auto __i_(valobj_sp->GetChildMemberWithName("__i_"));
       if (!__i_) {
         m_pair_ptr = nullptr;
         return false;
       }
       CompilerType pair_type(
           __i_->GetCompilerType().GetTypeTemplateArgument(0));
       std::string name;
       uint64_t bit_offset_ptr;
bool lldb_private::formatters::LibCxxUnorderedMapIteratorSyntheticFrontEnd::
   // and free their memory.
   m_iter_ptr =
       valobj_sp
           ->GetValueForExpressionPath(".__i_.__node_", nullptr, nullptr,
                                       exprPathOptions, nullptr)
           .get();
 
   if (m_iter_ptr) {
-    auto iter_child(valobj_sp->GetChildMemberWithName("__i_", true));
+    auto iter_child(valobj_sp->GetChildMemberWithName("__i_"));
     if (!iter_child) {
       m_iter_ptr = nullptr;
       return false;
     }
 
     CompilerType node_type(iter_child->GetCompilerType()
                                .GetTypeTemplateArgument(0)
                                .GetPointeeType());
lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetChildAtIndex(
   if (!m_cntrl)
     return lldb::ValueObjectSP();
 
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return lldb::ValueObjectSP();
 
   if (idx == 0)
-    return valobj_sp->GetChildMemberWithName("__ptr_", true);
+    return valobj_sp->GetChildMemberWithName("__ptr_");
 
   if (idx == 1) {
-    if (auto ptr_sp = valobj_sp->GetChildMemberWithName("__ptr_", true)) {
+    if (auto ptr_sp = valobj_sp->GetChildMemberWithName("__ptr_")) {
       Status status;
       auto value_sp = ptr_sp->Dereference(status);
       if (status.Success()) {
         auto value_type_sp =
             valobj_sp->GetCompilerType().GetTypeTemplateArgument(0);
         return value_sp->Cast(value_type_sp);
       }
     }
   }
 
   return lldb::ValueObjectSP();
 }
 
 bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() {
   m_cntrl = nullptr;
 
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
 
   TargetSP target_sp(valobj_sp->GetTargetSP());
   if (!target_sp)
     return false;
 
-  lldb::ValueObjectSP cntrl_sp(
-      valobj_sp->GetChildMemberWithName("__cntrl_", true));
+  lldb::ValueObjectSP cntrl_sp(valobj_sp->GetChildMemberWithName("__cntrl_"));
 
   m_cntrl = cntrl_sp.get(); // need to store the raw pointer to avoid a circular
                             // dependency
   return false;
 }
 
 bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::
     MightHaveChildren() {
lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::GetChildAtIndex(
   return lldb::ValueObjectSP();
 }
 
 bool lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::Update() {
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_", true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("__ptr_"));
   if (!ptr_sp)
     return false;
 
   // Retrieve the actual pointer and the deleter, and clone them to give them
   // user-friendly names.
   ValueObjectSP value_pointer_sp = GetFirstValueOfLibCXXCompressedPair(*ptr_sp);
   if (value_pointer_sp)
     m_value_ptr_sp = value_pointer_sp->Clone(ConstString("pointer"));

 enum class StringLayout { CSD, DSC };
 }
 
 /// Determine the size in bytes of \p valobj (a libc++ std::string object) and
 /// extract its data payload. Return the size + payload pair.
 // TODO: Support big-endian architectures.
 static std::optional<std::pair<uint64_t, ValueObjectSP>>
 ExtractLibcxxStringInfo(ValueObject &valobj) {
-  ValueObjectSP valobj_r_sp =
-      valobj.GetChildMemberWithName("__r_", /*can_create=*/true);
+  ValueObjectSP valobj_r_sp = valobj.GetChildMemberWithName("__r_");
   if (!valobj_r_sp || !valobj_r_sp->GetError().Success())
     return {};
 
   // __r_ is a compressed_pair of the actual data and the allocator. The data we
   // want is in the first base class.
   ValueObjectSP valobj_r_base_sp =
       valobj_r_sp->GetChildAtIndex(0, /*can_create=*/true);
   if (!valobj_r_base_sp)
     return {};
 
   ValueObjectSP valobj_rep_sp =
-      valobj_r_base_sp->GetChildMemberWithName("__value_", /*can_create=*/true);
+      valobj_r_base_sp->GetChildMemberWithName("__value_");
   if (!valobj_rep_sp)
     return {};
 
-  ValueObjectSP l = valobj_rep_sp->GetChildMemberWithName("__l",
-                                                          /*can_create=*/true);
+  ValueObjectSP l = valobj_rep_sp->GetChildMemberWithName("__l");
   if (!l)
     return {};
 
   StringLayout layout = l->GetIndexOfChildWithName("__data_") == 0
                             ? StringLayout::DSC
                             : StringLayout::CSD;
 
   bool short_mode = false; // this means the string is in short-mode and the
                            // data is stored inline
   bool using_bitmasks = true; // Whether the class uses bitmasks for the mode
                               // flag (pre-D123580).
   uint64_t size;
   uint64_t size_mode_value = 0;
 
-  ValueObjectSP short_sp =
-      valobj_rep_sp->GetChildMemberWithName("__s", /*can_create=*/true);
+  ValueObjectSP short_sp = valobj_rep_sp->GetChildMemberWithName("__s");
   if (!short_sp)
     return {};
 
-  ValueObjectSP is_long = short_sp->GetChildMemberWithName("__is_long_", true);
-  ValueObjectSP size_sp = short_sp->GetChildMemberWithName("__size_", true);
+  ValueObjectSP is_long = short_sp->GetChildMemberWithName("__is_long_");
+  ValueObjectSP size_sp = short_sp->GetChildMemberWithName("__size_");
   if (!size_sp)
     return {};
 
   if (is_long) {
     using_bitmasks = false;
     short_mode = !is_long->GetValueAsUnsigned(/*fail_value=*/0);
     size = size_sp->GetValueAsUnsigned(/*fail_value=*/0);
   } else {
     // The string mode is encoded in the size field.
     size_mode_value = size_sp->GetValueAsUnsigned(0);
     uint8_t mode_mask = layout == StringLayout::DSC ? 0x80 : 1;
     short_mode = (size_mode_value & mode_mask) == 0;
   }
 
   if (short_mode) {
-    ValueObjectSP location_sp =
-        short_sp->GetChildMemberWithName("__data_", true);
+    ValueObjectSP location_sp = short_sp->GetChildMemberWithName("__data_");
     if (using_bitmasks)
       size = (layout == StringLayout::DSC) ? size_mode_value
                                            : ((size_mode_value >> 1) % 256);
 
     // When the small-string optimization takes place, the data must fit in the
     // inline string buffer (23 bytes on x86_64/Darwin). If it doesn't, it's
     // likely that the string isn't initialized and we're reading garbage.
     ExecutionContext exe_ctx(location_sp->GetExecutionContextRef());
     const std::optional<uint64_t> max_bytes =
         location_sp->GetCompilerType().GetByteSize(
             exe_ctx.GetBestExecutionContextScope());
     if (!max_bytes || size > *max_bytes || !location_sp)
       return {};
 
     return std::make_pair(size, location_sp);
   }
 
   // we can use the layout_decider object as the data pointer
-  ValueObjectSP location_sp =
-      l->GetChildMemberWithName("__data_", /*can_create=*/true);
-  ValueObjectSP size_vo =
-      l->GetChildMemberWithName("__size_", /*can_create=*/true);
-  ValueObjectSP capacity_vo =
-      l->GetChildMemberWithName("__cap_", /*can_create=*/true);
+  ValueObjectSP location_sp = l->GetChildMemberWithName("__data_");
+  ValueObjectSP size_vo = l->GetChildMemberWithName("__size_");
+  ValueObjectSP capacity_vo = l->GetChildMemberWithName("__cap_");
   if (!size_vo || !location_sp || !capacity_vo)
     return {};
   size = size_vo->GetValueAsUnsigned(LLDB_INVALID_OFFSET);
   uint64_t capacity = capacity_vo->GetValueAsUnsigned(LLDB_INVALID_OFFSET);
   if (!using_bitmasks && layout == StringLayout::CSD)
     capacity *= 2;
   if (size == LLDB_INVALID_OFFSET || capacity == LLDB_INVALID_OFFSET ||
       capacity < size)

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

 // ValueObjectSP
 //
 ValueObjectSP
 lldb_private::formatters::GetLibCxxAtomicValue(ValueObject &valobj) {
   ValueObjectSP non_sythetic = valobj.GetNonSyntheticValue();
   if (!non_sythetic)
     return {};
 
-  ValueObjectSP member__a_ = non_sythetic->GetChildMemberWithName("__a_", true);
+  ValueObjectSP member__a_ = non_sythetic->GetChildMemberWithName("__a_");
   if (!member__a_)
     return {};
 
   ValueObjectSP member__a_value =
-      member__a_->GetChildMemberWithName("__a_value", true);
+      member__a_->GetChildMemberWithName("__a_value");
   if (!member__a_value)
     return member__a_;
 
   return member__a_value;
 }
 
 bool lldb_private::formatters::LibCxxAtomicSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {

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

lldb_private::formatters::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() {
   m_num_elements = 0;
-  ValueObjectSP size_sp(m_backend.GetChildMemberWithName("__size_", true));
+  ValueObjectSP size_sp(m_backend.GetChildMemberWithName("__size_"));
   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)
bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
   m_num_elements = 0;
   m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
   if (!m_element_type.IsValid())
     return false;
 
   if (std::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("__begin_", true).get();
+    m_start = m_backend.GetChildMemberWithName("__begin_").get();
   }
 
   return false;
 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     MightHaveChildren() {
   return true;

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

public:
   ListEntry() = default;
   ListEntry(ValueObjectSP entry_sp) : m_entry_sp(std::move(entry_sp)) {}
   ListEntry(ValueObject *entry)
       : m_entry_sp(entry ? entry->GetSP() : ValueObjectSP()) {}
 
   ListEntry next() {
     if (!m_entry_sp)
       return ListEntry();
-    return ListEntry(m_entry_sp->GetChildMemberWithName("__next_", true));
+    return ListEntry(m_entry_sp->GetChildMemberWithName("__next_"));
   }
 
   ListEntry prev() {
     if (!m_entry_sp)
       return ListEntry();
-    return ListEntry(m_entry_sp->GetChildMemberWithName("__prev_", true));
+    return ListEntry(m_entry_sp->GetChildMemberWithName("__prev_"));
   }
 
   uint64_t value() const {
     if (!m_entry_sp)
       return 0;
     return m_entry_sp->GetValueAsUnsigned(0);
   }
 

 bool ForwardListFrontEnd::Update() {
   AbstractListFrontEnd::Update();
 
   Status err;
   ValueObjectSP backend_addr(m_backend.AddressOf(err));
   if (err.Fail() || !backend_addr)
     return false;
 
-  ValueObjectSP impl_sp(
-      m_backend.GetChildMemberWithName("__before_begin_", true));
+  ValueObjectSP impl_sp(m_backend.GetChildMemberWithName("__before_begin_"));
   if (!impl_sp)
     return false;
   impl_sp = GetFirstValueOfLibCXXCompressedPair(*impl_sp);
   if (!impl_sp)
     return false;
-  m_head = impl_sp->GetChildMemberWithName("__next_", true).get();
+  m_head = impl_sp->GetChildMemberWithName("__next_").get();
   return false;
 }
 
 ListFrontEnd::ListFrontEnd(lldb::ValueObjectSP valobj_sp)
     : AbstractListFrontEnd(*valobj_sp) {
   if (valobj_sp)
     Update();
 }
 
 size_t ListFrontEnd::CalculateNumChildren() {
   if (m_count != UINT32_MAX)
     return m_count;
   if (!m_head || !m_tail || m_node_address == 0)
     return 0;
-  ValueObjectSP size_alloc(
-      m_backend.GetChildMemberWithName("__size_alloc_", true));
+  ValueObjectSP size_alloc(m_backend.GetChildMemberWithName("__size_alloc_"));
   if (size_alloc) {
     ValueObjectSP value = GetFirstValueOfLibCXXCompressedPair(*size_alloc);
     if (value) {
       m_count = value->GetValueAsUnsigned(UINT32_MAX);
     }
   }
   if (m_count != UINT32_MAX) {
     return m_count;
bool ListFrontEnd::Update() {
 
   Status err;
   ValueObjectSP backend_addr(m_backend.AddressOf(err));
   if (err.Fail() || !backend_addr)
     return false;
   m_node_address = backend_addr->GetValueAsUnsigned(0);
   if (!m_node_address || m_node_address == LLDB_INVALID_ADDRESS)
     return false;
-  ValueObjectSP impl_sp(m_backend.GetChildMemberWithName("__end_", true));
+  ValueObjectSP impl_sp(m_backend.GetChildMemberWithName("__end_"));
   if (!impl_sp)
     return false;
-  m_head = impl_sp->GetChildMemberWithName("__next_", true).get();
-  m_tail = impl_sp->GetChildMemberWithName("__prev_", true).get();
+  m_head = impl_sp->GetChildMemberWithName("__next_").get();
+  m_tail = impl_sp->GetChildMemberWithName("__prev_").get();
   return false;
 }
 
 SyntheticChildrenFrontEnd *formatters::LibcxxStdListSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   return (valobj_sp ? new ListFrontEnd(valobj_sp) : nullptr);
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxStdForwardListSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   return valobj_sp ? new ForwardListFrontEnd(*valobj_sp) : nullptr;
 }

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

 }
 
 size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     CalculateNumChildren() {
   if (m_count != UINT32_MAX)
     return m_count;
   if (m_tree == nullptr)
     return 0;
-  ValueObjectSP m_item(m_tree->GetChildMemberWithName("__pair3_", true));
+  ValueObjectSP m_item(m_tree->GetChildMemberWithName("__pair3_"));
   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("__first_", true);
+    m_item = m_item->GetChildMemberWithName("__first_");
     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("__value_", true);
+    m_item = first_elem_parent->GetChildMemberWithName("__value_");
     break;
   }
   default:
     return false;
   }
 
   if (!m_item)
     return 0;
   m_count = m_item->GetValueAsUnsigned(0);
   return m_count;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() {
   if (m_element_type.IsValid())
     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("__value_", true);
+  deref = deref->GetChildMemberWithName("__value_");
   if (deref) {
     m_element_type = deref->GetCompilerType();
     return true;
   }
   deref = m_backend.GetChildAtNamePath({"__tree_", "__pair3_"});
   if (!deref)
     return false;
   m_element_type = deref->GetCompilerType()
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("__value_", true);
+      auto child_sp = iterated_sp->GetChildMemberWithName("__value_");
       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(
   m_iterators[idx] = iterator;
   return potential_child_sp;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::Update() {
   m_count = UINT32_MAX;
   m_tree = m_root_node = nullptr;
   m_iterators.clear();
-  m_tree = m_backend.GetChildMemberWithName("__tree_", true).get();
+  m_tree = m_backend.GetChildMemberWithName("__tree_").get();
   if (!m_tree)
     return false;
-  m_root_node = m_tree->GetChildMemberWithName("__begin_node_", true).get();
+  m_root_node = m_tree->GetChildMemberWithName("__begin_node_").get();
   return false;
 }
 
 bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 

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

private:
   // is destroyed, so we must not store a shared pointer to any ValueObject
   // derived from our backend ValueObject (since we're in the same cluster).
   ValueObject* m_container_sp = nullptr;
 };
 } // namespace
 
 bool QueueFrontEnd::Update() {
   m_container_sp = nullptr;
-  ValueObjectSP c_sp = m_backend.GetChildMemberWithName("c", true);
+  ValueObjectSP c_sp = m_backend.GetChildMemberWithName("c");
   if (!c_sp)
     return false;
   m_container_sp = c_sp->GetSyntheticValue().get();
   return false;
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxQueueFrontEndCreator(CXXSyntheticChildren *,
                                        lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new QueueFrontEnd(*valobj_sp);
   return nullptr;
 }

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

 };
 }
 
 bool TupleFrontEnd::Update() {
   m_elements.clear();
   m_base = nullptr;
 
   ValueObjectSP base_sp;
-  base_sp = m_backend.GetChildMemberWithName("__base_", true);
+  base_sp = m_backend.GetChildMemberWithName("__base_");
   if (!base_sp) {
     // Pre r304382 name of the base element.
-    base_sp = m_backend.GetChildMemberWithName("base_", true);
+    base_sp = m_backend.GetChildMemberWithName("base_");
   }
   if (!base_sp)
     return false;
   m_base = base_sp.get();
   m_elements.assign(base_sp->GetCompilerType().GetNumDirectBaseClasses(),
                     nullptr);
   return false;
 }

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

while (idx >= m_elements_cache.size()) {
     if (m_next_element == nullptr)
       return lldb::ValueObjectSP();
 
     Status error;
     ValueObjectSP node_sp = m_next_element->Dereference(error);
     if (!node_sp || error.Fail())
       return lldb::ValueObjectSP();
 
-    ValueObjectSP value_sp = node_sp->GetChildMemberWithName("__value_", true);
-    ValueObjectSP hash_sp = node_sp->GetChildMemberWithName("__hash_", true);
+    ValueObjectSP value_sp = node_sp->GetChildMemberWithName("__value_");
+    ValueObjectSP hash_sp = node_sp->GetChildMemberWithName("__hash_");
     if (!hash_sp || !value_sp) {
       if (!m_element_type) {
         auto p1_sp = m_backend.GetChildAtNamePath({"__table_", "__p1_"});
         if (!p1_sp)
           return nullptr;
 
         ValueObjectSP first_sp = nullptr;
         switch (p1_sp->GetCompilerType().GetNumDirectBaseClasses()) {
         case 1:
           // Assume a pre llvm r300140 __compressed_pair implementation:
-          first_sp = p1_sp->GetChildMemberWithName("__first_", true);
+          first_sp = p1_sp->GetChildMemberWithName("__first_");
           break;
         case 2: {
           // Assume a post llvm r300140 __compressed_pair implementation:
           ValueObjectSP first_elem_parent_sp =
             p1_sp->GetChildAtIndex(0, true);
-          first_sp = p1_sp->GetChildMemberWithName("__value_", true);
+          first_sp = p1_sp->GetChildMemberWithName("__value_");
           break;
         }
         default:
           return nullptr;
         }
 
         if (!first_sp)
           return nullptr;
if (!hash_sp || !value_sp) {
           CompilerType actual_type = field_type.GetTypedefedType();
           if (isStdTemplate(actual_type.GetTypeName(), "pair"))
             m_element_type = actual_type;
         }
       }
       if (!m_node_type)
         return nullptr;
       node_sp = node_sp->Cast(m_node_type);
-      value_sp = node_sp->GetChildMemberWithName("__value_", true);
-      hash_sp = node_sp->GetChildMemberWithName("__hash_", true);
+      value_sp = node_sp->GetChildMemberWithName("__value_");
+      hash_sp = node_sp->GetChildMemberWithName("__hash_");
       if (!value_sp || !hash_sp)
         return nullptr;
     }
     m_elements_cache.push_back(
         {value_sp.get(), hash_sp->GetValueAsUnsigned(0)});
-    m_next_element = node_sp->GetChildMemberWithName("__next_", true).get();
+    m_next_element = node_sp->GetChildMemberWithName("__next_").get();
     if (!m_next_element || m_next_element->GetValueAsUnsigned(0) == 0)
       m_next_element = nullptr;
   }
 
   std::pair<ValueObject *, uint64_t> val_hash = m_elements_cache[idx];
   if (!val_hash.first)
     return lldb::ValueObjectSP();
   StreamString stream;
return CreateValueObjectFromData(stream.GetString(), data, exe_ctx,
                                    m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
     Update() {
   m_num_elements = 0;
   m_next_element = nullptr;
   m_elements_cache.clear();
-  ValueObjectSP table_sp = m_backend.GetChildMemberWithName("__table_", true);
+  ValueObjectSP table_sp = m_backend.GetChildMemberWithName("__table_");
   if (!table_sp)
     return false;
 
-  ValueObjectSP p2_sp = table_sp->GetChildMemberWithName("__p2_", true);
+  ValueObjectSP p2_sp = table_sp->GetChildMemberWithName("__p2_");
   ValueObjectSP num_elements_sp = nullptr;
   llvm::SmallVector<llvm::StringRef, 3> next_path;
   switch (p2_sp->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
-    num_elements_sp = p2_sp->GetChildMemberWithName("__first_", true);
+    num_elements_sp = p2_sp->GetChildMemberWithName("__first_");
     next_path.append({"__p1_", "__first_", "__next_"});
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent = p2_sp->GetChildAtIndex(0, true);
-    num_elements_sp =
-        first_elem_parent->GetChildMemberWithName("__value_", true);
+    num_elements_sp = first_elem_parent->GetChildMemberWithName("__value_");
     next_path.append({"__p1_", "__value_", "__next_"});
     break;
   }
   default:
     return false;
   }
 
   if (!num_elements_sp)

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

case 4:
     return static_cast<uint32_t>(-1);
   }
   lldbassert(false && "Unknown index type size");
   return static_cast<uint32_t>(-1); // Fallback to stable ABI type.
 }
 
 LibcxxVariantIndexValidity
 LibcxxVariantGetIndexValidity(ValueObjectSP &impl_sp) {
-  ValueObjectSP index_sp(impl_sp->GetChildMemberWithName("__index", true));
+  ValueObjectSP index_sp(impl_sp->GetChildMemberWithName("__index"));
 
   if (!index_sp)
     return LibcxxVariantIndexValidity::Invalid;
 
   // In the stable ABI, the type of __index is just int.
   // In the unstable ABI, where _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION is
   // enabled, the type can either be unsigned char/short/int depending on
   // how many variant types there are.
LibcxxVariantGetIndexValidity(ValueObjectSP &impl_sp) {
 
   if (index_value == npos_value)
     return LibcxxVariantIndexValidity::NPos;
 
   return LibcxxVariantIndexValidity::Valid;
 }
 
 std::optional<uint64_t> LibcxxVariantIndexValue(ValueObjectSP &impl_sp) {
-  ValueObjectSP index_sp(impl_sp->GetChildMemberWithName("__index", true));
+  ValueObjectSP index_sp(impl_sp->GetChildMemberWithName("__index"));
 
   if (!index_sp)
     return {};
 
   return {index_sp->GetValueAsUnsigned(0)};
 }
 
 ValueObjectSP LibcxxVariantGetNthHead(ValueObjectSP &impl_sp, uint64_t index) {
-  ValueObjectSP data_sp(impl_sp->GetChildMemberWithName("__data", true));
+  ValueObjectSP data_sp(impl_sp->GetChildMemberWithName("__data"));
 
   if (!data_sp)
     return ValueObjectSP{};
 
   ValueObjectSP current_level = data_sp;
   for (uint64_t n = index; n != 0; --n) {
-    ValueObjectSP tail_sp(
-        current_level->GetChildMemberWithName("__tail", true));
+    ValueObjectSP tail_sp(current_level->GetChildMemberWithName("__tail"));
 
     if (!tail_sp)
       return ValueObjectSP{};
 
     current_level = tail_sp;
   }
 
-  return current_level->GetChildMemberWithName("__head", true);
+  return current_level->GetChildMemberWithName("__head");
 }
 } // namespace
 
 namespace lldb_private {
 namespace formatters {
 bool LibcxxVariantSummaryProvider(ValueObject &valobj, Stream &stream,
                                   const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
ValueObjectSP VariantFrontEnd::GetChildAtIndex(size_t idx) {
   if (!head_type)
     return {};
 
   CompilerType template_type = head_type.GetTypeTemplateArgument(1);
 
   if (!template_type)
     return {};
 
-  ValueObjectSP head_value(nth_head->GetChildMemberWithName("__value", true));
+  ValueObjectSP head_value(nth_head->GetChildMemberWithName("__value"));
 
   if (!head_value)
     return {};
 
   return head_value->Clone(ConstString("Value"));
 }
 
 SyntheticChildrenFrontEnd *
 formatters::LibcxxVariantFrontEndCreator(CXXSyntheticChildren *,
                                          lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new VariantFrontEnd(*valobj_sp);
   return nullptr;
 }

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

lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::GetChildAtIndex(
   return CreateValueObjectFromAddress(name.GetString(), offset,
                                       m_backend.GetExecutionContextRef(),
                                       m_element_type);
 }
 
 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
   m_start = m_finish = nullptr;
   ValueObjectSP data_type_finder_sp(
-      m_backend.GetChildMemberWithName("__end_cap_", true));
+      m_backend.GetChildMemberWithName("__end_cap_"));
   if (!data_type_finder_sp)
     return false;
 
   switch (data_type_finder_sp->GetCompilerType().GetNumDirectBaseClasses()) {
   case 1:
     // Assume a pre llvm r300140 __compressed_pair implementation:
     data_type_finder_sp =
-        data_type_finder_sp->GetChildMemberWithName("__first_", true);
+        data_type_finder_sp->GetChildMemberWithName("__first_");
     break;
   case 2: {
     // Assume a post llvm r300140 __compressed_pair implementation:
     ValueObjectSP first_elem_parent_sp =
       data_type_finder_sp->GetChildAtIndex(0, true);
     data_type_finder_sp =
-        first_elem_parent_sp->GetChildMemberWithName("__value_", true);
+        first_elem_parent_sp->GetChildMemberWithName("__value_");
     break;
   }
   default:
     return false;
   }
 
   if (!data_type_finder_sp)
     return false;
   m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType();
   if (std::optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
     m_element_size = *size;
 
     if (m_element_size > 0) {
       // store raw pointers or end up with a circular dependency
-      m_start = m_backend.GetChildMemberWithName("__begin_", true).get();
-      m_finish = m_backend.GetChildMemberWithName("__end_", true).get();
+      m_start = m_backend.GetChildMemberWithName("__begin_").get();
+      m_finish = m_backend.GetChildMemberWithName("__end_").get();
     }
   }
   return false;
 }
 
 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
     MightHaveChildren() {
   return true;

  }*/
 
 bool lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() {
   m_children.clear();
   ValueObjectSP valobj_sp = m_backend.GetSP();
   if (!valobj_sp)
     return false;
   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
-  ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName("__size_", true));
+  ValueObjectSP size_sp(valobj_sp->GetChildMemberWithName("__size_"));
   if (!size_sp)
     return false;
   m_count = size_sp->GetValueAsUnsigned(0);
   if (!m_count)
     return true;
-  ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName("__begin_", true));
+  ValueObjectSP begin_sp(valobj_sp->GetChildMemberWithName("__begin_"));
   if (!begin_sp) {
     m_count = 0;
     return false;
   }
   m_base_data_address = begin_sp->GetValueAsUnsigned(0);
   if (!m_base_data_address) {
     m_count = 0;
     return false;

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

if (!target_sp)
     return false;
 
   bool is_64bit = (target_sp->GetArchitecture().GetAddressByteSize() == 8);
 
   if (!valobj_sp)
     return false;
   m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
 
-  ValueObjectSP _M_node_sp(valobj_sp->GetChildMemberWithName("_M_node", true));
+  ValueObjectSP _M_node_sp(valobj_sp->GetChildMemberWithName("_M_node"));
   if (!_M_node_sp)
     return false;
 
   m_pair_address = _M_node_sp->GetValueAsUnsigned(0);
   if (m_pair_address == 0)
     return false;
 
   m_pair_address += (is_64bit ? 32 : 16);
bool LibStdcppSharedPtrSyntheticFrontEnd::Update() {
   auto backend = m_backend.GetSP();
   if (!backend)
     return false;
 
   auto valobj_sp = backend->GetNonSyntheticValue();
   if (!valobj_sp)
     return false;
 
-  auto ptr_obj_sp = valobj_sp->GetChildMemberWithName("_M_ptr", true);
+  auto ptr_obj_sp = valobj_sp->GetChildMemberWithName("_M_ptr");
   if (!ptr_obj_sp)
     return false;
 
   m_ptr_obj = ptr_obj_sp->Clone(ConstString("pointer")).get();
 
   if (m_ptr_obj) {
     Status error;
     ValueObjectSP obj_obj = m_ptr_obj->Dereference(error);

 }
 
 bool lldb_private::formatters::LibStdcppSmartPointerSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue());
   if (!valobj_sp)
     return false;
 
-  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("_M_ptr", true));
+  ValueObjectSP ptr_sp(valobj_sp->GetChildMemberWithName("_M_ptr"));
   if (!ptr_sp)
     return false;
 
   ValueObjectSP usecount_sp(
       valobj_sp->GetChildAtNamePath({"_M_refcount", "_M_pi", "_M_use_count"}));
   if (!usecount_sp)
     return false;
 

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

while (next_child_sp != nullptr) {
     size_t child_count = current_child->GetNumChildren();
     for (size_t i = 0; i < child_count; ++i) {
       ValueObjectSP child_sp = current_child->GetChildAtIndex(i, true);
       llvm::StringRef name_str = child_sp->GetName().GetStringRef();
       if (name_str.startswith("std::_Tuple_impl<")) {
         next_child_sp = child_sp;
       } else if (name_str.startswith("std::_Head_base<")) {
         ValueObjectSP value_sp =
-            child_sp->GetChildMemberWithName("_M_head_impl", true);
+            child_sp->GetChildMemberWithName("_M_head_impl");
         if (value_sp) {
           StreamString name;
           name.Printf("[%zd]", m_members.size());
           m_members.push_back(value_sp->Clone(ConstString(name.GetString())).get());
         }
       }
     }
   }

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

ValueObjectSP LibStdcppUniquePtrSyntheticFrontEnd::GetTuple() {
 
   if (!valobj_backend_sp)
     return nullptr;
 
   ValueObjectSP valobj_sp = valobj_backend_sp->GetNonSyntheticValue();
   if (!valobj_sp)
     return nullptr;
 
-  ValueObjectSP obj_child_sp = valobj_sp->GetChildMemberWithName("_M_t", true);
+  ValueObjectSP obj_child_sp = valobj_sp->GetChildMemberWithName("_M_t");
   if (!obj_child_sp)
       return nullptr;
 
-  ValueObjectSP obj_subchild_sp =
-      obj_child_sp->GetChildMemberWithName("_M_t", true);
+  ValueObjectSP obj_subchild_sp = obj_child_sp->GetChildMemberWithName("_M_t");
 
   // if there is a _M_t subchild, the tuple is found in the obj_subchild_sp
   // (for libstdc++ 6.0.23).
   if (obj_subchild_sp) {
     return obj_subchild_sp;
   }
 
   return obj_child_sp;

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

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_(valobj_sp->GetChildMemberWithName("__f_", true));
+  ValueObjectSP member_f_(valobj_sp->GetChildMemberWithName("__f_"));
 
   if (member_f_) {
-    ValueObjectSP sub_member_f_(
-        member_f_->GetChildMemberWithName("__f_", true));
+    ValueObjectSP sub_member_f_(member_f_->GetChildMemberWithName("__f_"));
 
     if (sub_member_f_)
         member_f_ = sub_member_f_;
   }
 
   if (!member_f_)
     return optional_info;
 

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

static ThreadSP FailExceptionParsing(llvm::StringRef msg) {
   Log *log = GetLog(LLDBLog::Language);
   LLDB_LOG(log, "Failed getting backtrace from exception: {0}", msg);
   return ThreadSP();
 }
 
 ThreadSP AppleObjCRuntime::GetBacktraceThreadFromException(
     lldb::ValueObjectSP exception_sp) {
   ValueObjectSP reserved_dict =
-      exception_sp->GetChildMemberWithName("reserved", true);
+      exception_sp->GetChildMemberWithName("reserved");
   if (!reserved_dict)
     return FailExceptionParsing("Failed to get 'reserved' member.");
 
   reserved_dict = reserved_dict->GetSyntheticValue();
   if (!reserved_dict)
     return FailExceptionParsing("Failed to get synthetic value.");
 
   TypeSystemClangSP scratch_ts_sp =
if (lldb_private::formatters::NSStringSummaryProvider(
                                                     "callStackReturnAddresses");
         break;
       }
     }
   }
 
   if (!return_addresses)
     return FailExceptionParsing("Failed to get return addresses.");
-  auto frames_value = return_addresses->GetChildMemberWithName("_frames", true);
+  auto frames_value = return_addresses->GetChildMemberWithName("_frames");
   if (!frames_value)
     return FailExceptionParsing("Failed to get frames_value.");
   addr_t frames_addr = frames_value->GetValueAsUnsigned(0);
-  auto count_value = return_addresses->GetChildMemberWithName("_cnt", true);
+  auto count_value = return_addresses->GetChildMemberWithName("_cnt");
   if (!count_value)
     return FailExceptionParsing("Failed to get count_value.");
   size_t count = count_value->GetValueAsUnsigned(0);
-  auto ignore_value = return_addresses->GetChildMemberWithName("_ignore", true);
+  auto ignore_value = return_addresses->GetChildMemberWithName("_ignore");
   if (!ignore_value)
     return FailExceptionParsing("Failed to get ignore_value.");
   size_t ignore = ignore_value->GetValueAsUnsigned(0);
 
   size_t ptr_size = m_process->GetAddressByteSize();
   std::vector<lldb::addr_t> pcs;
   for (size_t idx = 0; idx < count; idx++) {
     Status error;

lldb/source/Target/StackFrame.cpp

for (const VariableSP &variable_sp : *variable_list) {
       if (!var_type)
         continue;
 
       if (!var_type->GetForwardCompilerType().IsAnonymousType())
         continue;
       valobj_sp = GetValueObjectForFrameVariable(variable_sp, use_dynamic);
       if (!valobj_sp)
         return valobj_sp;
-      valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string, true);
+      valobj_sp = valobj_sp->GetChildMemberWithName(name_const_string);
       if (valobj_sp)
         break;
     }
   }
 
   if (var_sp && !valobj_sp) {
     valobj_sp = GetValueObjectForFrameVariable(var_sp, use_dynamic);
     if (!valobj_sp)
case '.': {
             error.SetErrorStringWithFormat(
                 "\"%s\" is not a pointer and -> was used to attempt to "
                 "access \"%s\". Did you mean \"%s.%s\"?",
                 var_expr_path_strm.GetData(), child_name.GetCString(),
                 var_expr_path_strm.GetData(), var_expr.str().c_str());
           return ValueObjectSP();
         }
       }
-      child_valobj_sp = valobj_sp->GetChildMemberWithName(child_name, true);
+      child_valobj_sp = valobj_sp->GetChildMemberWithName(child_name);
       if (!child_valobj_sp) {
         if (!no_synth_child) {
           child_valobj_sp = valobj_sp->GetSyntheticValue();
           if (child_valobj_sp)
             child_valobj_sp =
-                child_valobj_sp->GetChildMemberWithName(child_name, true);
+                child_valobj_sp->GetChildMemberWithName(child_name);
         }
 
         if (no_synth_child || !child_valobj_sp) {
           // No child member with name "child_name"
           if (synthetically_added_instance_object) {
             // We added a "this->" or "self->" to the beginning of the
             // expression and this is the first pointer ivar access, so just
             // return the normal error