[lldb][NFC] Rename the second ValueObjectManager to ValueObjectUpdater and remove the dead code

[teemperor]

Summary

ValueObject.h contains the ValueObject::ValueObjectManager type which is just a typedef
for the ClusterManager that takes care of the whole ValueObject memory management. However,
there is also ValueObjectManager defined in the same header which is only used in the curses UI
implementation and consists mostly of dead and completely untested code.

This code been around since a while (it was added in 2016 as 8369b28da0750129ababae357bea98940800a0e0),
so I think we shouldn't just revert the whole patch.

Instead this patch just moves the class to its own header that it isn't just hiding in the ValueObject
header and renames it to ValueObjectUpdater that it at least has a unique name (which I hope also slightly
better reflects the purpose of this class). I also deleted all the dead code branches and functions.

[mib]

LGTM

[JDevlieghere]

Nice

lldb/include/lldb/Core/ValueObject.h

lldb::ValueObjectSP GetValueForExpressionPath_Impl(
       ExpressionPathEndResultType *final_value_type,
       const GetValueForExpressionPathOptions &options,
       ExpressionPathAftermath *final_task_on_target);
 
   ValueObject(const ValueObject &) = delete;
   const ValueObject &operator=(const ValueObject &) = delete;
 };
 
-/// A value object manager class that is seeded with the static variable value
-/// and it vends the user facing value object. If the type is dynamic it can
-/// vend the dynamic type. If this user type also has a synthetic type
-/// associated with it, it will vend the synthetic type. The class watches the
-/// process' stop
-/// ID and will update the user type when needed.
-class ValueObjectManager {
-  /// The root value object is the static typed variable object.
-  lldb::ValueObjectSP m_root_valobj_sp;
-  /// The user value object is the value object the user wants to see.
-  lldb::ValueObjectSP m_user_valobj_sp;
-  lldb::DynamicValueType m_use_dynamic;
-  /// The stop ID that m_user_valobj_sp is valid for.
-  uint32_t m_stop_id;
-  bool m_use_synthetic;
-
-public:
-  ValueObjectManager() {}
-  
-  ValueObjectManager(lldb::ValueObjectSP in_valobj_sp,
-                     lldb::DynamicValueType use_dynamic, bool use_synthetic);
-  
-  bool IsValid() const;
-  
-  lldb::ValueObjectSP GetRootSP() const { return m_root_valobj_sp; }
-
-  /// Gets the correct value object from the root object for a given process
-  /// stop ID. If dynamic values are enabled, or if synthetic children are
-  /// enabled, the value object that the user wants to see might change while
-  /// debugging.
-  lldb::ValueObjectSP GetSP();
-  
-  void SetUseDynamic(lldb::DynamicValueType use_dynamic);
-  void SetUseSynthetic(bool use_synthetic);
-  lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
-  bool GetUseSynthetic() const { return m_use_synthetic; }
-  lldb::TargetSP GetTargetSP() const;
-  lldb::ProcessSP GetProcessSP() const;
-  lldb::ThreadSP GetThreadSP() const;
-  lldb::StackFrameSP GetFrameSP() const;
-};
-
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECT_H

lldb/include/lldb/Core/ValueObjectUpdater.h

+//===-- ValueObjectUpdater.h ------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_CORE_VALUEOBJECTUPDATER_H
+#define LLDB_CORE_VALUEOBJECTUPDATER_H
+
+#include "lldb/Core/ValueObject.h"
+
+namespace lldb_private {
+
+/// A value object class that is seeded with the static variable value
+/// and it vends the user facing value object. If the type is dynamic it can
+/// vend the dynamic type. If this user type also has a synthetic type
+/// associated with it, it will vend the synthetic type. The class watches the
+/// process' stop ID and will update the user type when needed.
+class ValueObjectUpdater {
+  /// The root value object is the static typed variable object.
+  lldb::ValueObjectSP m_root_valobj_sp;
+  /// The user value object is the value object the user wants to see.
+  lldb::ValueObjectSP m_user_valobj_sp;
+  /// The stop ID that m_user_valobj_sp is valid for.
+  uint32_t m_stop_id = UINT32_MAX;
+
+public:
+  ValueObjectUpdater(lldb::ValueObjectSP in_valobj_sp);
+
+  /// Gets the correct value object from the root object for a given process
+  /// stop ID. If dynamic values are enabled, or if synthetic children are
+  /// enabled, the value object that the user wants to see might change while
+  /// debugging.
+  lldb::ValueObjectSP GetSP();
+
+  lldb::ProcessSP GetProcessSP() const;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_CORE_VALUEOBJECTUPDATER_H

lldb/source/Core/CMakeLists.txt

add_lldb_library(lldbCore
   ValueObjectConstResultCast.cpp
   ValueObjectConstResultChild.cpp
   ValueObjectConstResultImpl.cpp
   ValueObjectDynamicValue.cpp
   ValueObjectList.cpp
   ValueObjectMemory.cpp
   ValueObjectRegister.cpp
   ValueObjectSyntheticFilter.cpp
+  ValueObjectUpdater.cpp
   ValueObjectVariable.cpp
 
   DEPENDS
     clang-tablegen-targets
 
   LINK_LIBS
     lldbBreakpoint
     lldbDataFormatters

lldb/source/Core/IOHandlerCursesGUI.cpp

 
 #if defined(__APPLE__)
 #include <deque>
 #endif
 #include <string>
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
+#include "lldb/Core/ValueObjectUpdater.h"
 #include "lldb/Host/File.h"
 #include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Interpreter/CommandCompletions.h"
protected:
   bool m_update_screen = false;
 };
 
 } // namespace curses
 
 using namespace curses;
 
 struct Row {
-  ValueObjectManager value;
+  ValueObjectUpdater value;
   Row *parent;
   // The process stop ID when the children were calculated.
   uint32_t children_stop_id = 0;
   int row_idx = 0;
   int x = 1;
   int y = 1;
   bool might_have_children;
   bool expanded = false;
   bool calculated_children = false;
   std::vector<Row> children;
 
   Row(const ValueObjectSP &v, Row *p)
-      : value(v, lldb::eDynamicDontRunTarget, true), parent(p),
+      : value(v), parent(p),
         might_have_children(v ? v->MightHaveChildren() : false) {}
 
   size_t GetDepth() const {
     if (parent)
       return 1 + parent->GetDepth();
     return 0;
   }
 

lldb/source/Core/ValueObject.cpp

 
 void ValueObject::SetSyntheticChildrenGenerated(bool b) {
   m_flags.m_is_synthetic_children_generated = b;
 }
 
 uint64_t ValueObject::GetLanguageFlags() { return m_language_flags; }
 
 void ValueObject::SetLanguageFlags(uint64_t flags) { m_language_flags = flags; }
-
-ValueObjectManager::ValueObjectManager(lldb::ValueObjectSP in_valobj_sp,
-                                       lldb::DynamicValueType use_dynamic,
-                                       bool use_synthetic) : m_root_valobj_sp(),
-    m_user_valobj_sp(), m_use_dynamic(use_dynamic), m_stop_id(UINT32_MAX),
-    m_use_synthetic(use_synthetic) {
-  if (!in_valobj_sp)
-    return;
-  // If the user passes in a value object that is dynamic or synthetic, then
-  // water it down to the static type.
-  m_root_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(lldb::eNoDynamicValues, false);
-}
-
-bool ValueObjectManager::IsValid() const {
-  if (!m_root_valobj_sp)
-    return false;
-  lldb::TargetSP target_sp = GetTargetSP();
-  if (target_sp)
-    return target_sp->IsValid();
-  return false;
-}
-
-lldb::ValueObjectSP ValueObjectManager::GetSP() {
-  lldb::ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return lldb::ValueObjectSP();
-
-  const uint32_t current_stop_id = process_sp->GetLastNaturalStopID();
-  if (current_stop_id == m_stop_id)
-    return m_user_valobj_sp;
-
-  m_stop_id = current_stop_id;
-
-  if (!m_root_valobj_sp) {
-    m_user_valobj_sp.reset();
-    return m_root_valobj_sp;
-  }
-
-  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();
-    if (synthetic_sp)
-      m_user_valobj_sp = synthetic_sp;
-  }
-
-  return m_user_valobj_sp;
-}
-
-void ValueObjectManager::SetUseDynamic(lldb::DynamicValueType use_dynamic) {
-  if (use_dynamic != m_use_dynamic) {
-    m_use_dynamic = use_dynamic;
-    m_user_valobj_sp.reset();
-    m_stop_id = UINT32_MAX;
-  }
-}
-
-void ValueObjectManager::SetUseSynthetic(bool use_synthetic) {
-  if (m_use_synthetic != use_synthetic) {
-    m_use_synthetic = use_synthetic;
-    m_user_valobj_sp.reset();
-    m_stop_id = UINT32_MAX;
-  }
-}
-
-lldb::TargetSP ValueObjectManager::GetTargetSP() const {
-  if (!m_root_valobj_sp)
-    return m_root_valobj_sp->GetTargetSP();
-  return lldb::TargetSP();
-}
-
-lldb::ProcessSP ValueObjectManager::GetProcessSP() const {
-  if (m_root_valobj_sp)
-    return m_root_valobj_sp->GetProcessSP();
-  return lldb::ProcessSP();
-}
-
-lldb::ThreadSP ValueObjectManager::GetThreadSP() const {
-  if (m_root_valobj_sp)
-    return m_root_valobj_sp->GetThreadSP();
-  return lldb::ThreadSP();
-}
-
-lldb::StackFrameSP ValueObjectManager::GetFrameSP() const {
-  if (m_root_valobj_sp)
-    return m_root_valobj_sp->GetFrameSP();
-  return lldb::StackFrameSP();
-}

lldb/source/Core/ValueObjectUpdater.cpp

+//===-- ValueObjectUpdater.cpp --------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/ValueObjectUpdater.h"
+
+using namespace lldb_private;
+
+ValueObjectUpdater::ValueObjectUpdater(lldb::ValueObjectSP in_valobj_sp) {
+  if (!in_valobj_sp)
+    return;
+  // If the user passes in a value object that is dynamic or synthetic, then
+  // water it down to the static type.
+  m_root_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
+      lldb::eNoDynamicValues, false);
+}
+
+lldb::ValueObjectSP ValueObjectUpdater::GetSP() {
+  lldb::ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return lldb::ValueObjectSP();
+
+  const uint32_t current_stop_id = process_sp->GetLastNaturalStopID();
+  if (current_stop_id == m_stop_id)
+    return m_user_valobj_sp;
+
+  m_stop_id = current_stop_id;
+
+  if (!m_root_valobj_sp) {
+    m_user_valobj_sp.reset();
+    return m_root_valobj_sp;
+  }
+
+  m_user_valobj_sp = m_root_valobj_sp;
+
+  lldb::ValueObjectSP dynamic_sp =
+      m_user_valobj_sp->GetDynamicValue(lldb::eDynamicDontRunTarget);
+  if (dynamic_sp)
+    m_user_valobj_sp = dynamic_sp;
+
+  lldb::ValueObjectSP synthetic_sp = m_user_valobj_sp->GetSyntheticValue();
+  if (synthetic_sp)
+    m_user_valobj_sp = synthetic_sp;
+
+  return m_user_valobj_sp;
+}
+
+lldb::ProcessSP ValueObjectUpdater::GetProcessSP() const {
+  if (m_root_valobj_sp)
+    return m_root_valobj_sp->GetProcessSP();
+  return lldb::ProcessSP();
+}