3 files changed, 54 insertions, 9 deletions

diff --git a/docs/index.html b/docs/index.html
index 400ceb1..73753d7 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1008,6 +1008,7 @@
                 <li><tt>nil, "killed"</tt> if forcefully killed.</li>
                 <li>The return values of the lane function. If the first return value is <tt>nil</tt> (or there is no return value), an error is raised, to make sure you can tell timeout and error cases apart from successful return.</li>
         </ul>
+        If the lane handle obtained from <tt>lanes.gen()</tt> is to-be-closed, closing the value will cause a call to <tt>join()</tt>. Since it is implicit, the lane body isn't forced to return non-<tt>nil</tt> in that case.
 </p>
 
 <table border=1 bgcolor="#FFFFE0" cellpadding="10" style="width:50%"><tr><td><pre>
diff --git a/src/lane.cpp b/src/lane.cpp
index eaf1c1e..1a01a24 100644
--- a/src/lane.cpp
+++ b/src/lane.cpp
@@ -135,9 +135,9 @@ static LUAG_FUNC(thread_join)
     switch (_lane->status) {
     case Lane::Done:
         {
-            bool const _calledFromIndex{ lua_toboolean(L_, lua_upvalueindex(1)) ? true : false }; // this upvalue doesn't exist when called from Lua
+            bool const _calledFromLua{ lua_toboolean(L_, lua_upvalueindex(1)) ? false : true }; // this upvalue doesn't exist when called from Lua
             int const _n{ lua_gettop(_L2) }; // whole L2 stack
-            if (!_calledFromIndex && (_n == 0 || lua_isnil(_L2, 1))) {
+            if (_calledFromLua && (_n == 0 || lua_isnil(_L2, 1))) {
                 raise_luaL_error(L_, "First return value must be non-nil when using join()");
             }
             if (
@@ -216,7 +216,7 @@ static int thread_index_number(lua_State* L_)
         lua_pushboolean(L_, 1);                                                                    // L_: lane n {uv} 0 true
         lua_rawset(L_, kUsr);                                                                      // L_: lane n {uv}
         // tell join() that we are called from __index, to avoid raising an error if the first returned value is not nil
-        lua_pushboolean(L_, 1);                                                                    // L_: lane n {uv} true
+        std::ignore = luaG_pushstring(L_, "[]");                                                   // L_: lane n {uv} "[]"
         // wait until thread has completed, transfer everything from the lane's stack to our side
         lua_pushcclosure(L_, LG_thread_join, 1);                                                   // L_: lane n {uv} join
         lua_pushvalue(L_, kSelf);                                                                  // L_: lane n {uv} join lane
@@ -733,6 +733,24 @@ static void lane_main(Lane* lane_)
 
 // #################################################################################################
 
+#if LUA_VERSION_NUM >= 504
+static LUAG_FUNC(lane_close)
+{
+    [[maybe_unused]] Lane* const _lane{ ToLane(L_, 1) };                                           // L_: lane err|nil
+    // drop the error if any
+    lua_settop(L_, 1);                                                                             // L_: lane
+
+    // no error if the lane body doesn't return a non-nil first value
+    std::ignore = luaG_pushstring(L_, "close");                                                    // L_: lane "close"
+    lua_pushcclosure(L_, LG_thread_join, 1);                                                       // L_: lane join()
+    lua_insert(L_, 1);                                                                             // L_: join() lane
+    lua_call(L_, 1, LUA_MULTRET);                                                                  // L_: join() results
+    return lua_gettop(L_);
+}
+#endif // LUA_VERSION_NUM >= 504
+
+// #################################################################################################
+
 // = thread_gc( lane_ud )
 //
 // Cleanup for a thread userdata. If the thread is still executing, leave it
@@ -744,7 +762,7 @@ static void lane_main(Lane* lane_)
 // and the issue of canceling/killing threads at gc is not very nice, either
 // (would easily cause waits at gc cycle, which we don't want).
 //
-[[nodiscard]] static int lane_gc(lua_State* L_)
+static LUAG_FUNC(lane_gc)
 {
     bool _have_gc_cb{ false };
     Lane* const _lane{ ToLane(L_, 1) };                                                             // L_: ud
@@ -859,7 +877,10 @@ void Lane::changeDebugName(int const nameIdx_)
 namespace {
     namespace local {
         static struct luaL_Reg const sLaneFunctions[] = {
-            { "__gc", lane_gc },
+#if LUA_VERSION_NUM >= 504
+            { "__close", LG_lane_close },
+#endif // LUA_VERSION_NUM >= 504
+            { "__gc", LG_lane_gc },
             { "__index", LG_thread_index },
             { "cancel", LG_thread_cancel },
             { "get_debug_threadname", LG_get_debug_threadname },
diff --git a/tests/func_is_string.lua b/tests/func_is_string.lua
index d7cf0b2..a14c460 100644
--- a/tests/func_is_string.lua
+++ b/tests/func_is_string.lua
@@ -1,13 +1,36 @@
 local lanes = require "lanes"
-lanes.configure()
+
+-- Lua 5.4 specific:
+if _VERSION >= "Lua 5.4" then
+    -- go through a string so that the script we are in doesn't trigger a parse error with older Lua
+    local res = assert(load [[
+        local lanes = require 'lanes'
+        local r
+        do
+            local h <close> = lanes.gen('*', lanes.sleep)(0.5)
+            r = h
+        end -- h is closed here
+        return r.status
+    ]])()
+    -- when the do...end block is exited, the to-be-closed variable h is closed, which internally calls h:join()
+    -- therefore the status of the lane should be "done"
+    assert(res == "done")
+    print("close result:", res)
+end
+
 
 local options = {globals = { b = 666 }}
 
--- local gen1 = lanes.gen("*", "dofile('fibonacci.lua')")
+local gen1 = lanes.gen("*", "return true, dofile('fibonacci.lua')")
 local gen2 = lanes.gen(options, "return b")
 
--- fibLane = gen1()
+fibLane = gen1()
+lanes.sleep(0.1)
+print(fibLane, fibLane.status)
+local _status, _err = fibLane:join()
+print(_status, _err)
+
 retLane1, retLane2 = gen2(), gen2()
--- fibLane:join()
 
 print( retLane1[1], retLane2[1])
+print "TEST OK"
\ No newline at end of file