[SBValue] Add a method GetNumChildren(uint32_t max)

[sivachandra]

Summary

Along with this, support for an optional argument to the "num_children"
method of a Python synthetic child provider has also been added. These have
been added with the following use case in mind:

Synthetic child providers currently have a method "has_children" and
"num_children". While the former is good enough to know if there are
children, it does not give any insight into how many children there are.
Though the latter serves this purpose, calculating the number for children
of a data structure could be an O(N) operation if the data structure has N
children. The new method added in this change provide a middle ground.
One can call GetNumChildren(K) to know if a child exists at an index K
which can be as large as the callers tolerance can be. If the caller wants
to know about children beyond K, it can make an other call with 2K. If the
synthetic child provider maintains state about it counting till K
previosly, then the next call is only an O(K) operation. Infact, all
calls made progressively with steps of K will be O(K) operations.

[sivachandra]

If the general idea in this patch is OK, I will update it with tests.

[granata.enrico]

What do you plan to use this has_child_at_index call for?

My concern is that it adds complication to the synthetic child provider interface. Yes, I understand it is optional, but it seems like yet another thing in the "any children?" realm that I would rather much avoid if possible. Which is why my question. Let's start from the use case and see if we can come up with anything else that could cover it.

[sivachandra]

As I mentioned in the first post, this is the use case:

Synthetic child providers currently have a method "has_children" and
"get_num_children". While the former is good enough to know if there are
children, it does not give any insight into how many children there are.
Though the latter serves this purpose, calculating the number for children
of a data structure could be an O(N) operation if the data structure has N
children. The new methods added in this change provide a middle ground.
One can call HasChildAtIndex to know if a child exists at an index K which
can be as large as the callers tolerance can be. If the caller wants to
know about children beyond K, it can make an other call with 2K. If the
synthetic child provider maintains state about it counting till K
previosly, then the next call is only an O(K) operation. Infact, all
calls made progressively with steps of K will be O(K) operations.

[granata.enrico]

Is it possible to ask for concrete examples?

As in, for example, do you plan to change ValueObjectPrinter to use this API in some way?
Or do you have any specific synthetic providers that you would like to use this API in?

[sivachandra]

Yes, we would like to use this is specific synthetic providers. It will not be used by any part of LLDB internally.

[granata.enrico]

If so, why do you need this to be exposed as a call that LLDB knows about?

You are free to provide any methods you want in your synthetic child providers. Adding them to the interface as this patch does is only necessary if you want LLDB to use the new methods as part of its interaction with the child provider.

[sivachandra]

Ah, we want this exposed in the SBValue API. What I mean't in the earlier message was that no other part of LLDB will functionally depend/lookup/expect this "feature".

[granata.enrico]

So, if I understand this correctly, this HasChildAtIndex() API returns a three-state int:

1 == yes I do
0 == no I do not
-1 == maybe, can't tell

When would you ever run into the -1 case? It seems you're mostly using it as an invalid marker. Would 0 not be a better choice for those invalid cases? Then you could just use a boolean which seems a better answer for an inherently yes/no question (invalid objects do not have a child at index for any index, do they?)

Also, if you're only using this from inside a synthetic child provider, why does it need to be in SBValue? Or is your argument that you want to write scripts against LLDB that use this feature?

Truth be told, I am not particularly excited about this feature, and the fact that this seems to be introduced in a vacuum does nothing to assuage my original concern that is is a potentially avoidable complication to the model.

[clayborg]

I would almost rather change the GetNumChildren() to take a "max" param:

class SBValue
{
     uint32_t
     GetNumChildren ();
     uint32_t
     GetNumChildren (uint32_t max = UINT32_MAX);
};

We need to keep the other one so that our public API still has the old call, but the second version could limit the number of children to verify to at most "max".

[sivachandra]

I did consider the option of adding a new method GetNumChildren (uint32_t max = UINT32_MAX). This if fine from SBValue point of view. But from a the scripted synthetic provider point of view, I am not sure there is an easy/clean way of checking whether the num_children method takes the max cap argument. Are you suggesting that we have different method like "num_children_with_cap"?

[granata.enrico]

One alternative would be to have the num_children method on the synthetic provider itself be able to take an optional argument that is the max_count. That is, instead of defining

def num_children(self):
  ..

You would instead define

def num_children(self, max_count):
  ..

Of course, you would need to continue supporting both possible signatures in order to maintain compatibility with existing formatters. But we do have some support for that. If you look at LLDBSwigPythonCallCommand:

PyCallable::argc argc = pfunc.GetNumArguments();
if (argc.num_args == 5 || argc.varargs == true)
    pvalue = pfunc(debugger_sb, args, exe_ctx_sb, &cmd_retobj_sb, session_dict = FindSessionDictionary(session_dictionary_name));
else
    pvalue = pfunc(debugger_sb, args, &cmd_retobj_sb, session_dict = FindSessionDictionary(session_dictionary_name));

num_children could start doing something similar for 1 vs. 2 arguments

[sivachandra]

Ah, I did not notice PyCallable::GetNumArguments before you drew my attention to it. It seems to be using internals of PyCodeObject. When I said "no easy/clean way", I was talking about avoiding such a usage. If that is acceptable, I am fine with it. I will modify this patch to add SBValue::GetNumArguments(uint32 max=UINT32_MAX).

[sivachandra]

I did this experiment before setting off:

class A
{
public:
  int method();
  int method(int a = 10);
};

int
A::method()
{
  return 10;
}

int
A::method(int a)
{
  return a + 10;
}

int
main()
{
  A a;
  return a.method();
}

The invocation a.method() is ambiguous:

$> clang++-3.5 -g methods.cc 
methods.cc:25:12: error: call to member function 'method' is ambiguous
  return a.method();
         ~~^~~~~~
methods.cc:10:4: note: candidate function
A::method()
   ^
methods.cc:16:4: note: candidate function
A::method(int a)
   ^
1 error generated.

So, what is wrong if I just add SBValue::GetNumChildren(int max) without a default argument?

[clayborg]

For the public API you will need both and not have a default arg.

[labath]

Not really my area, but couldn't the needed functionality be implemented on top of GetChildAtIndex(). I mean, if GetChildAtIndex(50) returns a valid SBValue, then the container has at least 50 elements, right?
Then HasAtLeastNChildren(n) == GetChildAtIndex(n).IsValid() and we don't need to add anything to the public API. Or am I missing something here... (?)

[sivachandra]

There could be an error reading the k-th element for k < n.In which case, we will wrongly conclude that there are only k-1 elements.

[labath]

How big of an error does it have to be for that to happen? Is that something we would consider an "lldb bug"/"data formatter bug" or it can be caused by something out of our control, like missing debug info on one of the children?

[sivachandra]

When such an error occurs, it is unlikely to be an lldb bug, or data-formatter bug. One can come up with a data structure for which reading a child element would require complete debug info, but reading the # of child elements need not require complete debug info (there could be an instance variable storing the size). Another could be that a child is improperly initialized but the data structure itself is properly initialized.

[sivachandra]

Address comments.

[sivachandra]

Pinging to ensure that it did not get lost in the title change.

[labath]

When such an error occurs, it is unlikely to be an lldb bug, or data-formatter bug. One can come up with a data structure for which reading a child element would require complete debug info, but reading the # of child elements need not require complete debug info (there could be an instance variable storing the size). Another could be that a child is improperly initialized but the data structure itself is properly initialized.

Ok, that makes sense. No objections from my side.

source/API/SBValue.cpp

1285

You can replace this by return GetNumChildren(UINT32_MAX);

[sivachandra]

Add tests.

[clayborg]

Accepted as long as Enrico is OK with this.

[granata.enrico]

Looks fine

include/lldb/API/SBValue.h

#endif
     /// @return
     ///     A new SBValue object that represents the child member value.
     //------------------------------------------------------------------
     lldb::SBValue
     GetChildAtIndex (uint32_t idx, 
                      lldb::DynamicValueType use_dynamic,
                      bool can_create_synthetic);
 
+    /// The return value is a tri-state value. If it is positive, then it means that there
+    /// is indeed a child at index idx. If it is 0, then it means that there is no child
+    /// at that index. If it is negative, then it means that it (whether a child exists or not
+    /// at that said index) could not be evaluated properly.
+    int32_t
+    HasChildAtIndex (uint32_t idx);
+
     // Matches children of this object only and will match base classes and
     // member names if this is a clang typed object.
     uint32_t
     GetIndexOfChildWithName (const char *name);
 
     // Matches child members of this object and child members of any base
     // classes.
     lldb::SBValue

include/lldb/Core/ValueObject.h

//        SetContext (ExecutionContextScope *exe_scope);
     GetError();
 
     const ConstString &
     GetName() const;
 
     virtual lldb::ValueObjectSP
     GetChildAtIndex (size_t idx, bool can_create);
 
+    // The return value is a tri-state value. If it is positive, then it means that there
+    // is indeed a child at index idx. If it is 0, then it means that there is no child
+    // at that index. If it is negative, then it means that it (whether a child exists or not
+    // at that said index) could not be evaluated properly.
+    virtual int
+    HasChildAtIndex (size_t idx);
+
     // this will always create the children if necessary
     lldb::ValueObjectSP
     GetChildAtIndexPath (const std::initializer_list<size_t> &idxs,
                          size_t* index_of_error = NULL);
     
     lldb::ValueObjectSP
     GetChildAtIndexPath (const std::vector<size_t> &idxs,
                          size_t* index_of_error = NULL);

include/lldb/Core/ValueObjectSyntheticFilter.h

public:
     virtual size_t
     CalculateNumChildren();
 
     virtual lldb::ValueType
     GetValueType() const;
     
     virtual lldb::ValueObjectSP
     GetChildAtIndex (size_t idx, bool can_create);
-    
+    virtual int
+    HasChildAtIndex (size_t idx);
+    
     virtual lldb::ValueObjectSP
     GetChildMemberWithName (const ConstString &name, bool can_create);
     
     virtual size_t
     GetIndexOfChildWithName (const ConstString &name);
 
     virtual lldb::ValueObjectSP
     GetDynamicValue (lldb::DynamicValueType valueType);

include/lldb/DataFormatters/TypeSynthetic.h

public:
         {
         }
         
         virtual size_t
         CalculateNumChildren () = 0;
         
         virtual lldb::ValueObjectSP
         GetChildAtIndex (size_t idx) = 0;
-        
+        virtual int
+        HasChildAtIndex (size_t idx)
+        {
+            return -1;
+        }
+        
         virtual size_t
         GetIndexOfChildWithName (const ConstString &name) = 0;
         
         // this function is assumed to always succeed and it if fails, the front-end should know to deal
         // with it in the correct way (most probably, by refusing to return any children)
         // the return value of Update() should actually be interpreted as "ValueObjectSyntheticFilter cache is good/bad"
         // if =true, ValueObjectSyntheticFilter is allowed to use the children it fetched previously and cached
         // if =false, ValueObjectSyntheticFilter must throw away its cache, and query again for children
public:
         }
         
         size_t
         CalculateNumChildren() override { return 0; }
         
         lldb::ValueObjectSP
         GetChildAtIndex(size_t idx) override { return nullptr; }
         
+        int
+        HasChildAtIndex(size_t idx) override { return 0; }
+
         size_t
         GetIndexOfChildWithName(const ConstString &name) override { return UINT32_MAX; }
         
         bool
         Update() override { return false; }
         
         bool
         MightHaveChildren () override { return false; }
public:
             
             lldb::ValueObjectSP
             GetChildAtIndex(size_t idx) override
             {
                 if (idx >= filter->GetCount())
                     return lldb::ValueObjectSP();
                 return m_backend.GetSyntheticExpressionPathChild(filter->GetExpressionPathAtIndex(idx), true);
             }
-            
+            int
+            HasChildAtIndex(size_t idx) override
+            {
+                if (idx < filter->GetCount())
+                    return 1;
+                else
+                    return 0;
+            }
+            
             bool
             Update() override { return false; }
             
             bool
             MightHaveChildren() override
             {
                 return filter->GetCount() > 0;
             }
public:
             
             ~FrontEnd() override;
             
             size_t
             CalculateNumChildren() override;
             
             lldb::ValueObjectSP
             GetChildAtIndex(size_t idx) override;
-            
+            int
+            HasChildAtIndex(size_t idx) override;
+            
             bool
             Update() override;
             
             bool
             MightHaveChildren() override;
             
             size_t
             GetIndexOfChildWithName(const ConstString &name) override;

include/lldb/Interpreter/ScriptInterpreter.h

public:
 
     virtual lldb::ValueObjectSP
     GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx)
     {
         return lldb::ValueObjectSP();
     }
 
     virtual int
+    HasChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx)
+    {
+        return -1;
+    }
+
+    virtual int
     GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name)
     {
         return UINT32_MAX;
     }
 
     virtual bool
     UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor)
     {

scripts/Python/python-wrapper.swig

)
 
     if (sbvalue_ptr == NULL)
         return NULL;
 
     return py_return;
 }
 
 SWIGEXPORT int
+LLDBSwigPython_HasChildAtIndex
+(
+    PyObject *implementor,
+    uint32_t idx
+)
+{
+    PyErr_Cleaner py_err_cleaner(true);
+
+    PyCallable pfunc = PyCallable::FindWithMemberFunction(implementor, "has_child_at_index");
+
+    if (!pfunc)
+        return -1;
+
+    PyObject *py_return = NULL;
+    py_return = pfunc(idx);
+
+    if (py_return == NULL)
+        return -1;
+
+    int truth_value = PyObject_IsTrue(py_return);
+    Py_DECREF(py_return);
+
+    return truth_value;
+}
+
+SWIGEXPORT int
 LLDBSwigPython_GetIndexOfChildWithName
 (
     PyObject *implementor,
     const char* child_name
 )
 {
     PyErr_Cleaner py_err_cleaner(true);
 

scripts/interface/SBValue.i

public:
     /// @return
     ///     A new SBValue object that represents the child member value.
     //------------------------------------------------------------------
     ") GetChildAtIndex;
     lldb::SBValue
     GetChildAtIndex (uint32_t idx, 
                      lldb::DynamicValueType use_dynamic,
                      bool can_create_synthetic);
-    
+    %feature("docstring", "
+    //------------------------------------------------------------------
+    /// The return value is a tri-state value. If it is positive, then it means that there
+    /// is indeed a child at index idx. If it is 0, then it means that there is no child
+    /// at that index. If it is negative, then it means that it (whether a child exists or not
+    /// at that said index) could not be evaluated properly.
+    //------------------------------------------------------------------
+    ") HasChildAtIndex;
+    int32_t
+    HasChildAtIndex (uint32_t idx);
+    
     lldb::SBValue
     CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type);
     
     lldb::SBValue
     SBValue::Cast (lldb::SBType type);
 
     lldb::SBValue
     CreateValueFromExpression (const char *name, const char* expression);

source/API/SBValue.cpp

SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic)
     if (log)
         log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
                      static_cast<void*>(value_sp.get()), idx,
                      static_cast<void*>(value_sp.get()));
 
     return sb_value;
 }
 
+int32_t
+SBValue::HasChildAtIndex (uint32_t idx)
+{
+    ValueLocker locker;
+    lldb::ValueObjectSP value_sp(GetSP(locker));
+
+    if (!value_sp)
+        return -1;
+
+    return value_sp->HasChildAtIndex (idx);
+}
+
 uint32_t
 SBValue::GetIndexOfChildWithName (const char *name)
 {
     uint32_t idx = UINT32_MAX;
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
     {
if (log)
         log->Printf ("SBValue(%p)::IsRuntimeSupportValue() => %i",
                      static_cast<void*>(value_sp.get()), is_support);
     return is_support;
 }
 
 uint32_t
 SBValue::GetNumChildren ()
 {
     uint32_t num_children = 0;
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
         num_children = value_sp->GetNumChildren();
 
     if (log)

source/API/SystemInitializerFull.cpp

 
 extern "C" size_t
 LLDBSwigPython_CalculateNumChildren (void *implementor);
 
 extern "C" void *
 LLDBSwigPython_GetChildAtIndex (void *implementor, uint32_t idx);
 
 extern "C" int
+LLDBSwigPython_HasChildAtIndex (void *implementor, uint32_t idx);
+
+extern "C" int
 LLDBSwigPython_GetIndexOfChildWithName (void *implementor, const char* child_name);
 
 extern "C" void *
 LLDBSWIGPython_CastPyObjectToSBValue (void* data);
 
 extern lldb::ValueObjectSP
 LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data);
 
ScriptInterpreterPython::InitializeInterpreter(
         init_lldb,
         LLDBSwigPythonBreakpointCallbackFunction,
         LLDBSwigPythonWatchpointCallbackFunction,
         LLDBSwigPythonCallTypeScript,
         LLDBSwigPythonCreateSyntheticProvider,
         LLDBSwigPythonCreateCommandObject,
         LLDBSwigPython_CalculateNumChildren,
         LLDBSwigPython_GetChildAtIndex,
+        LLDBSwigPython_HasChildAtIndex,
         LLDBSwigPython_GetIndexOfChildWithName,
         LLDBSWIGPython_CastPyObjectToSBValue,
         LLDBSWIGPython_GetValueObjectSPFromSBValue,
         LLDBSwigPython_UpdateSynthProviderInstance,
         LLDBSwigPython_MightHaveChildrenSynthProviderInstance,
         LLDBSwigPython_GetValueSynthProviderInstance,
         LLDBSwigPythonCallCommand,
         LLDBSwigPythonCallCommandObject,

source/Core/ValueObject.cpp

if (idx < GetNumChildren())
         
         ValueObject* child = m_children.GetChildAtIndex(idx);
         if (child != NULL)
             return child->GetSP();
     }
     return child_sp;
 }
 
+int
+ValueObject::HasChildAtIndex (size_t idx)
+{
+    ExecutionContext exe_ctx (GetExecutionContextRef());
+    std::string child_name_str;
+    bool child_is_base_class, child_is_deref_of_parent;
+    int32_t child_byte_offset;
+    uint32_t child_byte_size, child_bitfield_bit_size, child_bitfield_bit_offset;
+
+    auto compiler_type = GetCompilerType().GetChildCompilerTypeAtIndex (&exe_ctx,
+                                                                        idx,
+                                                                        false, // transparent_pointers
+                                                                        true,  // omit_empty_base_classes,
+                                                                        false, //ignore_array_bounds,
+                                                                        child_name_str,
+                                                                        child_byte_size,
+                                                                        child_byte_offset,
+                                                                        child_bitfield_bit_size,
+                                                                        child_bitfield_bit_offset,
+                                                                        child_is_base_class,
+                                                                        child_is_deref_of_parent,
+                                                                        this);
+
+    if (compiler_type)
+        return 1;
+    else
+        return 0;
+}
+
 ValueObjectSP
 ValueObject::GetChildAtIndexPath (const std::initializer_list<size_t>& idxs,
                                   size_t* index_of_error)
 {
     if (idxs.size() == 0)
         return GetSP();
     ValueObjectSP root(GetSP());
     for (size_t idx : idxs)

source/Core/ValueObjectSyntheticFilter.cpp

CalculateNumChildren()
         return m_backend.GetNumChildren();
     }
     
     lldb::ValueObjectSP
     GetChildAtIndex (size_t idx)
     {
         return m_backend.GetChildAtIndex(idx, true);
     }
-    
+    int
+    HasChildAtIndex (size_t idx)
+    {
+        return m_backend.HasChildAtIndex(idx);
+    }
+
     size_t
     GetIndexOfChildWithName (const ConstString &name)
     {
         return m_backend.GetIndexOfChildWithName(name);
     }
     
     bool
     MightHaveChildren ()
if (m_children_byindex.GetValueForKey(idx, valobj) == false)
         }
         else
             return lldb::ValueObjectSP();
     }
     else
         return valobj->GetSP();
 }
 
+int
+ValueObjectSynthetic::HasChildAtIndex (size_t idx)
+{
+  UpdateValueIfNeeded();
+
+  if (m_synth_filter_ap.get() == NULL)
+      return -1;
+
+  return m_synth_filter_ap->HasChildAtIndex (idx);
+}
+
 lldb::ValueObjectSP
 ValueObjectSynthetic::GetChildMemberWithName (const ConstString &name, bool can_create)
 {
     UpdateValueIfNeeded();
 
     uint32_t index = GetIndexOfChildWithName(name);
     
     if (index == UINT32_MAX)

source/DataFormatters/TypeSynthetic.cpp

 ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex (size_t idx)
 {
     if (!m_wrapper_sp || !m_interpreter)
         return lldb::ValueObjectSP();
     
     return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx);
 }
 
+int
+ScriptedSyntheticChildren::FrontEnd::HasChildAtIndex (size_t idx)
+{
+    if (!m_wrapper_sp || !m_interpreter)
+        return -1;
+
+    return m_interpreter->HasChildAtIndex(m_wrapper_sp, idx);
+}
+
 bool
 ScriptedSyntheticChildren::FrontEnd::IsValid ()
 {
     return (m_wrapper_sp && m_wrapper_sp->IsValid() && m_interpreter);
 }
 
 size_t
 ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren ()

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.h

public:
     typedef bool (*SWIGPythonCallThreadPlan) (void *implementor, const char *method_name, Event *event_sp, bool &got_error);
 
     typedef void* (*SWIGPythonCreateOSPlugin) (const char *python_class_name,
                                                const char *session_dictionary_name,
                                                const lldb::ProcessSP& process_sp);
     
     typedef size_t          (*SWIGPythonCalculateNumChildren)                   (void *implementor);
     typedef void*           (*SWIGPythonGetChildAtIndex)                        (void *implementor, uint32_t idx);
+    typedef int             (*SWIGPythonHasChildAtIndex)                        (void *implementor, uint32_t idx);
     typedef int             (*SWIGPythonGetIndexOfChildWithName)                (void *implementor, const char* child_name);
     typedef void*           (*SWIGPythonCastPyObjectToSBValue)                  (void* data);
     typedef lldb::ValueObjectSP  (*SWIGPythonGetValueObjectSPFromSBValue)       (void* data);
     typedef bool            (*SWIGPythonUpdateSynthProviderInstance)            (void* data);
     typedef bool            (*SWIGPythonMightHaveChildrenSynthProviderInstance) (void* data);
     typedef void*           (*SWIGPythonGetValueSynthProviderInstance)          (void *implementor);
     
     typedef bool            (*SWIGPythonCallCommand)            (const char *python_function_name,
public:
 
     StructuredData::DictionarySP GetDynamicSettings(StructuredData::ObjectSP plugin_module_sp, Target *target, const char *setting_name,
                                                     lldb_private::Error &error) override;
 
     size_t CalculateNumChildren(const StructuredData::ObjectSP &implementor) override;
 
     lldb::ValueObjectSP GetChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) override;
 
+    int HasChildAtIndex(const StructuredData::ObjectSP &implementor, uint32_t idx) override;
+
     int GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor, const char *child_name) override;
 
     bool UpdateSynthProviderInstance(const StructuredData::ObjectSP &implementor) override;
 
     bool MightHaveChildrenSynthProviderInstance(const StructuredData::ObjectSP &implementor) override;
 
     lldb::ValueObjectSP GetSyntheticValue(const StructuredData::ObjectSP &implementor) override;
 
//                                              size_t bytes_len);
     InitializeInterpreter (SWIGInitCallback python_swig_init_callback,
                            SWIGBreakpointCallbackFunction swig_breakpoint_callback,
                            SWIGWatchpointCallbackFunction swig_watchpoint_callback,
                            SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
                            SWIGPythonCreateSyntheticProvider swig_synthetic_script,
                            SWIGPythonCreateCommandObject swig_create_cmd,
                            SWIGPythonCalculateNumChildren swig_calc_children,
                            SWIGPythonGetChildAtIndex swig_get_child_index,
+                           SWIGPythonHasChildAtIndex swig_has_child_at_index,
                            SWIGPythonGetIndexOfChildWithName swig_get_index_child,
                            SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue ,
                            SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
                            SWIGPythonUpdateSynthProviderInstance swig_update_provider,
                            SWIGPythonMightHaveChildrenSynthProviderInstance swig_mighthavechildren_provider,
                            SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
                            SWIGPythonCallCommand swig_call_command,
                            SWIGPythonCallCommandObject swig_call_command_object,

source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

 static ScriptInterpreterPython::SWIGInitCallback g_swig_init_callback = nullptr;
 static ScriptInterpreterPython::SWIGBreakpointCallbackFunction g_swig_breakpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGWatchpointCallbackFunction g_swig_watchpoint_callback = nullptr;
 static ScriptInterpreterPython::SWIGPythonTypeScriptCallbackFunction g_swig_typescript_callback = nullptr;
 static ScriptInterpreterPython::SWIGPythonCreateSyntheticProvider g_swig_synthetic_script = nullptr;
 static ScriptInterpreterPython::SWIGPythonCreateCommandObject g_swig_create_cmd = nullptr;
 static ScriptInterpreterPython::SWIGPythonCalculateNumChildren g_swig_calc_children = nullptr;
 static ScriptInterpreterPython::SWIGPythonGetChildAtIndex g_swig_get_child_index = nullptr;
+static ScriptInterpreterPython::SWIGPythonHasChildAtIndex g_swig_has_child_at_index = nullptr;
 static ScriptInterpreterPython::SWIGPythonGetIndexOfChildWithName g_swig_get_index_child = nullptr;
 static ScriptInterpreterPython::SWIGPythonCastPyObjectToSBValue g_swig_cast_to_sbvalue  = nullptr;
 static ScriptInterpreterPython::SWIGPythonGetValueObjectSPFromSBValue g_swig_get_valobj_sp_from_sbvalue = nullptr;
 static ScriptInterpreterPython::SWIGPythonUpdateSynthProviderInstance g_swig_update_provider = nullptr;
 static ScriptInterpreterPython::SWIGPythonMightHaveChildrenSynthProviderInstance g_swig_mighthavechildren_provider = nullptr;
 static ScriptInterpreterPython::SWIGPythonGetValueSynthProviderInstance g_swig_getvalue_provider = nullptr;
 static ScriptInterpreterPython::SWIGPythonCallCommand g_swig_call_command = nullptr;
 static ScriptInterpreterPython::SWIGPythonCallCommandObject g_swig_call_command_object = nullptr;
lldb::ValueObjectSP ret_val;
             Py_XDECREF(child_ptr);
         }
     }
     
     return ret_val;
 }
 
 int
+ScriptInterpreterPython::HasChildAtIndex(const StructuredData::ObjectSP &implementor_sp, uint32_t idx)
+{
+    if (!implementor_sp)
+        return -1;
+
+    StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
+    if (!generic)
+        return -1;
+    void *implementor = generic->GetValue();
+    if (!implementor)
+        return -1;
+
+    if (!g_swig_has_child_at_index)
+        return -1;
+
+    {
+        Locker py_lock(this, Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+        return g_swig_has_child_at_index (implementor, idx);
+    }
+}
+
+int
 ScriptInterpreterPython::GetIndexOfChildWithName(const StructuredData::ObjectSP &implementor_sp, const char *child_name)
 {
     if (!implementor_sp)
         return UINT32_MAX;
 
     StructuredData::Generic *generic = implementor_sp->GetAsGeneric();
     if (!generic)
         return UINT32_MAX;

 ScriptInterpreterPython::InitializeInterpreter (SWIGInitCallback swig_init_callback,
                                                 SWIGBreakpointCallbackFunction swig_breakpoint_callback,
                                                 SWIGWatchpointCallbackFunction swig_watchpoint_callback,
                                                 SWIGPythonTypeScriptCallbackFunction swig_typescript_callback,
                                                 SWIGPythonCreateSyntheticProvider swig_synthetic_script,
                                                 SWIGPythonCreateCommandObject swig_create_cmd,
                                                 SWIGPythonCalculateNumChildren swig_calc_children,
                                                 SWIGPythonGetChildAtIndex swig_get_child_index,
+                                                SWIGPythonHasChildAtIndex swig_has_child_at_index,
                                                 SWIGPythonGetIndexOfChildWithName swig_get_index_child,
                                                 SWIGPythonCastPyObjectToSBValue swig_cast_to_sbvalue ,
                                                 SWIGPythonGetValueObjectSPFromSBValue swig_get_valobj_sp_from_sbvalue,
                                                 SWIGPythonUpdateSynthProviderInstance swig_update_provider,
                                                 SWIGPythonMightHaveChildrenSynthProviderInstance swig_mighthavechildren_provider,
                                                 SWIGPythonGetValueSynthProviderInstance swig_getvalue_provider,
                                                 SWIGPythonCallCommand swig_call_command,
                                                 SWIGPythonCallCommandObject swig_call_command_object,
ScriptInterpreterPython::InitializeInterpreter (SWIGInitCallback swig_init_callback,
     g_swig_init_callback = swig_init_callback;
     g_swig_breakpoint_callback = swig_breakpoint_callback;
     g_swig_watchpoint_callback = swig_watchpoint_callback;
     g_swig_typescript_callback = swig_typescript_callback;
     g_swig_synthetic_script = swig_synthetic_script;
     g_swig_create_cmd = swig_create_cmd;
     g_swig_calc_children = swig_calc_children;
     g_swig_get_child_index = swig_get_child_index;
+    g_swig_has_child_at_index = swig_has_child_at_index;
     g_swig_get_index_child = swig_get_index_child;
     g_swig_cast_to_sbvalue = swig_cast_to_sbvalue;
     g_swig_get_valobj_sp_from_sbvalue = swig_get_valobj_sp_from_sbvalue;
     g_swig_update_provider = swig_update_provider;
     g_swig_mighthavechildren_provider = swig_mighthavechildren_provider;
     g_swig_getvalue_provider = swig_getvalue_provider;
     g_swig_call_command = swig_call_command;
     g_swig_call_command_object = swig_call_command_object;