Removed .demote_full_userdata

7 files changed, 29 insertions, 65 deletions

diff --git a/deep_test/deep_test.cpp b/deep_test/deep_test.cpp
index 812019a..178075d 100644
--- a/deep_test/deep_test.cpp
+++ b/deep_test/deep_test.cpp
@@ -58,7 +58,7 @@ void MyDeepFactory::deleteDeepObjectInternal(lua_State* const L_, DeepPrelude* c
 {
     MyDeepUserdata* const _self{ static_cast<MyDeepUserdata*>(MyDeepFactory::Instance.toDeep(L, 1)) };
     _self->inUse.fetch_add(1, std::memory_order_seq_cst);
-    std::ignore = luaG_pushstring(L, "%p:deep(%d)", lua_topointer(L, 1), _self->val);
+    std::ignore = luaG_pushstring(L, "%p:deep(%d)", _self, _self->val);
     _self->inUse.fetch_sub(1, std::memory_order_seq_cst);
     return 1;
 }
diff --git a/deep_test/deeptest.lua b/deep_test/deeptest.lua
index 250eb98..bab91d9 100644
--- a/deep_test/deeptest.lua
+++ b/deep_test/deeptest.lua
@@ -38,9 +38,13 @@ local printDeep = function( prefix_, obj_, t_)
                 print ("uv #" .. uvi, type( uservalue), uservalue, type(uservalue) == "function" and uservalue() or "")
         end
         if t_ then
-                for k, v in pairs( t_) do
+                local count = 0
+                for k, v in ipairs( t_) do
                         print( "t["..tostring(k).."]", v)
+                        count = count + 1
                 end
+                -- we should have only 2 indexed entries with the same value
+                assert(count == 2 and t_[1] == t_[2])
         end
         print()
 end
@@ -56,8 +60,11 @@ local performTest = function( obj_)
 
         local t =
         {
-                ["key"] = obj_,
-                [obj_] = "val" -- this one won't transfer because we don't support full uservalue as keys
+                -- two indices with an identical value: we should also have identical values on the other side (even if not the same as the original ones when they are clonables)
+                obj_,
+                obj_,
+                -- this one won't transfer because we don't support full uservalue as keys
+                [obj_] = "val"
         }
 
         -- read back the contents of the object
diff --git a/docs/index.html b/docs/index.html
index 5675f65..4e8cc25 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -368,19 +368,6 @@
                 </tr>
 
                 <tr valign=top>
-                        <td id="demote_full_userdata">
-                                <code>.demote_full_userdata</code>
-                        </td>
-                        <td>
-                                <tt>nil</tt>/<tt>false</tt>/<tt>true</tt>
-                        </td>
-                        <td>
-                                If equal to <tt>false</tt> or <tt>nil</tt>, Lanes raises an error when attempting to transfer a non-deep full userdata, else it will be demoted to a light userdata in the destination.
-                                Default is <tt>false</tt> (set to <tt>true</tt> to get the legacy behaviour).
-                        </td>
-                </tr>
-
-                <tr valign=top>
                         <td id="track_lanes">
                                 <code>.track_lanes</code>
                         </td>
@@ -1547,47 +1534,36 @@ On the other side, you need to use a common Linda for waiting for multiple keys.
 
 <p>
         Data passed between lanes (either as starting parameters, return values, upvalues or via Lindas) must conform to the following:
-</p>
-
-<p>
         <ul>
+                <li>Coroutines cannot be passed. A coroutine's Lua state is tied to the Lua state that created it, and there is no way the mixed C/Lua stack of a coroutine can be transfered from one Lua state to another.</li>
+                <li>Lane handles cannot be passed between lanes.</li>
                 <li>Booleans, numbers, strings, light userdata, Lua functions and tables of such can always be passed.</li>
                 <li>
                         Cyclic tables and/or duplicate references are allowed and reproduced appropriately, but only <u>within the same transmission</u>.
-                        <ul>
-                                <li>Using the same source table in multiple <a href="#lindas">Linda</a> messages keeps no ties between the tables (this is the same reason why tables can't be used as keys).</li>
-                        </ul>
+                        Using the same source table in multiple <a href="#lindas">Linda</a> messages keeps no ties between the tables (this is the same reason why tables can't be used as keys).
                 </li>
                 <li>
-                        Objects (tables with a metatable) are copyable between lanes.
+                        For tables and full userdata: before anything else, the metatable is searched for a <tt>__lanesconvert</tt> field. If found, the source object is converted as follows depending on <tt>__lanesconvert</tt>'s value:
                         <ul>
-                                <li>Metatables are assumed to be immutable; they are internally indexed and only copied once per each type of objects per lane.</li>
+                                <li><tt>lanes.null</tt>: The value is converted to <tt>nil</tt>.</li>
+                                <li><tt>"decay"</tt>: The value is converted to a light userdata obtained from <tt>lua_topointer()</tt>.</li>
+                                <li>A function: The function is called as <tt>o:__lanesconvert(string)</tt>, where the argument is either <tt>"keeper"</tt> or <tt>"regular"</tt>, depending on the type of destination. Its (single) return value is the result of the conversion.</li>
+                                <li>Any other value raises an error.</li>
                         </ul>
                 </li>
                 <li>
-                        C functions (<tt>lua_CFunction</tt>) referring to <tt>LUA_ENVIRONINDEX</tt> or <tt>LUA_REGISTRYINDEX</tt> might not do what you expect in the target, since they will actually use a different environment.
+                        Non-converted full userdata can be passed only if it is prepared using the <a href="#deep_userdata">deep userdata</a> system, which handles its lifespan management.
                 </li>
                 <li>
-                        Lua 5.2 functions may have a special <tt>_ENV</tt> upvalue if they perform 'global namespace' lookups. Unless special care is taken, this upvalue defaults to the table found at <tt>LUA_RIDX_GLOBALS</tt>.
-                        Obviously, we don't want to transfer the whole global table along with each Lua function. Therefore, any upvalue equal to the global table is not transfered by value, but simply bound
-                        to the global table in the destination state. Note that this also applies when Lanes is built for Lua 5.1, as it doesn't hurt.
+                        Objects (tables with a metatable) are copyable between lanes. Metatables are assumed to be immutable; they are internally indexed and only copied once per each type of objects per lane.
                 </li>
                 <li>
-                        Full userdata can be passed only if it is prepared using the <a href="#deep_userdata">deep userdata</a> system, which handles its lifespan management
-                        <ul>
-                                <li>In particular, lane handles cannot be passed between lanes.</li>
-                                <li>Lanes can either throw an error or attempt a <a href="#demote_full_userdata">light userdata demotion</a>.</li>
-                        </ul>
+                        C functions (<tt>lua_CFunction</tt>) referring to <tt>LUA_ENVIRONINDEX</tt> or <tt>LUA_REGISTRYINDEX</tt> might not do what you expect in the target, since they will actually use a different environment.
                 </li>
-                <li>Coroutines cannot be passed. A coroutine's Lua state is tied to the Lua state that created it, and there is no way the mixed C/Lua stack of a coroutine can be transfered from one Lua state to another.</li>
                 <li>
-                        If the metatable contains <tt>__lanesconvert</tt>, the object is converted as follows depending on the value:
-                        <ul>
-                                <li><tt>lanes.null</tt>: The value is converted to <tt>nil</tt>.</li>
-                                <li><tt>"decay"</tt>: The value is converted to a light userdata obtained from <tt>lua_topointer()</tt>.</li>
-                                <li>A function: The function is called as <tt>o:__lanesconvert(string)</tt>, where the argument is either <tt>"keeper"</tt> or <tt>"regular"</tt>, depending on the type of destination. Its (single) return value is the result of the conversion.</li>
-                                <li>Any other value raises an error.</li>
-                        </ul>
+                        Lua 5.2 functions may have a special <tt>_ENV</tt> upvalue if they perform 'global namespace' lookups. Unless special care is taken, this upvalue defaults to the table found at <tt>LUA_RIDX_GLOBALS</tt>.
+                        Obviously, we don't want to transfer the whole global table along with each Lua function. Therefore, any upvalue equal to the global table is not transfered by value, but simply bound
+                        to the global table in the destination state. Note that this also applies when Lanes is built for Lua 5.1, as it doesn't hurt.
                 </li>
         </ul>
 </p>
diff --git a/src/intercopycontext.cpp b/src/intercopycontext.cpp
index a5fd400..5be4304 100644
--- a/src/intercopycontext.cpp
+++ b/src/intercopycontext.cpp
@@ -718,6 +718,8 @@ LuaType InterCopyContext::processConversion() const
         return false;
     }
 
+    DEBUGSPEW_CODE(DebugSpew(U) << "CLONABLE USERDATA" << std::endl);
+
     // we need to copy over the uservalues of the userdata as well
     {
         int const _mt{ luaG_absindex(L1, -2) };                                                    // L1: ... mt __lanesclone
@@ -795,6 +797,7 @@ LuaType InterCopyContext::processConversion() const
         return false; // not a deep userdata
     }
 
+    DEBUGSPEW_CODE(DebugSpew(U) << "DEEP USERDATA" << std::endl);
     STACK_CHECK_START_REL(L1, 0);
     STACK_CHECK_START_REL(L2, 0);
 
@@ -1085,27 +1088,13 @@ LuaType InterCopyContext::processConversion() const
     STACK_CHECK(L2, 0);
 
     // Allow only deep userdata entities to be copied across
-    DEBUGSPEW_CODE(DebugSpew(nullptr) << "USERDATA" << std::endl);
     if (tryCopyDeep()) {
         STACK_CHECK(L1, 0);
         STACK_CHECK(L2, 1);
         return true;
     }
 
-    STACK_CHECK(L1, 0);
-    STACK_CHECK(L2, 0);
-
-    // Not a deep or clonable full userdata
-    if (U->demoteFullUserdata) { // attempt demotion to light userdata
-        void* const _lud{ lua_touserdata(L1, L1_i) };
-        lua_pushlightuserdata(L2, _lud);
-    } else { // raise an error
-        raise_luaL_error(getErrL(), "can't copy non-deep full userdata across lanes");
-    }
-
-    STACK_CHECK(L2, 1);
-    STACK_CHECK(L1, 0);
-    return true;
+    raise_luaL_error(getErrL(), "can't copy non-deep full userdata across lanes");
 }
 
 // #################################################################################################
diff --git a/src/lanes.lua b/src/lanes.lua
index 92e773a..1378412 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -92,7 +92,6 @@ local default_params =
 {
     -- LuaJIT provides a thread-unsafe allocator by default, so we need to protect it when used in parallel lanes
     allocator = isLuaJIT and "protected" or nil,
-    demote_full_userdata = nil,
     -- it looks also like LuaJIT allocator may not appreciate direct use of its allocator for other purposes than the VM operation
     internal_allocator = isLuaJIT and "libc" or "allocator",
     keepers_gc_threshold = -1,
@@ -119,7 +118,6 @@ local param_checkers =
         -- can be nil, "protected", or a function
         return val_ and (type(val_) == "function" or val_ == "protected") or true
     end,
-    demote_full_userdata = boolean_param_checker,
     internal_allocator = function(val_)
         -- can be "libc" or "allocator"
         return val_ == "libc" or val_ == "allocator"
diff --git a/src/universe.cpp b/src/universe.cpp
index 9ab6019..82522f1 100644
--- a/src/universe.cpp
+++ b/src/universe.cpp
@@ -107,7 +107,6 @@ Universe::Universe()
     lua_setmetatable(L_, -2);                                                                      // L_: settings universe
     lua_pop(L_, 1);                                                                                // L_: settings
 
-    // TODO: write some tests to see what happens when we trigger errors in stripped mode
     std::ignore = luaG_getfield(L_, 1, "strip_functions");                                         // L_: settings strip_functions
     _U->stripFunctions = lua_toboolean(L_, -1) ? true : false;
     lua_pop(L_, 1);                                                                                // L_: settings
@@ -115,9 +114,6 @@ Universe::Universe()
     std::ignore = luaG_getfield(L_, 1, "verbose_errors");                                          // L_: settings verbose_errors
     _U->verboseErrors = lua_toboolean(L_, -1) ? true : false;
     lua_pop(L_, 1);                                                                                // L_: settings
-    std::ignore = luaG_getfield(L_, 1, "demote_full_userdata");                                    // L_: settings demote_full_userdata
-    _U->demoteFullUserdata = lua_toboolean(L_, -1) ? true : false;
-    lua_pop(L_, 1);                                                                                // L_: settings
 
     // tracking
     std::ignore = luaG_getfield(L_, 1, "track_lanes");                                             // L_: settings track_lanes
diff --git a/src/universe.h b/src/universe.h
index 2b8cdf2..f0975d8 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -128,8 +128,6 @@ class Universe
     // for verbose errors
     bool verboseErrors{ false };
 
-    bool demoteFullUserdata{ false };
-
     bool stripFunctions{ true };
 
     // before a state is created, this function will be called to obtain the allocator