Lift restriction on functions and userdata as table keysHEADmaster

As demonstrated by the unit tests, there is no problem with using a function or a userdata as a table key, as long as they are transferable

6 files changed, 149 insertions, 50 deletions

diff --git a/Lanes.vcxproj b/Lanes.vcxproj
index 3d49d9e..120f473 100644
--- a/Lanes.vcxproj
+++ b/Lanes.vcxproj
@@ -2060,6 +2060,7 @@ xcopy /F /I /R /Y "$(OutputPath)$(TargetName).pdb" "$(SolutionDir)_LuaVersions/$
     <None Include="tests\objects.lua" />
     <None Include="tests\parallel_os_calls.lua" />
     <None Include="tests\perftest.lua" />
+    <None Include="tests\pingpong.lua" />
     <None Include="tests\protectproxy.lua" />
     <None Include="tests\protect_allocator.lua" />
     <None Include="tests\recursive.lua" />
diff --git a/Lanes.vcxproj.filters b/Lanes.vcxproj.filters
index 3014132..b8196c8 100644
--- a/Lanes.vcxproj.filters
+++ b/Lanes.vcxproj.filters
@@ -297,6 +297,9 @@
     <None Include="Lanes.slnenv">
       <Filter>Resource Files\Make</Filter>
     </None>
+    <None Include="tests\pingpong.lua">
+      <Filter>tests</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="src\lanes.lua">
diff --git a/src/intercopycontext.cpp b/src/intercopycontext.cpp
index 7fb2706..61ce08f 100644
--- a/src/intercopycontext.cpp
+++ b/src/intercopycontext.cpp
@@ -937,10 +937,6 @@ void InterCopyContext::interCopyBoolean() const
 [[nodiscard]]
 bool InterCopyContext::interCopyFunction() const
 {
-    if (vt == VT::KEY) {
-        return false;
-    }
-
     STACK_CHECK_START_REL(L1, 0);
     STACK_CHECK_START_REL(L2, 0);
     DEBUGSPEW_CODE(DebugSpew(nullptr) << "FUNCTION " << name << std::endl);
@@ -1169,9 +1165,6 @@ InterCopyOneResult InterCopyContext::interCopyUserdata() const
 {
     STACK_CHECK_START_REL(L1, 0);
     STACK_CHECK_START_REL(L2, 0);
-    if (vt == VT::KEY) {
-        return InterCopyOneResult::NotCopied;
-    }
 
     // try clonable userdata first
     if (tryCopyClonable()) {
diff --git a/tests/errhangtest.lua b/tests/errhangtest.lua
index 5b3f0c0..819bc10 100644
--- a/tests/errhangtest.lua
+++ b/tests/errhangtest.lua
@@ -42,19 +42,23 @@ if true then
         print "OK"
 end
 
--- send a table that contains a function
+-- =================================================================================================
+-- send a table that contains a function, both as key and value
+-- =================================================================================================
+
 if true then
         print "\n#### send table with a function"
-        local fun = function() print "function test ok" end
-        local t_in = { [fun] = fun, fun = fun }
+        local fun = function() print "function test ok" return 42 end
+        local t_in = { [fun] = fun, ["fun"] = fun }
         print(pcall(linda.send, linda, 'test', t_in))
-        local k,t_out = linda:receive('test') -- read the contents successfully sent
-        t_out.fun()
-        -- t_out should contain a single entry, as [fun] = fun should have been discarded because functions are not acceptable keys
+        local k, t_out = linda:receive('test') -- read the contents successfully sent
+        -- t_out should contain two entries, just like t_in
         local count = 0
         for k,v in pairs(t_out) do count = count + 1 end
-        assert(count == 1)
-        print "OK"
+        assert(count == 2)
+        assert(t_out["fun"] == t_out[t_out.fun]) -- t_out[t_out.fun] should be identical to t_out["fun"]
+        assert(t_out["fun"] ~= fun) -- even if the function is not the original one but a copy
+        assert(t_out["fun"]() == t_out[t_out.fun]() and t_out["fun"]() == fun()) -- all functions should return the same value, since they are the same
 end
 
 -- send a string
diff --git a/unit_tests/scripts/linda/send_receive_tables.lua b/unit_tests/scripts/linda/send_receive_tables.lua
index 08b1f16..0e1569a 100644
--- a/unit_tests/scripts/linda/send_receive_tables.lua
+++ b/unit_tests/scripts/linda/send_receive_tables.lua
@@ -1,41 +1,137 @@
 local lanes = require "lanes"
+local dt = lanes.require "deep_userdata_example"
 
--- a newly created linda doesn't contain anything
 local l = lanes.linda()
 
+-- =================================================================================================
 -- send a table with subtables, both as keys and values, making sure the structure is preserved
+-- =================================================================================================
 
-local t1 = {["name"] = "t1"}
-local t2 = {["name"] = "t2"}
-
-local t3 = {
-        ["name"] = "t3",
-        ["t1"] = t1,
-        [t1] = t2, -- table t1 as key, table t2 as value
-        ["t2"] = t2,
-        [t2] = t1 -- table t2 as key, table t1 as value
-}
-
--- add recursivity for good measure
-t3["t3"] = t3
-t3[t3] = t3
-t1["t3"] = t3
-t2["t3"] = t3
-
-l:send("data", t3)
-local k, t = l:receive("data")
-assert(k == "data" and type(t) == "table" and t.name == "t3")
--- when keys are strings
-assert(t["t3"] == t)
-assert(type(t["t1"]) == "table")
-assert(t["t1"].name == "t1")
-assert(type(t["t2"]) == "table")
-assert(t["t2"].name == "t2")
-assert(t["t1"].t3 == t)
-assert(t["t2"].t3 == t)
--- when keys are tables
-assert(t[t.t1] == t.t2)
-assert(t[t.t1]["t3"] == t)
-assert(t[t.t2] == t.t1)
-assert(t[t.t2]["t3"] == t)
-assert(t[t.t3] == t.t3)
+if true then
+        local t1 = {["name"] = "t1"}
+        local t2 = {["name"] = "t2"}
+
+        local t3 = {
+                ["name"] = "t3",
+                ["t1"] = t1,
+                [t1] = t2, -- table t1 as key, table t2 as value
+                ["t2"] = t2,
+                [t2] = t1 -- table t2 as key, table t1 as value
+        }
+
+        -- add recursivity for good measure
+        t3["t3"] = t3
+        t3[t3] = t3
+        t1["t3"] = t3
+        t2["t3"] = t3
+
+        l:send("data", t3)
+        local k, t = l:receive("data")
+        assert(k == "data" and type(t) == "table" and t.name == "t3")
+        -- when keys are strings
+        assert(t["t3"] == t)
+        assert(type(t["t1"]) == "table")
+        assert(t["t1"].name == "t1")
+        assert(type(t["t2"]) == "table")
+        assert(t["t2"].name == "t2")
+        assert(t["t1"].t3 == t)
+        assert(t["t2"].t3 == t)
+        -- when keys are tables
+        assert(t[t.t1] == t.t2)
+        assert(t[t.t1]["t3"] == t)
+        assert(t[t.t2] == t.t1)
+        assert(t[t.t2]["t3"] == t)
+        assert(t[t.t3] == t.t3)
+end
+
+-- =================================================================================================
+-- send a table with deep userdata keys and values
+-- =================================================================================================
+
+if true then
+        local fixture = assert(require "fixture")
+        local u = assert(fixture.newuserdata())
+        assert(type(u) == "userdata")
+
+        -- send a table where full userdata is used as key
+        -- should fail because the userdata is not deep
+        local s, r = pcall(l.send, l, "data", {["k"] = u})
+        assert(s == false and type(r) == "string", "got " .. r)
+
+        -- trying again with full userdata
+        local d1 = dt.new_deep()
+        assert(type(d1) == "userdata")
+        local d2 = dt.new_deep()
+        assert(type(d2) == "userdata")
+
+        local t4 =
+        {
+                [d1] = d2,
+                [d2] = d1
+        }
+
+        l:send("data", t4)
+        local k, t = l:receive("data")
+        assert(k == "data" and type(t) == "table")
+        -- we should have 2 userdata entries in the table
+        local count = 0
+        for k, v in pairs(t) do
+                assert(type(k) == "userdata")
+                assert(type(v) == "userdata")
+                count = count + 1
+        end
+        assert(count == 2, "got " .. count)
+        -- all userdata identities should be preserved
+        assert(type(t[d1]) == "userdata")
+        assert(type(t[d2]) == "userdata")
+        assert(t[d1] == d2)
+        assert(t[d2] == d1)
+        assert(t[d1] == t4[d1])
+        assert(t[d2] == t4[d2])
+end
+
+-- =================================================================================================
+-- send a table with clonable userdata keys and values
+-- =================================================================================================
+
+if true then
+        local c1 = dt.new_clonable()
+        c1:set(1)
+        assert(type(c1) == "userdata")
+        local c2 = dt.new_clonable()
+        c2:set(2)
+        assert(type(c2) == "userdata")
+
+        l:send("data", c1)
+        local k, c = l:receive("data")
+        assert(k == "data" and type(c) == "userdata" and c:get() == 1, "got " .. tostring(c))
+
+        local t5 =
+        {
+                [c1] = c2,
+                [c2] = c1
+        }
+
+        l:send("data", t5)
+        local k, t = l:receive("data")
+        assert(k == "data" and type(t) == "table")
+        -- all userdata identities should NOT be preserved, because the cloned userdatas in t are not the originals that were stored in t5
+        assert(type(t[c1]) == "nil")
+        assert(type(t[c2]) == "nil")
+        -- but we should still have 2 userdata entries in the table
+        local count = 0
+        for k, v in pairs(t) do
+                assert(type(k) == "userdata")
+                assert(type(v) == "userdata")
+                count = count + 1
+        end
+        assert(count == 2, "got " .. count)
+        -- and c1-as-key should be identical to c1-as-value (same for c2)
+        -- of course I can't be sure that enumerating the table will start with key c1, but that's not important
+        local c1_as_key, c2_as_value = next(t)
+        assert(type(c1_as_key) == "userdata" and type(c2_as_value) == "userdata" and c1_as_key:get() ~= c2_as_value:get())
+        local c2_as_key, c1_as_value = next(t, c1_as_key)
+        assert(type(c2_as_key) == "userdata" and type(c1_as_value) == "userdata" and c2_as_key:get() ~= c1_as_value:get())
+        assert(c1_as_key == c1_as_value)
+        assert(c2_as_key == c2_as_value)
+end
diff --git a/unit_tests/scripts/linda/send_registered_userdata.lua b/unit_tests/scripts/linda/send_registered_userdata.lua
index 90c05c9..f0ec3d4 100644
--- a/unit_tests/scripts/linda/send_registered_userdata.lua
+++ b/unit_tests/scripts/linda/send_registered_userdata.lua
@@ -1,5 +1,7 @@
 local lanes = require 'lanes'.configure{with_timers = false}
 local l = lanes.linda{name = 'gleh'}
+
+-- io.stdin is a full userdata that was registered by lanes when it was required and scanned the global environment
 l:set('yo', io.stdin)
 local n, stdin_out = l:get('yo')
 assert(n == 1 and stdin_out == io.stdin, tostring(stdin_out) .. " ~= " .. tostring(io.stdin))