Huge improvements to the library and fixes to compile in g++.

usertype now respects factory functions and does not make default constructors/destructors unless the compiler says its okay
new and __gc functions can be overridden for usertypes to provide handle-like creation and deletion functions
Overloading match fixes
RAII improvements for all usertypes
Added tests to make sure these features stay

sol/function.hpp

@@ -323,7 +323,7 @@ struct pusher<function_sig<Sigs...>> {
         int metapushed = luaL_newmetatable(L, metatablename);
         if(metapushed == 1) {
             lua_pushstring(L, "__gc");
-            stack::push<lua_CFunction>(L, detail::gc);
+            stack::push(L, detail::gc);
             lua_settable(L, -3);
             lua_pop(L, 1);
         }

sol/function_types.hpp

@@ -28,5 +28,6 @@
 #include "function_types_member.hpp"
 #include "function_types_usertype.hpp"
 #include "function_types_overload.hpp"
+#include "function_types_allocator.hpp"
 
 #endif // SOL_FUNCTION_TYPES_HPP

sol/function_types_allocator.hpp

@@ -22,9 +22,126 @@
 #ifndef SOL_FUNCTION_TYPES_ALLOCATOR_HPP
 #define SOL_FUNCTION_TYPES_ALLOCATOR_HPP
 
-#include "stack.hpp"
+#include "raii.hpp"
+#include "function_types_overload.hpp"
 
 namespace sol {
+namespace detail {
+template <typename T, typename List>
+struct void_call;
+
+template <typename T, typename... Args>
+struct void_call<T, types<Args...>> {
+    static void call(Args... args) {}
+};
+
+template <typename T>
+struct constructor_match {
+    T* obj;
+
+    constructor_match(T* obj) : obj(obj) {}
+
+    template <bool b, typename Fx, std::size_t I, typename... R, typename... Args>
+    int operator()(Bool<b>, types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
+        default_construct func{};
+        return stack::typed_call<b ? false : stack::stack_detail::default_check_arguments>(r, a, func, L, start, obj);
+    }
+};
+} // detail
+
+template <typename T, typename... TypeLists, typename Match>
+inline int construct(Match&& matchfx, lua_State* L, int fxarity, int start) {
+    // use same overload resolution matching as all other parts of the framework
+    return overload_match_arity<decltype(detail::void_call<T, TypeLists>::call)...>(std::forward<Match>(matchfx), L, fxarity, start);
+}
+
+template <typename T, typename... TypeLists>
+inline int construct(lua_State* L) {
+    static const auto& meta = usertype_traits<T>::metatable;
+    call_syntax syntax = stack::get_call_syntax(L, meta);
+    int argcount = lua_gettop(L) - static_cast<int>(syntax);
+
+    T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
+    T*& referencepointer = *pointerpointer;
+    T* obj = reinterpret_cast<T*>(pointerpointer + 1);
+    referencepointer = obj;
+    reference userdataref(L, -1);
+    userdataref.pop();
+        
+    construct<T, TypeLists...>(detail::constructor_match<T>(obj), L, argcount, 1 + static_cast<int>(syntax));
+
+    userdataref.push();
+    luaL_getmetatable(L, &meta[0]);
+    if (stack::get<type>(L) == type::nil) {
+        lua_pop(L, 1);
+        std::string err = "unable to get usertype metatable for ";
+        err += meta;
+        throw error(err);
+    }
+
+    lua_setmetatable(L, -2);
+    return 1;
+}
+
+template <typename T>
+inline int destruct(lua_State* L) {
+    userdata udata = stack::get<userdata>(L, 1);
+    // The first sizeof(T*) bytes are the reference: the rest is
+    // the actual data itself (if there is a reference at all)
+    T** pobj = reinterpret_cast<T**>(udata.value);
+    T*& obj = *pobj;
+    std::allocator<T> alloc{};
+    alloc.destroy(obj);
+    return 0;
+}
+
+template <typename T, typename... Functions>
+struct usertype_constructor_function : base_function {
+    typedef std::tuple<Functions...> overload_list;
+    typedef std::index_sequence_for<Functions...> indices;
+    overload_list overloads;
+
+    usertype_constructor_function(constructor_wrapper<Functions...> set) : usertype_constructor_function(indices(), set) {}
+
+    template <std::size_t... I>
+    usertype_constructor_function(std::index_sequence<I...>, constructor_wrapper<Functions...> set) : usertype_constructor_function(std::get<I>(set)...) {}
+
+    usertype_constructor_function(Functions... fxs) : overloads(fxs...) {}
+
+    template <bool b, typename Fx, std::size_t I, typename... R, typename... Args>
+    int call(Bool<b>, types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) {
+        static const auto& meta = usertype_traits<T>::metatable;
+        T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
+        T*& referencepointer = *pointerpointer;
+        T* obj = reinterpret_cast<T*>(pointerpointer + 1);
+        referencepointer = obj;
+        reference userdataref(L, -1);
+        userdataref.pop();
+
+        auto& func = std::get<I>(overloads);
+        stack::typed_call<b ? false : stack::stack_detail::default_check_arguments>(r, a, func, L, start, detail::implicit_wrapper<T>(obj));
+
+        userdataref.push();
+        luaL_getmetatable(L, &meta[0]);
+        if (stack::get<type>(L) == type::nil) {
+            lua_pop(L, 1);
+            std::string err = "unable to get usertype metatable for ";
+            err += meta;
+            throw error(err);
+        }
+        lua_setmetatable(L, -2);
+            
+        return 1;
+    }
+
+    virtual int operator()(lua_State* L) override {
+        static const auto& meta = usertype_traits<T>::metatable;
+        call_syntax syntax = stack::get_call_syntax(L, meta);
+        int argcount = lua_gettop(L) - static_cast<int>(syntax);
+        auto mfx = [&](auto&&... args) { return this->call(std::forward<decltype(args)>(args)...); };
+        return construct<T, pop_front_type_t<function_args_t<Functions>>...>(mfx, L, argcount, 1 + static_cast<int>(syntax));
+    }
+};
 } // sol
 
 #endif // SOL_FUNCTION_TYPES_ALLOCATOR_HPP

sol/function_types_core.hpp

@@ -31,6 +31,7 @@ struct ref_call_t {} const ref_call = ref_call_t{};
 template <typename T>
 struct implicit_wrapper {
     T& item;
+    implicit_wrapper(T* item) : item(*item) {}
     implicit_wrapper(T& item) : item(item) {}
     operator T& () {
         return item;
@@ -129,7 +130,7 @@ struct functor<T, Func, std::enable_if_t<std::is_member_object_pointer<Func>::va
 template<typename T, typename Func>
 struct functor<T, Func, std::enable_if_t<std::is_function<Func>::value || std::is_class<Func>::value>> {
     typedef callable_traits<Func> traits_type;
-    typedef remove_one_type<typename traits_type::args_type> args_type;
+    typedef pop_front_type_t<typename traits_type::args_type> args_type;
     typedef typename traits_type::return_type return_type;
     typedef std::tuple_element_t<0, typename traits_type::args_tuple_type> Arg0;
     typedef std::conditional_t<std::is_pointer<Func>::value || std::is_class<Func>::value, Func, std::add_pointer_t<Func>> function_type;
@@ -212,9 +213,10 @@ namespace detail {
 
 template <std::size_t limit>
 static void func_gc(std::false_type, lua_State* L) {
-		// Shut up clang tautological error without throwing out std::size_t
     for (std::size_t i = 0; i < limit; ++i) {
         upvalue up = stack::get<upvalue>(L, static_cast<int>(i + 1));
+        if (up.value == nullptr)
+            continue;
         base_function* obj = static_cast<base_function*>(up.value);
         std::allocator<base_function> alloc{};
         alloc.destroy(obj);
@@ -243,8 +245,7 @@ namespace detail {
     func_gc<I>(Bool<(I < 1)>(), L);
     return 0;
 }
-}
+} // detail
-
 } // sol
 
 #endif // SOL_FUNCTION_TYPES_CORE_HPP

sol/function_types_overload.hpp

@@ -28,45 +28,46 @@
 
 namespace sol {
 namespace detail {
-template <std::size_t... M, typename Match>
+template <std::size_t... M, typename Match, typename... Args>
-inline int match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, std::ptrdiff_t, lua_State*, Match&&, int) {
+inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State*, int, int, Args&&...) {
     throw error("no matching function call takes this number of arguments and the specified types");
 }
 
-template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match>
+template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
-inline int match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, std::ptrdiff_t fxarity, lua_State* L, Match&& matchfx, int start) {
+inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
     typedef function_traits<Fx> traits;
     typedef tuple_types<typename function_traits<Fx>::return_type> return_types;
     typedef typename function_traits<Fx>::args_type args_type;
     typedef typename args_type::indices args_indices;
     // compile-time eliminate any functions that we know ahead of time are of improper arity
-    if (find_in_pack_v<Index<traits::arity>, Index<M>...>::value || traits::arity != fxarity) {
+    if (find_in_pack_v<Index<traits::arity>, Index<M>...>::value) {
-        return match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), fxarity, L, std::forward<Match>(matchfx), start);
+        return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
     }
     if (traits::arity != fxarity) {
-	    return match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<traits::arity, M...>(), fxarity, L, std::forward<Match>(matchfx), start);
+        return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<traits::arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
     }
-    if (!detail::check_types(args_type(), args_indices(), L, start)) {
+    if (sizeof...(Fxs) != 0 && !detail::check_types(args_type(), args_indices(), L, start)) {
-        return match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), fxarity, L, std::forward<Match>(matchfx), start);
+        return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
     }
-    return matchfx(Index<I>(), fxarity, L, start);
+    return matchfx(Bool<sizeof...(Fxs) != 0>(), types<Fx>(), Index<I>(), return_types(), args_type(), L, fxarity, start, std::forward<Args>(args)...);
 }
 } // detail
 
-template <typename... Functions, typename Match>
+template <typename... Functions, typename Match, typename... Args>
-inline int match(std::ptrdiff_t fxarity, lua_State* L, Match&& matchfx, int start = 1) {
+inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start = 1, Args&&... args) {
-	return detail::match_arity(types<Functions...>(), std::index_sequence_for<Functions...>(), std::index_sequence<>(), fxarity, L, std::forward<Match>(matchfx), start);
+    return detail::overload_match_arity(types<Functions...>(), std::index_sequence_for<Functions...>(), std::index_sequence<>(), std::forward<Match>(matchfx), L, fxarity,  start, std::forward<Args>(args)...);
 }
 
-template <typename... Functions, typename Match>
+template <typename... Functions, typename Match, typename... Args>
-inline int match(lua_State* L, Match&& matchfx, int start = 1) {
+inline int overload_match(Match&& matchfx, lua_State* L, int start = 1, Args&&... args) {
-     std::ptrdiff_t fxarity = lua_gettop(L) - (start - 1);
+     int fxarity = lua_gettop(L) - (start - 1);
-     return match<Functions...>(fxarity, L, std::forward<Match>(matchfx), start);
+     return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
 }
 
 template <typename... Functions>
 struct overloaded_function : base_function {
     typedef std::tuple<Functions...> overload_list;
+    typedef std::index_sequence_for<Functions...> indices;
     overload_list overloads;
 
     overloaded_function(overload_set<Functions...> set)
@@ -74,26 +75,22 @@ struct overloaded_function : base_function {
 
     template <std::size_t... I>
     overloaded_function(std::index_sequence<I...>, overload_set<Functions...> set)
-    : overloaded_function(std::get<In>(set)...) {}
+    : overloaded_function(std::get<I>(set)...) {}
 
     overloaded_function(Functions... fxs)
     : overloads(fxs...) {
 
     }
 
-    template <std::size_t I>
+    template <bool b, typename Fx, std::size_t I, typename... R, typename... Args>
-    int call(Index<I>, int, lua_State* L, int) {
+    int call(Bool<b>, types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) {
         auto& func = std::get<I>(overloads);
-	   typedef Unqualified<decltype(func)> Fx;
+        return stack::typed_call<b ? false : stack::stack_detail::default_check_arguments>(r, a, func, L, start);
-        typedef function_traits<Fx> traits;
-        typedef tuple_types<typename function_traits<Fx>::return_type> return_types;
-        typedef typename function_traits<Fx>::args_type args_type;
-	   return stack::typed_call<false>(return_types(), args_type(), func, L);
     }
 
     virtual int operator()(lua_State* L) override {
-        auto mfx = [&](auto&&... args){ return call(std::forward<decltype(args)>(args)...); };
+        auto mfx = [&](auto&&... args){ return this->call(std::forward<decltype(args)>(args)...); };
-        return match<Functions...>(L, mfx);
+        return overload_match<Functions...>(mfx, L);
     }
 };
 
@@ -110,20 +107,16 @@ struct usertype_overloaded_function : base_function {
 
     usertype_overloaded_function(Functions... fxs) : overloads(fxs...) {}
 
-    template <std::size_t I>
+    template <bool b,typename Fx, std::size_t I, typename... R, typename... Args>
-    int call(Index<I>, int, lua_State* L, int) {
+    int call(Bool<b>, types<Fx>, Index<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) {
         auto& func = std::get<I>(overloads);
-        typedef Unqualified<decltype(func)> Fx;
-        typedef typename Fx::traits_type traits;
-        typedef tuple_types<typename Fx::return_type> return_types;
-        typedef typename Fx::args_type args_type;
         func.item = ptr(stack::get<T>(L, 1));
-        return stack::typed_call<false>(return_types(), args_type(), func, L);
+        return stack::typed_call<b ? false : stack::stack_detail::default_check_arguments>(r, a, func, L, start);
     }
 
     virtual int operator()(lua_State* L) override {
-        auto mfx = [&](auto&&... args){ return call(std::forward<decltype(args)>(args)...); };
+        auto mfx = [&](auto&&... args){ return this->call(std::forward<decltype(args)>(args)...); };
-        return match<Functions...>(L, mfx, 2);
+        return overload_match<Functions...>(mfx, L, 2);
     }
 
 };

sol/function_types_usertype.hpp

@@ -62,18 +62,17 @@ struct usertype_function_core : public base_function {
         return stack::push(L, std::forward<Return>(r));
     }
 
-    template<typename... Args>
+    template<typename... Args, std::size_t Start>
-    int operator()(types<void> tr, types<Args...> ta, lua_State* L) {
+    int operator()(types<void> tr, types<Args...> ta, Index<Start>, lua_State* L) {
-        //static const std::size_t skew = static_cast<std::size_t>(std::is_member_object_pointer<function_type>::value);
+        stack::call(tr, ta, L, static_cast<int>(Start), fx);
-        stack::call(tr, ta, L, 0, fx);
         int nargs = static_cast<int>(sizeof...(Args));
         lua_pop(L, nargs);
         return 0;
     }
 
-    template<typename... Ret, typename... Args>
+    template<typename... Ret, typename... Args, std::size_t Start>
-    int operator()(types<Ret...> tr, types<Args...> ta, lua_State* L) {
+    int operator()(types<Ret...> tr, types<Args...> ta, Index<Start>, lua_State* L) {
-        decltype(auto) r = stack::call(tr, ta, L, 0, fx);
+        decltype(auto) r = stack::call(tr, ta, L, static_cast<int>(Start), fx);
         int nargs = static_cast<int>(sizeof...(Args));
         lua_pop(L, nargs);
         int pushcount = push(L, std::forward<decltype(r)>(r));
@@ -97,7 +96,7 @@ struct usertype_function : public usertype_function_core<Function, Tp> {
         if(this->fx.item == nullptr) {
             throw error("userdata for function call is null: are you using the wrong syntax? (use item:function/variable(...) syntax)");
         }
-        return static_cast<base_t&>(*this)(tuple_types<return_type>(), args_type(), L);
+        return static_cast<base_t&>(*this)(tuple_types<return_type>(), args_type(), Index<2>(), L);
     }
 
     virtual int operator()(lua_State* L) override {
@@ -124,9 +123,9 @@ struct usertype_variable_function : public usertype_function_core<Function, Tp>
         }
         switch(argcount) {
         case 2:
-            return static_cast<base_t&>(*this)(tuple_types<return_type>(), types<>(), L);
+            return static_cast<base_t&>(*this)(tuple_types<return_type>(), types<>(), Index<2>(), L);
         case 3:
-            return static_cast<base_t&>(*this)(tuple_types<void>(), args_type(), L);
+            return static_cast<base_t&>(*this)(tuple_types<void>(), args_type(), Index<3>(), L);
         default:
             throw error("cannot get/set userdata member variable with inappropriate number of arguments");
         }

sol/raii.hpp

@@ -0,0 +1,84 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2016 Rapptz and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SOL_RAII_HPP
+#define SOL_RAII_HPP
+
+#include <memory>
+#include "traits.hpp"
+
+namespace sol {
+struct default_construct {
+    template<typename T, typename... Args>
+    void operator()(T&& obj, Args&&... args) const {
+        std::allocator<Unqualified<T>> alloc{};
+        alloc.construct(obj, std::forward<Args>(args)...);
+    }
+};
+
+template <typename T>
+struct placement_construct {
+    T obj;
+
+    template <typename... Args>
+    placement_construct( Args&&... args ) : obj(std::forward<Args>(args)...) {}
+
+    template<typename... Args>
+    void operator()(Args&&... args) const {
+        default_construct{}(obj, std::forward<Args>(args)...);
+    }
+};
+
+template<typename... Args>
+using constructors = sol::types<Args...>;
+
+const auto default_constructor = constructors<types<>>{};
+
+template <typename... Functions>
+struct constructor_wrapper : std::tuple<Functions...> {
+    using std::tuple<Functions...>::tuple;
+};
+
+template <typename... Functions>
+constructor_wrapper<Functions...> constructor(Functions&&... functions) {
+    return constructor_wrapper<Functions...>(std::forward<Functions>(functions)...);
+}
+
+template <typename Function>
+struct destructor_wrapper {
+    Function fx;
+    template <typename... Args>
+    destructor_wrapper(Args&&... args) : fx(std::forward<Args>(args)...) {}
+};
+
+template <>
+struct destructor_wrapper<void> {};
+
+const destructor_wrapper<void> default_destructor{};
+
+template <typename Fx>
+inline destructor_wrapper<Fx> destructor(Fx&& fx) {
+    return destructor_wrapper<Fx>(std::forward<Fx>(fx));
+}
+
+} // sol
+
+#endif // SOL_RAII_HPP

sol/stack.hpp

@@ -539,7 +539,7 @@ struct pusher<std::reference_wrapper<T>> {
 
 template<>
 struct pusher<bool> {
-    static int push(lua_State* L, const bool& b) {
+    static int push(lua_State* L, bool b) {
         lua_pushboolean(L, b);
         return 1;
     }
@@ -547,12 +547,20 @@ struct pusher<bool> {
 
 template<>
 struct pusher<nil_t> {
-    static int push(lua_State* L, const nil_t&) {
+    static int push(lua_State* L, nil_t) {
         lua_pushnil(L);
         return 1;
     }
 };
 
+template<>
+struct pusher<std::remove_pointer_t<lua_CFunction>> {
+    static int push(lua_State* L, lua_CFunction func, int n = 0) {
+        lua_pushcclosure(L, func, n);
+        return 1;
+    }
+};
+
 template<>
 struct pusher<lua_CFunction> {
     static int push(lua_State* L, lua_CFunction func, int n = 0) {
@@ -759,7 +767,6 @@ template <bool b>
 struct check_arguments {
     template <std::size_t I0, std::size_t... I, typename Arg0, typename... Args>
     static bool check(types<Arg0, Args...>, std::index_sequence<I0, I...>, lua_State* L, int firstargument) {
-        bool checks = true;
         if (!stack::check<Arg0>(L, firstargument + I0))
             return false;
         return check(types<Args...>(), std::index_sequence<I...>(), L, firstargument);
@@ -780,24 +787,14 @@ struct check_arguments<false> {
 
 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) {
-    const int stacksize = lua_gettop(L);
+    check_arguments<checkargs>{}.check(ta, tai, L, start);
-    const int firstargument = static_cast<int>(start + stacksize - std::max(sizeof...(Args)-1, static_cast<std::size_t>(0)));
+    return fx(std::forward<FxArgs>(args)..., stack::get<Args>(L, start + I)...);
-
-    check_arguments<checkargs>{}.check(ta, tai, L, firstargument);
-
-    return fx(std::forward<FxArgs>(args)..., stack::get<Args>(L, firstargument + I)...);
 }
 
 template <bool checkargs = default_check_arguments, std::size_t... I, typename... Args, typename Fx, typename... FxArgs>
 inline void call(types<void>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-    const int stacksize = lua_gettop(L);
+    check_arguments<checkargs>{}.check(ta, tai, L, start);
-    const int firstargument = static_cast<int>(start + stacksize - std::max(sizeof...(Args)-1, static_cast<std::size_t>(0)));
+    fx(std::forward<FxArgs>(args)..., stack::get<Args>(L, start + I)...);
-
-    bool checks = check_arguments<checkargs>{}.check(ta, tai, L, firstargument);
-    if ( !checks )
-        throw error("Arguments not of the proper types for this function call");
-
-    fx(std::forward<FxArgs>(args)..., stack::get<Args>(L, firstargument + I)...);
 }
 } // stack_detail
 
@@ -831,7 +828,12 @@ inline R call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx,
 
 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) {
-    return call<check_args>(tr, ta, L, 0, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+    return call<check_args>(tr, ta, L, 1, 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 top_call(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)...);
 }
 
 template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
@@ -842,20 +844,25 @@ inline void call(types<void> tr, types<Args...> ta, lua_State* L, int start, Fx&
 
 template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
 inline void call(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
-    call<check_args>(tr, ta, L, 0, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+    call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
 }
 
-template<bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx>
+template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
-inline int typed_call(types<void> tr, types<Args...> ta, Fx&& fx, lua_State* L, int start = 0) {
+inline void top_call(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
-    call<check_args>(tr, ta, L, start, fx);
+    call<check_args>(tr, ta, L, static_cast<int>(lua_gettop(L) - sizeof...(Args)), std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+}
+
+template<bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
+inline int typed_call(types<void> tr, types<Args...> ta, Fx&& fx, lua_State* L, int start = 1, FxArgs&&... fxargs) {
+    call<check_args>(tr, ta, L, start, fx, std::forward<FxArgs>(fxargs)...);
     int nargs = static_cast<int>(sizeof...(Args));
     lua_pop(L, nargs);
     return 0;
 }
 
-template<bool check_args = stack_detail::default_check_arguments, typename... Ret, typename... Args, typename Fx>
+template<bool check_args = stack_detail::default_check_arguments, typename Ret0, typename... Ret, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<Not<std::is_void<Ret0>>::value>>
-inline int typed_call(types<Ret...>, types<Args...> ta, Fx&& fx, lua_State* L, int start = 0) {
+inline int typed_call(types<Ret0, Ret...>, types<Args...> ta, Fx&& fx, lua_State* L, int start = 1, FxArgs&&... fxargs) {
-    decltype(auto) r = call<check_args>(types<ReturnType<Ret...>>(), ta, L, start, fx);
+    decltype(auto) r = call<check_args>(types<return_type_t<Ret0, Ret...>>(), ta, L, start, fx, std::forward<FxArgs>(fxargs)...);
     int nargs = static_cast<int>(sizeof...(Args));
     lua_pop(L, nargs);
     return push(L, std::forward<decltype(r)>(r));

sol/state_view.hpp

@@ -177,9 +177,16 @@ public:
         return *this;
     }
 
-    template<typename Class, typename... CTor, typename... Args>
+    template<typename Class, typename... Args>
     state_view& new_usertype(const std::string& name, Args&&... args) {
-        constructors<types<CTor...>> ctor{};
+        usertype<Class> utype(std::forward<Args>(args)...);
+        set_usertype(name, utype);
+        return *this;
+    }
+
+    template<typename Class, typename CTor0, typename... CTor, typename... Args>
+    state_view& new_usertype(const std::string& name, Args&&... args) {
+        constructors<types<CTor0, CTor...>> ctor{};
         return new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
     }
 

sol/traits.hpp

@@ -125,6 +125,15 @@ struct find_in_pack_v : Bool<false> { };
 template<typename V, typename Vs1, typename... Vs>
 struct find_in_pack_v<V, Vs1, Vs...> : Or<Bool<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> { };
 
+template<std::size_t I, typename... Args>
+struct at_in_pack {};
+
+template<std::size_t I, typename... Args>
+using at_in_pack_t = typename at_in_pack<I, Args...>::type;
+
+template<std::size_t I, typename Arg, typename... Args>
+struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> {};
+
 template<typename... Args>
 struct return_type {
     typedef std::tuple<Args...> type;
@@ -143,12 +152,6 @@ struct return_type<> {
 template <typename... Args>
 using return_type_t = typename return_type<Args...>::type;
 
-template <typename Empty, typename... Args>
-using ReturnTypeOr = typename std::conditional<(sizeof...(Args) < 1), Empty, return_type_t<Args...>>::type;
-
-template <typename... Args>
-using ReturnType = ReturnTypeOr<void, Args...>;
-
 namespace detail {
 
 template<typename T, bool isclass = std::is_class<Unqualified<T>>::value>

sol/tuple.hpp

@@ -30,15 +30,6 @@ template<typename... Args>
 struct types { typedef std::index_sequence_for<Args...> indices; static constexpr std::size_t size() { return sizeof...(Args); } };
  
 namespace detail {
-template<typename Arg>
-struct chop_one : types<> {};
-
-template<typename Arg0, typename Arg1, typename... Args>
-struct chop_one<types<Arg0, Arg1, Args...>> : types<Arg1, Args...> {};
-
-template<typename Arg, typename... Args>
-struct chop_one<types<Arg, Args...>> : types<Args...> {};
-
 template<typename... Args>
 struct tuple_types_ { typedef types<Args...> type; };
 
@@ -53,12 +44,15 @@ template<typename... Args>
 using tuple_types = typename detail::tuple_types_<Args...>::type;
 
 template<typename Arg>
-struct remove_one_type : detail::chop_one<Arg> {};
+struct pop_front_type;
+
+template<typename Arg>
+using pop_front_type_t = typename pop_front_type<Arg>::type;
+
+template<typename Arg, typename... Args>
+struct pop_front_type<types<Arg, Args...>> { typedef types<Args...> type; };
 
-template<typename... Args>
-using constructors = sol::types<Args...>;
 
-const auto default_constructor = constructors<types<>>{};
 
 } // sol
 

sol/usertype.hpp

@@ -25,7 +25,7 @@
 #include "state.hpp"
 #include "function_types.hpp"
 #include "usertype_traits.hpp"
-#include "default_construct.hpp"
+#include "raii.hpp"
 #include "deprecate.hpp"
 #include <vector>
 #include <array>
@@ -88,8 +88,34 @@ namespace sol {
 };
 
 namespace usertype_detail {
-		template<typename T, typename Funcs, typename FuncTable, typename MetaFuncTable>
+struct add_destructor_tag {};
-		inline void push_metatable(lua_State* L, Funcs&& funcs, FuncTable&&, MetaFuncTable&& metafunctable) {
+struct check_destructor_tag {};
+struct verified_tag {} const verified {};
+
+template <typename T>
+struct is_constructor : std::false_type {};
+
+template <typename... Args>
+struct is_constructor<constructors<Args...>> : std::true_type {};
+
+template <typename... Args>
+struct is_constructor<constructor_wrapper<Args...>> : std::true_type {};
+
+template <typename... Args>
+using has_constructor = Or<is_constructor<Unqualified<Args>>...>;
+
+template <typename T>
+struct is_destructor : std::false_type {};
+
+template <typename Fx>
+struct is_destructor<destructor_wrapper<Fx>> : std::true_type {};
+
+template <typename... Args>
+using has_destructor = Or<is_destructor<Unqualified<Args>>...>;
+
+template<typename T, bool refmeta, typename Funcs, typename FuncTable, typename MetaFuncTable>
+inline void push_metatable(lua_State* L, bool needsindexfunction, Funcs&& funcs, FuncTable&& functable, MetaFuncTable&& metafunctable) {
+    static const auto& gcname = meta_function_names[static_cast<int>(meta_function::garbage_collect)];
     luaL_newmetatable(L, &usertype_traits<T>::metatable[0]);
     int metatableindex = lua_gettop(L);
     if (funcs.size() < 1 && metafunctable.size() < 2) {
@@ -97,53 +123,46 @@ namespace sol {
     }
     // Metamethods directly on the metatable itself
     int metaup = stack::stack_detail::push_upvalues(L, funcs);
-			if (std::is_pointer<T>::value) {
+    if (refmeta && gcname == metafunctable[metafunctable.size()-2].name) {
-				// Insert nullptr before new/gc methods for pointer types;
+        // We can just "clip" out the __gc function,
-				// prevents calling new/GC on pointer-based tables.
+        // which we always put as the last entry in the meta function table.
-				luaL_Reg& oldref = metafunctable[metafunctable.size() - 3];
+        luaL_Reg& target = metafunctable[metafunctable.size() - 2];
-				luaL_Reg old = oldref;
+        luaL_Reg old = target;
-				oldref = { nullptr, nullptr };
+        target = { nullptr, nullptr };
         luaL_setfuncs(L, metafunctable.data(), metaup);
-				oldref = old;
+        target = old;
     }
     else {
+        // Otherwise, just slap it in there.
         luaL_setfuncs(L, metafunctable.data(), metaup);
     }
+    if (needsindexfunction) {
+        // We don't need to do anything more
+        // since we've already bound the __index field using
+        // setfuncs above...
+        return;
+    }
+    // Otherwise, we use quick, fast table indexing for methods
+    // gives us performance boost in calling them
+    lua_createtable(L, 0, functable.size());
+    int up = stack::stack_detail::push_upvalues(L, funcs);
+    luaL_setfuncs(L, functable.data(), up);
+    lua_setfield(L, metatableindex, "__index");
+    return;
 }
 
 template <typename T, typename Functions>
-		inline void set_global_deleter(lua_State* L, lua_CFunction cleanup, Functions&& metafunctions) {
+inline void set_global_deleter(lua_State* L, lua_CFunction cleanup, Functions&& functions) {
     // Automatic deleter table -- stays alive until lua VM dies
     // even if the user calls collectgarbage(), weirdly enough
-			lua_createtable(L, 0, 0);
+    lua_createtable(L, 0, 0); // global table that sits at toplevel
-			lua_createtable(L, 0, 1);
+    lua_createtable(L, 0, 1); // metatable for the global table
-			int up = stack::stack_detail::push_upvalues<true>(L, metafunctions);
+    int up = stack::stack_detail::push_upvalues<true>(L, functions);
-			lua_pushcclosure(L, cleanup, up);
+    stack::set_field(L, "__gc", c_closure(cleanup, up));
-			lua_setfield(L, -2, "__gc");
     lua_setmetatable(L, -2);
     // gctable name by default has ♻ part of it
     lua_setglobal(L, &usertype_traits<T>::gc_table[0]);
 }
-
-		template<typename T, typename... Args>
-		static void do_constructor(lua_State* L, T* obj, call_syntax syntax, int, types<Args...>) {
-			default_construct fx{};
-			stack::call(types<void>(), types<Args...>(), L, -1 + static_cast<int>(syntax), fx, obj);
-		}
-
-		template <typename T>
-		static void match_constructor(lua_State*, T*, call_syntax, int) {
-			throw error("No matching constructor for the arguments provided");
-		}
-
-		template<typename T, typename ...CArgs, typename... Args>
-		static void match_constructor(lua_State* L, T* obj, call_syntax syntax, int argcount, types<CArgs...> t, Args&&... args) {
-			if (argcount == sizeof...(CArgs)) {
-				do_constructor<T>(L, obj, syntax, argcount, t);
-				return;
-			}
-			match_constructor<T>(L, obj, syntax, argcount, std::forward<Args>(args)...);
-		}
 }
 
 template<typename T>
@@ -157,50 +176,20 @@ namespace sol {
     base_function* indexfunc;
     base_function* newindexfunc;
     function_map_t indexwrapper, newindexwrapper;
-		base_function* constructfunc;
+    lua_CFunction constructfunc;
-		base_function* destructfunc;
+    const char* destructfuncname;
-		lua_CFunction functiongc;
+    lua_CFunction destructfunc;
-
+    lua_CFunction functiongcfunc;
-		template<typename... TTypes>
+    bool needsindexfunction;
-		struct constructor {
-			static int construct(lua_State* L) {
-				const auto& meta = usertype_traits<T>::metatable;
-				call_syntax syntax = stack::get_call_syntax(L, meta);
-				int argcount = lua_gettop(L);
-
-				T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
-				T*& referencepointer = *pointerpointer;
-				T* obj = reinterpret_cast<T*>(pointerpointer + 1);
-				referencepointer = obj;
-				int userdataindex = lua_gettop(L);
-				usertype_detail::match_constructor(L, obj, syntax, argcount - static_cast<int>(syntax), identity_t<TTypes>()...);
-
-				if (luaL_newmetatable(L, &meta[0]) == 1) {
-					lua_pop(L, 1);
-					std::string err = "unable to get usertype metatable for ";
-					err += meta;
-					throw error(err);
-				}
-				lua_setmetatable(L, userdataindex);
-
-				return 1;
-			}
-		};
-
-		static int destruct(lua_State* L) {
-			userdata udata = stack::get<userdata>(L, 1);
-			// The first sizeof(T*) bytes are the reference: the rest is
-			// the actual data itself (if there is a reference at all)
-			T** pobj = reinterpret_cast<T**>(udata.value);
-			T*& obj = *pobj;
-			std::allocator<T> alloc{};
-			alloc.destroy(obj);
-			return 0;
-		}
 
     template<typename... Functions>
     std::unique_ptr<base_function> make_function(const std::string&, overload_set<Functions...> func) {
-			return std::make_unique<usertype_overloaded_function<T, Functions...>>(func);
+        return std::make_unique<usertype_overloaded_function<T, Functions...>>(std::move(func));
+    }
+
+    template<typename... Functions>
+    std::unique_ptr<base_function> make_function(const std::string&, constructor_wrapper<Functions...> func) {
+        return std::make_unique<usertype_constructor_function<T, Functions...>>(std::move(func));
     }
 
     template<typename Arg, typename... Args, typename Ret>
@@ -241,33 +230,85 @@ namespace sol {
         return std::make_unique<usertype_function<function_type, T>>(func);
     }
 
+    template<std::size_t N, typename... Args>
+    void build_function(std::string funcname, constructors<Args...>) {
+        functionnames.push_back(std::move(funcname));
+        std::string& name = functionnames.back();
+        // Insert bubble to keep with compile-time argument count (simpler and cheaper to do)
+        functions.push_back(nullptr);
+        constructfunc = construct<T, Args...>;
+        metafunctiontable.push_back({ functionnames.back().c_str(), constructfunc });
+    }
+
+    template<std::size_t N>
+    void build_function(std::string funcname, destructor_wrapper<void>) {
+        auto metamethodfind = std::find(meta_function_names.begin(), meta_function_names.end(), funcname);
+        if (metamethodfind == meta_function_names.end())
+            throw error("cannot set destructor to anything but the metamethod \"__gc\"");
+        meta_function metafunction = static_cast<meta_function>(metamethodfind - meta_function_names.begin());
+        if (metafunction != meta_function::garbage_collect)
+            throw error("cannot set destructor to anything but the metamethod \"__gc\"");
+            
+        functionnames.push_back(std::move(funcname));
+        std::string& name = functionnames.back();
+        destructfunc = destruct<T>;
+        destructfuncname = name.c_str();
+        // Insert bubble to stay with the compile-time count
+        functions.push_back(nullptr);    
+    }
+
+    template<std::size_t N, typename Fx>
+    void build_function(std::string funcname, destructor_wrapper<Fx> dx) {
+        auto metamethodfind = std::find(meta_function_names.begin(), meta_function_names.end(), funcname);
+        if (metamethodfind == meta_function_names.end())
+            throw error("cannot set destructor to anything but the metamethod \"__gc\"");
+        meta_function metafunction = static_cast<meta_function>(metamethodfind - meta_function_names.begin());
+        if (metafunction != meta_function::garbage_collect)
+            throw error("cannot set destructor to anything but the metamethod \"__gc\"");
+
+        functionnames.push_back(std::move(funcname));
+        std::string& name = functionnames.back();
+        auto baseptr = make_function(name, std::move(dx.fx));
+        functions.emplace_back(std::move(baseptr));
+        destructfunc = detail::usertype_call<N>;
+        destructfuncname = name.c_str();
+    }
+
     template<std::size_t N, typename Fx>
     void build_function(std::string funcname, Fx&& func) {
         typedef std::is_member_object_pointer<Unqualified<Fx>> is_variable;
-			typedef std::decay_t<Fx> function_type;
         functionnames.push_back(std::move(funcname));
         std::string& name = functionnames.back();
         auto baseptr = make_function(name, std::forward<Fx>(func));
         functions.emplace_back(std::move(baseptr));
-			if (is_variable::value) {
-				indexwrapper.insert({ name, { false, functions.back().get() } });
-				newindexwrapper.insert({ name, { false, functions.back().get() } });
-				return;
-			}
         auto metamethodfind = std::find(meta_function_names.begin(), meta_function_names.end(), name);
         if (metamethodfind != meta_function_names.end()) {
+            metafunctiontable.push_back({ name.c_str(), detail::usertype_call<N> });
             meta_function metafunction = static_cast<meta_function>(metamethodfind - meta_function_names.begin());
             switch (metafunction) {
+            case meta_function::garbage_collect:
+                destructfuncname = name.c_str();
+                destructfunc = detail::usertype_call<N>;
+                return;
             case meta_function::index:
                 indexfunc = functions.back().get();
+                needsindexfunction = true;
                 break;
             case meta_function::new_index:
                 newindexfunc = functions.back().get();
                 break;
+            case meta_function::construct:
+                constructfunc = detail::usertype_call<N>;
+                break;
             default:
                 break;
             }
-				metafunctiontable.push_back({ name.c_str(), detail::usertype_call<N> });
+            return;
+        }
+        if (is_variable::value) {
+            needsindexfunction = true;
+            indexwrapper.insert({ name, { false, functions.back().get() } });
+            newindexwrapper.insert({ name, { false, functions.back().get() } });
             return;
         }
         indexwrapper.insert({ name, { true, functions.back().get() } });
@@ -300,55 +341,59 @@ namespace sol {
             metafunctiontable.push_back({ "__newindex", indexwrapper.empty() ? detail::usertype_call<N> : detail::usertype_call<N + 1> });
             ++variableend;
         }
+        if (destructfunc != nullptr) {
+            metafunctiontable.push_back({ destructfuncname, destructfunc });
+        }
         switch (variableend) {
         case 2:
-				functiongc = detail::usertype_gc<N + 2>;
+            functiongcfunc = detail::usertype_gc<N + 2>;
             break;
         case 1:
-				functiongc = detail::usertype_gc<N + 1>;
+            functiongcfunc = detail::usertype_gc<N + 1>;
             break;
         case 0:
-				functiongc = detail::usertype_gc<N + 0>;
+            functiongcfunc = detail::usertype_gc<N + 0>;
             break;
         }
     }
 
-	public:
     template<typename... Args>
-		usertype(Args&&... args) : usertype(default_constructor, std::forward<Args>(args)...) {}
+    usertype(usertype_detail::verified_tag, Args&&... args) : indexfunc(nullptr), newindexfunc(nullptr), constructfunc(nullptr), destructfunc(nullptr), functiongcfunc(nullptr), needsindexfunction(false) {
-
-		template<typename... Args, typename... CArgs>
-		usertype(constructors<CArgs...>, Args&&... args) 
-		: indexfunc(nullptr), newindexfunc(nullptr), constructfunc(nullptr), destructfunc(nullptr), functiongc(nullptr) {
         functionnames.reserve(sizeof...(args)+3);
         functiontable.reserve(sizeof...(args)+3);
         metafunctiontable.reserve(sizeof...(args)+3);
 
         build_function_tables<0>(std::forward<Args>(args)...);
-		
-			functionnames.push_back("new");
-			metafunctiontable.push_back({ functionnames.back().c_str(), &constructor<CArgs...>::construct });
-			functionnames.push_back("__gc");
-			metafunctiontable.push_back({ functionnames.back().c_str(), destruct });
-
-			// ptr_functions does not participate in garbage collection/new,
-			// as all pointered types are considered
-			// to be references. This makes returns of
-			// `std::vector<int>&` and `std::vector<int>*` work
         metafunctiontable.push_back({ nullptr, nullptr });
         functiontable.push_back({ nullptr, nullptr });
     }
 
+    template<typename... Args>
+    usertype(usertype_detail::add_destructor_tag, Args&&... args) : usertype(usertype_detail::verified, "__gc", default_destructor, std::forward<Args>(args)...) {}
+
+    template<typename... Args>
+    usertype(usertype_detail::check_destructor_tag, Args&&... args) : usertype(If<And<std::is_destructible<T>, Not<usertype_detail::has_destructor<Args...>>>, usertype_detail::add_destructor_tag, usertype_detail::verified_tag>(), std::forward<Args>(args)...) {}
+
+public:
+
+    template<typename... Args>
+    usertype(Args&&... args) : usertype(If<And<std::is_default_constructible<T>, Not<usertype_detail::has_constructor<Args...>>>, decltype(default_constructor), usertype_detail::check_destructor_tag>(), std::forward<Args>(args)...) {}
+
+    template<typename... Args, typename... CArgs>
+    usertype(constructors<CArgs...> constructorlist, Args&&... args) : usertype(usertype_detail::verified, "new", constructorlist, "__gc", default_destructor, std::forward<Args>(args)...) {
+            
+    }
+
     int push(lua_State* L) {
         // push pointer tables first,
-			usertype_detail::push_metatable<T*>(L, functions, functiontable, metafunctiontable);
+        usertype_detail::push_metatable<T*, true>(L, needsindexfunction, functions, functiontable, metafunctiontable);
         lua_pop(L, 1);
         // but leave the regular T table on last
         // so it can be linked to a type for usage with `.new(...)` or `:new(...)`
-			usertype_detail::push_metatable<T>(L, functions, functiontable, metafunctiontable);
+        usertype_detail::push_metatable<T, false>(L, needsindexfunction, functions, functiontable, metafunctiontable);
         // Make sure to drop a table in the global namespace to properly destroy the pushed functions
         // at some later point in life
-			usertype_detail::set_global_deleter<T>(L, functiongc, functions);
+        usertype_detail::set_global_deleter<T>(L, functiongcfunc, functions);
         return 1;
     }
 };

tests.cpp

@@ -224,6 +224,41 @@ struct giver {
 
 };
 
+struct factory_test {
+private:
+    factory_test() { a = true_a; }
+    ~factory_test() { a = 0; }
+public:
+    static int num_saved;
+    static int num_killed;
+
+    struct deleter {
+        void operator()(factory_test* f) {
+            f->~factory_test();
+        }
+    };
+
+    static const int true_a = 156;
+    int a;
+
+    static std::unique_ptr<factory_test, deleter> make() {
+        return std::unique_ptr<factory_test, deleter>( new factory_test(), deleter());
+    }
+
+    static void save(factory_test& f) {
+        new(&f)factory_test();
+        ++num_saved;
+    }
+
+    static void kill(factory_test& f) {
+        f.~factory_test();
+        ++num_killed;
+    }
+};
+
+int factory_test::num_saved = 0;
+int factory_test::num_killed = 0;
+
 TEST_CASE("table/traversal", "ensure that we can chain requests and tunnel down into a value if we desire") {
 
     sol::state lua;
@@ -1307,6 +1342,36 @@ func(1,2,3)
     REQUIRE_THROWS(lua.script("func(1,2,'meow')"));
 }
 
+TEST_CASE("usertype/private constructible", "Check to make sure special snowflake types from Enterprise thingamahjongs work properly.") {
+    int numsaved = factory_test::num_saved;
+    int numkilled = factory_test::num_killed;
+    {
+        sol::state lua;
+        lua.open_libraries(sol::lib::base);
+
+        lua.new_usertype<factory_test>("factory_test",
+           "new", sol::constructor(factory_test::save),
+           "__gc", sol::destructor(factory_test::kill),
+          "a", &factory_test::a
+        );
+    
+        std::unique_ptr<factory_test, factory_test::deleter> f = factory_test::make();
+        lua.set("true_a", factory_test::true_a, "f", f.get());
+        REQUIRE_NOTHROW(lua.script(R"(
+assert(f.a == true_a)
+)"));
+
+        REQUIRE_NOTHROW(lua.script(R"(
+local fresh_f = factory_test:new()
+assert(fresh_f.a == true_a)
+)"));
+    }
+    int expectednumsaved = numsaved + 1;
+    int expectednumkilled = numkilled + 1;
+    REQUIRE(expectednumsaved == factory_test::num_saved);
+    REQUIRE(expectednumkilled == factory_test::num_killed);
+}
+
 TEST_CASE("usertype/overloading", "Check if overloading works properly for usertypes") {
     struct woof {
         int var;