From 0cc7436be1f57299384c5acad5d32e13f2f4d1cf Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 27 Jun 2024 19:47:00 -0400
Subject: Introduce TypeTag<T> template whose int value differs for each T.

This replaces type_tag<T>(), which searched and possibly extended the type_tags
unordered_map at runtime. If we called lua_emplace<T>() from different threads,
that would require locking type_tags.

In contrast, the compiler must instantiate a distinct TypeTag<T> for every
distinct T passed to lua_emplace<T>(), so each gets a distinct value at static
initialization time. No locking is required; no lookup; no allocations.

Add a test to llluamanager_test.cpp to verify that each distinct T passed to
lua_emplace<T>() gets its own TypeTag<T>::value, and that each gets its own
destructor -- but that different lua_emplace<T>() calls with the same T share
the same TypeTag<T>::value and the same destructor.
---
 indra/newview/tests/llluamanager_test.cpp | 35 +++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

(limited to 'indra/newview/tests')

diff --git a/indra/newview/tests/llluamanager_test.cpp b/indra/newview/tests/llluamanager_test.cpp
index 2d525f7913..d3fc70dfd5 100644
--- a/indra/newview/tests/llluamanager_test.cpp
+++ b/indra/newview/tests/llluamanager_test.cpp
@@ -465,4 +465,39 @@ namespace tut
         ensure_equals(desc + " count: " + result.asString(), count, -1);
         ensure_contains(desc + " result", result.asString(), "terminated");
     }
+
+    template <typename T>
+    struct Visible
+    {
+        Visible(T name): name(name)
+        {
+            LL_INFOS() << "Visible<" << LLError::Log::classname<T>() << ">('" << name << "')" << LL_ENDL;
+        }
+        Visible(const Visible&) = delete;
+        Visible& operator=(const Visible&) = delete;
+        ~Visible()
+        {
+            LL_INFOS() << "~Visible<" << LLError::Log::classname<T>() << ">('" << name << "')" << LL_ENDL;
+        }
+        T name;
+    };
+
+    template<> template<>
+    void object::test<9>()
+    {
+        set_test_name("track distinct lua_emplace<T>() types");
+        LuaState L;
+        lua_emplace<Visible<std::string>>(L, "std::string 0");
+        int st0tag = lua_userdatatag(L, -1);
+        lua_emplace<Visible<const char*>>(L, "const char* 0");
+        int cp0tag = lua_userdatatag(L, -1);
+        lua_emplace<Visible<std::string>>(L, "std::string 1");
+        int st1tag = lua_userdatatag(L, -1);
+        lua_emplace<Visible<const char*>>(L, "const char* 1");
+        int cp1tag = lua_userdatatag(L, -1);
+        lua_settop(L, 0);
+        ensure_equals("lua_emplace<std::string>() tags diverge", st0tag, st1tag);
+        ensure_equals("lua_emplace<const char*>() tags diverge", cp0tag, cp1tag);
+        ensure_not_equals("lua_emplace<>() tags collide", st0tag, cp0tag);
+    }
 } // namespace tut
-- 
cgit v1.2.3