Enable shared_ptr to work without ContainerTraits::construct

Source/LuaBridge/detail/TypeTraits.h

@@ -23,6 +23,10 @@ using is_base_of_template = decltype(is_base_of_template_impl<C>(std::declval<T*
 
 template <class T, template <class...> class C>
 static inline constexpr bool is_base_of_template_v = is_base_of_template<T, C>::value;
+
+template <class... Args>
+constexpr bool dependent_false = false;
+
 } // namespace detail
 
 //=================================================================================================
@@ -68,18 +72,25 @@ struct ContainerTraits
 /**
  * @brief Register shared_ptr support as container.
  *
- * @tparam T Class that is hold by the shared_ptr, must inherit from std::enable_shared_from_this.
+ * @tparam T Class that is hold by the shared_ptr, must inherit from std::enable_shared_from_this to support Stack::get to reconstruct it from lua.
  */
 template <class T>
 struct ContainerTraits<std::shared_ptr<T>>
 {
-    static_assert(detail::is_base_of_template_v<T, std::enable_shared_from_this>);
-
     using Type = T;
 
-    static std::shared_ptr<T> construct(T* t)
+    template <class U = T>
+    static std::shared_ptr<U> construct(U* t)
     {
-        return std::static_pointer_cast<T>(t->shared_from_this());
+        if constexpr (detail::is_base_of_template_v<U, std::enable_shared_from_this>)
+        {
+            return std::static_pointer_cast<U>(t->shared_from_this());
+        }
+        else
+        {
+            static_assert(detail::dependent_false<U>,
+                "Failed reconstructing the reference count of the object instance, class must inherit from std::enable_shared_from_this");
+        }
     }
 
     static T* get(const std::shared_ptr<T>& c)

Source/LuaBridge/detail/Userdata.h

@@ -986,7 +986,8 @@ struct StackOpSelector<T*, true>
 
     static ReturnType get(lua_State* L, int index) { return Userdata::get<T>(L, index, false); }
 
-    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<T>(L, index); }
+    template <class U = T>
+    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<U>(L, index); }
 };
 
 // pointer to const
@@ -999,7 +1000,8 @@ struct StackOpSelector<const T*, true>
 
     static ReturnType get(lua_State* L, int index) { return Userdata::get<T>(L, index, true); }
 
-    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<T>(L, index); }
+    template <class U = T>
+    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<U>(L, index); }
 };
 
 // l-value reference
@@ -1013,7 +1015,8 @@ struct StackOpSelector<T&, true>
 
     static ReturnType get(lua_State* L, int index) { return Helper::get(L, index); }
 
-    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<T>(L, index); }
+    template <class U = T>
+    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<U>(L, index); }
 };
 
 // l-value reference to const
@@ -1027,7 +1030,8 @@ struct StackOpSelector<const T&, true>
 
     static ReturnType get(lua_State* L, int index) { return Helper::get(L, index); }
 
-    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<T>(L, index); }
+    template <class U = T>
+    static bool isInstance(lua_State* L, int index) { return Userdata::isInstance<U>(L, index); }
 };
 
 } // namespace detail

Tests/Source/Tests.cpp

@@ -720,6 +720,43 @@ TEST_F(LuaBridgeTest, StdSharedPtrAsProperty)
     EXPECT_EQ(42, result<int>());
 }
 
+TEST_F(LuaBridgeTest, SharedPtrNoEnableSharedFromThis)
+{
+    using TestC = TestClass<int>;
+
+    luabridge::getGlobalNamespace(L)
+        .beginNamespace("ns")
+            .beginClass<TestC>("TestClass")
+                .addFunction("getValue", &TestC::getValue)
+                .addFunction("getValueConst", &TestC::getValueConst)
+            .endClass()
+        .endNamespace();
+
+    {
+        std::shared_ptr<TestC> a = std::make_shared<TestC>(42);
+        auto result = luabridge::setGlobal(L, a, "a");
+        ASSERT_TRUE(result);
+    }
+
+    runLua("result = a");
+    ASSERT_TRUE(result().isInstance<TestC*>());
+    ASSERT_TRUE(result().isInstance<const TestC*>());
+    ASSERT_TRUE(result().isInstance<TestC&>());
+    ASSERT_TRUE(result().isInstance<const TestC&>());
+
+    auto x1 = result<TestC*>();
+    EXPECT_EQ(42, x1->getValue());
+
+    auto x2 = result<const TestC*>();
+    EXPECT_EQ(42, x2->getValueConst());
+
+    auto& x3 = result<TestC&>();
+    EXPECT_EQ(42, x3.getValue());
+
+    auto x4 = result<const TestC&>();
+    EXPECT_EQ(42, x4.getValueConst());
+}
+
 #if LUABRIDGE_HAS_EXCEPTIONS
 namespace {
 template <class... Args>