[PyROOT] Get names and types of all overloads' signature

Expose two new attributes of a CPPOverload object on the Python side,
namely `func_overloads_names` and `func_overloads_types`. The first
returns a dictionary with all the input parameter names for all the
overloads, the second returns a dictionary with the types of the return
and input parameters for all the overloads. An example:

```python
import ROOT
from pprint import pprint

ROOT.gInterpreter.Declare("""
 int foo(int a, float b);
 int foo(int a);
 float foo(float b);
 double foo(int a, float b, double c);
""")

pprint(ROOT.foo.func_overloads_names)
pprint(ROOT.foo.func_overloads_types)
```
Output:
```
{'double ::foo(int a, float b, double c)': ('a', 'b', 'c'),
 'float ::foo(float b)': ('b',),
 'int ::foo(int a)': ('a',),
 'int ::foo(int a, float b)': ('a', 'b')}
{'double ::foo(int a, float b, double c)': {'input_types': ('int',
                                                            'float',
                                                            'double'),
                                            'return_type': 'double'},
 'float ::foo(float b)': {'input_types': ('float',), 'return_type': 'float'},
 'int ::foo(int a)': {'input_types': ('int',), 'return_type': 'int'},
 'int ::foo(int a, float b)': {'input_types': ('int', 'float'),
                               'return_type': 'int'}}
```

Author: vepadulano

bindings/pyroot/cppyy/CPyCppyy/src/CPPMethod.cxx

@@ -801,6 +801,70 @@ PyObject* CPyCppyy::CPPMethod::GetSignature(bool fa)
     return CPyCppyy_PyText_FromString(GetSignatureString(fa).c_str());
 }
 
+/**
+ * @brief Returns a tuple with the names of the input parameters of this method.
+ *
+ * For example given a function with prototype:
+ *
+ * double foo(int a, float b, double c)
+ *
+ * this function returns:
+ *
+ * ('a', 'b', 'c')
+ */
+PyObject *CPyCppyy::CPPMethod::GetSignatureNames()
+{
+   // Build a tuple of the argument names for this signature.
+   int argcount = GetMaxArgs();
+   PyObject *signature_names = PyTuple_New(argcount);
+
+   for (int iarg = 0; iarg < argcount; ++iarg) {
+      const std::string &argname_cpp = Cppyy::GetMethodArgName(fMethod, iarg);
+      PyObject *argname_py = CPyCppyy_PyText_FromString(argname_cpp.c_str());
+      PyTuple_SET_ITEM(signature_names, iarg, argname_py);
+   }
+
+   return signature_names;
+}
+
+/**
+ * @brief Returns a dictionary with the types of the signature of this method.
+ *
+ * This dictionary will store both the return type and the input parameter
+ * types of this method, respectively with keys "return_type" and
+ * "input_types", for example given a function with prototype:
+ *
+ * double foo(int a, float b, double c)
+ *
+ * this function returns:
+ *
+ * {'input_types': ('int', 'float', 'double'), 'return_type': 'double'}
+ */
+PyObject *CPyCppyy::CPPMethod::GetSignatureTypes()
+{
+
+   PyObject *signature_types_dict = PyDict_New();
+
+   // Insert the return type first
+   std::string return_type = GetReturnTypeName();
+   PyObject *return_type_py = CPyCppyy_PyText_FromString(return_type.c_str());
+   PyDict_SetItem(signature_types_dict, CPyCppyy_PyText_FromString("return_type"), return_type_py);
+
+   // Build a tuple of the argument types for this signature.
+   int argcount = GetMaxArgs();
+   PyObject *parameter_types = PyTuple_New(argcount);
+
+   for (int iarg = 0; iarg < argcount; ++iarg) {
+      const std::string &argtype_cpp = Cppyy::GetMethodArgType(fMethod, iarg);
+      PyObject *argtype_py = CPyCppyy_PyText_FromString(argtype_cpp.c_str());
+      PyTuple_SET_ITEM(parameter_types, iarg, argtype_py);
+   }
+
+   PyDict_SetItem(signature_types_dict, CPyCppyy_PyText_FromString("input_types"), parameter_types);
+
+   return signature_types_dict;
+}
+
 //----------------------------------------------------------------------------
 std::string CPyCppyy::CPPMethod::GetReturnTypeName()
 {

bindings/pyroot/cppyy/CPyCppyy/src/CPPMethod.h

@@ -24,6 +24,8 @@ class CPPMethod : public PyCallable {
 
 public:
     virtual PyObject* GetSignature(bool show_formalargs = true);
+    virtual PyObject* GetSignatureNames();
+    virtual PyObject* GetSignatureTypes();
     virtual PyObject* GetPrototype(bool show_formalargs = true);
     virtual int       GetPriority();
     virtual bool IsGreedy();

bindings/pyroot/cppyy/CPyCppyy/src/CPPOverload.cxx

@@ -58,6 +58,15 @@ class TPythonCallback : public PyCallable {
     virtual PyObject* GetSignature(bool /*show_formalargs*/ = true) {
         return CPyCppyy_PyText_FromString("*args, **kwargs");
     }
+
+    virtual PyObject* GetSignatureNames() {
+        return PyTuple_New(0);
+    }
+
+    virtual PyObject* GetSignatureTypes() {
+        return PyTuple_New(0);
+    }
+
     virtual PyObject* GetPrototype(bool /*show_formalargs*/ = true) {
         return CPyCppyy_PyText_FromString("<callback>");
     }
@@ -241,6 +250,54 @@ static PyObject* mp_doc(CPPOverload* pymeth, void*)
     return doc;
 }
 
+/**
+ * @brief Returns a dictionary with the input parameter names for all overloads.
+ *
+ * This dictionary may look like:
+ *
+ * {'double ::foo(int a, float b, double c)': ('a', 'b', 'c'),
+ *  'float ::foo(float b)': ('b',),
+ *  'int ::foo(int a)': ('a',),
+ *  'int ::foo(int a, float b)': ('a', 'b')}
+ */
+static PyObject *mp_func_overloads_names(CPPOverload *pymeth)
+{
+
+   const CPPOverload::Methods_t &methods = pymeth->fMethodInfo->fMethods;
+
+   PyObject *overloads_names_dict = PyDict_New();
+
+   for (PyCallable *method : methods) {
+      PyDict_SetItem(overloads_names_dict, method->GetPrototype(), method->GetSignatureNames());
+   }
+
+   return overloads_names_dict;
+}
+
+/**
+ * @brief Returns a dictionary with the types of all overloads.
+ *
+ * This dictionary may look like:
+ *
+ * {'double ::foo(int a, float b, double c)': {'input_types': ('int', 'float', 'double'), 'return_type': 'double'},
+ *  'float ::foo(float b)': {'input_types': ('float',), 'return_type': 'float'},
+ *  'int ::foo(int a)': {'input_types': ('int',), 'return_type': 'int'},
+ *  'int ::foo(int a, float b)': {'input_types': ('int', 'float'), 'return_type': 'int'}}
+ */
+static PyObject *mp_func_overloads_types(CPPOverload *pymeth)
+{
+
+   const CPPOverload::Methods_t &methods = pymeth->fMethodInfo->fMethods;
+
+   PyObject *overloads_types_dict = PyDict_New();
+
+   for (PyCallable *method : methods) {
+      PyDict_SetItem(overloads_types_dict, method->GetPrototype(), method->GetSignatureTypes());
+   }
+
+   return overloads_types_dict;
+}
+
 //----------------------------------------------------------------------------
 static PyObject* mp_meth_func(CPPOverload* pymeth, void*)
 {
@@ -514,6 +571,8 @@ static PyGetSetDef mp_getset[] = {
     {(char*)"func_globals",  (getter)mp_func_globals,  nullptr, nullptr, nullptr},
     {(char*)"func_doc",      (getter)mp_doc,           nullptr, nullptr, nullptr},
     {(char*)"func_name",     (getter)mp_name,          nullptr, nullptr, nullptr},
+    {(char*)"func_overloads_types",    (getter)mp_func_overloads_types,    nullptr, nullptr, nullptr},
+    {(char*)"func_overloads_names",    (getter)mp_func_overloads_names,    nullptr, nullptr, nullptr},
 
     {(char*)"__creates__",         (getter)mp_getcreates, (setter)mp_setcreates,
       (char*)"For ownership rules of result: if true, objects are python-owned", nullptr},

bindings/pyroot/cppyy/CPyCppyy/src/PyCallable.h

@@ -15,6 +15,8 @@ class PyCallable {
 
 public:
     virtual PyObject* GetSignature(bool show_formalargs = true) = 0;
+    virtual PyObject* GetSignatureNames() = 0;
+    virtual PyObject* GetSignatureTypes() = 0;
     virtual PyObject* GetPrototype(bool show_formalargs = true) = 0;
     virtual PyObject* GetDocString() { return GetPrototype(); }