[lldb][NFC] Move trivial ValueObject getters/setters to the header

[teemperor]

Summary

NFC refactoring that moves the definitions of all the trivial getters/setters to the header file
which is what we usually do in LLVM.

[JDevlieghere]

LGTM

[teemperor]

• Rebased

lldb/include/lldb/Core/ValueObject.h

public:
   }
 
   lldb::StackFrameSP GetFrameSP() const {
     return m_update_point.GetExecutionContextRef().GetFrameSP();
   }
 
   void SetNeedsUpdate();
 
-  CompilerType GetCompilerType();
+  CompilerType GetCompilerType() { return MaybeCalculateCompleteType(); }
 
   // this vends a TypeImpl that is useful at the SB API layer
-  virtual TypeImpl GetTypeImpl();
+  virtual TypeImpl GetTypeImpl() { return TypeImpl(GetCompilerType()); }
 
   virtual bool CanProvideValue();
 
   // Subclasses must implement the functions below.
   virtual llvm::Optional<uint64_t> GetByteSize() = 0;
 
   virtual lldb::ValueType GetValueType() const = 0;
 
   // Subclasses can implement the functions below.
-  virtual ConstString GetTypeName();
+  virtual ConstString GetTypeName() { return GetCompilerType().GetTypeName(); }
 
-  virtual ConstString GetDisplayTypeName();
+  virtual ConstString GetDisplayTypeName() { return GetTypeName(); }
 
-  virtual ConstString GetQualifiedTypeName();
+  virtual ConstString GetQualifiedTypeName() {
+    return GetCompilerType().GetTypeName();
+  }
 
-  virtual lldb::LanguageType GetObjectRuntimeLanguage();
+  virtual lldb::LanguageType GetObjectRuntimeLanguage() {
+    return GetCompilerType().GetMinimumLanguage();
+  }
 
   virtual uint32_t
-  GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr);
+  GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) {
+    return GetCompilerType().GetTypeInfo(pointee_or_element_compiler_type);
+  }
 
-  virtual bool IsPointerType();
+  virtual bool IsPointerType() { return GetCompilerType().IsPointerType(); }
 
-  virtual bool IsArrayType();
+  virtual bool IsArrayType() { return GetCompilerType().IsArrayType(); }
 
-  virtual bool IsScalarType();
+  virtual bool IsScalarType() { return GetCompilerType().IsScalarType(); }
 
-  virtual bool IsPointerOrReferenceType();
+  virtual bool IsPointerOrReferenceType() {
+    return GetCompilerType().IsPointerOrReferenceType();
+  }
 
   virtual bool IsPossibleDynamicType();
 
   bool IsNilReference();
 
   bool IsUninitializedReference();
 
   virtual bool IsBaseClass() { return false; }
 
   bool IsBaseClass(uint32_t &depth);
 
   virtual bool IsDereferenceOfParent() { return false; }
 
-  bool IsIntegerType(bool &is_signed);
+  bool IsIntegerType(bool &is_signed) {
+    return GetCompilerType().IsIntegerType(is_signed);
+  }
 
   virtual void GetExpressionPath(
       Stream &s,
       GetExpressionPathFormat = eGetExpressionPathFormatDereferencePointers);
 
   lldb::ValueObjectSP GetValueForExpressionPath(
       llvm::StringRef expression,
       ExpressionPathScanEndReason *reason_to_stop = nullptr,
public:
   /// a null pointer
   ValueObject *FollowParentChain(std::function<bool(ValueObject *)>);
 
   virtual bool GetDeclaration(Declaration &decl);
 
   // The functions below should NOT be modified by subclasses
   const Status &GetError();
 
-  ConstString GetName() const;
+  ConstString GetName() const { return m_name; }
 
   /// Returns a unique id for this ValueObject.
   lldb::user_id_t GetID() const { return m_id.GetID(); }
 
   virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create);
 
   // this will always create the children if necessary
   lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
public:
 
   virtual lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
                                                      bool can_create);
 
   virtual size_t GetIndexOfChildWithName(ConstString name);
 
   size_t GetNumChildren(uint32_t max = UINT32_MAX);
 
-  const Value &GetValue() const;
+  const Value &GetValue() const { return m_value; }
 
-  Value &GetValue();
+  Value &GetValue() { return m_value; }
 
   virtual bool ResolveValue(Scalar &scalar);
 
   // return 'false' whenever you set the error, otherwise callers may assume
   // true means everything is OK - this will break breakpoint conditions among
   // potentially a few others
   virtual bool IsLogicalTrue(Status &error);
 
-  virtual const char *GetLocationAsCString();
+  virtual const char *GetLocationAsCString() {
+    return GetLocationAsCStringImpl(m_value, m_data);
+  }
 
   const char *
   GetSummaryAsCString(lldb::LanguageType lang = lldb::eLanguageTypeUnknown);
 
   bool
   GetSummaryAsCString(TypeSummaryImpl *summary_ptr, std::string &destination,
                       lldb::LanguageType lang = lldb::eLanguageTypeUnknown);
 
public:
   bool
   DumpPrintableRepresentation(Stream &s,
                               ValueObjectRepresentationStyle val_obj_display =
                                   eValueObjectRepresentationStyleSummary,
                               lldb::Format custom_format = lldb::eFormatInvalid,
                               PrintableRepresentationSpecialCases special =
                                   PrintableRepresentationSpecialCases::eAllow,
                               bool do_dump_error = true);
-  bool GetValueIsValid() const;
+  bool GetValueIsValid() const { return m_flags.m_value_is_valid; }
 
   // If you call this on a newly created ValueObject, it will always return
   // false.
-  bool GetValueDidChange();
+  bool GetValueDidChange() { return m_flags.m_value_did_change; }
 
   bool UpdateValueIfNeeded(bool update_format = true);
 
   bool UpdateFormatsIfNeeded();
 
   lldb::ValueObjectSP GetSP() { return m_manager->GetSharedPointer(this); }
 
   /// Change the name of the current ValueObject. Should *not* be used from a
   /// synthetic child provider as it would change the name of the non synthetic
   /// child as well.
-  void SetName(ConstString name);
+  void SetName(ConstString name) { m_name = name; }
 
   virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
                                     AddressType *address_type = nullptr);
 
   lldb::addr_t GetPointerValue(AddressType *address_type = nullptr);
 
   lldb::ValueObjectSP GetSyntheticChild(ConstString key) const;
 
public:
   virtual lldb::ValueObjectSP
   GetSyntheticBase(uint32_t offset, const CompilerType &type, bool can_create,
                    ConstString name_const_str = ConstString());
 
   virtual lldb::ValueObjectSP GetDynamicValue(lldb::DynamicValueType valueType);
 
   lldb::DynamicValueType GetDynamicValueType();
 
-  virtual lldb::ValueObjectSP GetStaticValue();
+  virtual lldb::ValueObjectSP GetStaticValue() { return GetSP(); }
 
-  virtual lldb::ValueObjectSP GetNonSyntheticValue();
+  virtual lldb::ValueObjectSP GetNonSyntheticValue() { return GetSP(); }
 
   lldb::ValueObjectSP GetSyntheticValue();
 
   virtual bool HasSyntheticValue();
 
   virtual bool IsSynthetic() { return false; }
 
   lldb::ValueObjectSP
ClearUserVisibleData(eClearUserVisibleDataItemsValue |
                          eClearUserVisibleDataItemsSummary |
                          eClearUserVisibleDataItemsDescription);
   }
 
   virtual bool IsDynamic() { return false; }
 
   virtual bool DoesProvideSyntheticValue() { return false; }
 
-  virtual bool IsSyntheticChildrenGenerated();
+  virtual bool IsSyntheticChildrenGenerated() {
+    return m_flags.m_is_synthetic_children_generated;
+  }
 
-  virtual void SetSyntheticChildrenGenerated(bool b);
+  virtual void SetSyntheticChildrenGenerated(bool b) {
+    m_flags.m_is_synthetic_children_generated = b;
+  }
 
   virtual SymbolContextScope *GetSymbolContextScope();
 
   void Dump(Stream &s);
 
   void Dump(Stream &s, const DumpValueObjectOptions &options);
 
   static lldb::ValueObjectSP
public:
   virtual void SetFormat(lldb::Format format) {
     if (format != m_format)
       ClearUserVisibleData(eClearUserVisibleDataItemsValue);
     m_format = format;
   }
 
   virtual lldb::LanguageType GetPreferredDisplayLanguage();
 
-  void SetPreferredDisplayLanguage(lldb::LanguageType);
+  void SetPreferredDisplayLanguage(lldb::LanguageType lt) {
+    m_preferred_display_language = lt;
+  }
 
   lldb::TypeSummaryImplSP GetSummaryFormat() {
     UpdateFormatsIfNeeded();
     return m_type_summary_sp;
   }
 
   void SetSummaryFormat(lldb::TypeSummaryImplSP format) {
     m_type_summary_sp = std::move(format);
public:
   ///     Returns \b true if the ValueObject might have children, or \b
   ///     false otherwise.
   virtual bool MightHaveChildren();
 
   virtual lldb::VariableSP GetVariable() { return nullptr; }
 
   virtual bool IsRuntimeSupportValue();
 
-  virtual uint64_t GetLanguageFlags();
+  virtual uint64_t GetLanguageFlags() { return m_language_flags; }
 
-  virtual void SetLanguageFlags(uint64_t flags);
+  virtual void SetLanguageFlags(uint64_t flags) { m_language_flags = flags; }
 
 protected:
   typedef ClusterManager<ValueObject> ValueObjectManager;
 
   class ChildrenManager {
   public:
     ChildrenManager() : m_mutex(), m_children(), m_children_count(0) {}
 
virtual ValueObject *CreateChildAtIndex(size_t idx,
                                           bool synthetic_array_member,
                                           int32_t synthetic_index);
 
   /// Should only be called by ValueObject::GetNumChildren().
   virtual size_t CalculateNumChildren(uint32_t max = UINT32_MAX) = 0;
 
   void SetNumChildren(size_t num_children);
 
-  void SetValueDidChange(bool value_changed);
+  void SetValueDidChange(bool value_changed) {
+    m_flags.m_value_did_change = value_changed;
+  }
 
-  void SetValueIsValid(bool valid);
+  void SetValueIsValid(bool valid) { m_flags.m_value_is_valid = valid; }
 
   void ClearUserVisibleData(
       uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings);
 
   void AddSyntheticChild(ConstString key, ValueObject *valobj);
 
   DataExtractor &GetDataExtractor();
 
   void ClearDynamicTypeInformation();
 
   // Subclasses must implement the functions below.
 
   virtual CompilerType GetCompilerTypeImpl() = 0;
 
   const char *GetLocationAsCStringImpl(const Value &value,
                                        const DataExtractor &data);
 
-  bool IsChecksumEmpty();
+  bool IsChecksumEmpty() { return m_value_checksum.empty(); }
 
   void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType);
 
 protected:
   virtual void DoUpdateChildrenAddressType(ValueObject &valobj) { return; };
 
 private:
   virtual CompilerType MaybeCalculateCompleteType();

lldb/source/Core/ValueObject.cpp

 #include <memory>
 #include <tuple>
 
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <lldb/Core/ValueObject.h>
+
 namespace lldb_private {
 class ExecutionContextScope;
 }
 namespace lldb_private {
 class SymbolContextScope;
 }
 
 using namespace lldb;
if (llvm::Optional<CompilerType> complete_type =
       m_override_type = complete_type.getValue();
       if (m_override_type.IsValid())
         return m_override_type;
     }
   }
   return compiler_type;
 }
 
-CompilerType ValueObject::GetCompilerType() {
-  return MaybeCalculateCompleteType();
-}
 
-TypeImpl ValueObject::GetTypeImpl() { return TypeImpl(GetCompilerType()); }
 
 DataExtractor &ValueObject::GetDataExtractor() {
   UpdateValueIfNeeded(false);
   return m_data;
 }
 
 const Status &ValueObject::GetError() {
   UpdateValueIfNeeded(false);
   return m_error;
 }
 
-ConstString ValueObject::GetName() const { return m_name; }
-
-const char *ValueObject::GetLocationAsCString() {
-  return GetLocationAsCStringImpl(m_value, m_data);
-}
-
 const char *ValueObject::GetLocationAsCStringImpl(const Value &value,
                                                   const DataExtractor &data) {
   if (UpdateValueIfNeeded(false)) {
     if (m_location_str.empty()) {
       StreamString sstr;
 
       Value::ValueType value_type = value.GetValueType();
 
if (m_location_str.empty()) {
         m_location_str = std::string(sstr.GetString());
       } break;
       }
     }
   }
   return m_location_str.c_str();
 }
 
-Value &ValueObject::GetValue() { return m_value; }
-
-const Value &ValueObject::GetValue() const { return m_value; }
-
 bool ValueObject::ResolveValue(Scalar &scalar) {
   if (UpdateValueIfNeeded(
           false)) // make sure that you are up to date before returning anything
   {
     ExecutionContext exe_ctx(GetExecutionContextRef());
     Value tmp_value(m_value);
     scalar = tmp_value.ResolveValue(&exe_ctx);
     if (scalar.IsValid()) {
bool ValueObject::IsLogicalTrue(Status &error) {
   }
 
   bool ret;
   ret = scalar_value.ULongLong(1) != 0;
   error.Clear();
   return ret;
 }
 
-bool ValueObject::GetValueIsValid() const { return m_flags.m_value_is_valid; }
-
-void ValueObject::SetValueIsValid(bool b) { m_flags.m_value_is_valid = b; }
-
-bool ValueObject::GetValueDidChange() { return m_flags.m_value_did_change; }
-
-void ValueObject::SetValueDidChange(bool value_changed) {
-  m_flags.m_value_did_change = value_changed;
-}
-
 ValueObjectSP ValueObject::GetChildAtIndex(size_t idx, bool can_create) {
   ValueObjectSP child_sp;
   // We may need to update our value if we are dynamic
   if (IsPossibleDynamicType())
     UpdateValueIfNeeded(false);
   if (idx < GetNumChildren()) {
     // Check if we have already made the child value object?
     if (can_create && !m_children.HasChildAtIndex(idx)) {

 }
 
 // Should only be called by ValueObject::GetNumChildren()
 void ValueObject::SetNumChildren(size_t num_children) {
   m_flags.m_children_count_valid = true;
   m_children.SetChildrenCount(num_children);
 }
 
-void ValueObject::SetName(ConstString name) { m_name = name; }
-
 ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
                                              bool synthetic_array_member,
                                              int32_t synthetic_index) {
   ValueObject *valobj = nullptr;
 
   bool omit_empty_base_classes = true;
   bool ignore_array_bounds = synthetic_array_member;
   std::string child_name_str;
bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
   return true;
 }
 
 bool ValueObject::GetDeclaration(Declaration &decl) {
   decl.Clear();
   return false;
 }
 
-ConstString ValueObject::GetTypeName() {
-  return GetCompilerType().GetTypeName();
-}
-
-ConstString ValueObject::GetDisplayTypeName() { return GetTypeName(); }
-
-ConstString ValueObject::GetQualifiedTypeName() {
-  return GetCompilerType().GetTypeName();
-}
-
-LanguageType ValueObject::GetObjectRuntimeLanguage() {
-  return GetCompilerType().GetMinimumLanguage();
-}
-
 void ValueObject::AddSyntheticChild(ConstString key,
                                     ValueObject *valobj) {
   m_synthetic_children[key] = valobj;
 }
 
 ValueObjectSP ValueObject::GetSyntheticChild(ConstString key) const {
   ValueObjectSP synthetic_child_sp;
   std::map<ConstString, ValueObject *>::const_iterator pos =
       m_synthetic_children.find(key);
   if (pos != m_synthetic_children.end())
     synthetic_child_sp = pos->second->GetSP();
   return synthetic_child_sp;
 }
 
-uint32_t
-ValueObject::GetTypeInfo(CompilerType *pointee_or_element_compiler_type) {
-  return GetCompilerType().GetTypeInfo(pointee_or_element_compiler_type);
-}
-
-bool ValueObject::IsPointerType() { return GetCompilerType().IsPointerType(); }
-
-bool ValueObject::IsArrayType() { return GetCompilerType().IsArrayType(); }
-
-bool ValueObject::IsScalarType() { return GetCompilerType().IsScalarType(); }
-
-bool ValueObject::IsIntegerType(bool &is_signed) {
-  return GetCompilerType().IsIntegerType(is_signed);
-}
-
-bool ValueObject::IsPointerOrReferenceType() {
-  return GetCompilerType().IsPointerOrReferenceType();
-}
-
 bool ValueObject::IsPossibleDynamicType() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   Process *process = exe_ctx.GetProcessPtr();
   if (process)
     return process->IsPossibleDynamicValue(*this);
   else
     return GetCompilerType().IsPossibleDynamicType(nullptr, true, true);
 }
if (!IsDynamic() && m_dynamic_value == nullptr) {
     CalculateDynamicValue(use_dynamic);
   }
   if (m_dynamic_value)
     return m_dynamic_value->GetSP();
   else
     return ValueObjectSP();
 }
 
-ValueObjectSP ValueObject::GetStaticValue() { return GetSP(); }
-
-lldb::ValueObjectSP ValueObject::GetNonSyntheticValue() { return GetSP(); }
-
 ValueObjectSP ValueObject::GetSyntheticValue() {
   CalculateSyntheticValue();
 
   if (m_synthetic_value)
     return m_synthetic_value->GetSP();
   else
     return ValueObjectSP();
 }
if (GetRoot()) {
       } else {
         type = GetRoot()->GetPreferredDisplayLanguage();
       }
     }
   }
   return (m_preferred_display_language = type); // only compute it once
 }
 
-void ValueObject::SetPreferredDisplayLanguage(lldb::LanguageType lt) {
-  m_preferred_display_language = lt;
-}
-
 void ValueObject::SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType lt) {
   if (m_preferred_display_language == lldb::eLanguageTypeUnknown)
     SetPreferredDisplayLanguage(lt);
 }
 
 bool ValueObject::CanProvideValue() {
   // we need to support invalid types as providers of values because some bare-
   // board debugging scenarios have no notion of types, but still manage to
   // have raw numeric values for things like registers. sigh.
   CompilerType type = GetCompilerType();
   return (!type.IsValid()) || (0 != (type.GetTypeInfo() & eTypeHasValue));
 }
 
-bool ValueObject::IsChecksumEmpty() { return m_value_checksum.empty(); }
+
 
 ValueObjectSP ValueObject::Persist() {
   if (!UpdateValueIfNeeded())
     return nullptr;
 
   TargetSP target_sp(GetTargetSP());
   if (!target_sp)
     return nullptr;
ValueObjectSP ValueObject::Persist() {
 
   ExpressionVariableSP persistent_var_sp =
       persistent_state->CreatePersistentVariable(const_result_sp);
   persistent_var_sp->m_live_sp = persistent_var_sp->m_frozen_sp;
   persistent_var_sp->m_flags |= ExpressionVariable::EVIsProgramReference;
 
   return persistent_var_sp->GetValueObject();
 }
-
-bool ValueObject::IsSyntheticChildrenGenerated() {
-  return m_flags.m_is_synthetic_children_generated;
-}
-
-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; }