Begin converting uses of PyCallable to PythonCallable.

PyCallable is a class that exists solely within the swig wrapper
code.  PythonCallable is a more generic implementation of the same
idea that can be used by any Python-related interop code, and lives
in PythonDataObjects.h

The CL is mostly mechanical, and it doesn't cover every possible
user of PyCallable, because I want to minimize the impact of this
change (as well as making it easier to figure out what went wrong
in case this causes a failure).  I plan to finish up the rest of
the changes in a subsequent patch, culminating in the removal of
PyCallable entirely.

llvm-svn: 252906

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

@@ -207,9 +207,23 @@ public:
     static PythonObject
     ResolveNameWithDictionary(llvm::StringRef name, PythonDictionary dict);
 
+    template<typename T>
+    static T
+    ResolveNameWithDictionary(llvm::StringRef name, PythonDictionary dict)
+    {
+        return ResolveNameWithDictionary(name, dict).AsType<T>();
+    }
+
     PythonObject
     ResolveName(llvm::StringRef name) const;
 
+    template<typename T>
+    T
+    ResolveName(llvm::StringRef name) const
+    {
+        return ResolveName(name).AsType<T>();
+    }
+
     bool
     HasAttribute(llvm::StringRef attribute) const;
 
@@ -410,6 +424,12 @@ class PythonModule : public PythonObject
 class PythonCallable : public PythonObject
 {
 public:
+    struct ArgInfo {
+        size_t count;
+        bool has_varargs : 1;
+        bool has_kwargs : 1;
+    };
+
     PythonCallable();
     PythonCallable(PyRefType type, PyObject *o);
     PythonCallable(const PythonCallable &dict);
@@ -425,14 +445,24 @@ public:
     void
     Reset(PyRefType type, PyObject *py_obj) override;
 
-    void
-    GetNumArguments(size_t &num_args, bool &has_varargs, bool &has_kwargs) const;
+    ArgInfo
+    GetNumArguments() const;
+
+    PythonObject
+    operator ()();
 
     PythonObject
     operator ()(std::initializer_list<PyObject*> args);
 
     PythonObject
     operator ()(std::initializer_list<PythonObject> args);
+
+    template<typename Arg, typename... Args>
+    PythonObject
+    operator ()(const Arg &arg, Args... args)
+    {
+        return operator()({ arg, args... });
+    }
 };