From 8ce65709225bac5922e6b2b80a912cf9796949b1 Mon Sep 17 00:00:00 2001
From: tzik <tzik@chromium.org>
Date: Thu, 5 Feb 2015 11:11:26 -0800
Subject: [PATCH] Bind: Use Variadic Templates in bind_internal.h

* Introduce TypeList as helpers.
* Drop bind_internal.h.pump and replace generated codes with Variadic Templates version.

BUG=433164

Review URL: https://codereview.chromium.org/743853002

Cr-Commit-Position: refs/heads/master@{#314847}
---
 base/bind.h                                    |  14 +-
 base/bind_helpers.h                            | 139 +++++++++++----
 base/{bind_internal.h.pump => bind_internal.h} | 228 +++++++------------------
 base/bind_unittest.nc                          |   2 +-
 4 files changed, 180 insertions(+), 203 deletions(-)
 rename base/{bind_internal.h.pump => bind_internal.h} (72%)

diff --git a/base/bind.h b/base/bind.h
index 7874656c6091..51be10dd7e65 100644
--- a/base/bind.h
+++ b/base/bind.h
@@ -52,13 +52,14 @@ base::Callback<
     typename internal::BindState<
         typename internal::FunctorTraits<Functor>::RunnableType,
         typename internal::FunctorTraits<Functor>::RunType,
-        void()>::UnboundRunType>
+        internal::TypeList<>>::UnboundRunType>
 Bind(Functor functor) {
   // Typedefs for how to store and run the functor.
   typedef typename internal::FunctorTraits<Functor>::RunnableType RunnableType;
   typedef typename internal::FunctorTraits<Functor>::RunType RunType;
 
-  typedef internal::BindState<RunnableType, RunType, void()> BindState;
+  typedef internal::BindState<RunnableType, RunType,
+                              internal::TypeList<>> BindState;
 
   return Callback<typename BindState::UnboundRunType>(
       new BindState(internal::MakeRunnable(functor)));
@@ -69,7 +70,8 @@ base::Callback<
     typename internal::BindState<
         typename internal::FunctorTraits<Functor>::RunnableType,
         typename internal::FunctorTraits<Functor>::RunType,
-        void(typename internal::CallbackParamTraits<Args>::StorageType...)>
+        internal::TypeList<
+            typename internal::CallbackParamTraits<Args>::StorageType...>>
             ::UnboundRunType>
 Bind(Functor functor, const Args&... args) {
   // Typedefs for how to store and run the functor.
@@ -101,8 +103,10 @@ Bind(Functor functor, const Args&... args) {
       !internal::HasRefCountedParamAsRawPtr<is_method, Args...>::value,
       "a_parameter_is_refcounted_type_and_needs_scoped_refptr");
 
-  typedef internal::BindState<RunnableType, RunType,
-      void(typename internal::CallbackParamTraits<Args>::StorageType...)>
+  typedef internal::BindState<
+      RunnableType, RunType,
+      internal::TypeList<
+          typename internal::CallbackParamTraits<Args>::StorageType...>>
       BindState;
 
   return Callback<typename BindState::UnboundRunType>(
diff --git a/base/bind_helpers.h b/base/bind_helpers.h
index f3efc31953c7..f8e89bd8f01e 100644
--- a/base/bind_helpers.h
+++ b/base/bind_helpers.h
@@ -435,45 +435,46 @@ struct UnwrapTraits<PassedWrapper<T> > {
 
 // Utility for handling different refcounting semantics in the Bind()
 // function.
-template <bool is_method, typename T>
-struct MaybeRefcount;
+template <bool is_method, typename... T>
+struct MaybeScopedRefPtr;
 
-template <typename T>
-struct MaybeRefcount<false, T> {
-  static void AddRef(const T&) {}
-  static void Release(const T&) {}
+template <bool is_method>
+struct MaybeScopedRefPtr<is_method> {
+  MaybeScopedRefPtr() {}
 };
 
-template <typename T, size_t n>
-struct MaybeRefcount<false, T[n]> {
-  static void AddRef(const T*) {}
-  static void Release(const T*) {}
+template <typename T, typename... Rest>
+struct MaybeScopedRefPtr<false, T, Rest...> {
+  MaybeScopedRefPtr(const T&, const Rest&...) {}
 };
 
-template <typename T>
-struct MaybeRefcount<true, T> {
-  static void AddRef(const T&) {}
-  static void Release(const T&) {}
+template <typename T, size_t n, typename... Rest>
+struct MaybeScopedRefPtr<false, T[n], Rest...> {
+  MaybeScopedRefPtr(const T*, const Rest&...) {}
 };
 
-template <typename T>
-struct MaybeRefcount<true, T*> {
-  static void AddRef(T* o) { o->AddRef(); }
-  static void Release(T* o) { o->Release(); }
+template <typename T, typename... Rest>
+struct MaybeScopedRefPtr<true, T, Rest...> {
+  MaybeScopedRefPtr(const T& o, const Rest&...) {}
+};
+
+template <typename T, typename... Rest>
+struct MaybeScopedRefPtr<true, T*, Rest...> {
+  MaybeScopedRefPtr(T* o, const Rest&...) : ref_(o) {}
+  scoped_refptr<T> ref_;
 };
 
 // No need to additionally AddRef() and Release() since we are storing a
 // scoped_refptr<> inside the storage object already.
-template <typename T>
-struct MaybeRefcount<true, scoped_refptr<T> > {
-  static void AddRef(const scoped_refptr<T>& o) {}
-  static void Release(const scoped_refptr<T>& o) {}
+template <typename T, typename... Rest>
+struct MaybeScopedRefPtr<true, scoped_refptr<T>, Rest...> {
+  MaybeScopedRefPtr(const scoped_refptr<T>&, const Rest&...) {}
 };
 
-template <typename T>
-struct MaybeRefcount<true, const T*> {
-  static void AddRef(const T* o) { o->AddRef(); }
-  static void Release(const T* o) { o->Release(); }
+template <typename T, typename... Rest>
+struct MaybeScopedRefPtr<true, const T*, Rest...> {
+  MaybeScopedRefPtr(const T* o, const Rest&...) : ref_(o) {}
+  scoped_refptr<const T> ref_;
 };
 
 // IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
@@ -481,15 +482,89 @@ struct MaybeRefcount<true, const T*> {
 // InvokeHelper that will no-op itself in the event the WeakPtr<> for
 // the target object is invalidated.
 //
-// P1 should be the type of the object that will be received of the method.
-template <bool IsMethod, typename P1>
+// The first argument should be the type of the object that will be received by
+// the method.
+template <bool IsMethod, typename... Args>
 struct IsWeakMethod : public false_type {};
 
-template <typename T>
-struct IsWeakMethod<true, WeakPtr<T> > : public true_type {};
+template <typename T, typename... Args>
+struct IsWeakMethod<true, WeakPtr<T>, Args...> : public true_type {};
 
-template <typename T>
-struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T> > > : public true_type {};
+template <typename T, typename... Args>
+struct IsWeakMethod<true, ConstRefWrapper<WeakPtr<T>>, Args...>
+    : public true_type {};
+
+
+// Packs a list of types to hold them in a single type.
+template <typename... Types>
+struct TypeList {};
+
+// Used for DropTypeListItem implementation.
+template <size_t n, typename List>
+struct DropTypeListItemImpl;
+
+// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
+template <size_t n, typename T, typename... List>
+struct DropTypeListItemImpl<n, TypeList<T, List...>>
+    : DropTypeListItemImpl<n - 1, TypeList<List...>> {};
+
+template <typename T, typename... List>
+struct DropTypeListItemImpl<0, TypeList<T, List...>> {
+  typedef TypeList<T, List...> Type;
+};
+
+template <>
+struct DropTypeListItemImpl<0, TypeList<>> {
+  typedef TypeList<> Type;
+};
+
+// A type-level function that drops |n| list item from given TypeList.
+template <size_t n, typename List>
+using DropTypeListItem = typename DropTypeListItemImpl<n, List>::Type;
+
+// Used for ConcatTypeLists implementation.
+template <typename List1, typename List2>
+struct ConcatTypeListsImpl;
+
+template <typename... Types1, typename... Types2>
+struct ConcatTypeListsImpl<TypeList<Types1...>, TypeList<Types2...>> {
+  typedef TypeList<Types1..., Types2...> Type;
+};
+
+// A type-level function that concats two TypeLists.
+template <typename List1, typename List2>
+using ConcatTypeLists = typename ConcatTypeListsImpl<List1, List2>::Type;
+
+template <size_t n, typename List>
+struct NthTypeImpl;
+
+template <size_t n, typename T, typename... Types>
+struct NthTypeImpl<n, TypeList<T, Types...>>
+    : NthTypeImpl<n - 1, TypeList<Types...>> {
+};
+
+template <typename T, typename... Types>
+struct NthTypeImpl<0, TypeList<T, Types...>> {
+  typedef T Type;
+};
+
+// A type-level function that extracts |n|th type from a TypeList.
+template <size_t n, typename List>
+using NthType = typename NthTypeImpl<n, List>::Type;
+
+// Used for MakeFunctionType implementation.
+template <typename R, typename ArgList>
+struct MakeFunctionTypeImpl;
+
+template <typename R, typename... Args>
+struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
+  typedef R(Type)(Args...);
+};
+
+// A type-level function that constructs a function type that has |R| as its
+// return type and has TypeLists items as its arguments.
+template <typename R, typename ArgList>
+using MakeFunctionType = typename MakeFunctionTypeImpl<R, ArgList>::Type;
 
 }  // namespace internal
 
diff --git a/base/bind_internal.h.pump b/base/bind_internal.h
similarity index 72%
rename from base/bind_internal.h.pump
rename to base/bind_internal.h
index 0ed3ca2eebd9..5fc14592cd3a 100644
--- a/base/bind_internal.h.pump
+++ b/base/bind_internal.h
@@ -1,14 +1,3 @@
-$$ This is a pump file for generating file templates.  Pump is a python
-$$ script that is part of the Google Test suite of utilities.  Description
-$$ can be found here:
-$$
-$$ http://code.google.com/p/googletest/wiki/PumpManual
-$$
-
-$$ See comment for MAX_ARITY in base/bind.h.pump.
-$var MAX_ARITY = 7
-$range ARITY 0..MAX_ARITY
-
 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
@@ -21,6 +10,7 @@ $range ARITY 0..MAX_ARITY
 #include "base/memory/raw_scoped_refptr_mismatch_checker.h"
 #include "base/memory/weak_ptr.h"
 #include "base/template_util.h"
+#include "base/tuple.h"
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
@@ -57,10 +47,6 @@ namespace internal {
 // Types:
 //  RunnableAdapter<> -- Wraps the various "function" pointer types into an
 //                       object that adheres to the Runnable interface.
-//  FunctionTraits<> -- Type traits that unwrap a function signature into a
-//                      a set of easier to use typedefs.  Used mainly for
-//                      compile time asserts.
-//                      There are |ARITY| FunctionTraits types.
 //  ForceVoidReturn<> -- Helper class for translating function signatures to
 //                       equivalent forms with a "void" return type.
 //  FunctorTraits<> -- Type traits used determine the correct RunType and
@@ -70,12 +56,11 @@ namespace internal {
 //                    type class that represents the underlying Functor.
 //                    There are |O(1)| MakeRunnable types.
 //  InvokeHelper<> -- Take a Runnable + arguments and actully invokes it.
-//                    Handle the differing syntaxes needed for WeakPtr<> support,
-//                    and for ignoring return values.  This is separate from
-//                    Invoker to avoid creating multiple version of Invoker<>
-//                    which grows at O(n^2) with the arity.
+//                    Handle the differing syntaxes needed for WeakPtr<>
+//                    support, and for ignoring return values.  This is separate
+//                    from Invoker to avoid creating multiple version of
+//                    Invoker<>.
 //  Invoker<> -- Unwraps the curried parameters and executes the Runnable.
-//               There are |(ARITY^2 + ARITY)/2| Invoketypes.
 //  BindState<> -- Stores the curried parameters, and is the main entry point
 //                 into the Bind() system, doing most of the type resolution.
 //                 There are ARITY BindState types.
@@ -215,29 +200,6 @@ class RunnableAdapter<R(T::*)(Args...) const> {
   R (T::*method_)(Args...) const;
 };
 
-// TODO(tzik): Remove FunctionTraits after we finish removing bind.pump.
-// FunctionTraits<>
-//
-// Breaks a function signature apart into typedefs for easier introspection.
-template <typename Sig>
-struct FunctionTraits;
-
-$for ARITY [[
-$range ARG 1..ARITY
-
-template <typename R[[]]
-$if ARITY > 0[[, ]] $for ARG , [[typename A$(ARG)]]>
-struct FunctionTraits<R($for ARG , [[A$(ARG)]])> {
-  typedef R ReturnType;
-$for ARG [[
-
-  typedef A$(ARG) A$(ARG)Type;
-]]
-
-};
-
-]]
-
 
 // ForceVoidReturn<>
 //
@@ -261,14 +223,14 @@ struct FunctorTraits {
 };
 
 template <typename T>
-struct FunctorTraits<IgnoreResultHelper<T> > {
+struct FunctorTraits<IgnoreResultHelper<T>> {
   typedef typename FunctorTraits<T>::RunnableType RunnableType;
   typedef typename ForceVoidReturn<
       typename RunnableType::RunType>::RunType RunType;
 };
 
 template <typename T>
-struct FunctorTraits<Callback<T> > {
+struct FunctorTraits<Callback<T>> {
   typedef Callback<T> RunnableType;
   typedef typename Callback<T>::RunType RunType;
 };
@@ -290,7 +252,7 @@ MakeRunnable(const IgnoreResultHelper<T>& t) {
 }
 
 template <typename T>
-const typename FunctorTraits<Callback<T> >::RunnableType&
+const typename FunctorTraits<Callback<T>>::RunnableType&
 MakeRunnable(const Callback<T>& t) {
   DCHECK(!t.is_null());
   return t;
@@ -319,22 +281,21 @@ template <bool IsWeakCall, typename ReturnType, typename Runnable,
 struct InvokeHelper;
 
 template <typename ReturnType, typename Runnable, typename... Args>
-struct InvokeHelper<false, ReturnType, Runnable,
-    void(Args...)>  {
+struct InvokeHelper<false, ReturnType, Runnable, TypeList<Args...>> {
   static ReturnType MakeItSo(Runnable runnable, Args... args) {
     return runnable.Run(CallbackForward(args)...);
   }
 };
 
 template <typename Runnable, typename... Args>
-struct InvokeHelper<false, void, Runnable, void(Args...)>  {
+struct InvokeHelper<false, void, Runnable, TypeList<Args...>> {
   static void MakeItSo(Runnable runnable, Args... args) {
     runnable.Run(CallbackForward(args)...);
   }
 };
 
 template <typename Runnable, typename BoundWeakPtr, typename... Args>
-struct InvokeHelper<true, void, Runnable, void(BoundWeakPtr, Args...)>  {
+struct InvokeHelper<true, void, Runnable, TypeList<BoundWeakPtr, Args...>> {
   static void MakeItSo(Runnable runnable, BoundWeakPtr weak_ptr, Args... args) {
     if (!weak_ptr.get()) {
       return;
@@ -359,77 +320,33 @@ struct InvokeHelper<true, ReturnType, Runnable, ArgsType> {
 // Invoker<>
 //
 // See description at the top of the file.
-template <int NumBound, typename Storage, typename RunType>
+template <typename BoundIndices,
+          typename StorageType, typename Unwrappers,
+          typename InvokeHelperType, typename UnboundForwardRunType>
 struct Invoker;
 
-$for ARITY [[
-
-$$ Number of bound arguments.
-$range BOUND 0..ARITY
-$for BOUND [[
-
-$var UNBOUND = ARITY - BOUND
-$range ARG 1..ARITY
-$range BOUND_ARG 1..BOUND
-$range UNBOUND_ARG (ARITY - UNBOUND + 1)..ARITY
-
-// Arity $(ARITY) -> $(UNBOUND).
-template <typename StorageType, typename R[[]]
-$if ARITY > 0 [[,]][[]]
-$for ARG , [[typename X$(ARG)]]>
-struct Invoker<$(BOUND), StorageType, R($for ARG , [[X$(ARG)]])> {
-  typedef R(RunType)(BindStateBase*[[]]
-$if UNBOUND != 0 [[, ]]
-$for UNBOUND_ARG , [[typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType]]);
-
-  typedef R(UnboundRunType)($for UNBOUND_ARG , [[X$(UNBOUND_ARG)]]);
-
-  static R Run(BindStateBase* base[[]]
-$if UNBOUND != 0 [[, ]][[]]
-$for UNBOUND_ARG , [[
-typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
-]][[]]
-) {
+template <size_t... bound_indices,
+          typename StorageType,
+          typename... Unwrappers,
+          typename InvokeHelperType,
+          typename R,
+          typename... UnboundForwardArgs>
+struct Invoker<IndexSequence<bound_indices...>,
+               StorageType, TypeList<Unwrappers...>,
+               InvokeHelperType, R(UnboundForwardArgs...)> {
+  static R Run(BindStateBase* base,
+               UnboundForwardArgs... unbound_args) {
     StorageType* storage = static_cast<StorageType*>(base);
-
     // Local references to make debugger stepping easier. If in a debugger,
     // you really want to warp ahead and step through the
     // InvokeHelper<>::MakeItSo() call below.
-$for BOUND_ARG
-[[
-
-    typedef typename StorageType::Bound$(BOUND_ARG)UnwrapTraits Bound$(BOUND_ARG)UnwrapTraits;
-]]
-
-
-$for BOUND_ARG
-[[
-
-    typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType x$(BOUND_ARG) =
-        Bound$(BOUND_ARG)UnwrapTraits::Unwrap(storage->p$(BOUND_ARG)_);
-]]
-
-    return InvokeHelper<StorageType::IsWeakCall::value, R,
-           typename StorageType::RunnableType,
-           void(
-$for BOUND_ARG , [[
-typename Bound$(BOUND_ARG)UnwrapTraits::ForwardType
-]]
-
-$if UNBOUND > 0 [[$if BOUND > 0 [[, ]]]][[]]
-
-$for UNBOUND_ARG , [[
-typename CallbackParamTraits<X$(UNBOUND_ARG)>::ForwardType x$(UNBOUND_ARG)
-]]
-)>
-               ::MakeItSo(storage->runnable_
-$if ARITY > 0[[, ]] $for ARG , [[CallbackForward(x$(ARG))]]);
+    return InvokeHelperType::MakeItSo(
+        storage->runnable_,
+        Unwrappers::Unwrap(get<bound_indices>(storage->bound_args_))...,
+        CallbackForward(unbound_args)...);
   }
 };
 
-]] $$ for BOUND
-]] $$ for ARITY
-
 
 // BindState<>
 //
@@ -443,73 +360,54 @@ $if ARITY > 0[[, ]] $for ARG , [[CallbackForward(x$(ARG))]]);
 //
 // BoundArgsType contains the storage type for all the bound arguments by
 // (ab)using a function type.
-template <typename Runnable, typename RunType, typename BoundArgsType>
+template <typename Runnable, typename RunType, typename BoundArgList>
 struct BindState;
 
-$for ARITY [[
-$range ARG 1..ARITY
-
-template <typename Runnable, typename RunType[[]]
-$if ARITY > 0[[, ]] $for ARG , [[typename P$(ARG)]]>
-struct BindState<Runnable, RunType, void($for ARG , [[P$(ARG)]])> : public BindStateBase {
-  typedef Runnable RunnableType;
-
-$if ARITY > 0 [[
-  typedef IsWeakMethod<HasIsMethodTag<Runnable>::value, P1> IsWeakCall;
-]] $else [[
-  typedef false_type IsWeakCall;
-]]
-
-  typedef Invoker<$(ARITY), BindState, RunType> InvokerType;
-  typedef typename InvokerType::UnboundRunType UnboundRunType;
-
-$if ARITY > 0 [[
-
-  // Convenience typedefs for bound argument types.
-
-$for ARG [[
-  typedef UnwrapTraits<P$(ARG)> Bound$(ARG)UnwrapTraits;
-
-]]  $$ for ARG
+template <typename Runnable,
+          typename R, typename... Args,
+          typename... BoundArgs>
+struct BindState<Runnable, R(Args...), TypeList<BoundArgs...>>
+    : public BindStateBase {
+ private:
+  using StorageType = BindState<Runnable, R(Args...), TypeList<BoundArgs...>>;
+  using RunnableType = Runnable;
 
+  // true_type if Runnable is a method invocation and the first bound argument
+  // is a WeakPtr.
+  using IsWeakCall =
+      IsWeakMethod<HasIsMethodTag<Runnable>::value, BoundArgs...>;
 
-]]  $$ if ARITY > 0
+  using BoundIndices = MakeIndexSequence<sizeof...(BoundArgs)>;
+  using Unwrappers = TypeList<UnwrapTraits<BoundArgs>...>;
+  using UnboundForwardArgs = DropTypeListItem<
+      sizeof...(BoundArgs),
+      TypeList<typename CallbackParamTraits<Args>::ForwardType...>>;
+  using UnboundForwardRunType = MakeFunctionType<R, UnboundForwardArgs>;
 
-$$ The extra [[ ]] is needed to massage spacing. Silly pump.py.
-[[  ]]$if ARITY == 0 [[explicit ]]BindState(const Runnable& runnable
-$if ARITY > 0 [[, ]] $for ARG , [[const P$(ARG)& p$(ARG)]])
-      : runnable_(runnable)[[]]
-$if ARITY == 0 [[
- {
+  using InvokeHelperArgs = ConcatTypeLists<
+      TypeList<typename UnwrapTraits<BoundArgs>::ForwardType...>,
+      UnboundForwardArgs>;
+  using InvokeHelperType =
+      InvokeHelper<IsWeakCall::value, R, Runnable, InvokeHelperArgs>;
 
-]] $else [[
-, $for ARG , [[
+  using UnboundArgs = DropTypeListItem<sizeof...(BoundArgs), TypeList<Args...>>;
 
-        p$(ARG)_(p$(ARG))
-]] {
-    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::AddRef(p1_);
+ public:
+  using InvokerType = Invoker<BoundIndices, StorageType, Unwrappers,
+                              InvokeHelperType, UnboundForwardRunType>;
+  using UnboundRunType = MakeFunctionType<R, UnboundArgs>;
 
-]]
-  }
+  BindState(const Runnable& runnable, const BoundArgs&... bound_args)
+      : runnable_(runnable), ref_(bound_args...), bound_args_(bound_args...) {}
 
   RunnableType runnable_;
-
-$for ARG [[
-  P$(ARG) p$(ARG)_;
-
-]]
+  MaybeScopedRefPtr<HasIsMethodTag<Runnable>::value, BoundArgs...> ref_;
+  Tuple<BoundArgs...> bound_args_;
 
  private:
-  ~BindState() override {
-$if ARITY > 0 [[
-    MaybeRefcount<HasIsMethodTag<Runnable>::value, P1>::Release(p1_);
-]]
-  }
-
+  ~BindState() override {}
 };
 
-]] $$ for ARITY
-
 }  // namespace internal
 }  // namespace base
 
diff --git a/base/bind_unittest.nc b/base/bind_unittest.nc
index 33b5f5c858e6..259638673a91 100644
--- a/base/bind_unittest.nc
+++ b/base/bind_unittest.nc
@@ -190,7 +190,7 @@ void WontCompile() {
   weak_ptr_with_non_void_return_type.Run();
 }
 
-#elif defined(NCTEST_DISALLOW_ASSIGN_DIFFERENT_TYPES)  // [r"fatal error: no viable conversion from 'Callback<typename internal::BindState<typename internal::FunctorTraits<void \(\*\)\(int\)>::RunnableType, typename internal::FunctorTraits<void \(\*\)\(int\)>::RunType, void \(\)>::UnboundRunType>' to 'Callback<void \(\)>'"]
+#elif defined(NCTEST_DISALLOW_ASSIGN_DIFFERENT_TYPES)  // [r"fatal error: no viable conversion from 'Callback<typename internal::BindState<typename internal::FunctorTraits<void \(\*\)\(int\)>::RunnableType, typename internal::FunctorTraits<void \(\*\)\(int\)>::RunType, internal::TypeList<> >::UnboundRunType>' to 'Callback<void \(\)>'"]
 
 // Bind result cannot be assigned to Callbacks with a mismatching type.
 void WontCompile() {
-- 
2.11.4.GIT