[ValueObjectSynthetic and ValueObjectDynamicValue] Override GetDeclaration

[sivachandra]

Summary

Returns the declaration of the parent (non-synthetic or static) value.

[granata.enrico]

That looks reasonable

Does ValueObjectDynamic need the same change? You could have dynamic+synthetic combinations (e.g. NSArray/NSDictionary on Mac OS X) where the synthetic value sits on top of the dynamic value

[sivachandra]

Override GetDeclaration in ValueObjectDynamicValue as well.

[granata.enrico]

Assuming it passes the test suite, LGTM

[clayborg]

I'm good if the test suite is clean.

[sivachandra]

Committed. Test suite is clean.

include/lldb/Core/ValueObjectDynamicValue.h

GetParent() const
             return NULL;
     }
 
     virtual lldb::ValueObjectSP
     GetStaticValue ()
     {
         return m_parent->GetSP();
     }
-    
     void
     SetOwningSP (lldb::ValueObjectSP &owning_sp)
     {
         if (m_owning_valobj_sp == owning_sp)
             return;
             
         assert (m_owning_valobj_sp.get() == NULL);
         m_owning_valobj_sp = owning_sp;
     }
     
     virtual bool
     SetValueFromCString (const char *value_str, Error& error);
     
     virtual bool
     SetData (DataExtractor &data, Error &error);
     
     virtual TypeImpl
     GetTypeImpl ();
     
+    virtual bool
+    GetDeclaration (Declaration &decl);
+
 protected:
     virtual bool
     UpdateValue ();
     
     virtual LazyBool
     CanUpdateWithInvalidExecutionContext ()
     {
         return eLazyBoolYes;

include/lldb/Core/ValueObjectSyntheticFilter.h

public:
     }
 
     virtual bool
     SetValueFromCString (const char *value_str, Error& error);
     
     virtual void
     SetFormat (lldb::Format format);
     
+    virtual bool
+    GetDeclaration (Declaration &decl);
+
 protected:
     virtual bool
     UpdateValue ();
     
     virtual LazyBool
     CanUpdateWithInvalidExecutionContext ()
     {
         return eLazyBoolYes;

source/Core/ValueObjectDynamicValue.cpp

if (my_value != parent_value)
             return false;
         }
     }
     
     bool ret_val = m_parent->SetData(data, error);
     SetNeedsUpdate();
     return ret_val;
 }
+
+bool
+ValueObjectDynamicValue::GetDeclaration (Declaration &decl)
+{
+    if (m_parent)
+        return m_parent->GetDeclaration(decl);
+
+    return ValueObject::GetDeclaration(decl);
+}

source/Core/ValueObjectSyntheticFilter.cpp

ValueObjectSynthetic::SetFormat (lldb::Format format)
     if (m_parent)
     {
         m_parent->ClearUserVisibleData(eClearUserVisibleDataItemsAll);
         m_parent->SetFormat(format);
     }
     this->ValueObject::SetFormat(format);
     this->ClearUserVisibleData(eClearUserVisibleDataItemsAll);
 }
+
+bool
+ValueObjectSynthetic::GetDeclaration (Declaration &decl)
+{
+    if (m_parent)
+        return m_parent->GetDeclaration(decl);
+
+    return ValueObject::GetDeclaration(decl);
+}

test/python_api/formatters/TestFormattersSBAPI.py

def formatters(self):
              substrs = ['X = 1'])
 
         self.dbg.GetCategory("CCCSynth").SetEnabled(True)
         self.expect("frame variable ccc", matching=True,
              substrs = ['CCC object with leading value (int) a = 111', 'a = 111', 'b = 222', 'c = 333'])
 
         foo_var = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('foo')
         self.assertTrue(foo_var.IsValid(), 'could not find foo')
+        self.assertTrue(foo_var.GetDeclaration().IsValid(), 'foo declaration is invalid')
 
         self.assertTrue(foo_var.GetNumChildren() == 2, 'synthetic value has wrong number of child items (synth)')
         self.assertTrue(foo_var.GetChildMemberWithName('X').GetValueAsUnsigned() == 1, 'foo_synth.X has wrong value (synth)')
         self.assertFalse(foo_var.GetChildMemberWithName('B').IsValid(), 'foo_synth.B is valid but should not (synth)')
 
         self.dbg.GetCategory("JASSynth").SetEnabled(False)
         foo_var = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('foo')
         self.assertTrue(foo_var.IsValid(), 'could not find foo')