Reduce more template bloat

Author: tarasko

include/pybind11/attr.h

@@ -117,7 +117,7 @@ enum op_id : int;
 enum op_type : int;
 struct undefined_t;
 template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_;
-template <size_t NumArgs> void keep_alive_impl(size_t Nurse, size_t Patient, function_call_impl<NumArgs> &call, handle ret);
+void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret);
 template <typename... Args> struct process_attributes;
 
 template <typename T>
@@ -966,8 +966,8 @@ template <typename T> struct process_attribute_default {
     /// Default implementation: do nothing
     static void init(const T &, function_record *) { }
     static void init(const T &, type_record *) { }
-    template<size_t NumArgs> static void precall(function_call_impl<NumArgs> &) { }
-    template<size_t NumArgs> static void postcall(function_call_impl<NumArgs> &, handle) { }
+    static void precall(function_call &) { }
+    static void postcall(function_call &, handle) { }
 };
 
 /// Process an attribute specifying the function's name
@@ -1107,14 +1107,14 @@ struct process_attribute<call_guard<Ts...>> : process_attribute_default<call_gua
  * otherwise
  */
 template <size_t Nurse, size_t Patient> struct process_attribute<keep_alive<Nurse, Patient>> : public process_attribute_default<keep_alive<Nurse, Patient>> {
-    template <size_t NumArgs, size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
-    static void precall(function_call_impl<NumArgs> &call) { keep_alive_impl(Nurse, Patient, call, handle()); }
-    template <size_t NumArgs, size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
-    static void postcall(function_call_impl<NumArgs> &, handle) { }
-    template <size_t NumArgs, size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
-    static void precall(function_call_impl<NumArgs> &) { }
-    template <size_t NumArgs, size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
-    static void postcall(function_call_impl<NumArgs> &call, handle ret) { keep_alive_impl(Nurse, Patient, call, ret); }
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
+    static void precall(function_call &call) { keep_alive_impl(Nurse, Patient, call, handle()); }
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
+    static void postcall(function_call &, handle) { }
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
+    static void precall(function_call &) { }
+    template <size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
+    static void postcall(function_call &call, handle ret) { keep_alive_impl(Nurse, Patient, call, ret); }
 };
 
 /// Recursively iterate over variadic template arguments
@@ -1127,13 +1127,11 @@ template <typename... Args> struct process_attributes {
         int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
         ignore_unused(unused);
     }
-    template<size_t NumArgs>
-    static void precall(function_call_impl<NumArgs> &call) {
+    static void precall(function_call &call) {
         int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::precall(call), 0) ... };
         ignore_unused(unused);
     }
-    template<size_t NumArgs>
-    static void postcall(function_call_impl<NumArgs> &call, handle fn_ret) {
+    static void postcall(function_call &call, handle fn_ret) {
         int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::postcall(call, fn_ret), 0) ... };
         ignore_unused(unused);
     }

include/pybind11/cast.h

@@ -1884,10 +1884,12 @@ NAMESPACE_BEGIN(detail)
 
 struct function_call
 {
-    function_call(handle p) : parent(p) {}
+    function_call(handle p, size_t n) : parent(p), num_args(n) {}
 
     virtual ~function_call() {}
     virtual void set_arg(size_t idx, handle h, bool convert) = 0;
+    virtual handle arg_at(size_t idx) const = 0;
+    virtual bool arg_convert_at(size_t idx) const = 0;
 
 public:
     /// Extra references for the optional `py::args` and/or `py::kwargs` arguments (which, if
@@ -1899,19 +1901,32 @@ struct function_call
 
     /// If this is a call to an initializer, this argument contains `self`
     handle init_self;
+
+    /// Number of arguments
+    size_t num_args;
 };
 
 /// Internal data associated with a single function call
 template<size_t NumArgs>
 struct function_call_impl : function_call {
-    using function_call::function_call;
+    function_call_impl(handle p) : function_call(p, NumArgs)  {}
 
-    PYBIND11_NOINLINE void set_arg(size_t idx, handle h, bool convert) override
+    void set_arg(size_t idx, handle h, bool convert) override
     {
         args[idx] = h;
         args_convert.set(idx, convert);
     }
 
+    handle arg_at(size_t idx) const override
+    {
+        return args[idx];
+    }
+
+    bool arg_convert_at(size_t idx) const override
+    {
+        return args_convert[idx];
+    }
+
 public:
     /// Arguments passed to the function:
     std::array<handle, NumArgs> args;
@@ -1943,7 +1958,7 @@ class argument_loader {
 
     static constexpr auto arg_names = concat(type_descr(make_caster<Args>::name)...);
 
-    bool load_args(function_call_impl<num_args> &call) {
+    bool load_args(function_call &call) {
         return load_impl_sequence(call, indices{});
     }
 
@@ -1960,11 +1975,11 @@ class argument_loader {
 
 private:
 
-    static bool load_impl_sequence(function_call_impl<num_args>&, index_sequence<>) { return true; }
+    static bool load_impl_sequence(function_call&, index_sequence<>) { return true; }
 
     template <size_t... Is>
-    bool load_impl_sequence(function_call_impl<num_args>&call, index_sequence<Is...>) {
-        for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
+    bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
+        for (bool r : {std::get<Is>(argcasters).load(call.arg_at(Is), call.arg_convert_at(Is))...})
             if (!r)
                 return false;
         return true;

include/pybind11/pybind11.h

@@ -966,15 +966,14 @@ inline void keep_alive_impl(handle nurse, handle patient) {
     }
 }
 
-template<size_t NumArgs>
-PYBIND11_NOINLINE void keep_alive_impl(size_t Nurse, size_t Patient, function_call_impl<NumArgs> &call, handle ret) {
+PYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
     auto get_arg = [&](size_t n) {
         if (n == 0)
             return ret;
         else if (n == 1 && call.init_self)
             return call.init_self;
-        else if (n <= call.args.size())
-            return call.args[n - 1];
+        else if (n <= call.num_args)
+            return call.arg_at(n - 1);
         return handle();
     };