[lldb] Delete ValueObject::GetBaseClassPath

[xiaobai]

Summary

This method has exactly one call site, which is only actually executed
if ValueObject::IsBaseClass returns false. However, the first thing
that ValueObject::GetBaseClassPath does is check if ValueObject::IsBaseClass
is true. Because this can never be the case, this method always returns false
and is therefore effectively dead.

[xiaobai]

Note: This makes D69820 unnecessary so I will close that if this goes through.

[JDevlieghere]

Doesn't look like it's used in the swift fork downstream either. LGTM

[labath]

lldb/source/Core/ValueObject.cpp

2041

Should we remove the qualify_cxx_base_classes argument as well, given that it no longer does anything ?

[xiaobai]

lldb/source/Core/ValueObject.cpp

2041

It seems that this is a part of the SBValue interface. I think we can remove it from ValueObject but SBValue will have to stick with it.

[labath]

lldb/source/Core/ValueObject.cpp

2041

That sounds reasonable.

lldb/include/lldb/Core/ValueObject.h

public:
   virtual bool IsBaseClass() { return false; }
 
   bool IsBaseClass(uint32_t &depth);
 
   virtual bool IsDereferenceOfParent() { return false; }
 
   bool IsIntegerType(bool &is_signed);
 
-  virtual bool GetBaseClassPath(Stream &s);
-
   virtual void GetExpressionPath(
       Stream &s, bool qualify_cxx_base_classes,
       GetExpressionPathFormat = eGetExpressionPathFormatDereferencePointers);
 
   lldb::ValueObjectSP GetValueForExpressionPath(
       llvm::StringRef expression,
       ExpressionPathScanEndReason *reason_to_stop = nullptr,
       ExpressionPathEndResultType *final_value_type = nullptr,

lldb/source/Core/ValueObject.cpp

bool ValueObject::HasSyntheticValue() {
   if (m_synthetic_children_sp.get() == nullptr)
     return false;
 
   CalculateSyntheticValue(true);
 
   return m_synthetic_value != nullptr;
 }
 
-bool ValueObject::GetBaseClassPath(Stream &s) {
-  if (IsBaseClass()) {
-    bool parent_had_base_class =
-        GetParent() && GetParent()->GetBaseClassPath(s);
-    CompilerType compiler_type = GetCompilerType();
-    llvm::Optional<std::string> cxx_class_name =
-        TypeSystemClang::GetCXXClassName(compiler_type);
-    if (cxx_class_name) {
-      if (parent_had_base_class)
-        s.PutCString("::");
-      s.PutCString(cxx_class_name.getValue());
-    }
-    return parent_had_base_class || cxx_class_name;
-  }
-  return false;
-}
-
 ValueObject *ValueObject::GetNonBaseClassParent() {
   if (GetParent()) {
     if (GetParent()->IsBaseClass())
       return GetParent()->GetNonBaseClassParent();
     else
       return GetParent();
   }
   return nullptr;
if (GetParent()) {
     depth = depth + 1;
     return true;
   }
   // TODO: a base of no parent? weird..
   depth = 1;
   return true;
 }
 
 void ValueObject::GetExpressionPath(Stream &s, bool qualify_cxx_base_classes,
                                     GetExpressionPathFormat epformat) {
   // synthetic children do not actually "exist" as part of the hierarchy, and
   // sometimes they are consed up in ways that don't make sense from an
   // underlying language/API standpoint. So, use a special code path here to
   // return something that can hopefully be used in expression
   if (m_is_synthetic_children_generated) {
     UpdateValueIfNeeded();
 
if (!is_deref_of_parent) {
                        !(non_base_class_parent_type_info & eTypeIsArray)) {
               s.PutChar('.');
             }
           }
         }
       }
 
       const char *name = GetName().GetCString();
-      if (name) {
-        if (qualify_cxx_base_classes) {
-          if (GetBaseClassPath(s))
-            s.PutCString("::");
-        }
+      if (name)
         s.PutCString(name);
-      }
-    }
-  }
 
   if (is_deref_of_parent &&
       epformat == eGetExpressionPathFormatDereferencePointers) {
     s.PutChar(')');
   }
 }
 
 ValueObjectSP ValueObject::GetValueForExpressionPath(