Report struct/union/array members in -var-update response

Fixes #25.

Before this commit, when LLDB-MI would get a -var-update request for a
complex variable (struct, union, array), it would analyze if value
changed and if it is, then it would return a changelist for this this
value only, which in case of struct and unions means `{...}`. Child
member value were not reported even when changed - MI client would need
to request them individually. This is different from GDB behavior, where
complex object is not reported at all, but child values are reported.
This was causing troubles for Eclipse Variables view which was written
under assumption that -var-update for a complex variable returns
changelist for all children - as a result values of struct fields were
not updated when changed, view continued to show obsolete value.

The fix is complicated by the fact that response should include children
only if they have been listed with -var-list-children. What is more,
according to GDB MI docs [1] range specified to -var-list-children
shouldn't affect -var-update, instead -var-set-update-range should be
used to specify range of children to be reported in -var-update
response, however LLDB-MI doesn't support the -var-set-update-range
request at all - so instead this commit implementation relies on
-var-list-children. It is also not clear how to efficiently identify
which children have been listed and which not - complex var objects
don't contain links to children, instead they exist in a flat namespace,
where children-parent relationship is established through a name.
Therefore in this commit child will be added to the changelist if it's
value changed and there is an existing var object with the same name.
Probably it would be faster to iterate through known var objects and
compare their names with a name of a root object, but
CMICmnLLDBDebugSessionInfoVarObj doesn't provide an interface to iterate
through objects and changing this class was out of scope for my fix -
fix relies only on existing public functions.

Additional noticable problem is recursion, if children objects contain a
pointer to the parent object, however LLDB-MI doesn't has to stop it
itself. A user may "open up" loop of parent/children in the
infinite fashion as much as they want - LLDB-MI and Eclipse GUI would
just print as many nested levels as needed. Note that
CMICmdCmdVarUpdate::ExamineSBValueForChange explicitly halts on pointers
and references, because it scans through SBValue children and doesn't
know which children will be printed or not - structure with unlisted
children still will be reported as one that changed its value.

The one case where this code still doesn't work, if we had construct
like

    struct S { int i; }
    struct S s = { 1 };
    struct S *ps = NULL;

Then a variable will be created for ps->i, and because ps is NULL, that
variable will have a printed value of `??`. If later application does

    ps = &s;

Then ps->i will effectively change its value, but this will not be
reported in the changelist, because SBValue::GetValueDidChange() returns
false for this value. Apparantly change from "invalid" value to a valid
one is not considered a "value change" in API, but this disagreese how
this should be represented in the Eclipse GUI. The only way to fix this
in MI, I think is to compare "old" and "new" string value in MI, which
means need to store old string value - and that is not very effective,
so I don't want to try to fix this problem in this commit. As far as I
observe this is specific to cases with NULL pointer, if pointer was
pointing to a valid structure, than started to point to another -
changes in children values will be properly reported by SBValue, and
this will make their way into the changelist.

[1] https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Variable-Objects.html#The-_002dvar_002dlist_002dchildren-Command

Author: anthony-kolesov

src/MICmdCmdVar.cpp

@@ -356,6 +356,78 @@ bool CMICmdCmdVarUpdate::ParseArgs() {
   return ParseValidateCmdOptions();
 }
 
+//++
+// Details: Print an SBValue or its children into the changelist response. This
+//          is a recursive function. Note that user code may contain infinite
+//          recursion, if a structure contains a pointer to itself (directly or
+//          indirectly) - but this code can't really break this recursion,
+//          because user still may open up elements in variables view into many
+//          levels of nesting. In practice recursion is stopped by the user who
+//          at some point stops expanding nested elements, and this would mean
+//          that at some point complex variable will not have its children
+//          listed with -var-list-children and that will stop recursion.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+//--
+bool CMICmdCmdVarUpdate::PrintValue(
+    CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e eVarInfoFormat,
+    lldb::SBValue &value, const CMIUtilString &valueName) {
+
+  bool bPrintedChildren = false;
+  if (value.MightHaveChildren()) {
+    // Scan children recursively and print those that changed.
+    const MIuint nChildren = value.GetNumChildren();
+    for (MIuint i = 0; i < nChildren; i++) {
+      lldb::SBValue child = value.GetChildAtIndex(i);
+
+      // Did this child changed its value?
+      bool childValueChanged = false;
+      if (!ExamineSBValueForChange(child, childValueChanged))
+        return MIstatus::failure;
+      if (!childValueChanged)
+        continue;
+
+      // rValue.GetNumChildren() returns all members, but this function should
+      // print only those that has been listed by -var-list-children or
+      // -var-set-update-range. LLDB-MI doens't support the latter, though.
+      // I don't know any better way to check if member has been listed than
+      // to attempt to get the member by its name.
+      const CMIUtilString childName(
+          GetMemberName(valueName, CMICmnLLDBUtilSBValue(child).GetName(), i));
+      CMICmnLLDBDebugSessionInfoVarObj childVarObj;
+      if (!CMICmnLLDBDebugSessionInfoVarObj::VarObjGet(childName, childVarObj))
+        continue;
+
+      PrintValue(eVarInfoFormat, child, childName);
+      bPrintedChildren = true;
+    }
+  }
+
+  if (!bPrintedChildren ||
+      (value.GetType().GetTypeFlags() & lldb::eTypeIsPointer &&
+       value.GetValueDidChange())) {
+    // Print scalar values or complex value if its children were not printed.
+    // Pointer to a structure is also printed if its own value changed
+    // (structure is printed as `{...}`, while pointer to a structure is printed
+    // as an address value).
+    const bool bPrintValue =
+        ((eVarInfoFormat ==
+          CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues) ||
+         (eVarInfoFormat ==
+              CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_SimpleValues &&
+          value.GetNumChildren() == 0));
+    const CMIUtilString strValue(
+        CMICmnLLDBDebugSessionInfoVarObj::GetValueStringFormatted(
+            value, CMICmnLLDBDebugSessionInfoVarObj::eVarFormat_Natural));
+    const CMIUtilString strInScope(value.IsInScope() ? "true" : "false");
+
+    MIFormResponse(valueName, bPrintValue ? strValue.c_str() : nullptr,
+                   strInScope);
+  }
+
+  return MIstatus::success;
+}
+
 //++
 // Details: The invoker requires this function. The command does work in this
 // function.
@@ -417,16 +489,7 @@ bool CMICmdCmdVarUpdate::Execute() {
 
   if (m_bValueChanged) {
     varObj.UpdateValue();
-    const bool bPrintValue(
-        (eVarInfoFormat ==
-         CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues) ||
-        (eVarInfoFormat ==
-             CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_SimpleValues &&
-         rValue.GetNumChildren() == 0));
-    const CMIUtilString strValue(bPrintValue ? varObj.GetValueFormatted() : "");
-    const CMIUtilString strInScope(rValue.IsInScope() ? "true" : "false");
-    MIFormResponse(rVarObjName, bPrintValue ? strValue.c_str() : nullptr,
-                   strInScope);
+    return PrintValue(eVarInfoFormat, rValue, rVarObjName);
   }
 
   return MIstatus::success;
@@ -524,6 +587,11 @@ void CMICmdCmdVarUpdate::MIFormResponse(const CMIUtilString &vrStrVarName,
 //--
 bool CMICmdCmdVarUpdate::ExamineSBValueForChange(lldb::SBValue &vrwValue,
                                                  bool &vrwbChanged) {
+  // Note SBValue::GetValueDidChange() returns false if value changes from
+  // invalid (for example if it represents a field of a structure, and
+  // structure is pointed at with a NULL pointer) to a valid value, which is not
+  // a desired result for -var-update changelist - it will miss case of
+  // invalid-to-valid change.
   if (vrwValue.GetValueDidChange()) {
     vrwbChanged = true;
     return MIstatus::success;

src/MICmdCmdVar.h

@@ -115,6 +115,9 @@ class CMICmdCmdVarUpdate : public CMICmdBase {
   // Methods:
 private:
   bool ExamineSBValueForChange(lldb::SBValue &vrwValue, bool &vrwbChanged);
+  bool
+  PrintValue(CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e eVarInfoFormat,
+             lldb::SBValue &value, const CMIUtilString &valueName);
   void MIFormResponse(const CMIUtilString &vrStrVarName,
                       const char *const vpValue,
                       const CMIUtilString &vrStrScope);