Add support for sythetic operator dereference

[tberghammer]

Summary

After this change a sythetic child provider can generate a special child
named "$$dereference$$" what if present is used when "operator*" or
"operator->" used on a ValueObject. The goal of the change is to make
expressions like "up->foo" work inside the "frame variable" command.

[jingham]

The idea here seems fine, but why does StackFrame have to know the magic $$dereference$$? Why can't it call the Dereference on the synthetic value?

[tberghammer]

Changed StackFrame to use Dereference instead of accessing the $$dereference$$ magic field.

[jingham]

This seems great. The only remaining thing is to document this in the Synthetic Children section of the Variable Formatting page (www/varformats.html).

[tberghammer]

Add documentation to the website

[jingham]

One grammar comment in the docs, and then this is good.

www/varformats.html

1071 ↗

(On Diff #93525)

grammar: "what will be" -> "which will be"

Though I think it would be clearer to say:

If a synthetic child provider supplies a special child named $$dereference$$ it will be...

[tberghammer]

Fix grammer for the html documentation.

[jingham]

Excellent!

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/unique_ptr/TestDataFormatterStdUniquePtr.py

def test_with_run_command(self):
         self.expect("frame variable iup", substrs=['iup = 0x'])
         self.expect("frame variable sup", substrs=['sup = 0x'])
 
         self.expect("frame variable ndp", substrs=['ndp = nullptr'])
         self.expect("frame variable idp", substrs=['idp = 0x', 'deleter = ', 'a = 1', 'b = 2'])
         self.expect("frame variable sdp", substrs=['sdp = 0x', 'deleter = ', 'a = 3', 'b = 4'])
 
         self.assertEqual(123, frame.GetValueForVariablePath("iup.object").GetValueAsUnsigned())
+        self.assertEqual(123, frame.GetValueForVariablePath("*iup").GetValueAsUnsigned())
         self.assertFalse(frame.GetValueForVariablePath("iup.deleter").IsValid())
 
         self.assertEqual('"foobar"', frame.GetValueForVariablePath("sup.object").GetSummary())
+        self.assertEqual('"foobar"', frame.GetValueForVariablePath("*sup").GetSummary())
         self.assertFalse(frame.GetValueForVariablePath("sup.deleter").IsValid())
 
         self.assertEqual(456, frame.GetValueForVariablePath("idp.object").GetValueAsUnsigned())
+        self.assertEqual(456, frame.GetValueForVariablePath("*idp").GetValueAsUnsigned())
         self.assertEqual('"baz"', frame.GetValueForVariablePath("sdp.object").GetSummary())
+        self.assertEqual('"baz"', frame.GetValueForVariablePath("*sdp").GetSummary())
 
         idp_deleter = frame.GetValueForVariablePath("idp.deleter")
         self.assertTrue(idp_deleter.IsValid())
         self.assertEqual(1, idp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned())
         self.assertEqual(2, idp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned())
 
         sdp_deleter = frame.GetValueForVariablePath("sdp.deleter")
         self.assertTrue(sdp_deleter.IsValid())
def test_recursive_unique_ptr(self):
         self.expect("frame variable --ptr-depth=1 f1->fp",
                     substrs=['data = 2', 'fp = 0x'])
         self.expect("frame variable --ptr-depth=2 f1->fp",
                     substrs=['data = 2', 'fp = 0x', 'data = 1'])
 
         frame = self.frame()
         self.assertTrue(frame.IsValid())
         self.assertEqual(2, frame.GetValueForVariablePath("f1->fp.object.data").GetValueAsUnsigned())
+        self.assertEqual(2, frame.GetValueForVariablePath("f1->fp->data").GetValueAsUnsigned())
         self.assertEqual(1, frame.GetValueForVariablePath("f1->fp.object.fp.object.data").GetValueAsUnsigned())
+        self.assertEqual(1, frame.GetValueForVariablePath("f1->fp->fp->data").GetValueAsUnsigned())
 

source/Core/ValueObject.cpp

if (child_compiler_type && child_byte_size) {
         child_name.SetCString(child_name_str.c_str());
 
       m_deref_valobj = new ValueObjectChild(
           *this, child_compiler_type, child_name, child_byte_size,
           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(ConstString("$$dereference$$"), true)
+            .get();
   }
 
   if (m_deref_valobj) {
     error.Clear();
     return m_deref_valobj->GetSP();
   } else {
     StreamString strm;
     GetExpressionPath(strm, true);

source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp

 }
 
 size_t LibStdcppUniquePtrSyntheticFrontEnd::GetIndexOfChildWithName(
     const ConstString &name) {
   if (name == ConstString("ptr") || name == ConstString("pointer"))
     return 0;
   if (name == ConstString("del") || name == ConstString("deleter"))
     return 1;
-  if (name == ConstString("obj") || name == ConstString("object"))
+  if (name == ConstString("obj") || name == ConstString("object") ||
+      name == ConstString("$$dereference$$"))
     return 2;
   return UINT32_MAX;
 }
 
 bool LibStdcppUniquePtrSyntheticFrontEnd::GetSummary(
     Stream &stream, const TypeSummaryOptions &options) {
   if (!m_ptr_obj)
     return false;

source/Target/StackFrame.cpp

if (!valobj_sp) {
     return ValueObjectSP();
   }
 
   // We are dumping at least one child
   while (separator_idx != std::string::npos) {
     // Calculate the next separator index ahead of time
     ValueObjectSP child_valobj_sp;
     const char separator_type = var_expr[0];
+    bool expr_is_ptr = false;
     switch (separator_type) {
     case '-':
+      expr_is_ptr = true;
       if (var_expr.size() >= 2 && var_expr[1] != '>')
         return ValueObjectSP();
 
       if (no_fragile_ivar) {
         // Make sure we aren't trying to deref an objective
         // C ivar if this is not allowed
         const uint32_t pointer_type_flags =
             valobj_sp->GetCompilerType().GetTypeInfo(nullptr);
         if ((pointer_type_flags & eTypeIsObjC) &&
             (pointer_type_flags & eTypeIsPointer)) {
           // This was an objective C object pointer and
           // it was requested we skip any fragile ivars
           // so return nothing here
           return ValueObjectSP();
         }
       }
+
+      // If we have a non pointer type with a sythetic value then lets check if
+      // we have an sythetic dereference specified.
+      if (!valobj_sp->IsPointerType() && valobj_sp->HasSyntheticValue()) {
+        valobj_sp = valobj_sp->GetSyntheticValue()->GetChildMemberWithName(
+            ConstString("$$dereference$$"), true);
+        if (valobj_sp) {
+          expr_is_ptr = false;
+        } else {
+          error.SetErrorString(
+              "Failed to access synthetic dereference member.");
+          return ValueObjectSP();
+        }
+      }
+
       var_expr = var_expr.drop_front(); // Remove the '-'
       LLVM_FALLTHROUGH;
     case '.': {
-      const bool expr_is_ptr = var_expr[0] == '>';
-
       var_expr = var_expr.drop_front(); // Remove the '.' or '>'
       separator_idx = var_expr.find_first_of(".-[");
       ConstString child_name(var_expr.substr(0, var_expr.find_first_of(".-[")));
 
       if (check_ptr_vs_member) {
         // We either have a pointer type and need to verify
         // valobj_sp is a pointer, or we have a member of a
         // class/union/struct being accessed with the . syntax