stack implementation, plus reference semantics within lua for usertypes/data now.

I hate my life.
I hate the projects I'm working on.
Closes #53
Closes #56
Closes #52

sol/function.hpp

@@ -32,22 +32,23 @@
 #include <memory>
 
 namespace sol {
-class function : public reference {
+template <typename base_t>
+class basic_function : public base_t {
 private:
     void luacall( std::ptrdiff_t argcount, std::ptrdiff_t resultcount ) const {
-        lua_callk( lua_state( ), static_cast<int>( argcount ), static_cast<int>( resultcount ), 0, nullptr );
+        lua_callk( base_t::lua_state( ), static_cast<int>( argcount ), static_cast<int>( resultcount ), 0, nullptr );
     }
 
     template<std::size_t... I, typename... Ret>
     auto invoke( types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n ) const {
         luacall( n, sizeof...( Ret ) );
-        return stack::pop<std::tuple<Ret...>>( lua_state( ) );
+        return stack::pop<std::tuple<Ret...>>( base_t::lua_state( ) );
     }
 
     template<std::size_t I, typename Ret>
     Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n ) const {
         luacall( n, 1 );
-        return stack::pop<Ret>( lua_state( ) );
+        return stack::pop<Ret>( base_t::lua_state( ) );
     }
 
     template <std::size_t I>
@@ -56,21 +57,21 @@ private:
     }
 
     function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n ) const {
-        int stacksize = lua_gettop( lua_state( ) );
+        int stacksize = lua_gettop( base_t::lua_state( ) );
         int firstreturn = std::max( 1, stacksize - static_cast<int>( n ) );
         luacall(n, LUA_MULTRET);
-        int poststacksize = lua_gettop( lua_state( ) );
+        int poststacksize = lua_gettop( base_t::lua_state( ) );
         int returncount = poststacksize - (firstreturn - 1);
-        return function_result( lua_state( ), firstreturn, returncount );
+        return function_result( base_t::lua_state( ), firstreturn, returncount );
     }
 
 public:
-    function() = default;
+    basic_function() = default;
-    function(const function&) = default;
+    basic_function(const basic_function&) = default;
-    function& operator=(const function&) = default;
+    basic_function& operator=(const basic_function&) = default;
-    function( function&& ) = default;
+    basic_function(basic_function&& ) = default;
-    function& operator=( function&& ) = default;
+    basic_function& operator=(basic_function&& ) = default;
-    function(lua_State* L, int index = -1): reference(L, index) {
+    basic_function(lua_State* L, int index = -1): base_t(L, index) {
 #ifdef SOL_CHECK_ARGUMENTS
         type_assert(L, index, type::function);
 #endif // Safety
@@ -88,8 +89,8 @@ public:
 
     template<typename... Ret, typename... Args>
     decltype(auto) call( Args&&... args ) const {
-        push( );
+        base_t::push( );
-        int pushcount = stack::multi_push( lua_state( ), std::forward<Args>( args )... );
+        int pushcount = stack::multi_push( base_t::lua_state( ), std::forward<Args>( args )... );
         return invoke( types<Ret...>( ), std::make_index_sequence<sizeof...(Ret)>(), pushcount );
     }
 };

sol/function_types.hpp

@@ -103,7 +103,7 @@ struct pusher<function_sig<Sigs...>> {
 
     template <typename Fx, typename T, typename... Args>
     static void select_member_variable(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-        typedef meta::Bool<meta::is_specialization_of<meta::Unqualified<T>, std::reference_wrapper>::value || std::is_pointer<T>::value> is_reference;
+        typedef meta::Bool<meta::is_specialization_of<std::reference_wrapper, meta::Unqualified<T>>::value || std::is_pointer<T>::value> is_reference;
         select_reference_member_variable(is_reference(), L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
     }
 
@@ -141,7 +141,7 @@ struct pusher<function_sig<Sigs...>> {
 
     template <typename Fx, typename T, typename... Args>
     static void select_member_function(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-        typedef meta::Bool<meta::is_specialization_of<meta::Unqualified<T>, std::reference_wrapper>::value || std::is_pointer<T>::value> is_reference;
+        typedef meta::Bool<meta::is_specialization_of<std::reference_wrapper, meta::Unqualified<T>>::value || std::is_pointer<T>::value> is_reference;
         select_reference_member_function(is_reference(), L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
     }
 

sol/function_types_allocator.hpp

@@ -45,7 +45,7 @@ struct constructor_match {
     template <typename Fx, std::size_t I, typename... R, typename... Args>
     int operator()(types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
         default_construct func{};
-        return stack::call_into_lua<0, false>(r, a, func, L, start, obj);
+        return stack::call_into_lua<0, false>(r, a, L, start, func, obj);
     }
 };
 } // detail
@@ -115,7 +115,7 @@ struct usertype_constructor_function : base_function {
         userdataref.pop();
 
         auto& func = std::get<I>(overloads);
-        stack::call_into_lua<false>(r, a, func, L, start, function_detail::implicit_wrapper<T>(obj));
+        stack::call_into_lua<false>(r, a, L, start, func, function_detail::implicit_wrapper<T>(obj));
 
         userdataref.push();
         luaL_getmetatable(L, &meta[0]);

sol/function_types_basic.hpp

@@ -34,7 +34,7 @@ struct upvalue_free_function {
     static int real_call(lua_State* L) {
         auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
         function_type* fx = udata.first;
-        int r = stack::call_into_lua(meta::tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), fx, L, 1);
+        int r = stack::call_into_lua(meta::tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), L, 1, fx);
         return r;
     }
 
@@ -65,7 +65,7 @@ struct upvalue_member_function {
         auto fx = [&item, &memfx](auto&&... args) -> typename traits_type::return_type { 
             return (item.*memfx)(std::forward<decltype(args)>(args)...);
         };
-        return stack::call_into_lua(meta::tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), fx, L, 1);
+        return stack::call_into_lua(meta::tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), L, 1, fx);
     }
 
     static int call (lua_State* L) {
@@ -124,11 +124,11 @@ struct upvalue_this_member_function {
         // idx 1...n: verbatim data of member variable pointer
         auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L, 1);
         function_type& memfx = memberdata.first;
-        auto fx = [&memfx](lua_State* L, auto&&... args) -> typename traits_type::return_type { 
+        auto fx = [&L, &memfx](auto&&... args) -> typename traits_type::return_type { 
             auto& item = stack::get<T>(L, 1);
             return (item.*memfx)(std::forward<decltype(args)>(args)...);
         };
-        int n = stack::call_into_lua<1>(meta::tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), fx, L, 2, L);
+        int n = stack::call_into_lua<1>(meta::tuple_types<typename traits_type::return_type>(), typename traits_type::args_type(), L, 2, fx);
         return n;
     }
 

sol/function_types_core.hpp

@@ -97,19 +97,19 @@ struct functor<T, Func, std::enable_if_t<std::is_member_object_pointer<Func>::va
     }
 
     template<typename Arg>
-    void call(types<return_type>, Arg&& arg) {
+    void call(Arg&& arg) {
         T& member = *item;
         (member.*invocation) = std::forward<Arg>(arg);
     }
 
-    return_type call(types<return_type>) {
+    return_type& call() {
          T& member = *item;
          return (member.*invocation);
     }
 
     template<typename... Args>
-    auto operator()(Args&&... args) -> decltype(std::declval<functor>().call(types<return_type>{}, std::forward<Args>(args)...)) {
+    decltype(auto) operator()(Args&&... args) {
-        return this->call(types<return_type>{}, std::forward<Args>(args)...);
+        return this->call(std::forward<Args>(args)...);
     }
 };
 

sol/function_types_member.hpp

@@ -38,7 +38,7 @@ struct functor_function : public base_function {
     functor_function(Args&&... args): fx(std::forward<Args>(args)...) {}
 
     int call(lua_State* L) {
-        return stack::call_into_lua(meta::tuple_types<return_type>(), args_types(), fx, L, 1);
+        return stack::call_into_lua(meta::tuple_types<return_type>(), args_types(), L, 1, fx);
     }
 
     virtual int operator()(lua_State* L) override {
@@ -70,7 +70,7 @@ struct member_function : public base_function {
     member_function(F&& f, Args&&... args) : fx(std::forward<F>(f), std::forward<Args>(args)...) {}
 
     int call(lua_State* L) {
-        return stack::call_into_lua(meta::tuple_types<return_type>(), args_types(), fx, L, 1);
+        return stack::call_into_lua(meta::tuple_types<return_type>(), args_types(), L, 1, fx);
     }
 
     virtual int operator()(lua_State* L) override {
@@ -86,21 +86,39 @@ struct member_variable : public base_function {
     typedef typename meta::bind_traits<function_type>::args_type args_types;
     function_type var;
     T member;
+    typedef std::add_lvalue_reference_t<meta::Unwrapped<std::remove_reference_t<decltype(detail::deref(member))>>> M;
 
-    template<typename Fx, typename... Args>
+    template<typename V, typename... Args>
-    member_variable(Fx&& fx, Args&&... args): var(std::forward<Fx>(fx)), member(std::forward<Args>(args)...) {}
+    member_variable(V&& v, Args&&... args): var(std::forward<V>(v)), member(std::forward<Args>(args)...) {}
 
-    int call(lua_State* L) {
+    int set_assignable(std::false_type, lua_State* L, M) {
-        auto& mem = detail::unwrap(detail::deref(member));
+        lua_pop(L, 1);
-        switch (lua_gettop(L)) {
+        return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
-        case 0: {
-            stack::push(L, (mem.*var));
-            return 1; 
     }
-        case 1:
+
+    int set_assignable(std::true_type, lua_State* L, M mem) {
         (mem.*var) = stack::get<return_type>(L, 1);
         lua_pop(L, 1);
         return 0;
+    }
+
+    int set_variable(std::true_type, lua_State* L, M mem) {
+        return set_assignable(std::is_assignable<std::add_lvalue_reference_t<return_type>, return_type>(), L, mem);
+    }
+
+    int set_variable(std::false_type, lua_State* L, M) {
+        lua_pop(L, 1);
+        return luaL_error(L, "cannot write to a const variable");
+    }
+
+    int call(lua_State* L) {
+        M mem = detail::unwrap(detail::deref(member));
+        switch (lua_gettop(L)) {
+        case 0:
+            stack::push(L, (mem.*var));
+            return 1;
+        case 1:
+            return set_variable(meta::Not<std::is_const<return_type>>(), L, mem);
         default:
             return luaL_error(L, "sol: incorrect number of arguments to member variable function");
         }

sol/function_types_overload.hpp

@@ -92,7 +92,7 @@ struct overloaded_function : base_function {
     template <typename Fx, std::size_t I, typename... R, typename... Args>
     int call(types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) {
         auto& func = std::get<I>(overloads);
-        return stack::call_into_lua<0, false>(r, a, func, L, start);
+        return stack::call_into_lua<0, false>(r, a, L, start, func);
     }
 
     virtual int operator()(lua_State* L) override {
@@ -113,7 +113,7 @@ struct usertype_overloaded_function : base_function {
     int call(types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) {
         auto& func = std::get<I>(overloads);
         func.item = detail::ptr(stack::get<T>(L, 1));
-        return stack::call_into_lua<0, false>(r, a, func, L, start);
+        return stack::call_into_lua<0, false>(r, a, L, start, func);
     }
 
     virtual int operator()(lua_State* L) override {

sol/function_types_templated.hpp

@@ -34,6 +34,30 @@ namespace function_detail {
         return stack::call_into_lua(return_type(), args_type(), fx, L, 1);
     }
 
+    template <typename R, typename V, V, typename T>
+    inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
+        lua_pop(L, 2);
+        return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+    }
+
+    template <typename R, typename V, V variable, typename T>
+    inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
+        (mem.*variable) = stack::get<R>(L, 2);
+        lua_pop(L, 2);
+        return 0;
+    }
+
+    template <typename R, typename V, V, typename T>
+    inline int call_set_variable(std::false_type, lua_State* L, T&&) {
+        lua_pop(L, 2);
+        return luaL_error(L, "cannot write to a const variable");
+    }
+
+    template <typename R, typename V, V variable, typename T>
+    inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
+        return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
+    }
+
     template <typename V, V variable>
     inline int call_wrapper_variable(std::true_type, lua_State* L) {
         typedef meta::bind_traits<meta::Unqualified<V>> traits_type;
@@ -41,14 +65,13 @@ namespace function_detail {
         typedef typename traits_type::return_type R;
         auto& mem = stack::get<T>(L, 1);
         switch (lua_gettop(L)) {
-        case 1:
+        case 1: {
+            decltype(auto) r = (mem.*variable);
             lua_pop(L, 1);
-            stack::push(L, (mem.*variable));
+            stack::push_reference(L, std::forward<decltype(r)>(r));
-            return 1;
+            return 1; }
         case 2:
-            (mem.*variable) = stack::get<R>(L, 2);
+            return call_set_variable<R, V, variable>(meta::Not<std::is_const<R>>(), L, mem);
-            lua_pop(L, 2);
-            return 0;
         default:
             return luaL_error(L, "incorrect number of arguments to member variable function call");
         }
@@ -70,7 +93,7 @@ namespace function_detail {
             auto& member = stack::get<T>(L, 1);
             return (member.*fx)(std::forward<decltype(args)>(args)...);
         };
-        int n = stack::call_into_lua<1>(return_type_list(), args_type(), mfx, L, 2);
+        int n = stack::call_into_lua<1>(return_type_list(), args_type(), L, 2, mfx);
         return n;
     }
 

sol/function_types_usertype.hpp

@@ -55,17 +55,17 @@ struct usertype_function_core : public base_function {
             // without allocating an extra userdata, apparently!
             return 1;
         }
-        return stack::push(L, std::forward<Return>(r));
+        return stack::push_reference(L, std::forward<Return>(r));
     }
 
     template<typename Return, typename Raw = meta::Unqualified<Return>>
     std::enable_if_t<!std::is_same<T, Raw>::value, int> push(lua_State* L, Return&& r) {
-        return stack::push(L, std::forward<Return>(r));
+        return stack::push_reference(L, std::forward<Return>(r));
     }
 
     template<typename... Args, std::size_t Start>
     int operator()(types<void> tr, types<Args...> ta, Index<Start>, lua_State* L) {
-        stack::call(tr, ta, L, static_cast<int>(Start), fx);
+        stack::call_into_lua(tr, ta, L, static_cast<int>(Start), fx);
         int nargs = static_cast<int>(sizeof...(Args));
         lua_pop(L, nargs);
         return 0;
@@ -113,6 +113,24 @@ struct usertype_variable_function : public usertype_function_core<Function, Tp>
     template<typename... Args>
     usertype_variable_function(Args&&... args): base_t(std::forward<Args>(args)...) {}
 
+    int set_assignable(std::false_type, lua_State* L) {
+        lua_pop(L, 2);
+        return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+    }
+
+    int set_assignable(std::true_type, lua_State* L) {
+        return static_cast<base_t&>(*this)(meta::tuple_types<void>(), args_type(), Index<3>(), L);
+    }
+
+    int set_variable(std::false_type, lua_State* L) {
+        lua_pop(L, 2);
+        return luaL_error(L, "cannot write to a const variable");
+    }
+
+    int set_variable(std::true_type, lua_State* L) {
+        return set_assignable(std::is_assignable<std::add_lvalue_reference_t<return_type>, return_type>(), L);
+    }
+
     int prelude(lua_State* L) {
         int argcount = lua_gettop(L);
         this->fx.item = stack::get<T*>(L, 1);
@@ -120,7 +138,7 @@ struct usertype_variable_function : public usertype_function_core<Function, Tp>
         case 2:
             return static_cast<base_t&>(*this)(meta::tuple_types<return_type>(), types<>(), Index<2>(), L);
         case 3:
-            return static_cast<base_t&>(*this)(meta::tuple_types<void>(), args_type(), Index<3>(), L);
+            return set_variable(meta::Not<std::is_const<return_type>>(), L);
         default:
             return luaL_error(L, "sol: cannot get/set userdata member variable with inappropriate number of arguments");
         }

sol/object.hpp

@@ -27,23 +27,46 @@
 #include "stack.hpp"
 
 namespace sol {
-class object : public reference {
+template <typename base_t>
-public:
+class basic_object : public base_t {
-    using reference::reference;
+private:
+    template<typename T>
+    decltype(auto) as_stack(std::true_type) const {
+        return stack::get<T>(lua_state(), base_t::stack_index());
+    }
 
     template<typename T>
-    decltype(auto) as() const {
+    decltype(auto) as_stack(std::false_type) const {
-        push();
+        base_t::push();
         return stack::pop<T>(lua_state());
     }
 
     template<typename T>
-    bool is() const {
+    bool is_stack(std::true_type) const {
-        if (!valid())
+        return stack::check<T>(lua_state(), base_t::stack_index(), no_panic);
-            return false;
+    }
+
+    template<typename T>
+    bool is_stack(std::false_type) const {
         auto pp = stack::push_pop(*this);
         return stack::check<T>(lua_state(), -1, no_panic);
     }
+
+public:
+    using base_t::base_t;
+    using base_t::lua_state;
+
+    template<typename T>
+    decltype(auto) as() const {
+        return as_stack<T>( std::is_same<base_t, stack_reference>() );
+    }
+
+    template<typename T>
+    bool is() const {
+        if (!base_t::valid())
+            return false;
+        return is_stack<T>(std::is_same<base_t, stack_reference>());
+    }
 };
 
 inline bool operator==(const object& lhs, const nil_t&) {

sol/protected_function.hpp

@@ -28,7 +28,8 @@
 #include <cstdint>
 
 namespace sol {
-class protected_function : public reference {
+template <typename base_t>
+class basic_protected_function : public base_t {
 private:
     static reference& handler_storage() {
         static sol::reference h;
@@ -62,19 +63,19 @@ private:
     };
 
     int luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount, handler& h) const {
-        return lua_pcallk(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), h.stackindex, 0, nullptr);
+        return lua_pcallk(base_t::lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), h.stackindex, 0, nullptr);
     }
 
     template<std::size_t... I, typename... Ret>
     auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, handler& h) const {
         luacall(n, sizeof...(Ret), h);
-        return stack::pop<std::tuple<Ret...>>(lua_state());
+        return stack::pop<std::tuple<Ret...>>(base_t::lua_state());
     }
 
     template<std::size_t I, typename Ret>
     Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, handler& h) const {
         luacall(n, 1, h);
-        return stack::pop<Ret>(lua_state());
+        return stack::pop<Ret>(base_t::lua_state());
     }
 
     template <std::size_t I>
@@ -83,7 +84,7 @@ private:
     }
 
     protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, handler& h) const {
-        int stacksize = lua_gettop(lua_state());
+        int stacksize = lua_gettop(base_t::lua_state());
         int firstreturn = std::max(1, stacksize - static_cast<int>(n) - 1);
         int returncount = 0;
         call_status code = call_status::ok;
@@ -92,49 +93,49 @@ private:
             h.stackindex = 0;
             if (h.target.valid()) {
                 h.target.push();
-                stack::push(lua_state(), error);
+                stack::push(base_t::lua_state(), error);
-                lua_call(lua_state(), 1, 1);
+                lua_call(base_t::lua_state(), 1, 1);
             }
             else {
-                stack::push(lua_state(), error);
+                stack::push(base_t::lua_state(), error);
             }
         };
         try {
 #endif // No Exceptions
             code = static_cast<call_status>(luacall(n, LUA_MULTRET, h));
-            int poststacksize = lua_gettop(lua_state());
+            int poststacksize = lua_gettop(base_t::lua_state());
             returncount = poststacksize - (stacksize - 1);
 #ifndef SOL_NO_EXCEPTIONS
         }
         // Handle C++ errors thrown from C++ functions bound inside of lua
         catch (const char* error) {
             onexcept(error);
-            firstreturn = lua_gettop(lua_state());
+            firstreturn = lua_gettop(base_t::lua_state());
-            return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+            return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
         }
         catch (const std::exception& error) {
             onexcept(error.what());
-            firstreturn = lua_gettop(lua_state());
+            firstreturn = lua_gettop(base_t::lua_state());
-            return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+            return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
         }
         catch (...) {
             onexcept("caught (...) unknown error during protected_function call");
-            firstreturn = lua_gettop(lua_state());
+            firstreturn = lua_gettop(base_t::lua_state());
-            return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+            return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
         }
 #endif // No Exceptions
-        return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
+        return protected_function_result(base_t::lua_state(), firstreturn, returncount, returncount, code);
     }
 
 public:
     reference error_handler;
 
-    protected_function() = default;
+    basic_protected_function() = default;
-    protected_function(const protected_function&) = default;
+    basic_protected_function(const basic_protected_function&) = default;
-    protected_function& operator=(const protected_function&) = default;
+    basic_protected_function& operator=(const basic_protected_function&) = default;
-    protected_function( protected_function&& ) = default;
+    basic_protected_function(basic_protected_function&& ) = default;
-    protected_function& operator=( protected_function&& ) = default;
+    basic_protected_function& operator=(basic_protected_function&& ) = default;
-    protected_function(lua_State* L, int index = -1): reference(L, index), error_handler(get_default_handler()) {
+    basic_protected_function(lua_State* L, int index = -1): base_t(L, index), error_handler(get_default_handler()) {
 #ifdef SOL_CHECK_ARGUMENTS
         type_assert(L, index, type::function);
 #endif // Safety
@@ -153,8 +154,8 @@ public:
     template<typename... Ret, typename... Args>
     decltype(auto) call(Args&&... args) const {
         handler h(error_handler);
-        push();
+        base_t::push();
-        int pushcount = stack::multi_push(lua_state(), std::forward<Args>(args)...);
+        int pushcount = stack::multi_push(base_t::lua_state(), std::forward<Args>(args)...);
         return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
     }
 };

sol/proxy.hpp

@@ -32,7 +32,7 @@ namespace sol {
 template<typename Table, typename Key>
 struct proxy : public proxy_base<proxy<Table, Key>> {
 private:
-    typedef meta::If<meta::is_specialization_of<Key, std::tuple>, Key, std::tuple<meta::If<std::is_array<meta::Unqualified<Key>>, Key&, meta::Unqualified<Key>>>> key_type;
+    typedef meta::If<meta::is_specialization_of<std::tuple, Key>, Key, std::tuple<meta::If<std::is_array<meta::Unqualified<Key>>, Key&, meta::Unqualified<Key>>>> key_type;
 
     template<typename T, std::size_t... I>
     decltype(auto) tuple_get(std::index_sequence<I...>) const {

sol/reference.hpp

@@ -23,6 +23,7 @@
 #define SOL_REFERENCE_HPP
 
 #include "types.hpp"
+#include "stack_reference.hpp"
 
 namespace sol {
 namespace stack {
@@ -65,9 +66,14 @@ protected:
         ref = luaL_ref(L, LUA_REGISTRYINDEX);
     }
 
+    int stack_index() const noexcept {
+        return -1;
+    }
+
 public:
     reference() noexcept = default;
-
+    reference(const stack_reference& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
+    reference(stack_reference&& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
     reference(lua_State* L, int index = -1) noexcept : L(L) {
         lua_pushvalue(L, index);
         ref = luaL_ref(L, LUA_REGISTRYINDEX);

sol/stack.hpp

@@ -68,7 +68,7 @@ inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 1) {
 }
 
 template <bool checkargs = default_check_arguments, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-inline R call(types<R>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+inline decltype(auto) call(types<R>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
     check_types<checkargs>{}.check(ta, tai, L, start, type_panic);
     return fx(std::forward<FxArgs>(args)..., stack_detail::unchecked_get<Args>(L, start + I)...);
 }
@@ -103,13 +103,13 @@ inline void remove( lua_State* L, int index, int count ) {
 }
 
 template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-inline R call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
     typedef typename types<Args...>::indices args_indices;
     return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
 }
 
 template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-inline R call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
     return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
 }
 
@@ -125,7 +125,7 @@ inline void call(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArg
 }
 
 template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-inline R call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
     return call<check_args>(tr, ta, L, static_cast<int>(lua_gettop(L) - sizeof...(Args)), std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
 }
 
@@ -135,16 +135,16 @@ inline void call_from_top(types<void> tr, types<Args...> ta, lua_State* L, Fx&&
 }
 
 template<int additionalpop = 0, bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
-inline int call_into_lua(types<void> tr, types<Args...> ta, Fx&& fx, lua_State* L, int start, FxArgs&&... fxargs) {
+inline int call_into_lua(types<void> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
-    call<check_args>(tr, ta, L, start, fx, std::forward<FxArgs>(fxargs)...);
+    call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
     int nargs = static_cast<int>(sizeof...(Args)) + additionalpop;
     lua_pop(L, nargs);
     return 0;
 }
 
 template<int additionalpop = 0, bool check_args = stack_detail::default_check_arguments, typename Ret0, typename... Ret, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<meta::Not<std::is_void<Ret0>>::value>>
-inline int call_into_lua(types<Ret0, Ret...>, types<Args...> ta, Fx&& fx, lua_State* L, int start, FxArgs&&... fxargs) {
+inline int call_into_lua(types<Ret0, Ret...>, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
-    decltype(auto) r = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, fx, std::forward<FxArgs>(fxargs)...);
+    decltype(auto) r = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
     int nargs = static_cast<int>(sizeof...(Args)) + additionalpop;
     lua_pop(L, nargs);
     return push(L, std::forward<decltype(r)>(r));

sol/stack_check.hpp

@@ -182,8 +182,7 @@ struct checker<T, type::userdata, C> {
         if (meta::Or<std::is_same<T, light_userdata_value>, std::is_same<T, userdata_value>>::value)
             return true;
         if (lua_getmetatable(L, index) == 0) {
-             handler(L, index, type::userdata, indextype);
+             return true;
-             return false;
         }
         if (stack_detail::check_metatable<U>(L))
             return true;

sol/stack_core.hpp

@@ -32,6 +32,8 @@
 
 namespace sol {
 namespace detail {
+struct as_reference_tag{};
+
 using special_destruct_func = void(*)(void*);
 
 template <typename T, typename Real>
@@ -134,6 +136,16 @@ inline int multi_push(lua_State* L, T&& t, Args&&... args) {
     return pushcount;
 }
 
+template<typename T, typename... Args>
+inline int push_reference(lua_State* L, T&& t, Args&&... args) {
+    typedef meta::And<
+        std::is_lvalue_reference<T>, 
+        meta::Not<std::is_const<T>>, 
+        meta::Not<is_lua_primitive<T>>
+    > use_reference_tag;
+    return pusher<std::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::Unqualified<T>>>{}.push(L, std::forward<T>(t), std::forward<Args>(args)...);
+}
+
 template <typename T, typename Handler>
 bool check(lua_State* L, int index, Handler&& handler) {
     typedef meta::Unqualified<T> Tu;

sol/stack_get.hpp

@@ -69,6 +69,13 @@ struct getter<T, std::enable_if_t<std::is_base_of<reference, T>::value>> {
     }
 };
 
+template<typename T>
+struct getter<T, std::enable_if_t<std::is_base_of<stack_reference, T>::value>> {
+    static T get(lua_State* L, int index = -1) {
+        return T(L, index);
+    }
+};
+
 template<>
 struct getter<stack_reference> {
     static stack_reference get(lua_State* L, int index = -1) {

sol/stack_guard.hpp

@@ -34,7 +34,7 @@ inline void stack_fail(int, int) {
 #else
     // Lol, what do you want, an error printout? :3c
     // There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
-    // hopefully someone will register their own stack_fail thing here
+    // hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
 #endif // No Exceptions
 }
 } // detail
@@ -42,16 +42,16 @@ inline void stack_fail(int, int) {
 struct stack_guard {
     lua_State* L;
     int top;
-    std::function<void(int, int)> fx;
+    std::function<void(int, int)> on_mismatch;
 
     stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {}
-    stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), fx(std::move(fx)) {}
+    stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {}
     ~stack_guard() {
         int bottom = lua_gettop(L);
         if (top == bottom) {
             return;
         }
-	   fx(top, bottom);
+        on_mismatch(top, bottom);
     }
 };
 } // sol

sol/stack_pop.hpp

@@ -55,6 +55,11 @@ struct popper<std::pair<A, B>> {
         return r;
     }
 };
+
+template <typename T>
+struct popper<T, std::enable_if_t<std::is_base_of<stack_reference, meta::Unqualified<T>>::value>> {
+    static_assert(meta::Not<std::is_base_of<stack_reference, meta::Unqualified<T>>>::value, "You cannot pop something that derives from stack_reference: it will not remain on the stack and thusly will go out of scope!");
+};
 } // stack
 } // sol
 

sol/stack_push.hpp

@@ -50,6 +50,14 @@ struct pusher {
     }
 };
 
+template <>
+struct pusher<detail::as_reference_tag> {
+    template <typename T>
+    static int push(lua_State* L, T&& obj) {
+        return stack::push(L, detail::ptr(obj));
+    }
+};
+
 template<typename T>
 struct pusher<T*> {
     static int push(lua_State* L, T* obj) {

sol/stack_reference.hpp

@@ -22,8 +22,6 @@
 #ifndef SOL_STACK_REFERENCE_HPP
 #define SOL_STACK_REFERENCE_HPP
 
-#include "reference.hpp"
-
 namespace sol {
 class stack_reference {
 private:
@@ -31,6 +29,9 @@ private:
     int index = 0;
 
 protected:
+    int registry_index () const noexcept {
+        return LUA_NOREF;
+    }
 
 public:
     stack_reference() noexcept = default;
@@ -45,6 +46,10 @@ public:
         return 1;
     }
 
+    int stack_index () const noexcept {
+        return index;
+    }
+
     type get_type() const noexcept {
         int result = lua_type(L, index);
         return static_cast<type>(result);

sol/state.hpp

@@ -25,11 +25,28 @@
 #include "state_view.hpp"
 
 namespace sol {
+inline int default_at_panic(lua_State* L) {
+#ifdef SOL_NO_EXCEPTIONS
+    (void)L;
+    return -1;
+#else
+    const char* message = lua_tostring(L, -1);
+    std::string err = message ? message : "An unexpected error occurred and forced the lua state to call atpanic";
+    throw error(err);
+#endif
+}
+
 class state : private std::unique_ptr<lua_State, void(*)(lua_State*)>, public state_view {
 private:
     typedef std::unique_ptr<lua_State, void(*)(lua_State*)> unique_base;
 public:
-    state(lua_CFunction panic = detail::atpanic) : unique_base(luaL_newstate(), lua_close),
+    state(lua_CFunction panic = default_at_panic) : unique_base(luaL_newstate(), lua_close),
+    state_view(unique_base::get()) {
+        set_panic(panic);
+        stack::luajit_exception_handler(unique_base::get());
+    }
+
+    state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr) : unique_base(lua_newstate(alfunc, alpointer), lua_close),
     state_view(unique_base::get()) {
         set_panic(panic);
         stack::luajit_exception_handler(unique_base::get());

sol/state_view.hpp

@@ -27,19 +27,6 @@
 #include <memory>
 
 namespace sol {
-namespace detail {
-inline int atpanic(lua_State* L) {
-#ifdef SOL_NO_EXCEPTIONS
-    (void)L;
-    return -1;
-#else
-    const char* message = lua_tostring(L, -1);
-    std::string err = message ? message : "An unexpected error occurred and forced the lua state to call atpanic";
-    throw error(err);
-#endif
-}
-} // detail
-
 enum class lib : char {
     base,
     package,
@@ -60,6 +47,9 @@ private:
     table reg;
     global_table global;
 public:
+    typedef typename global_table::iterator iterator;
+    typedef typename global_table::const_iterator const_iterator;
+
     state_view(lua_State* L):
     L(L),
     reg(L, LUA_REGISTRYINDEX),
@@ -152,19 +142,19 @@ public:
         }
     }
 
-    table_iterator begin () const {
+    iterator begin () const {
         return global.begin();
     }
 
-    table_iterator end() const {
+    iterator end() const {
         return global.end();
     }
 
-    table_iterator cbegin() const {
+    const_iterator cbegin() const {
         return global.cbegin();
     }
 
-    table_iterator cend() const {
+    const_iterator cend() const {
         return global.cend();
     }
 

sol/table_core.hpp

@@ -34,8 +34,9 @@ template <std::size_t n>
 struct clean { lua_State* L; clean(lua_State* L) : L(L) {} ~clean() { lua_pop(L, static_cast<int>(n)); } };
 struct ref_clean { lua_State* L; int& n; ref_clean(lua_State* L, int& n) : L(L), n(n) {} ~ref_clean() { lua_pop(L, static_cast<int>(n)); } };
 }
-template <bool top_level>
+
-class table_core : public reference {
+template <bool top_level, typename base_t>
+class basic_table_core : public base_t {
     friend class state;
     friend class state_view;
 
@@ -45,25 +46,25 @@ class table_core : public reference {
     template<typename Fx>
     void for_each(std::true_type, Fx&& fx) const {
         auto pp = stack::push_pop( *this );
-        stack::push( lua_state( ), nil );
+        stack::push( base_t::lua_state( ), nil );
-        while ( lua_next( this->lua_state( ), -2 ) ) {
+        while ( lua_next( base_t::lua_state( ), -2 ) ) {
-            sol::object key( lua_state( ), -2 );
+            sol::object key( base_t::lua_state( ), -2 );
-            sol::object value( lua_state( ), -1 );
+            sol::object value( base_t::lua_state( ), -1 );
             std::pair<sol::object&, sol::object&> keyvalue(key, value);
             fx( keyvalue );
-            lua_pop( lua_state( ), 1 );
+            lua_pop( base_t::lua_state( ), 1 );
         }
     }
 
     template<typename Fx>
     void for_each(std::false_type, Fx&& fx) const {
         auto pp = stack::push_pop( *this );
-        stack::push( lua_state( ), nil );
+        stack::push( base_t::lua_state( ), nil );
-        while ( lua_next( this->lua_state( ), -2 ) ) {
+        while ( lua_next( base_t::lua_state( ), -2 ) ) {
-            sol::object key( lua_state( ), -2 );
+            sol::object key( base_t::lua_state( ), -2 );
-            sol::object value( lua_state( ), -1 );
+            sol::object value( base_t::lua_state( ), -1 );
             fx( key, value );
-            lua_pop( lua_state( ), 1 );
+            lua_pop( base_t::lua_state( ), 1 );
         }
     }
 
@@ -72,21 +73,21 @@ class table_core : public reference {
     -> decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)){
         typedef decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)) Tup;
         return Tup(
-            traverse_get_optional<top_level, Ret0>(meta::is_specialization_of<meta::Unqualified<Ret0>, sol::optional>(), detail::forward_get<0>(keys)),
+            traverse_get_optional<top_level, Ret0>(meta::is_specialization_of<sol::optional, meta::Unqualified<Ret0>>(), detail::forward_get<0>(keys)),
-            traverse_get_optional<top_level, Ret1>(meta::is_specialization_of<meta::Unqualified<Ret1>, sol::optional>(), detail::forward_get<1>(keys)),
+            traverse_get_optional<top_level, Ret1>(meta::is_specialization_of<sol::optional, meta::Unqualified<Ret1>>(), detail::forward_get<1>(keys)),
-            traverse_get_optional<top_level, Ret>(meta::is_specialization_of<meta::Unqualified<Ret>, sol::optional>(), detail::forward_get<I>(keys))...
+            traverse_get_optional<top_level, Ret>(meta::is_specialization_of<sol::optional, meta::Unqualified<Ret>>(), detail::forward_get<I>(keys))...
         );
     }
 
     template<typename Ret, std::size_t I, typename Keys>
     decltype(auto) tuple_get( types<Ret>, std::index_sequence<I>, Keys&& keys ) const {
-        return traverse_get_optional<top_level, Ret>( meta::is_specialization_of<meta::Unqualified<Ret>, sol::optional>(), detail::forward_get<I>(keys) );
+        return traverse_get_optional<top_level, Ret>( meta::is_specialization_of<sol::optional, meta::Unqualified<Ret>>(), detail::forward_get<I>(keys) );
     }
 
     template<typename Pairs, std::size_t... I>
     void tuple_set( std::index_sequence<I...>, Pairs&& pairs ) {
         auto pp = stack::push_pop<top_level && (is_global<decltype(detail::forward_get<I * 2>(pairs))...>::value)>(*this);
-        void(detail::swallow{ (stack::set_field<top_level>(lua_state(), 
+        void(detail::swallow{ (stack::set_field<top_level>(base_t::lua_state(), 
             detail::forward_get<I * 2>(pairs),
             detail::forward_get<I * 2 + 1>(pairs)
         ), 0)... });
@@ -94,28 +95,28 @@ class table_core : public reference {
 
     template <bool global, typename T, typename Key>
     decltype(auto) traverse_get_deep( Key&& key ) const {
-        stack::get_field<global>( lua_state( ), std::forward<Key>( key ) );
+        stack::get_field<global>( base_t::lua_state( ), std::forward<Key>( key ) );
-        return stack::get<T>( lua_state( ) );
+        return stack::get<T>( base_t::lua_state( ) );
     }
 
     template <bool global, typename T, typename Key, typename... Keys>
     decltype(auto) traverse_get_deep( Key&& key, Keys&&... keys ) const {
-        stack::get_field<global>( lua_state( ), std::forward<Key>( key ) );
+        stack::get_field<global>( base_t::lua_state( ), std::forward<Key>( key ) );
         return traverse_get_deep<false, T>(std::forward<Keys>(keys)...);
     }
 
     template <bool global, typename T, std::size_t I, typename Key>
     decltype(auto) traverse_get_deep_optional( int& popcount, Key&& key ) const {
-        auto p = stack::probe_get_field<global>(lua_state(), std::forward<Key>(key), -1);
+        auto p = stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), -1);
         popcount += p.levels;
         if (!p.success)
             return T(nullopt);
-        return stack::get<T>( lua_state( ) );
+        return stack::get<T>( base_t::lua_state( ) );
     }
 
     template <bool global, typename T, std::size_t I, typename Key, typename... Keys>
     decltype(auto) traverse_get_deep_optional( int& popcount, Key&& key, Keys&&... keys ) const {
-        auto p = I > 0 ? stack::probe_get_field<global>(lua_state(), std::forward<Key>(key), - 1) : stack::probe_get_field<global>( lua_state( ), std::forward<Key>( key ) );
+        auto p = I > 0 ? stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), - 1) : stack::probe_get_field<global>( base_t::lua_state( ), std::forward<Key>( key ) );
         popcount += p.levels;
         if (!p.success)
             return T(nullopt);
@@ -124,52 +125,57 @@ class table_core : public reference {
 
     template <bool global, typename T, typename... Keys>
     decltype(auto) traverse_get_optional( std::false_type, Keys&&... keys ) const {
-        detail::clean<sizeof...(Keys)> c(lua_state());
+        detail::clean<sizeof...(Keys)> c(base_t::lua_state());
         return traverse_get_deep<top_level, T>(std::forward<Keys>(keys)...);
     }
 
     template <bool global, typename T, typename... Keys>
     decltype(auto) traverse_get_optional( std::true_type, Keys&&... keys ) const {
         int popcount = 0;
-        detail::ref_clean c(lua_state(), popcount);
+        detail::ref_clean c(base_t::lua_state(), popcount);
         return traverse_get_deep_optional<top_level, T, 0>(popcount, std::forward<Keys>(keys)...);
     }
 
     template <bool global, typename Key, typename Value>
     void traverse_set_deep( Key&& key, Value&& value ) const {
-        stack::set_field<global>( lua_state( ), std::forward<Key>( key ), std::forward<Value>(value) );
+        stack::set_field<global>( base_t::lua_state( ), std::forward<Key>( key ), std::forward<Value>(value) );
     }
 
     template <bool global, typename Key, typename... Keys>
     void traverse_set_deep( Key&& key, Keys&&... keys ) const {
-        stack::get_field<global>( lua_state( ), std::forward<Key>( key ) );
+        stack::get_field<global>( base_t::lua_state( ), std::forward<Key>( key ) );
         traverse_set_deep<false>(std::forward<Keys>(keys)...);
     }
 
-    table_core(lua_State* L, detail::global_tag t) noexcept : reference(L, t) { }
+    basic_table_core(lua_State* L, detail::global_tag t) noexcept : reference(L, t) { }
 
 public:
-    table_core( ) noexcept : reference( ) { }
+    typedef basic_table_iterator<base_t> iterator;
-    table_core( const table_core<true>& global ) noexcept : reference( global ) { }
+    typedef iterator const_iterator;
-    table_core( lua_State* L, int index = -1 ) : reference( L, index ) {
+
+    basic_table_core( ) noexcept : base_t( ) { }
+    basic_table_core( const table_core<true>& global ) noexcept : base_t( global ) { }
+    basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
+    basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
+    basic_table_core( lua_State* L, int index = -1 ) : base_t( L, index ) {
 #ifdef SOL_CHECK_ARGUMENTS
         type_assert( L, index, type::table );
 #endif // Safety
     }
 
-    table_iterator begin () const {
+    iterator begin () const {
-        return table_iterator(*this);
+        return iterator(*this);
     }
 
-    table_iterator end() const {
+    iterator end() const {
-        return table_iterator();
+        return iterator();
     }
 
-    table_iterator cbegin() const {
+    const_iterator cbegin() const {
         return begin();
     }
 
-    table_iterator cend() const {
+    const_iterator cend() const {
         return end();
     }
 
@@ -202,48 +208,48 @@ public:
     template <typename T, typename... Keys>
     decltype(auto) traverse_get( Keys&&... keys ) const {
         auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
-        return traverse_get_optional<top_level, T>(meta::is_specialization_of<meta::Unqualified<T>, sol::optional>(), std::forward<Keys>(keys)...);
+        return traverse_get_optional<top_level, T>(meta::is_specialization_of<sol::optional, meta::Unqualified<T>>(), std::forward<Keys>(keys)...);
     }
 
     template <typename... Keys>
-    table_core& traverse_set( Keys&&... keys ) {
+    basic_table_core& traverse_set( Keys&&... keys ) {
         auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
         traverse_set_deep<top_level>(std::forward<Keys>(keys)...);
-        lua_pop(lua_state(), static_cast<int>(sizeof...(Keys)-2));
+        lua_pop(base_t::lua_state(), static_cast<int>(sizeof...(Keys)-2));
         return *this;
     }
 
     template<typename... Args>
-    table_core& set( Args&&... args ) {
+    basic_table_core& set( Args&&... args ) {
         tuple_set(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
         return *this;
     }
 
     template<typename T>
-    table_core& set_usertype( usertype<T>& user ) {
+    basic_table_core& set_usertype( usertype<T>& user ) {
         return set_usertype(usertype_traits<T>::name, user);
     }
 
     template<typename Key, typename T>
-    table_core& set_usertype( Key&& key, usertype<T>& user ) {
+    basic_table_core& set_usertype( Key&& key, usertype<T>& user ) {
         return set(std::forward<Key>(key), user);
     }
 
     template<typename Class, typename... Args>
-    table_core& new_usertype(const std::string& name, Args&&... args) {
+    basic_table_core& new_usertype(const std::string& name, Args&&... args) {
         usertype<Class> utype(std::forward<Args>(args)...);
         set_usertype(name, utype);
         return *this;
     }
 
     template<typename Class, typename CTor0, typename... CTor, typename... Args>
-    table_core& new_usertype(const std::string& name, Args&&... args) {
+    basic_table_core& new_usertype(const std::string& name, Args&&... args) {
         constructors<types<CTor0, CTor...>> ctor{};
         return new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
     }
 
     template<typename Class, typename... CArgs, typename... Args>
-    table_core& new_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
+    basic_table_core& new_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
         usertype<Class> utype(ctor, std::forward<Args>(args)...);
         set_usertype(name, utype);
         return *this;
@@ -257,7 +263,7 @@ public:
 
     size_t size( ) const {
         auto pp = stack::push_pop( *this );
-        return lua_rawlen(lua_state(), -1);
+        return lua_rawlen(base_t::lua_state(), -1);
     }
 
     bool empty() const {
@@ -265,28 +271,28 @@ public:
     }
 
     template<typename T>
-    proxy<table_core&, T> operator[]( T&& key ) & {
+    proxy<basic_table_core&, T> operator[]( T&& key ) & {
-        return proxy<table_core&, T>( *this, std::forward<T>( key ) );
+        return proxy<basic_table_core&, T>( *this, std::forward<T>( key ) );
     }
 
     template<typename T>
-    proxy<const table_core&, T> operator[]( T&& key ) const & {
+    proxy<const basic_table_core&, T> operator[]( T&& key ) const & {
-        return proxy<const table_core&, T>( *this, std::forward<T>( key ) );
+        return proxy<const basic_table_core&, T>( *this, std::forward<T>( key ) );
     }
 
     template<typename T>
-    proxy<table_core, T> operator[]( T&& key ) && {
+    proxy<basic_table_core, T> operator[]( T&& key ) && {
-        return proxy<table_core, T>( *this, std::forward<T>( key ) );
+        return proxy<basic_table_core, T>( *this, std::forward<T>( key ) );
     }
 
     template<typename Sig, typename Key, typename... Args>
-    table_core& set_function( Key&& key, Args&&... args ) {
+    basic_table_core& set_function( Key&& key, Args&&... args ) {
         set_fx( types<Sig>( ), std::forward<Key>( key ), std::forward<Args>( args )... );
         return *this;
     }
 
     template<typename Key, typename... Args>
-    table_core& set_function( Key&& key, Args&&... args ) {
+    basic_table_core& set_function( Key&& key, Args&&... args ) {
         set_fx( types<>( ), std::forward<Key>( key ), std::forward<Args>( args )... );
         return *this;
     }
@@ -297,12 +303,12 @@ private:
         set_resolved_function<R( Args... )>( std::forward<Key>( key ), std::forward<Fx>( fx ) );
     }
 
-    template<typename Fx, typename Key, meta::EnableIf<meta::is_specialization_of<meta::Unqualified<Fx>, overload_set>> = 0>
+    template<typename Fx, typename Key, meta::EnableIf<meta::is_specialization_of<overload_set, meta::Unqualified<Fx>>> = 0>
     void set_fx( types<>, Key&& key, Fx&& fx ) {
         set(std::forward<Key>(key), std::forward<Fx>(fx));
     }
 
-    template<typename Fx, typename Key, typename... Args, meta::DisableIf<meta::is_specialization_of<meta::Unqualified<Fx>, overload_set>> = 0>
+    template<typename Fx, typename Key, typename... Args, meta::DisableIf<meta::is_specialization_of<overload_set, meta::Unqualified<Fx>>> = 0>
     void set_fx( types<>, Key&& key, Fx&& fx, Args&&... args ) {
         set(std::forward<Key>(key), function_args(std::forward<Fx>(fx), std::forward<Args>(args)...));
     }
@@ -336,31 +342,31 @@ public:
     }
 
     table create(int narr = 0, int nrec = 0) {
-        return create(lua_state(), narr, nrec);
+        return create(base_t::lua_state(), narr, nrec);
     }
 
     template <typename Key, typename Value, typename... Args>
     table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-        return create(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+        return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
     }
     
     template <typename Name>
     table create(Name&& name, int narr = 0, int nrec = 0) {
-        table x = create(lua_state(), narr, nrec);
+        table x = create(base_t::lua_state(), narr, nrec);
         this->set(std::forward<Name>(name), x);
         return x;
     }
 
     template <typename Name, typename Key, typename Value, typename... Args>
     table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-        table x = create(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+        table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
         this->set(std::forward<Name>(name), x);
         return x;
     }
 
     template <typename... Args>
     table create_with(Args&&... args) {
-        return create_with(lua_state(), std::forward<Args>(args)...);
+        return create_with(base_t::lua_state(), std::forward<Args>(args)...);
     }
 
     template <typename Name, typename... Args>

sol/table_iterator.hpp

@@ -27,7 +27,8 @@
 
 namespace sol {
 
-class table_iterator : public std::iterator<std::input_iterator_tag, std::pair<object, object>> {
+template <typename reference_type>
+class basic_table_iterator : public std::iterator<std::input_iterator_tag, std::pair<object, object>> {
 private:
     typedef std::iterator<std::input_iterator_tag, std::pair<object, object>> base_t;
 public:
@@ -41,19 +42,18 @@ public:
     typedef const value_type& const_reference;
 
 private:
-    typedef ::sol::reference ref_t;
     std::pair<object, object> kvp;
-    ref_t ref;
+    reference_type ref;
     int tableidx = 0;
     std::ptrdiff_t idx = 0;
 
 public:
 
-    table_iterator () : idx(-1) {
+    basic_table_iterator () : idx(-1) {
 
     }
 
-    table_iterator(ref_t x) : ref(std::move(x)) {
+    basic_table_iterator(reference_type x) : ref(std::move(x)) {
         ref.push();
         tableidx = lua_gettop(ref.lua_state());
         stack::push(ref.lua_state(), nil);
@@ -64,7 +64,7 @@ public:
         --idx;
     }
 
-    table_iterator& operator++() {
+    basic_table_iterator& operator++() {
         if (idx == -1)
             return *this;
 
@@ -80,7 +80,7 @@ public:
         return *this;
     }
 
-    table_iterator operator++(int) {
+    basic_table_iterator operator++(int) {
         auto saved = *this;
         this->operator++();
         return saved;
@@ -94,15 +94,15 @@ public:
         return kvp;
     }
 
-    bool operator== (const table_iterator& right) const {
+    bool operator== (const basic_table_iterator& right) const {
         return idx == right.idx;
     }
 
-    bool operator!= (const table_iterator& right) const {
+    bool operator!= (const basic_table_iterator& right) const {
         return idx != right.idx;
     }
 
-    ~table_iterator() {
+    ~basic_table_iterator() {
         if (ref.valid()) {
             stack::remove(ref.lua_state(), tableidx, 1);
         }

sol/traits.hpp

@@ -70,10 +70,10 @@ struct remove_member_pointer<R T::* const> {
 template<typename T>
 using remove_member_pointer_t = remove_member_pointer<T>;
 
-template<typename T, template<typename...> class Templ>
+template<template<typename...> class Templ, typename T>
 struct is_specialization_of : std::false_type { };
 template<typename... T, template<typename...> class Templ>
-struct is_specialization_of<Templ<T...>, Templ> : std::true_type { };
+struct is_specialization_of<Templ, Templ<T...>> : std::true_type { };
 
 template<class T, class...>
 struct are_same : std::true_type { };
@@ -380,12 +380,12 @@ using is_c_str = Or<
 >;
 
 namespace meta_detail {
-template <typename T, meta::DisableIf<meta::is_specialization_of<meta::Unqualified<T>, std::tuple>> = 0>
+template <typename T, meta::DisableIf<meta::is_specialization_of<std::tuple, meta::Unqualified<T>>> = 0>
 decltype(auto) force_tuple(T&& x) {
     return std::forward_as_tuple(std::forward<T>(x));
 }
 
-template <typename T, meta::EnableIf<meta::is_specialization_of<meta::Unqualified<T>, std::tuple>> = 0>
+template <typename T, meta::EnableIf<meta::is_specialization_of<std::tuple, meta::Unqualified<T>>> = 0>
 decltype(auto) force_tuple(T&& x) {
     return std::forward<T>(x);
 }

sol/types.hpp

@@ -105,6 +105,12 @@ struct up_value_index {
     operator int() const { return index; }
 };
 
+struct absolute_index {
+    int index;
+    absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {}
+    operator int() const { return index; }
+};
+
 struct light_userdata_value {
     void* value;
     light_userdata_value(void* data) : value(data) {}
@@ -203,17 +209,38 @@ class reference;
 class stack_reference;
 template<typename T>
 class usertype;
-template <bool>
+template <bool, typename T>
-class table_core;
+class basic_table_core;
+template <bool b>
+using table_core = basic_table_core<b, reference>;
+template <bool b>
+using stack_table_core = basic_table_core<b, stack_reference>;
 typedef table_core<false> table;
 typedef table_core<true> global_table;
-class function;
+typedef stack_table_core<false> stack_table;
-class protected_function;
+typedef stack_table_core<true> stack_global_table;
+template <typename T>
+class basic_function;
+template <typename T>
+class basic_protected_function;
+using function = basic_function<reference>;
+using protected_function = basic_protected_function<reference>;
+using stack_function = basic_function<stack_reference>;
+using stack_protected_function = basic_protected_function<stack_reference>;
+template <typename base_t>
+class basic_object;
+template <typename base_t>
+class basic_userdata;
+template <typename base_t>
+class basic_lightuserdata;
+using object = basic_object<reference>;
+using stack_object = basic_object<stack_reference>;
+using userdata = basic_userdata<reference>;
+using stack_userdata = basic_userdata<stack_reference>;
+using lightuserdata = basic_lightuserdata<reference>;
+using stack_lightuserdata = basic_lightuserdata<stack_reference>;
 class coroutine;
 class thread;
-class object;
-class userdata;
-class lightuserdata;
 
 template <typename T, typename = void>
 struct lua_type_of : std::integral_constant<type, type::userdata> {};
@@ -242,14 +269,20 @@ struct lua_type_of<table> : std::integral_constant<type, type::table> { };
 template <>
 struct lua_type_of<global_table> : std::integral_constant<type, type::table> { };
 
+template <>
+struct lua_type_of<stack_table> : std::integral_constant<type, type::table> { };
+
+template <>
+struct lua_type_of<stack_global_table> : std::integral_constant<type, type::table> { };
+
 template <>
 struct lua_type_of<reference> : std::integral_constant<type, type::poly> {};
 
 template <>
 struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> {};
 
-template <>
+template <typename Base>
-struct lua_type_of<object> : std::integral_constant<type, type::poly> {};
+struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> {};
 
 template <typename... Args>
 struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> {};
@@ -263,17 +296,20 @@ struct lua_type_of<light_userdata_value> : std::integral_constant<type, type::li
 template <>
 struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> {};
 
-template <>
+template <typename Base>
-struct lua_type_of<lightuserdata> : std::integral_constant<type, type::lightuserdata> {};
+struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> {};
 
-template <>
+template <typename Base>
-struct lua_type_of<userdata> : std::integral_constant<type, type::userdata> {};
+struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> {};
 
 template <>
 struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> {};
 
-template <>
+template <typename Base>
-struct lua_type_of<function> : std::integral_constant<type, type::function> {};
+struct lua_type_of<basic_function<Base>> : std::integral_constant<type, type::function> {};
+
+template <typename Base>
+struct lua_type_of<basic_protected_function<Base>> : std::integral_constant<type, type::function> {};
 
 template <>
 struct lua_type_of<coroutine> : std::integral_constant<type, type::function> {};
@@ -281,9 +317,6 @@ struct lua_type_of<coroutine> : std::integral_constant<type, type::function> {};
 template <>
 struct lua_type_of<thread> : std::integral_constant<type, type::thread> {};
 
-template <>
-struct lua_type_of<protected_function> : std::integral_constant<type, type::function> {};
-
 template <typename Signature>
 struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function>{};
 
@@ -303,10 +336,15 @@ template <typename T>
 struct is_lua_primitive : std::integral_constant<bool, 
     type::userdata != lua_type_of<meta::Unqualified<T>>::value
     || std::is_base_of<reference, meta::Unqualified<T>>::value
-    || meta::is_specialization_of<meta::Unqualified<T>, std::tuple>::value
+    || std::is_base_of<stack_reference, meta::Unqualified<T>>::value
-    || meta::is_specialization_of<meta::Unqualified<T>, std::pair>::value
+    || meta::is_specialization_of<std::tuple, meta::Unqualified<T>>::value
+    || meta::is_specialization_of<std::pair, meta::Unqualified<T>>::value
 > { };
 
+template <typename T>
+struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
+template <typename T>
+struct is_lua_primitive<optional<T>> : std::true_type {};
 template <typename T>
 struct is_lua_primitive<T*> : std::true_type {};
 template <>
@@ -319,12 +357,6 @@ struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> {};
 template <typename T>
 struct is_proxy_primitive : is_lua_primitive<T> { };
 
-template <typename T>
-struct is_proxy_primitive<std::reference_wrapper<T>> : std::true_type { };
-
-template <typename T>
-struct is_proxy_primitive<optional<T>> : std::true_type {};
-
 template <typename T>
 struct is_unique_usertype : std::false_type {};
 

sol/userdata.hpp

@@ -25,28 +25,34 @@
 #include "reference.hpp"
 
 namespace sol {
-class userdata : public reference {
+template <typename base_t>
+class basic_userdata : public base_t {
 public:
-    userdata () noexcept = default;
+    basic_userdata () noexcept = default;
-    userdata(const userdata&) = default;
+    basic_userdata(const basic_userdata&) = default;
-    userdata(userdata&&) = default;
+    basic_userdata(basic_userdata&&) = default;
-    userdata& operator=(const userdata&) = default;
+    basic_userdata& operator=(const basic_userdata&) = default;
-    userdata& operator=(userdata&&) = default;
+    basic_userdata& operator=(basic_userdata&&) = default;
-    userdata(lua_State* L, int index = -1) : reference(L, index) {
+    basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
+    basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
+    basic_userdata(lua_State* L, int index = -1) : base_t(L, index) {
 #ifdef SOL_CHECK_ARGUMENTS
         type_assert(L, index, type::userdata);
 #endif // Safety
     }
 };
 
-class lightuserdata : public reference {
+template <typename base_t>
+class basic_lightuserdata : public base_t {
 public:
-    lightuserdata () noexcept = default;
+    basic_lightuserdata () noexcept = default;
-    lightuserdata(const lightuserdata&) = default;
+    basic_lightuserdata(const basic_lightuserdata&) = default;
-    lightuserdata(lightuserdata&&) = default;
+    basic_lightuserdata(basic_lightuserdata&&) = default;
-    lightuserdata& operator=(const lightuserdata&) = default;
+    basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
-    lightuserdata& operator=(lightuserdata&&) = default;
+    basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
-    lightuserdata(lua_State* L, int index = -1) : reference(L, index) {
+    basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
+    basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
+    basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
 #ifdef SOL_CHECK_ARGUMENTS
         type_assert(L, index, type::lightuserdata);
 #endif // Safety

tests.cpp

@@ -801,3 +801,60 @@ TEST_CASE("usertype/overloading", "Check if overloading works properly for usert
 
     REQUIRE_THROWS(lua.script("r:func(1,2,'meow')"));
 }
+
+TEST_CASE("usertype/reference-and-constness", "Make sure constness compiles properly and errors out at runtime") {
+    struct bark {
+        int var = 50;
+    };
+    struct woof {
+        bark b;
+    };
+
+    struct nested {
+        const int f = 25;
+    };
+
+    struct outer {
+        nested n;
+    };
+
+    bool caughterror = false;
+    std::string msg;
+    sol::state lua;
+    lua.new_usertype<woof>("woof",
+        "b", &woof::b);
+    lua.new_usertype<bark>("bark",
+        "var", &bark::var);
+    lua.new_usertype<outer>("outer",
+        "n", &outer::n);
+    lua.set("w", woof());
+    lua.set("n", nested());
+    lua.set("o", outer());
+    lua.set("f", sol::c_call<decltype(&nested::f), &nested::f>);
+    try {
+        lua.script(R"(
+    x = w.b
+    x.var = 20
+    val = w.b.var == x.var
+    v = f(n);
+    f(n, 50)
+)");
+    }
+    catch (const sol::error& e) {
+        msg = e.what();
+        caughterror = true;
+    }
+    REQUIRE(caughterror);
+    REQUIRE(!msg.empty());
+    woof& w = lua["w"];
+    bark& x = lua["x"];
+    nested& n = lua["n"];
+    int v = lua["v"];
+    bool val = lua["val"];
+    // enforce reference semantics
+    REQUIRE(std::addressof(w.b) == std::addressof(x));
+    REQUIRE(n.f == 25);
+    REQUIRE(v == 25);
+    REQUIRE(val);
+    REQUIRE_THROWS(lua.script("o.n = 25"));
+}