From 86b16dc61b924250524f621a17f2e41f5ab45edb Mon Sep 17 00:00:00 2001
From: ThePhD <phdofthehouse@gmail.com>
Date: Mon, 2 Dec 2013 20:12:25 -0500
Subject: [PATCH] GCC is still not compiling, complaining about detail::ltr_pop
 and not being able to find a proper overload. I'm not sure why it's
 complaining, I'll have to look in more detail soon.

---
 sol/function.hpp     | 43 +++++++++----------------------------------
 sol/lua_function.hpp |  2 +-
 sol/stack.hpp        | 12 ++++++------
 sol/table.hpp        |  1 -
 4 files changed, 16 insertions(+), 42 deletions(-)

diff --git a/sol/function.hpp b/sol/function.hpp
index da976d04..d77bf480 100644
--- a/sol/function.hpp
+++ b/sol/function.hpp
@@ -30,50 +30,25 @@ namespace sol {
 class function : virtual public reference {
 private:
 
-    template<typename... Ret>
-    struct invoker {
-        template<typename... Args>
-        static std::tuple<Ret...> call(const function& ref, Args&&... args) {
-            lua_pcall( ref.state( ), sizeof...( Args ), sizeof...( Ret ), 0 );
-            return std::make_tuple(stack::pop<Ret>(ref.state())...);
-        }
-    };
-
-    template<>
-    struct invoker<> {
-        template<typename... Args>
-        static void call(const function& ref, Args&&... args) {
-            lua_pcall( ref.state( ), sizeof...( Args ), 0, 0 );
-        }
-    };
-
-    template<typename T>
-    struct invoker<T> {
-        template<typename... Args>
-        static T call(const function& ref, Args&&... args) {
-           lua_pcall( ref.state( ), sizeof...( Args ), 1, 0 );
-           return stack::pop<T>( ref.state( ) );
-
-        }
-    };
-
     template <typename... Ret>
-    std::tuple<Ret...> invoke( types<Ret...>, std::size_t n ) {
+    std::tuple<Ret...> call( types<Ret...>, std::size_t n ) {
+        typedef typename std::decay<decltype(std::make_tuple<Ret...>)>::type maketuple_t;
+        maketuple_t m = &std::make_tuple<Ret...>;
         lua_pcall( state( ), n, sizeof...( Ret ), 0 );
-        return stack::pop_call( state( ), std::make_tuple<Ret...>, types<Ret...>() );
+        return stack::pop_call( state( ), m, types<Ret...>() );
     }
 
     template <typename Ret>
-    Ret invoke( types<Ret>, std::size_t n ) {
+    Ret call( types<Ret>, std::size_t n ) {
         lua_pcall( state( ), n, 1, 0 );
         return stack::pop<Ret>( state( ) );
     }
 
-    void invoke( types<void>, std::size_t n ) {
+    void call( types<void>, std::size_t n ) {
         lua_pcall( state( ), n, 0, 0 );
     }
 
-    void invoke( types<>, std::size_t n ) {
+    void call( types<>, std::size_t n ) {
         lua_pcall( state( ), n, 0, 0 );
     }
 
@@ -84,10 +59,10 @@ public:
     }
 
     template<typename... Ret, typename... Args>
-    auto invoke(Args&&... args) -> decltype(invoke( types<Ret...>( ), sizeof...( Args ) )) {
+    auto invoke(Args&&... args) -> decltype(call(types<Ret...>( ), sizeof...( Args ))) {
         push( );
         stack::push_args( state( ), std::forward<Args>( args )... );
-        return invoke( types<Ret...>( ), sizeof...( Args ) );
+        return call( types<Ret...>( ), sizeof...( Args ) );
     }
 };
 } // sol
diff --git a/sol/lua_function.hpp b/sol/lua_function.hpp
index f295030e..225fda71 100644
--- a/sol/lua_function.hpp
+++ b/sol/lua_function.hpp
@@ -128,7 +128,7 @@ struct explicit_lua_func<TFx, T, true> : public lua_func {
     }
 
     template<typename... Args>
-    int operator () (types<void>, types<Args...>, lua_State* L) {
+    int operator () (types<void>, types<Args...> t, lua_State* L) {
         stack::pop_call(L, fx, t);
         return 0;
     }
diff --git a/sol/stack.hpp b/sol/stack.hpp
index 9fcfb3c4..c0d262ba 100644
--- a/sol/stack.hpp
+++ b/sol/stack.hpp
@@ -160,16 +160,16 @@ inline void push(lua_State* L, indices<I...>, const T& tuplen) {
 }
 
 template<class T, class F, class... Vs>
-auto ltr_pop(T&& extra, F f, types<>, Vs&&... vs)
+auto ltr_pop(T&&, F&& f, types<>, Vs&&... vs)
     -> decltype(f(std::forward<Vs>(vs)...)) {
     return f(std::forward<Vs>(vs)...);
 }
 
 // take head, produce value from it, pass after other values
 template<class F, class Head, class... Tail, class... Vs>
-auto ltr_pop(lua_State* L, F f, types<Head, Tail...>, Vs&&... vs)
--> decltype(ltr_pop(L, f, types<Tail...>{}, std::forward<Vs>(vs)..., pop<Head>(L))) {
-    return ltr_pop(L, f, types<Tail...>{}, std::forward<Vs>(vs)..., pop<Head>(L));
+auto ltr_pop(lua_State* L, F&& f, types<Head, Tail...>, Vs&&... vs)
+-> decltype(ltr_pop(L, std::forward<F>(f), types<Tail...>(), std::forward<Vs>(vs)..., pop<Head>(L))) {
+    return ltr_pop(L, std::forward<F>(f), types<Tail...>(), std::forward<Vs>(vs)..., pop<Head>(L));
 }
 
 } // detail
@@ -180,8 +180,8 @@ inline void push(lua_State* L, const std::tuple<Args...>& tuplen) {
 }
 
 template<typename... Args, typename TFx>
-inline auto pop_call(lua_State* L, TFx&& fx, types<Args...> t)->decltype(detail::ltr_pop(L, fx, t)) {
-    return detail::ltr_pop(L, fx, t);
+inline auto pop_call( lua_State* L, TFx&& fx, types<Args...> )->decltype( detail::ltr_pop( L, std::forward<TFx>( fx ), types<Args...>() ) ) {
+    return detail::ltr_pop( L, std::forward<TFx>( fx ), types<Args...>());
 }
 
 template<typename... Args>
diff --git a/sol/table.hpp b/sol/table.hpp
index 9b9d6ab2..679a817b 100644
--- a/sol/table.hpp
+++ b/sol/table.hpp
@@ -89,7 +89,6 @@ private:
 
     template<typename T, typename TFx>
     table& set_fx(std::false_type, T&& key, TFx&& fx) {
-        typedef typename std::remove_pointer<typename std::decay<TFx>::type>::type clean_fx;
         typedef typename std::decay<TFx>::type ptr_fx;
         std::unique_ptr<detail::lua_func> sptr(new detail::explicit_lua_func<ptr_fx>(std::forward<TFx>(fx)));
         return set_fx(std::forward<T>(key), std::move(sptr));