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

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()) {
+        Error deref_error;
+        if (valobj_sp->GetCompilerType().IsReferenceType()) {
+          valobj_sp = valobj_sp->GetSyntheticValue()->Dereference(deref_error);
+          if (error.Fail()) {
+            error.SetErrorStringWithFormatv(
+                "Failed to dereference reference type: %s", deref_error);
+            return ValueObjectSP();
+          }
+        }
+
+        valobj_sp = valobj_sp->Dereference(deref_error);
+        if (error.Fail()) {
+          error.SetErrorStringWithFormatv(
+              "Failed to dereference sythetic value: %s", deref_error);
+          return ValueObjectSP();
+        }
+        expr_is_ptr = false;
+      }
+
       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

www/varformats.html

<code>
       &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<i>this call can return an SBValue to be presented as the value of the synthetic value under consideration.</i><sup>[3]</sup><br/>
       
     </code>
 <sup>[1]</sup> This method is optional. Also, it may optionally choose to return a value (starting with SVN rev153061/LLDB-134). If it returns a value, and that value is <font color=blue><code>True</code></font>, LLDB will be allowed to cache the children and the children count it previously obtained, and will not return to the provider class to ask. If nothing, <font color=blue><code>None</code></font>, or anything other than <font color=blue><code>True</code></font> is returned, LLDB will discard the cached information and ask. Regardless, whenever necessary LLDB will call <code>update</code>.
 <br/>
 <sup>[2]</sup> This method is optional (starting with SVN rev166495/LLDB-175). While implementing it in terms of <code>num_children</code> is acceptable, implementors are encouraged to look for optimized coding alternatives whenever reasonable.
 <br/>
 <sup>[3]</sup> This method is optional (starting with SVN revision 219330). The SBValue you return here will most likely be a numeric type (int, float, ...) as its value bytes will be used as-if they were the value of the root SBValue proper. As a shortcut for this, you can inherit from lldb.SBSyntheticValueProvider, and just define get_value as other methods are defaulted in the superclass as returning default no-children responses.
+<p>If a synthetic child provider supplies a special child named <code>$$dereference$$</code> then it will be used when evaluating <code>opertaor*</code> and <code>operator-&gt;</code> in the <code>frame variable</code> command and related SB API functions.</p>
     <p>For examples of how synthetic children are created, you are encouraged to look at <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/synthetic/">examples/synthetic</a> in the LLDB trunk. Please, be aware that the code in those files (except bitfield/)
       is legacy code and is not maintained.
       You may especially want to begin looking at <a href="http://llvm.org/svn/llvm-project/lldb/trunk/examples/synthetic/bitfield">this example</a> to get
       a feel for this feature, as it is a very easy and well commented example.</p>
       The design pattern consistently used in synthetic providers shipping with LLDB
         is to use the <code>__init__</code> to store the SBValue instance as a part of <code>self</code>. The <code>update</code> function is then used
         to perform the actual initialization.