[lldb] Remove 'use_synthetic' parameters in ValueObject code

[teemperor]

Summary

CalculateSyntheticValue and GetSyntheticValue have a use_synthetic parameter
that makes the function do nothing when it's false. We obviously always pass true
to the function (or check that the value we pass is true), because there really isn't
any point calling with function with a false. This just removes all of this.

[teemperor]

lldb/source/API/SBValue.cpp

139

Here we check it's true.

lldb/source/Core/ValueObject.cpp

1992

Here we check it's true for the call below.

3343

Here we check the value is true.

[davide]

LGTM

lldb/include/lldb/Core/ValueObject.h

public:
   virtual lldb::ValueObjectSP GetDynamicValue(lldb::DynamicValueType valueType);
 
   lldb::DynamicValueType GetDynamicValueType();
 
   virtual lldb::ValueObjectSP GetStaticValue();
 
   virtual lldb::ValueObjectSP GetNonSyntheticValue();
 
-  lldb::ValueObjectSP GetSyntheticValue(bool use_synthetic = true);
+  lldb::ValueObjectSP GetSyntheticValue();
 
   virtual bool HasSyntheticValue();
 
   virtual bool IsSynthetic() { return false; }
 
   lldb::ValueObjectSP
   GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue,
                                         bool synthValue);
protected:
   virtual void CalculateDynamicValue(lldb::DynamicValueType use_dynamic);
 
   virtual lldb::DynamicValueType GetDynamicValueTypeImpl() {
     return lldb::eNoDynamicValues;
   }
 
   virtual bool HasDynamicValueTypeInfo() { return false; }
 
-  virtual void CalculateSyntheticValue(bool use_synthetic = true);
+  virtual void CalculateSyntheticValue();
 
   // Should only be called by ValueObject::GetChildAtIndex() Returns a
   // ValueObject managed by this ValueObject's manager.
   virtual ValueObject *CreateChildAtIndex(size_t idx,
                                           bool synthetic_array_member,
                                           int32_t synthetic_index);
 
   // Should only be called by ValueObject::GetNumChildren()

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

public:
   GetDynamicValue(lldb::DynamicValueType valueType) override;
 
   bool IsInScope() override;
 
   bool HasSyntheticValue() override { return false; }
 
   bool IsSynthetic() override { return true; }
 
-  void CalculateSyntheticValue(bool use_synthetic) override {}
+  void CalculateSyntheticValue() override {}
 
   bool IsDynamic() override {
     return ((m_parent != nullptr) ? m_parent->IsDynamic() : false);
   }
 
   lldb::ValueObjectSP GetStaticValue() override {
     return ((m_parent != nullptr) ? m_parent->GetStaticValue() : GetSP());
   }

lldb/source/API/SBValue.cpp

lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker,
     }
 
     if (m_use_dynamic != eNoDynamicValues) {
       ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
       if (dynamic_sp)
         value_sp = dynamic_sp;
     }
 
     if (m_use_synthetic) {
-      ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(m_use_synthetic);
+      ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue();
       if (synthetic_sp)
         value_sp = synthetic_sp;
     }
 
     if (!value_sp)
       error.SetErrorString("invalid value object");
     if (!m_name.IsEmpty())
       value_sp->SetName(m_name);

lldb/source/Core/ValueObject.cpp

if (synthetic_child_sp.get()) {
       AddSyntheticChild(name_const_string, synthetic_child_sp.get());
       synthetic_child_sp->SetName(
           ConstString(SkipLeadingExpressionPathSeparators(expression)));
     }
   }
   return synthetic_child_sp;
 }
 
-void ValueObject::CalculateSyntheticValue(bool use_synthetic) {
-  if (!use_synthetic)
-    return;
-
+void ValueObject::CalculateSyntheticValue() {
   TargetSP target_sp(GetTargetSP());
   if (target_sp && !target_sp->GetEnableSyntheticValue()) {
     m_synthetic_value = nullptr;
     return;
   }
 
   lldb::SyntheticChildrenSP current_synth_sp(m_synthetic_children_sp);
 
ValueObjectSP ValueObject::GetDynamicValue(DynamicValueType use_dynamic) {
   else
     return ValueObjectSP();
 }
 
 ValueObjectSP ValueObject::GetStaticValue() { return GetSP(); }
 
 lldb::ValueObjectSP ValueObject::GetNonSyntheticValue() { return GetSP(); }
 
-ValueObjectSP ValueObject::GetSyntheticValue(bool use_synthetic) {
-  if (!use_synthetic)
-    return ValueObjectSP();
-
-  CalculateSyntheticValue(use_synthetic);
+ValueObjectSP ValueObject::GetSyntheticValue() {
+  CalculateSyntheticValue();
 
   if (m_synthetic_value)
     return m_synthetic_value->GetSP();
   else
     return ValueObjectSP();
 }
 
 bool ValueObject::HasSyntheticValue() {
   UpdateFormatsIfNeeded();
 
   if (m_synthetic_children_sp.get() == nullptr)
     return false;
 
-  CalculateSyntheticValue(true);
+  CalculateSyntheticValue();
 
   return m_synthetic_value != nullptr;
 }
 
 ValueObject *ValueObject::GetNonBaseClassParent() {
   if (GetParent()) {
     if (GetParent()->IsBaseClass())
       return GetParent()->GetNonBaseClassParent();
lldb::ValueObjectSP ValueObjectManager::GetSP() {
   m_user_valobj_sp = m_root_valobj_sp;
 
   if (m_use_dynamic != lldb::eNoDynamicValues) {
     lldb::ValueObjectSP dynamic_sp = m_user_valobj_sp->GetDynamicValue(m_use_dynamic);
     if (dynamic_sp)
       m_user_valobj_sp = dynamic_sp;
   }
 
   if (m_use_synthetic) {
-    lldb::ValueObjectSP synthetic_sp = m_user_valobj_sp->GetSyntheticValue(m_use_synthetic);
+    lldb::ValueObjectSP synthetic_sp = m_user_valobj_sp->GetSyntheticValue();
     if (synthetic_sp)
       m_user_valobj_sp = synthetic_sp;
   }
 
   return m_user_valobj_sp;
 }
 
 void ValueObjectManager::SetUseDynamic(lldb::DynamicValueType use_dynamic) {