19 files changed, 271 insertions, 256 deletions

diff --git a/src/cancel.cpp b/src/cancel.cpp
index e08e975..2f3c22e 100644
--- a/src/cancel.cpp
+++ b/src/cancel.cpp
@@ -51,7 +51,7 @@ THE SOFTWARE.
 * Returns CANCEL_SOFT/HARD if any locks are to be exited, and 'raise_cancel_error()' called,
 * to make execution of the lane end.
 */
-static inline CancelRequest cancel_test(lua_State* L)
+[[nodiscard]] static inline CancelRequest cancel_test(lua_State* L)
 {
     Lane* const lane{ LANE_POINTER_REGKEY.readLightUserDataValue<Lane>(L) };
     // 'lane' is nullptr for the original main state (and no-one can cancel that)
@@ -76,7 +76,7 @@ LUAG_FUNC( cancel_test)
 // ################################################################################################
 // ################################################################################################
 
-static void cancel_hook(lua_State* L, [[maybe_unused]] lua_Debug* ar)
+[[nodiscard]] static void cancel_hook(lua_State* L, [[maybe_unused]] lua_Debug* ar)
 {
     DEBUGSPEW_CODE(fprintf(stderr, "cancel_hook\n"));
     if (cancel_test(L) != CancelRequest::None)
@@ -108,7 +108,7 @@ static void cancel_hook(lua_State* L, [[maybe_unused]] lua_Debug* ar)
 
 // ################################################################################################
 
-static CancelResult thread_cancel_soft(Lane* lane_, lua_Duration duration_, bool wake_lane_)
+[[nodiscard]] static CancelResult thread_cancel_soft(Lane* lane_, lua_Duration duration_, bool wake_lane_)
 {
     lane_->cancel_request = CancelRequest::Soft; // it's now signaled to stop
     // negative timeout: we don't want to truly abort the lane, we just want it to react to cancel_test() on its own
@@ -126,7 +126,7 @@ static CancelResult thread_cancel_soft(Lane* lane_, lua_Duration duration_, bool
 
 // ################################################################################################
 
-static CancelResult thread_cancel_hard(Lane* lane_, lua_Duration duration_, bool wake_lane_)
+[[nodiscard]] static CancelResult thread_cancel_hard(Lane* lane_, lua_Duration duration_, bool wake_lane_)
 {
     lane_->cancel_request = CancelRequest::Hard; // it's now signaled to stop
     //lane_->m_thread.get_stop_source().request_stop();
@@ -204,7 +204,7 @@ CancelOp which_cancel_op(char const* op_string_)
 
 // ################################################################################################
 
-static CancelOp which_cancel_op(lua_State* L, int idx_)
+[[nodiscard]] static CancelOp which_cancel_op(lua_State* L, int idx_)
 {
     if (lua_type(L, idx_) == LUA_TSTRING)
     {
@@ -273,7 +273,7 @@ LUAG_FUNC(thread_cancel)
 
         case CancelResult::Cancelled:
         lua_pushboolean(L, 1);
-        push_thread_status(L, lane);
+        std::ignore = push_thread_status(L, lane);
         break;
     }
     // should never happen, only here to prevent the compiler from complaining of "not all control paths returning a value"
diff --git a/src/cancel.h b/src/cancel.h
index 954b04e..060edb3 100644
--- a/src/cancel.h
+++ b/src/cancel.h
@@ -49,8 +49,8 @@ enum class CancelOp
 // crc64/we of string "CANCEL_ERROR" generated at http://www.nitrxgen.net/hashgen/
 static constexpr UniqueKey CANCEL_ERROR{ 0xe97d41626cc97577ull }; // 'raise_cancel_error' sentinel
 
-CancelOp which_cancel_op(char const* op_string_);
-CancelResult thread_cancel(Lane* lane_, CancelOp op_, int hook_count_, lua_Duration secs_, bool wake_lindas_);
+[[nodiscard]] CancelOp which_cancel_op(char const* op_string_);
+[[nodiscard]] CancelResult thread_cancel(Lane* lane_, CancelOp op_, int hook_count_, lua_Duration secs_, bool wake_lindas_);
 
 [[noreturn]] static inline void raise_cancel_error(lua_State* L)
 {
diff --git a/src/compat.cpp b/src/compat.cpp
index 8acab25..9807390 100644
--- a/src/compat.cpp
+++ b/src/compat.cpp
@@ -15,7 +15,7 @@
 // ################################################################################################
 // ################################################################################################
 
-static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
+[[nodiscard]] static int luaL_getsubtable(lua_State* L, int idx, const char* fname)
 {
     lua_getfield(L, idx, fname);
     if (lua_istable(L, -1))
@@ -33,12 +33,12 @@ static int luaL_getsubtable (lua_State *L, int idx, const char *fname)
 
 // ################################################################################################
 
-void luaL_requiref (lua_State *L, const char *modname, lua_CFunction openf, int glb)
+void luaL_requiref(lua_State *L, const char *modname, lua_CFunction openf, int glb)
 {
     lua_pushcfunction(L, openf);
     lua_pushstring(L, modname);  /* argument to open function */
     lua_call(L, 1, 1);  /* open module */
-    luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
+    std::ignore = luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
     lua_pushvalue(L, -2);  /* make copy of module (call result) */
     lua_setfield(L, -2, modname);  /* _LOADED[modname] = module */
     lua_pop(L, 1);  /* remove _LOADED table */
diff --git a/src/deep.cpp b/src/deep.cpp
index 55063b3..a3806aa 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -107,7 +107,7 @@ static void get_deep_lookup(lua_State* L)
 * Return the registered ID function for 'index' (deep userdata proxy),
 * or nullptr if 'index' is not a deep userdata proxy.
 */
-static inline luaG_IdFunction get_idfunc(lua_State* L, int index, LookupMode mode_)
+[[nodiscard]] static inline luaG_IdFunction get_idfunc(lua_State* L, int index, LookupMode mode_)
 {
     // when looking inside a keeper, we are 100% sure the object is a deep userdata
     if (mode_ == LookupMode::FromKeeper)
@@ -160,7 +160,7 @@ void free_deep_prelude(lua_State* L, DeepPrelude* prelude_)
  * End of life for a proxy object; reduce the deep reference count and clean it up if reaches 0.
  *
  */
-static int deep_userdata_gc(lua_State* L)
+[[nodiscard]] static int deep_userdata_gc(lua_State* L)
 {
     DeepPrelude** const proxy{ lua_tofulluserdata<DeepPrelude*>(L, 1) };
     DeepPrelude* p = *proxy;
@@ -470,10 +470,14 @@ bool copydeep(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode
         int const clone_i = lua_gettop( L2);
         while( nuv)
         {
-            inter_copy_one( U, L2, L2_cache_i, L,  lua_absindex( L, -1), VT::NORMAL, mode_, upName_);       // u uv
+            std::ignore = inter_copy_one(U
+                , L2, L2_cache_i
+                , L,  lua_absindex( L, -1)
+                , VT::NORMAL, mode_, upName_
+            );                                                                                              // u uv
             lua_pop( L, 1);                                                              // ... u [uv]*
             // this pops the value from the stack
-            lua_setiuservalue( L2, clone_i, nuv);                                                           // u
+            lua_setiuservalue(L2, clone_i, nuv);                                                            // u
             -- nuv;
         }
     }
diff --git a/src/deep.h b/src/deep.h
index 6cf33ec..7be5c5d 100644
--- a/src/deep.h
+++ b/src/deep.h
@@ -36,7 +36,7 @@ enum class DeepOp
     Module,
 };
 
-using luaG_IdFunction = void*(*)( lua_State* L, DeepOp op_);
+using luaG_IdFunction = void*(*)(lua_State* L, DeepOp op_);
 
 // ################################################################################################
 
@@ -54,8 +54,8 @@ struct DeepPrelude
     std::atomic<int> m_refcount{ 0 };
 };
 
-char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
-void free_deep_prelude( lua_State* L, DeepPrelude* prelude_);
+[[nodiscard]] char const* push_deep_proxy(Dest L, DeepPrelude* prelude, int nuv_, LookupMode mode_);
+void free_deep_prelude(lua_State* L, DeepPrelude* prelude_);
 
-LANES_API int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_);
-LANES_API DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index);
+LANES_API [[nodiscard]] int luaG_newdeepuserdata(Dest L, luaG_IdFunction idfunc, int nuv_);
+LANES_API [[nodiscard]] DeepPrelude* luaG_todeep(lua_State* L, luaG_IdFunction idfunc, int index);
diff --git a/src/keeper.cpp b/src/keeper.cpp
index 9718bda..19fbd06 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -61,12 +61,12 @@ class keeper_fifo
     int limit{ -1 };
 
     // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
-    static void* operator new([[maybe_unused]] size_t size_, lua_State* L) noexcept { return lua_newuserdatauv<keeper_fifo>(L, 1); }
+    [[nodiscard]] static void* operator new([[maybe_unused]] size_t size_, lua_State* L) noexcept { return lua_newuserdatauv<keeper_fifo>(L, 1); }
     // always embedded somewhere else or "in-place constructed" as a full userdata
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
     static void operator delete([[maybe_unused]] void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
 
-    static keeper_fifo* getPtr(lua_State* L, int idx_)
+    [[nodiscard]] static keeper_fifo* getPtr(lua_State* L, int idx_)
     {
         return lua_tofulluserdata<keeper_fifo>(L, idx_);
     }
@@ -77,7 +77,7 @@ static constexpr int CONTENTS_TABLE{ 1 };
 // ##################################################################################################
 
 // replaces the fifo ud by its uservalue on the stack
-static keeper_fifo* prepare_fifo_access(lua_State* L, int idx_)
+[[nodiscard]] static keeper_fifo* prepare_fifo_access(lua_State* L, int idx_)
 {
     keeper_fifo* const fifo{ keeper_fifo::getPtr(L, idx_) };
     if (fifo != nullptr)
@@ -95,7 +95,7 @@ static keeper_fifo* prepare_fifo_access(lua_State* L, int idx_)
 
 // in: nothing
 // out: { first = 1, count = 0, limit = -1}
-static keeper_fifo* fifo_new(lua_State* L)
+[[nodiscard]] static keeper_fifo* fifo_new(lua_State* L)
 {
     STACK_GROW(L, 2);
     STACK_CHECK_START_REL(L, 0);
@@ -213,46 +213,46 @@ int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_)
     Source const KL{ K ? K->L : nullptr };
     if (KL == nullptr)
         return 0;
-    STACK_GROW(KL, 4);
+    STACK_GROW(KL, 4);                                                      // KEEPER                       MAIN
     STACK_CHECK_START_REL(KL, 0);
-    FIFOS_KEY.pushValue(KL);                                      // fifos
-    lua_pushlightuserdata(KL, ptr_);                              // fifos ud
-    lua_rawget(KL, -2);                                           // fifos storage
-    lua_remove(KL, -2);                                           // storage
+    FIFOS_KEY.pushValue(KL);                                                // fifos
+    lua_pushlightuserdata(KL, ptr_);                                        // fifos ud
+    lua_rawget(KL, -2);                                                     // fifos storage
+    lua_remove(KL, -2);                                                     // storage
     if (!lua_istable(KL, -1))
     {
-        lua_pop(KL, 1);                                           //
+        lua_pop(KL, 1);                                                     //
         STACK_CHECK(KL, 0);
         return 0;
     }
-    // move data from keeper to destination state                    KEEPER                       MAIN
-    lua_pushnil(KL);                                              // storage nil
+    // move data from keeper to destination state
+    lua_pushnil(KL);                                                        // storage nil
     STACK_GROW(L, 5);
     STACK_CHECK_START_REL(L, 0);
     lua_newtable(L);                                                                           // out
-    while (lua_next(KL, -2))                                      // storage key fifo
+    while (lua_next(KL, -2))                                                // storage key fifo
     {
-        keeper_fifo* fifo = prepare_fifo_access(KL, -1);          // storage key fifotbl
-        lua_pushvalue(KL, -2);                                    // storage key fifotbl key
-        luaG_inter_move(U, KL, L, 1, LookupMode::FromKeeper);     // storage key fifotbl       // out key
+        keeper_fifo* fifo = prepare_fifo_access(KL, -1);                    // storage key fifotbl
+        lua_pushvalue(KL, -2);                                              // storage key fifotbl key
+        std::ignore = luaG_inter_move(U, KL, L, 1, LookupMode::FromKeeper); // storage key fifotbl       // out key
         STACK_CHECK(L, 2);
-        lua_newtable(L);                                                                       // out key keyout
-        luaG_inter_move(U, KL, L, 1, LookupMode::FromKeeper);     // storage key               // out key keyout fifotbl
-        lua_pushinteger(L, fifo->first);                                                       // out key keyout fifotbl first
+        lua_newtable(L);                                                                                 // out key keyout
+        std::ignore = luaG_inter_move(U, KL, L, 1, LookupMode::FromKeeper); // storage key               // out key keyout fifotbl
+        lua_pushinteger(L, fifo->first);                                                                 // out key keyout fifotbl first
         STACK_CHECK(L, 5);
-        lua_setfield(L, -3, "first");                                                          // out key keyout fifotbl
-        lua_pushinteger(L, fifo->count);                                                       // out key keyout fifobtl count
+        lua_setfield(L, -3, "first");                                                                    // out key keyout fifotbl
+        lua_pushinteger(L, fifo->count);                                                                 // out key keyout fifobtl count
         STACK_CHECK(L, 5);
-        lua_setfield(L, -3, "count");                                                          // out key keyout fifotbl
-        lua_pushinteger(L, fifo->limit);                                                       // out key keyout fifotbl limit
+        lua_setfield(L, -3, "count");                                                                    // out key keyout fifotbl
+        lua_pushinteger(L, fifo->limit);                                                                 // out key keyout fifotbl limit
         STACK_CHECK(L, 5);
-        lua_setfield(L, -3, "limit");                                                          // out key keyout fifotbl
-        lua_setfield(L, -2, "fifo");                                                           // out key keyout
-        lua_rawset(L, -3);                                                                     // out
+        lua_setfield(L, -3, "limit");                                                                    // out key keyout fifotbl
+        lua_setfield(L, -2, "fifo");                                                                     // out key keyout
+        lua_rawset(L, -3);                                                                               // out
         STACK_CHECK(L, 1);
     }
     STACK_CHECK(L, 1);
-    lua_pop(KL, 1);                                               //
+    lua_pop(KL, 1);                                                         //
     STACK_CHECK(KL, 0);
     return 1;
 }
@@ -287,7 +287,7 @@ int keepercall_send(lua_State* L)
     if( lua_isnil(L, -1))
     {
         lua_pop(L, 1);                            // ud key ... fifos
-        fifo_new(L);                              // ud key ... fifos fifo
+        std::ignore = fifo_new(L);                // ud key ... fifos fifo
         lua_pushvalue(L, 2);                      // ud key ... fifos fifo key
         lua_pushvalue(L, -2);                     // ud key ... fifos fifo key fifo
         lua_rawset(L, -4);                        // ud key ... fifos fifo
@@ -465,7 +465,7 @@ int keepercall_set(lua_State* L)
         {                                                  // fifos key [val [, ...]] nil
             // no need to wake writers in that case, because a writer can't wait on an inexistent key
             lua_pop(L, 1);                                 // fifos key [val [, ...]]
-            fifo_new(L);                                   // fifos key [val [, ...]] fifo
+            std::ignore = fifo_new(L);                     // fifos key [val [, ...]] fifo
             lua_pushvalue(L, 2);                           // fifos key [val [, ...]] fifo key
             lua_pushvalue(L, -2);                          // fifos key [val [, ...]] fifo key fifo
             lua_rawset(L, 1);                              // fifos key [val [, ...]] fifo
diff --git a/src/keeper.h b/src/keeper.h
index 89fa2ab..627c7ea 100644
--- a/src/keeper.h
+++ b/src/keeper.h
@@ -38,23 +38,23 @@ static constexpr UniqueKey NIL_SENTINEL{ 0x7eaafa003a1d11a1ull };
 void init_keepers(Universe* U, lua_State* L);
 void close_keepers(Universe* U);
 
-Keeper* which_keeper(Keepers* keepers_, uintptr_t magic_);
-Keeper* keeper_acquire(Keepers* keepers_, uintptr_t magic_);
+[[nodiscard]] Keeper* which_keeper(Keepers* keepers_, uintptr_t magic_);
+[[nodiscard]] Keeper* keeper_acquire(Keepers* keepers_, uintptr_t magic_);
 void keeper_release(Keeper* K_);
 void keeper_toggle_nil_sentinels(lua_State* L, int val_i_, LookupMode const mode_);
-int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_);
+[[nodiscard]] int keeper_push_linda_storage(Universe* U, Dest L, void* ptr_, uintptr_t magic_);
 
 using keeper_api_t = lua_CFunction;
 #define KEEPER_API(_op) keepercall_##_op
 #define PUSH_KEEPER_FUNC lua_pushcfunction
 // lua_Cfunctions to run inside a keeper state
-int keepercall_clear(lua_State* L);
-int keepercall_send(lua_State* L);
-int keepercall_receive(lua_State* L);
-int keepercall_receive_batched(lua_State* L);
-int keepercall_limit(lua_State* L);
-int keepercall_get(lua_State* L);
-int keepercall_set(lua_State* L);
-int keepercall_count(lua_State* L);
-
-int keeper_call(Universe* U, lua_State* K, keeper_api_t _func, lua_State* L, void* linda, int starting_index);
+[[nodiscard]] int keepercall_clear(lua_State* L);
+[[nodiscard]] int keepercall_send(lua_State* L);
+[[nodiscard]] int keepercall_receive(lua_State* L);
+[[nodiscard]] int keepercall_receive_batched(lua_State* L);
+[[nodiscard]] int keepercall_limit(lua_State* L);
+[[nodiscard]] int keepercall_get(lua_State* L);
+[[nodiscard]] int keepercall_set(lua_State* L);
+[[nodiscard]] int keepercall_count(lua_State* L);
+
+[[nodiscard]] int keeper_call(Universe* U, lua_State* K, keeper_api_t _func, lua_State* L, void* linda, int starting_index);
diff --git a/src/lanes.cpp b/src/lanes.cpp
index 3d0c70d..2a5ebfd 100644
--- a/src/lanes.cpp
+++ b/src/lanes.cpp
@@ -162,7 +162,7 @@ static void securize_debug_threadname(lua_State* L, Lane* lane_)
 }
 
 #if ERROR_FULL_STACK
-static int lane_error(lua_State* L);
+[[nodiscard]] static int lane_error(lua_State* L);
 // crc64/we of string "STACKTRACE_REGKEY" generated at http://www.nitrxgen.net/hashgen/
 static constexpr UniqueKey STACKTRACE_REGKEY{ 0x534af7d3226a429full };
 #endif // ERROR_FULL_STACK
@@ -188,7 +188,7 @@ static constexpr UniqueKey FINALIZER_REGKEY{ 0x188fccb8bf348e09ull };
 * Returns: true if a table was pushed
 *          false if no table found, not created, and nothing pushed
 */
-static bool push_registry_table( lua_State* L, UniqueKey key, bool create)
+[[nodiscard]] static bool push_registry_table(lua_State* L, UniqueKey key, bool create)
 {
     STACK_GROW(L, 3);
     STACK_CHECK_START_REL(L, 0);
@@ -237,7 +237,7 @@ static void tracking_add(Lane* lane_)
 /*
  * A free-running lane has ended; remove it from tracking chain
  */
-static bool tracking_remove(Lane* lane_)
+[[nodiscard]] static bool tracking_remove(Lane* lane_)
 {
     bool found{ false };
     std::lock_guard<std::mutex> guard{ lane_->U->tracking_cs };
@@ -277,7 +277,7 @@ Lane::~Lane()
     if (U->tracking_first != nullptr)
     {
         // Lane was cleaned up, no need to handle at process termination
-        tracking_remove(this);
+        std::ignore = tracking_remove(this);
     }
 #endif // HAVE_LANE_TRACKING()
 }
@@ -300,10 +300,10 @@ LUAG_FUNC( set_finalizer)
 {
     luaL_argcheck(L, lua_isfunction(L, 1), 1, "finalizer should be a function");
     luaL_argcheck(L, lua_gettop( L) == 1, 1, "too many arguments");
-    // Get the current finalizer table (if any)
-    push_registry_table(L, FINALIZER_REGKEY, true /*do create if none*/);      // finalizer {finalisers}
+    // Get the current finalizer table (if any), create one if it doesn't exist
+    std::ignore = push_registry_table(L, FINALIZER_REGKEY, true);               // finalizer {finalisers}
     STACK_GROW(L, 2);
-    lua_pushinteger(L, lua_rawlen(L, -1) + 1);                                 // finalizer {finalisers} idx
+    lua_pushinteger(L, lua_rawlen(L, -1) + 1);                                  // finalizer {finalisers} idx
     lua_pushvalue(L, 1);                                                        // finalizer {finalisers} idx finalizer
     lua_rawset(L, -3);                                                          // finalizer {finalisers}
     lua_pop(L, 2);                                                              //
@@ -326,7 +326,7 @@ LUAG_FUNC( set_finalizer)
 //
 static void push_stack_trace( lua_State* L, int rc_, int stk_base_);
 
-static int run_finalizers( lua_State* L, int lua_rc)
+[[nodiscard]] static int run_finalizers(lua_State* L, int lua_rc)
 {
     int finalizers_index;
     int n;
@@ -430,7 +430,7 @@ static void selfdestruct_add(Lane* lane_)
 /*
  * A free-running lane has ended; remove it from selfdestruct chain
  */
-static bool selfdestruct_remove(Lane* lane_)
+[[nodiscard]] static bool selfdestruct_remove(Lane* lane_)
 {
     bool found{ false };
     std::lock_guard<std::mutex> guard{ lane_->U->selfdestruct_cs };
@@ -465,7 +465,7 @@ static bool selfdestruct_remove(Lane* lane_)
 /*
 * Process end; cancel any still free-running threads
 */
-static int universe_gc( lua_State* L)
+[[nodiscard]] static int universe_gc(lua_State* L)
 {
     Universe* const U{ lua_tofulluserdata<Universe>(L, 1) };
     lua_Duration const shutdown_timeout{ lua_tonumber(L, lua_upvalueindex(1)) };
@@ -638,7 +638,7 @@ LUAG_FUNC( set_error_reporting)
     return 0;
 }
 
-static int lane_error(lua_State* L)
+[[nodiscard]] static int lane_error(lua_State* L)
 {
     // error message (any type)
     STACK_CHECK_START_ABS(L, 1);                                                       // some_error
@@ -1176,7 +1176,10 @@ LUAG_FUNC(lane_new)
                     if (lua_pcall( L2, 1, 1, 0) != LUA_OK)                                                                                          // ret/errcode
                     {
                         // propagate error to main state if any
-                        luaG_inter_move(U, Source{ L2 }, Dest{ L }, 1, LookupMode::LaneBody); // func libs priority globals package required gc_cb [... args ...] n "modname" error
+                        std::ignore = luaG_inter_move(U
+                            , Source{ L2 }, Dest{ L }
+                            , 1, LookupMode::LaneBody
+                        );                                                  // func libs priority globals package required gc_cb [... args ...] n "modname" error
                         raise_lua_error(L);
                     }
                     // after requiring the module, register the functions it exported in our name<->function database
@@ -1209,7 +1212,7 @@ LUAG_FUNC(lane_new)
         lua_pushglobaltable(L2);                                                                                                                    // _G
         while( lua_next(L, globals_idx))                                    // func libs priority globals package required gc_cb [... args ...] k v
         {
-            luaG_inter_copy(U, Source{ L }, Dest{ L2 }, 2, LookupMode::LaneBody);                                                                   // _G k v
+            std::ignore = luaG_inter_copy(U, Source{ L }, Dest{ L2 }, 2, LookupMode::LaneBody);                                                     // _G k v
             // assign it in L2's globals table
             lua_rawset(L2, -3);                                                                                                                     // _G
             lua_pop(L, 1);                                                  // func libs priority globals package required gc_cb [... args ...] k
@@ -1290,7 +1293,7 @@ LUAG_FUNC(lane_new)
 // 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).
 //
-static int lane_gc(lua_State* L)
+[[nodiscard]] static int lane_gc(lua_State* L)
 {
     bool have_gc_cb{ false };
     Lane* const lane{ lua_toLane(L, 1) };                                // ud
@@ -1356,7 +1359,7 @@ static int lane_gc(lua_State* L)
 //                   / "error"     finished at an error, error value is there
 //                   / "cancelled"   execution cancelled by M (state gone)
 //
-static char const * thread_status_string(Lane* lane_)
+[[nodiscard]] static char const* thread_status_string(Lane* lane_)
 {
     Lane::Status const st{ lane_->m_status }; // read just once (volatile)
     char const* str =
@@ -1624,20 +1627,20 @@ LUAG_FUNC(threads)
     {
         Lane* lane{ U->tracking_first };
         int index = 0;
-        lua_newtable(L);                         // {}
+        lua_newtable(L);                                       // {}
         while (lane != TRACKING_END)
         {
             // insert a { name, status } tuple, so that several lanes with the same name can't clobber each other
-            lua_newtable(L);                     // {} {}
-            lua_pushstring(L, lane->debug_name); // {} {} "name"
-            lua_setfield(L, -2, "name");         // {} {}
-            push_thread_status(L, lane);         // {} {} "status"
-            lua_setfield(L, -2, "status");       // {} {}
-            lua_rawseti(L, -2, ++index);         // {}
+            lua_newtable(L);                                   // {} {}
+            lua_pushstring(L, lane->debug_name);               // {} {} "name"
+            lua_setfield(L, -2, "name");                       // {} {}
+            std::ignore = push_thread_status(L, lane);         // {} {} "status"
+            lua_setfield(L, -2, "status");                     // {} {}
+            lua_rawseti(L, -2, ++index);                       // {}
             lane = lane->tracking_next;
         }
     }
-    return lua_gettop(L) - top;                  // 0 or 1
+    return lua_gettop(L) - top;                                // 0 or 1
 }
 #endif // HAVE_LANE_TRACKING()
 
@@ -1723,7 +1726,7 @@ LUAG_FUNC(wakeup_conv)
  */
 
 extern int LG_linda(lua_State* L);
-static const struct luaL_Reg lanes_functions[] =
+static struct luaL_Reg const lanes_functions[] =
 {
     { "linda", LG_linda },
     { "now_secs", LG_now_secs },
@@ -2022,9 +2025,9 @@ LANES_API int luaopen_lanes_core( lua_State* L)
     return 1;
 }
 
-static int default_luaopen_lanes( lua_State* L)
+[[nodiscard]] static int default_luaopen_lanes(lua_State* L)
 {
-    int rc = luaL_loadfile(L, "lanes.lua") || lua_pcall(L, 0, 1, 0);
+    int const rc{ luaL_loadfile(L, "lanes.lua") || lua_pcall(L, 0, 1, 0) };
     if (rc != LUA_OK)
     {
         return luaL_error(L, "failed to initialize embedded Lanes");
diff --git a/src/lanes.h b/src/lanes.h
index 05a0a5c..bc8de55 100644
--- a/src/lanes.h
+++ b/src/lanes.h
@@ -20,7 +20,7 @@ extern "C" {
 #define LANES_VERSION_GREATER_THAN(MAJOR, MINOR, PATCH)     ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>PATCH))))
 #define LANES_VERSION_GREATER_OR_EQUAL(MAJOR, MINOR, PATCH) ((LANES_VERSION_MAJOR>MAJOR) || (LANES_VERSION_MAJOR==MAJOR && (LANES_VERSION_MINOR>MINOR || (LANES_VERSION_MINOR==MINOR && LANES_VERSION_PATCH>=PATCH))))
 
-LANES_API int luaopen_lanes_core(lua_State* L);
+LANES_API [[nodiscard]] int luaopen_lanes_core(lua_State* L);
 
 // Call this to work with embedded Lanes instead of calling luaopen_lanes_core()
 LANES_API void luaopen_lanes_embedded(lua_State* L, lua_CFunction _luaopen_lanes);
diff --git a/src/lanes_private.h b/src/lanes_private.h
index 0fcbbfc..ba40e44 100644
--- a/src/lanes_private.h
+++ b/src/lanes_private.h
@@ -78,7 +78,7 @@ class Lane
     //
     // For tracking only
 
-    static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
+    [[nodiscard]] static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
     static void operator delete(void* p_, Universe* U_) { U_->internal_allocator.free(p_, sizeof(Lane)); }
     // this one is for us, to make sure memory is freed by the correct allocator
@@ -87,7 +87,7 @@ class Lane
     Lane(Universe* U_, lua_State* L_);
     ~Lane();
 
-    bool waitForCompletion(lua_Duration duration_);
+    [[nodiscard]] bool waitForCompletion(lua_Duration duration_);
     void startThread(int priority_);
 };
 
@@ -98,6 +98,9 @@ static constexpr UniqueKey LANE_POINTER_REGKEY{ 0xB3022205633743BCull }; // used
 // 'Lane' are malloc/free'd and the handle only carries a pointer.
 // This is not deep userdata since the handle's not portable among lanes.
 //
-#define lua_toLane(L, i) (*((Lane**) luaL_checkudata( L, i, "Lane")))
+[[nodiscard]] inline Lane* lua_toLane(lua_State* L, int i_)
+{
+    return *(static_cast<Lane**>(luaL_checkudata(L, i_, "Lane")));
+}
 
-int push_thread_status(lua_State* L, Lane* s);
+[[nodiscard]] int push_thread_status(lua_State* L, Lane* s);
diff --git a/src/linda.cpp b/src/linda.cpp
index 39977bc..50964ad 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -70,7 +70,7 @@ class Linda : public DeepPrelude // Deep userdata MUST start with this header
     public:
 
     // a fifo full userdata has one uservalue, the table that holds the actual fifo contents
-    static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
+    [[nodiscard]] static void* operator new(size_t size_, Universe* U_) noexcept { return U_->internal_allocator.alloc(size_); }
     // always embedded somewhere else or "in-place constructed" as a full userdata
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
     static void operator delete(void* p_, Universe* U_) { U_->internal_allocator.free(p_, sizeof(Linda)); }
@@ -137,10 +137,10 @@ class Linda : public DeepPrelude // Deep userdata MUST start with this header
         return nullptr;
     }
 };
-static void* linda_id( lua_State*, DeepOp);
+[[nodiscard]] static void* linda_id(lua_State*, DeepOp);
 
 template<bool OPT>
-static inline Linda* lua_toLinda(lua_State* L, int idx_)
+[[nodiscard]] static inline Linda* lua_toLinda(lua_State* L, int idx_)
 {
     Linda* const linda{ static_cast<Linda*>(luaG_todeep(L, linda_id, idx_)) };
     if (!OPT)
@@ -742,7 +742,7 @@ LUAG_FUNC(linda_deep)
 */
 
 template <bool OPT>
-static int linda_tostring(lua_State* L, int idx_)
+[[nodiscard]] static int linda_tostring(lua_State* L, int idx_)
 {
     Linda* const linda{ lua_toLinda<OPT>(L, idx_) };
     if (linda != nullptr)
@@ -851,7 +851,7 @@ LUAG_FUNC(linda_towatch)
 * For any other strings, the ID function must not react at all. This allows
 * future extensions of the system. 
 */
-static void* linda_id( lua_State* L, DeepOp op_)
+[[nodiscard]] static void* linda_id(lua_State* L, DeepOp op_)
 {
     switch( op_)
     {
@@ -907,7 +907,7 @@ static void* linda_id( lua_State* L, DeepOp op_)
                 // Clean associated structures in the keeper state.
                 Keeper* const K{ need_acquire_release ? keeper_acquire(linda->U->keepers, linda->hashSeed()) : myK };
                 // hopefully this won't ever raise an error as we would jump to the closest pcall site while forgetting to release the keeper mutex...
-                keeper_call(linda->U, K->L, KEEPER_API(clear), L, linda, 0);
+                std::ignore = keeper_call(linda->U, K->L, KEEPER_API(clear), L, linda, 0);
                 if (need_acquire_release)
                 {
                     keeper_release(K);
diff --git a/src/macros_and_utils.h b/src/macros_and_utils.h
index 47ce90c..31ae8bd 100644
--- a/src/macros_and_utils.h
+++ b/src/macros_and_utils.h
@@ -23,11 +23,13 @@ extern char const* debugspew_indent;
 #define INDENT_BEGIN "%.*s "
 #define INDENT_END , (U ? U->debugspew_indent_depth.load(std::memory_order_relaxed) : 0), debugspew_indent
 #define DEBUGSPEW_CODE(_code) _code
-#define DEBUGSPEW_PARAM_COMMA( param_) param_,
+#define DEBUGSPEW_OR_NOT(a_, b_) a_
+#define DEBUGSPEW_PARAM_COMMA(param_) param_,
 #define DEBUGSPEW_COMMA_PARAM( param_) , param_
 #else // USE_DEBUG_SPEW()
 #define DEBUGSPEW_CODE(_code)
-#define DEBUGSPEW_PARAM_COMMA( param_)
+#define DEBUGSPEW_OR_NOT(a_, b_) b_
+#define DEBUGSPEW_PARAM_COMMA(param_)
 #define DEBUGSPEW_COMMA_PARAM( param_)
 #endif // USE_DEBUG_SPEW()
 
@@ -130,20 +132,20 @@ inline void STACK_GROW(lua_State* L, int n_)
     }
 }
 
-#define LUAG_FUNC( func_name) int LG_##func_name( lua_State* L)
+#define LUAG_FUNC(func_name) [[nodiscard]] int LG_##func_name(lua_State* L)
 
 // #################################################################################################
 
 // a small helper to extract a full userdata pointer from the stack in a safe way
 template<typename T>
-T* lua_tofulluserdata(lua_State* L, int index_)
+[[nodiscard]] T* lua_tofulluserdata(lua_State* L, int index_)
 {
     ASSERT_L(lua_isnil(L, index_) || lua_type(L, index_) == LUA_TUSERDATA);
     return static_cast<T*>(lua_touserdata(L, index_));
 }
 
 template<typename T>
-auto lua_tolightuserdata(lua_State* L, int index_)
+[[nodiscard]] auto lua_tolightuserdata(lua_State* L, int index_)
 {
     ASSERT_L(lua_isnil(L, index_) || lua_islightuserdata(L, index_));
     if constexpr (std::is_pointer_v<T>)
@@ -157,7 +159,7 @@ auto lua_tolightuserdata(lua_State* L, int index_)
 }
 
 template <typename T>
-T* lua_newuserdatauv(lua_State* L, int nuvalue_)
+[[nodiscard]] T* lua_newuserdatauv(lua_State* L, int nuvalue_)
 {
     return static_cast<T*>(lua_newuserdatauv(L, sizeof(T), nuvalue_));
 }
@@ -175,6 +177,7 @@ using lua_Duration = std::chrono::template duration<lua_Number>;
 
 // #################################################################################################
 
+// A unique type generator
 template <typename T, auto = []{}>
 struct Unique
 {
diff --git a/src/state.cpp b/src/state.cpp
index 6a9ada7..496e21e 100644
--- a/src/state.cpp
+++ b/src/state.cpp
@@ -49,7 +49,7 @@ THE SOFTWARE.
 //
 // Upvalues: [1]: original 'require' function
 //
-static int luaG_new_require( lua_State* L)
+[[nodiscard]] static int luaG_new_require(lua_State* L)
 {
     int rc;
     int const args = lua_gettop( L);                                    // args
@@ -110,7 +110,7 @@ void serialize_require(DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L)
 
 /*---=== luaG_newstate ===---*/
 
-static int require_lanes_core( lua_State* L)
+[[nodiscard]] static int require_lanes_core(lua_State* L)
 {
     // leaves a copy of 'lanes.core' module table on the stack
     luaL_requiref( L, "lanes.core", luaopen_lanes_core, 0);
@@ -118,7 +118,7 @@ static int require_lanes_core( lua_State* L)
 }
 
 
-static const luaL_Reg libs[] =
+static luaL_Reg const libs[] =
 {
     { LUA_LOADLIBNAME, luaopen_package},
     { LUA_TABLIBNAME, luaopen_table},
diff --git a/src/state.h b/src/state.h
index 2601f77..e1c311a 100644
--- a/src/state.h
+++ b/src/state.h
@@ -10,8 +10,8 @@ void serialize_require(DEBUGSPEW_PARAM_COMMA(Universe* U) lua_State* L);
 
 // ################################################################################################
 
-lua_State* create_state(Universe* U, lua_State* from_);
-lua_State* luaG_newstate(Universe* U, Source _from, char const* libs);
+[[nodiscard]] lua_State* create_state(Universe* U, lua_State* from_);
+[[nodiscard]] lua_State* luaG_newstate(Universe* U, Source _from, char const* libs);
 
 // ################################################################################################
 
diff --git a/src/threading.cpp b/src/threading.cpp
index d278bb1..259693a 100644
--- a/src/threading.cpp
+++ b/src/threading.cpp
@@ -209,7 +209,7 @@ void THREAD_SETNAME(char const* _name)
 // general its implementation is pretty much trivial, as on Win32 target
 // just SCHED_OTHER can be supported.
 #undef pthread_attr_setschedpolicy
-static int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy)
+[[nodiscard]] static int pthread_attr_setschedpolicy(pthread_attr_t* attr, int policy)
 {
     if (policy != SCHED_OTHER)
     {
@@ -348,7 +348,7 @@ static int const gs_prio_remap[] =
 #endif // _PRIO_0
 };
 
-static int select_prio(int prio /* -3..+3 */)
+[[nodiscard]] static int select_prio(int prio /* -3..+3 */)
 {
     if (prio == THREAD_PRIO_DEFAULT)
         prio = 0;
diff --git a/src/threading_osx.h b/src/threading_osx.h
index b47d2f6..f4d41e0 100644
--- a/src/threading_osx.h
+++ b/src/threading_osx.h
@@ -2,8 +2,7 @@
  * THREADING_OSX.H
  * http://yyshen.github.io/2015/01/18/binding_threads_to_cores_osx.html
  */
-#ifndef __threading_osx_h__
-#define __threading_osx_h__ 1
+#pragma once
 
 #include <mach/mach_types.h>
 #include <mach/thread_act.h>
@@ -18,9 +17,9 @@ struct cpu_set_t
 
 static inline void CPU_ZERO(cpu_set_t *cs) { cs->count = 0; }
 static inline void CPU_SET(int num, cpu_set_t *cs) { cs->count |= (1 << num); }
-static inline int CPU_ISSET(int num, cpu_set_t *cs) { return (cs->count & (1 << num)); }
+[[nodiscard]] static inline int CPU_ISSET(int num, cpu_set_t *cs) { return (cs->count & (1 << num)); }
 
-int sched_getaffinity(pid_t pid, size_t cpu_size, cpu_set_t *cpu_set)
+[[nodiscard]] int sched_getaffinity(pid_t pid, size_t cpu_size, cpu_set_t *cpu_set)
 {
         int32_t core_count = 0;
         size_t  len = sizeof(core_count);
@@ -39,7 +38,7 @@ int sched_getaffinity(pid_t pid, size_t cpu_size, cpu_set_t *cpu_set)
         return 0;
 }
 
-int pthread_setaffinity_np(pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set)
+[[nodiscard]] int pthread_setaffinity_np(pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set)
 {
         thread_port_t mach_thread;
         int core = 0;
@@ -57,4 +56,3 @@ int pthread_setaffinity_np(pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set
         return 0;
 }
 
-#endif
diff --git a/src/tools.cpp b/src/tools.cpp
index 07f9ae6..4083a57 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -144,7 +144,7 @@ void luaG_dump( lua_State* L)
 // ################################################################################################
 
 // same as PUC-Lua l_alloc
-extern "C" static void* libc_lua_Alloc([[maybe_unused]] void* ud, [[maybe_unused]] void* ptr_, [[maybe_unused]] size_t osize_, size_t nsize_)
+extern "C" [[nodiscard]] static void* libc_lua_Alloc([[maybe_unused]] void* ud, [[maybe_unused]] void* ptr_, [[maybe_unused]] size_t osize_, size_t nsize_)
 {
     if (nsize_ == 0)
     {
@@ -159,7 +159,7 @@ extern "C" static void* libc_lua_Alloc([[maybe_unused]] void* ud, [[maybe_unused
 
 // #################################################################################################
 
-static int luaG_provide_protected_allocator(lua_State* L)
+[[nodiscard]] static int luaG_provide_protected_allocator(lua_State* L)
 {
     Universe* const U{ universe_get(L) };
     // push a new full userdata on the stack, giving access to the universe's protected allocator
@@ -234,7 +234,7 @@ void initialize_allocator_function(Universe* U, lua_State* L)
 
 // ################################################################################################
 
-static int dummy_writer( lua_State* L, void const* p, size_t sz, void* ud)
+[[nodiscard]] static int dummy_writer(lua_State* L, void const* p, size_t sz, void* ud)
 {
     (void)L; (void)p; (void)sz; (void) ud; // unused
     return 666;
@@ -291,7 +291,7 @@ FuncSubType luaG_getfuncsubtype( lua_State *L, int _i)
 
 // #################################################################################################
 
-static lua_CFunction luaG_tocfunction(lua_State* L, int _i, FuncSubType* _out)
+[[nodiscard]] static lua_CFunction luaG_tocfunction(lua_State* L, int _i, FuncSubType* _out)
 {
     lua_CFunction p = lua_tocfunction( L, _i);
     *_out = luaG_getfuncsubtype( L, _i);
@@ -304,7 +304,7 @@ static constexpr UniqueKey LOOKUPCACHE_REGKEY{ 0x837a68dfc6fcb716ull };
 // #################################################################################################
 
 // inspired from tconcat() in ltablib.c
-static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
+[[nodiscard]] static char const* luaG_pushFQN(lua_State* L, int t, int last, size_t* length)
 {
     int i = 1;
     luaL_Buffer b;
@@ -338,7 +338,7 @@ static char const* luaG_pushFQN( lua_State* L, int t, int last, size_t* length)
  * if we already had an entry of type [o] = ..., replace the name if the new one is shorter
  * pops the processed object from the stack
  */
-static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _depth)
+static void update_lookup_entry(DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State* L, int _ctx_base, int _depth)
 {
     // slot 1 in the stack contains the table that receives everything we found
     int const dest = _ctx_base;
@@ -362,7 +362,7 @@ static void update_lookup_entry( DEBUGSPEW_PARAM_COMMA( Universe* U) lua_State*
     ++ _depth;
     lua_rawseti( L, fqn, _depth);                                                         // ... {bfc} k o name?
     // generate name
-    DEBUGSPEW_CODE( newName =) luaG_pushFQN( L, fqn, _depth, &newNameLength);             // ... {bfc} k o name? "f.q.n"
+    DEBUGSPEW_OR_NOT(newName, std::ignore) = luaG_pushFQN(L, fqn, _depth, &newNameLength);// ... {bfc} k o name? "f.q.n"
     // Lua 5.2 introduced a hash randomizer seed which causes table iteration to yield a different key order
     // on different VMs even when the tables are populated the exact same way.
     // When Lua is built with compatibility options (such as LUA_COMPAT_ALL),
@@ -613,7 +613,7 @@ static constexpr UniqueKey REG_MTID{ 0x2e68f9b4751584dcull };
 /*
 * Get a unique ID for metatable at [i].
 */
-static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
+[[nodiscard]] static lua_Integer get_mt_id(Universe* U, lua_State* L, int i)
 {
     lua_Integer id;
 
@@ -654,25 +654,25 @@ static lua_Integer get_mt_id( Universe* U, lua_State* L, int i)
 // #################################################################################################
 
 // function sentinel used to transfer native functions from/to keeper states
-static int func_lookup_sentinel( lua_State* L)
+[[nodiscard]] static int func_lookup_sentinel(lua_State* L)
 {
-    return luaL_error( L, "function lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "function lookup sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
 // #################################################################################################
 
 // function sentinel used to transfer native table from/to keeper states
-static int table_lookup_sentinel( lua_State* L)
+[[nodiscard]] static int table_lookup_sentinel(lua_State* L)
 {
-    return luaL_error( L, "table lookup sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "table lookup sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
 // #################################################################################################
 
 // function sentinel used to transfer cloned full userdata from/to keeper states
-static int userdata_clone_sentinel( lua_State* L)
+[[nodiscard]] static int userdata_clone_sentinel(lua_State* L)
 {
-    return luaL_error( L, "userdata clone sentinel for %s, should never be called", lua_tostring( L, lua_upvalueindex( 1)));
+    return luaL_error(L, "userdata clone sentinel for %s, should never be called", lua_tostring(L, lua_upvalueindex(1)));
 }
 
 // #################################################################################################
@@ -680,7 +680,7 @@ static int userdata_clone_sentinel( lua_State* L)
 /*
  * retrieve the name of a function/table in the lookup database
  */
-static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char const* upName_, size_t* len_)
+[[nodiscard]] static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char const* upName_, size_t* len_)
 {
     DEBUGSPEW_CODE( Universe* const U = universe_get( L));
     char const* fqn;
@@ -753,7 +753,7 @@ static char const* find_lookup_name(lua_State* L, int i, LookupMode mode_, char
 /*
  * Push a looked-up table, or nothing if we found nothing
  */
-static bool lookup_table(Dest L2, Source L, int i, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool lookup_table(Dest L2, Source L, int i, LookupMode mode_, char const* upName_)
 {
     // get the name of the table we want to send
     size_t len;
@@ -830,13 +830,12 @@ static bool lookup_table(Dest L2, Source L, int i, LookupMode mode_, char const*
  * Returns true if the table was cached (no need to fill it!); false if
  * it's a virgin.
  */
-static bool push_cached_table(lua_State* L2, int L2_cache_i, lua_State* L, int i)
+[[nodiscard]] static bool push_cached_table(Dest L2, int L2_cache_i, Source L, int i)
 {
-    bool not_found_in_cache;                                                                         // L2
     void const* p{ lua_topointer(L, i) };
 
     ASSERT_L( L2_cache_i != 0);
-    STACK_GROW( L2, 3);
+    STACK_GROW( L2, 3);                                                                              // L2
     STACK_CHECK_START_REL(L2, 0);
 
     // We don't need to use the from state ('L') in ID since the life span
@@ -847,7 +846,7 @@ static bool push_cached_table(lua_State* L2, int L2_cache_i, lua_State* L, int i
     //fprintf( stderr, "<< ID: %s >>\n", lua_tostring( L2, -1));
 
     lua_rawget( L2, L2_cache_i);                                                                     // ... {cached|nil}
-    not_found_in_cache = lua_isnil( L2, -1);
+    bool const not_found_in_cache{ lua_isnil(L2, -1) };
     if( not_found_in_cache)
     {
         lua_pop( L2, 1);                                                                             // ...
@@ -866,83 +865,83 @@ static bool push_cached_table(lua_State* L2, int L2_cache_i, lua_State* L, int i
 /*
  * Return some name helping to identify an object
  */
-static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
+[[nodiscard]] static int discover_object_name_recur(lua_State* L, int shortest_, int depth_)
 {
     int const what = 1;                                     // o "r" {c} {fqn} ... {?}
     int const result = 2;
     int const cache = 3;
     int const fqn = 4;
     // no need to scan this table if the name we will discover is longer than one we already know
-    if( shortest_ <= depth_ + 1)
+    if (shortest_ <= depth_ + 1)
     {
         return shortest_;
     }
-    STACK_GROW( L, 3);
+    STACK_GROW(L, 3);
     STACK_CHECK_START_REL(L, 0);
     // stack top contains the table to search in
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_rawget( L, cache);                                  // o "r" {c} {fqn} ... {?} nil/1
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_rawget(L, cache);                                  // o "r" {c} {fqn} ... {?} nil/1
     // if table is already visited, we are done
-    if( !lua_isnil( L, -1))
+    if( !lua_isnil(L, -1))
     {
-        lua_pop( L, 1);                                       // o "r" {c} {fqn} ... {?}
+        lua_pop(L, 1);                                       // o "r" {c} {fqn} ... {?}
         return shortest_;
     }
     // examined table is not in the cache, add it now
-    lua_pop( L, 1);                                         // o "r" {c} {fqn} ... {?}
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_pushinteger( L, 1);                                 // o "r" {c} {fqn} ... {?} {?} 1
-    lua_rawset( L, cache);                                  // o "r" {c} {fqn} ... {?}
+    lua_pop(L, 1);                                         // o "r" {c} {fqn} ... {?}
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_pushinteger(L, 1);                                 // o "r" {c} {fqn} ... {?} {?} 1
+    lua_rawset(L, cache);                                  // o "r" {c} {fqn} ... {?}
     // scan table contents
-    lua_pushnil( L);                                        // o "r" {c} {fqn} ... {?} nil
-    while( lua_next( L, -2))                                // o "r" {c} {fqn} ... {?} k v
+    lua_pushnil(L);                                        // o "r" {c} {fqn} ... {?} nil
+    while (lua_next(L, -2))                                // o "r" {c} {fqn} ... {?} k v
     {
-        //char const *const strKey = (lua_type( L, -2) == LUA_TSTRING) ? lua_tostring( L, -2) : nullptr; // only for debugging
-        //lua_Number const numKey = (lua_type( L, -2) == LUA_TNUMBER) ? lua_tonumber( L, -2) : -6666; // only for debugging
-        STACK_CHECK( L, 2);
+        //char const *const strKey = (lua_type(L, -2) == LUA_TSTRING) ? lua_tostring(L, -2) : nullptr; // only for debugging
+        //lua_Number const numKey = (lua_type(L, -2) == LUA_TNUMBER) ? lua_tonumber(L, -2) : -6666; // only for debugging
+        STACK_CHECK(L, 2);
         // append key name to fqn stack
         ++ depth_;
-        lua_pushvalue( L, -2);                                // o "r" {c} {fqn} ... {?} k v k
-        lua_rawseti( L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k v
-        if( lua_rawequal( L, -1, what)) // is it what we are looking for?
+        lua_pushvalue(L, -2);                                // o "r" {c} {fqn} ... {?} k v k
+        lua_rawseti(L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k v
+        if (lua_rawequal(L, -1, what)) // is it what we are looking for?
         {
-            STACK_CHECK( L, 2);
+            STACK_CHECK(L, 2);
             // update shortest name
             if( depth_ < shortest_)
             {
                 shortest_ = depth_;
-                luaG_pushFQN( L, fqn, depth_, nullptr);           // o "r" {c} {fqn} ... {?} k v "fqn"
-                lua_replace( L, result);                          // o "r" {c} {fqn} ... {?} k v
+                std::ignore = luaG_pushFQN(L, fqn, depth_, nullptr); // o "r" {c} {fqn} ... {?} k v "fqn"
+                lua_replace(L, result);                          // o "r" {c} {fqn} ... {?} k v
             }
             // no need to search further at this level
-            lua_pop( L, 2);                                     // o "r" {c} {fqn} ... {?}
-            STACK_CHECK( L, 0);
+            lua_pop(L, 2);                                     // o "r" {c} {fqn} ... {?}
+            STACK_CHECK(L, 0);
             break;
         }
-        switch( lua_type( L, -1))                             // o "r" {c} {fqn} ... {?} k v
+        switch (lua_type(L, -1))                             // o "r" {c} {fqn} ... {?} k v
         {
             default: // nil, boolean, light userdata, number and string aren't identifiable
             break;
 
             case LUA_TTABLE:                                    // o "r" {c} {fqn} ... {?} k {}
-            STACK_CHECK( L, 2);
-            shortest_ = discover_object_name_recur( L, shortest_, depth_);
+            STACK_CHECK(L, 2);
+            shortest_ = discover_object_name_recur(L, shortest_, depth_);
             // search in the table's metatable too
-            if( lua_getmetatable( L, -1))                       // o "r" {c} {fqn} ... {?} k {} {mt}
+            if (lua_getmetatable(L, -1))                       // o "r" {c} {fqn} ... {?} k {} {mt}
             {
-                if( lua_istable( L, -1))
+                if( lua_istable(L, -1))
                 {
                     ++ depth_;
-                    lua_pushliteral( L, "__metatable");             // o "r" {c} {fqn} ... {?} k {} {mt} "__metatable"
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
-                    shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                    lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k {} {mt} nil
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
+                    lua_pushliteral(L, "__metatable");             // o "r" {c} {fqn} ... {?} k {} {mt} "__metatable"
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
+                    shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                    lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k {} {mt} nil
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k {} {mt}
                     -- depth_;
                 }
-                lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k {}
+                lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k {}
             }
-            STACK_CHECK( L, 2);
+            STACK_CHECK(L, 2);
             break;
 
             case LUA_TTHREAD:                                   // o "r" {c} {fqn} ... {?} k T
@@ -950,61 +949,61 @@ static int discover_object_name_recur( lua_State* L, int shortest_, int depth_)
             break;
 
             case LUA_TUSERDATA:                                 // o "r" {c} {fqn} ... {?} k U
-            STACK_CHECK( L, 2);
+            STACK_CHECK(L, 2);
             // search in the object's metatable (some modules are built that way)
-            if( lua_getmetatable( L, -1))                       // o "r" {c} {fqn} ... {?} k U {mt}
+            if (lua_getmetatable(L, -1))                       // o "r" {c} {fqn} ... {?} k U {mt}
             {
-                if( lua_istable( L, -1))
+                if (lua_istable(L, -1))
                 {
                     ++ depth_;
-                    lua_pushliteral( L, "__metatable");             // o "r" {c} {fqn} ... {?} k U {mt} "__metatable"
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
-                    shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                    lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k U {mt} nil
-                    lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
+                    lua_pushliteral(L, "__metatable");             // o "r" {c} {fqn} ... {?} k U {mt} "__metatable"
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
+                    shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                    lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k U {mt} nil
+                    lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k U {mt}
                     -- depth_;
                 }
-                lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k U
+                lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k U
             }
-            STACK_CHECK( L, 2);
+            STACK_CHECK(L, 2);
             // search in the object's uservalues
             {
                 int uvi = 1;
-                while( lua_getiuservalue( L, -1, uvi) != LUA_TNONE) // o "r" {c} {fqn} ... {?} k U {u}
+                while (lua_getiuservalue(L, -1, uvi) != LUA_TNONE) // o "r" {c} {fqn} ... {?} k U {u}
                 {
-                    if( lua_istable( L, -1)) // if it is a table, look inside
+                    if( lua_istable(L, -1)) // if it is a table, look inside
                     {
                         ++ depth_;
-                        lua_pushliteral( L, "uservalue");               // o "r" {c} {fqn} ... {?} k v {u} "uservalue"
-                        lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
-                        shortest_ = discover_object_name_recur( L, shortest_, depth_);
-                        lua_pushnil( L);                                // o "r" {c} {fqn} ... {?} k v {u} nil
-                        lua_rawseti( L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
+                        lua_pushliteral(L, "uservalue");               // o "r" {c} {fqn} ... {?} k v {u} "uservalue"
+                        lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
+                        shortest_ = discover_object_name_recur(L, shortest_, depth_);
+                        lua_pushnil(L);                                // o "r" {c} {fqn} ... {?} k v {u} nil
+                        lua_rawseti(L, fqn, depth_);                   // o "r" {c} {fqn} ... {?} k v {u}
                         -- depth_;
                     }
-                    lua_pop( L, 1);                                   // o "r" {c} {fqn} ... {?} k U
+                    lua_pop(L, 1);                                   // o "r" {c} {fqn} ... {?} k U
                     ++ uvi;
                 }
                 // when lua_getiuservalue() returned LUA_TNONE, it pushed a nil. pop it now
-                lua_pop( L, 1);                                     // o "r" {c} {fqn} ... {?} k U
+                lua_pop(L, 1);                                     // o "r" {c} {fqn} ... {?} k U
             }
-            STACK_CHECK( L, 2);
+            STACK_CHECK(L, 2);
             break;
         }
         // make ready for next iteration
-        lua_pop( L, 1);                                       // o "r" {c} {fqn} ... {?} k
+        lua_pop(L, 1);                                       // o "r" {c} {fqn} ... {?} k
         // remove name from fqn stack
-        lua_pushnil( L);                                      // o "r" {c} {fqn} ... {?} k nil
-        lua_rawseti( L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k
-        STACK_CHECK( L, 1);
+        lua_pushnil(L);                                      // o "r" {c} {fqn} ... {?} k nil
+        lua_rawseti(L, fqn, depth_);                         // o "r" {c} {fqn} ... {?} k
+        STACK_CHECK(L, 1);
         -- depth_;
     }                                                       // o "r" {c} {fqn} ... {?}
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
     // remove the visited table from the cache, in case a shorter path to the searched object exists
-    lua_pushvalue( L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
-    lua_pushnil( L);                                        // o "r" {c} {fqn} ... {?} {?} nil
-    lua_rawset( L, cache);                                  // o "r" {c} {fqn} ... {?}
-    STACK_CHECK( L, 0);
+    lua_pushvalue(L, -1);                                  // o "r" {c} {fqn} ... {?} {?}
+    lua_pushnil(L);                                        // o "r" {c} {fqn} ... {?} {?} nil
+    lua_rawset(L, cache);                                  // o "r" {c} {fqn} ... {?}
+    STACK_CHECK(L, 0);
     return shortest_;
 }
 
@@ -1169,7 +1168,7 @@ static char const* vt_names[] =
 // we have to do it that way because we can't unbalance the stack between buffer operations
 // namely, this means we can't push a function on top of the stack *after* we initialize the buffer!
 // luckily, this also works with earlier Lua versions
-static int buf_writer( lua_State* L, void const* b, size_t size, void* ud)
+[[nodiscard]] static int buf_writer(lua_State* L, void const* b, size_t size, void* ud)
 {
     luaL_Buffer* B = (luaL_Buffer*) ud;
     if( !B->L)
@@ -1339,7 +1338,7 @@ static void copy_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, Loo
 static void copy_cached_func(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
     FuncSubType funcSubType;
-    /*lua_CFunction cfunc =*/ luaG_tocfunction( L, i, &funcSubType); // nullptr for LuaJIT-fast && bytecode functions
+    std::ignore = luaG_tocfunction(L, i, &funcSubType); // nullptr for LuaJIT-fast && bytecode functions
     if( funcSubType == FST_Bytecode)
     {
         void* const aspointer = (void*)lua_topointer( L, i);
@@ -1391,7 +1390,7 @@ static void copy_cached_func(Universe* U, Dest L2, int L2_cache_i, Source L, int
 
 // #################################################################################################
 
-static bool push_cached_metatable(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool push_cached_metatable(Universe* U, Dest L2, int L2_cache_i, Source L, int i, LookupMode mode_, char const* upName_)
 {
     STACK_CHECK_START_REL(L, 0);
     if( lua_getmetatable( L, i))                                                 // ... mt
@@ -1442,7 +1441,7 @@ static bool push_cached_metatable(Universe* U, Dest L2, int L2_cache_i, Source L
 
 // #################################################################################################
 
-static void inter_copy_keyvaluepair(Universe* U, Dest L2, int L2_cache_i, Source L, VT vt_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static void inter_copy_keyvaluepair(Universe* U, Dest L2, int L2_cache_i, Source L, VT vt_, LookupMode mode_, char const* upName_)
 {
     int val_i = lua_gettop(L);
     int key_i = val_i - 1;
@@ -1514,7 +1513,7 @@ static void inter_copy_keyvaluepair(Universe* U, Dest L2, int L2_cache_i, Source
 */
 static constexpr UniqueKey CLONABLES_CACHE_KEY{ 0xD04EE018B3DEE8F5ull };
 
-static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, LookupMode mode_, char const* upName_)
 {
     void* const source = lua_touserdata( L, source_i_);
     source_i_ = lua_absindex( L, source_i_);
@@ -1600,7 +1599,11 @@ static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source
         // assign uservalues
         while( uvi > 0)
         {
-            inter_copy_one(U, L2, L2_cache_i, L, lua_absindex( L, -1), VT::NORMAL, mode_, upName_);          // ... u uv
+            std::ignore = inter_copy_one(U
+                , L2, L2_cache_i
+                , L, lua_absindex(L, -1)
+                , VT::NORMAL, mode_, upName_
+            );                                                                                               // ... u uv
             lua_pop( L, 1);                                                      // ... mt __lanesclone [uv]*
             // this pops the value from the stack
             lua_setiuservalue( L2, -2, uvi);                                                                 // ... u
@@ -1629,7 +1632,7 @@ static bool copyclone(Universe* U, Dest L2, int L2_cache_i, Source L, int source
 
 // #################################################################################################
 
-static bool inter_copy_userdata(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool inter_copy_userdata(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
     STACK_CHECK_START_REL(L, 0);
     STACK_CHECK_START_REL(L2, 0);
@@ -1679,7 +1682,7 @@ static bool inter_copy_userdata(Universe* U, Dest L2, int L2_cache_i, Source L,
 
 // #################################################################################################
 
-static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, VT vt_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L, int source_i_, VT vt_, LookupMode mode_, char const* upName_)
 {
     if (vt_ == VT::KEY)
     {
@@ -1693,13 +1696,10 @@ static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L,
     if( lua_tocfunction( L, source_i_) == userdata_clone_sentinel) // we are actually copying a clonable full userdata from a keeper
     {
         // clone the full userdata again
-        size_t userdata_size = 0;
-        void* source;
-        void* clone;
 
         // let's see if we already restored this userdata
         lua_getupvalue( L, source_i_, 2);                                          // ... u
-        source = lua_touserdata( L, -1);
+        void* source = lua_touserdata( L, -1);
         lua_pushlightuserdata( L2, source);                                                                      // ... source
         lua_rawget( L2, L2_cache_i);                                                                             // ... u?
         if( !lua_isnil( L2, -1))
@@ -1712,12 +1712,13 @@ static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L,
         lua_pop( L2, 1);                                                                                         // ...
 
         // this function has 2 upvalues: the fqn of its metatable, and the userdata itself
-        lookup_table( L2, L, source_i_, mode_, upName_);                                                         // ... mt
+        std::ignore = lookup_table( L2, L, source_i_, mode_, upName_);                                           // ... mt
         // originally 'source_i_' slot was the proxy closure, but from now on it indexes the actual userdata we extracted from it
         source_i_ = lua_gettop( L);
         source = lua_touserdata( L, -1);
+        void* clone{ nullptr };
         // get the number of bytes to allocate for the clone
-        userdata_size = (size_t) lua_rawlen( L, -1);
+        size_t const userdata_size { lua_rawlen(L, -1) };
         {
             // extract uservalues (don't transfer them yet)
             int uvi = 0;
@@ -1738,7 +1739,11 @@ static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L,
             // transfer and assign uservalues
             while( uvi > 0)
             {
-                inter_copy_one(U, L2, L2_cache_i, L, lua_absindex(L, -1), vt_, mode_, upName_);                  // ... mt u uv
+                std::ignore = inter_copy_one(U
+                    , L2, L2_cache_i
+                    , L, lua_absindex(L, -1)
+                    , vt_, mode_, upName_
+                );                                                                                               // ... mt u uv
                 lua_pop( L, 1);                                                    // ... u [uv]*
                 // this pops the value from the stack
                 lua_setiuservalue( L2, -2, uvi);                                                                 // ... mt u
@@ -1774,7 +1779,7 @@ static bool inter_copy_function(Universe* U, Dest L2, int L2_cache_i, Source L,
 
 // #################################################################################################
 
-static bool inter_copy_table(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
+[[nodiscard]] static bool inter_copy_table(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
     if (vt_ == VT::KEY)
     {
@@ -1846,7 +1851,7 @@ static bool inter_copy_table(Universe* U, Dest L2, int L2_cache_i, Source L, int
 *
 * Returns true if value was pushed, false if its type is non-supported.
 */
-bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
+[[nodiscard]] bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_)
 {
     bool ret{ true };
     int val_type = lua_type( L, i);
@@ -1971,78 +1976,77 @@ bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt
 *
 * Note: Parameters are in this order ('L' = from first) to be same as 'lua_xmove'.
 */
-int luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
+[[nodiscard]] int luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
 {
-    int top_L = lua_gettop(L); // ... {}n
-    int top_L2 = lua_gettop(L2); // ...
-    int i, j;
+    int const top_L{ lua_gettop(L) };                             // ... {}n
+    int const top_L2{ lua_gettop(L2) };                                                             // ...
     char tmpBuf[16];
-    char const* pBuf = U->verboseErrors ? tmpBuf : "?";
-    bool copyok{ true };
+    char const* pBuf{ U->verboseErrors ? tmpBuf : "?" };
 
-    DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "luaG_inter_copy()\n" INDENT_END));
+    DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy()\n" INDENT_END));
     DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
 
-    if( n > top_L)
+    if (n > top_L)
     {
         // requesting to copy more than is available?
-        DEBUGSPEW_CODE( fprintf( stderr, INDENT_BEGIN "nothing to copy()\n" INDENT_END));
+        DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "nothing to copy()\n" INDENT_END));
         DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
         return -1;
     }
 
     STACK_CHECK_START_REL(L2, 0);
-    STACK_GROW( L2, n + 1);
+    STACK_GROW(L2, n + 1);
 
     /*
     * Make a cache table for the duration of this copy. Collects tables and
     * function entries, avoiding the same entries to be passed on as multiple
     * copies. ESSENTIAL i.e. for handling upvalue tables in the right manner!
     */
-    lua_newtable( L2);                                                                              // ... cache
+    lua_newtable(L2);                                                                               // ... cache
 
     STACK_CHECK_START_REL(L, 0);
-    for( i = top_L - n + 1, j = 1; i <= top_L; ++ i, ++ j)
+    bool copyok{ true };
+    for (int i = top_L - n + 1, j = 1; i <= top_L; ++i, ++j)
     {
-        if( U->verboseErrors)
+        if (U->verboseErrors)
         {
-            sprintf( tmpBuf, "arg_%d", j);
+            sprintf(tmpBuf, "arg_%d", j);
         }
         copyok = inter_copy_one(U, L2, top_L2 + 1, L, i, VT::NORMAL, mode_, pBuf);                  // ... cache {}n
-        if( !copyok)
+        if (!copyok)
         {
             break;
         }
     }
-    STACK_CHECK( L, 0);
+    STACK_CHECK(L, 0);
 
     DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
 
-    if( copyok)
+    if (copyok)
     {
-        STACK_CHECK( L2, n + 1);
+        STACK_CHECK(L2, n + 1);
         // Remove the cache table. Persistent caching would cause i.e. multiple
         // messages passed in the same table to use the same table also in receiving end.
-        lua_remove( L2, top_L2 + 1);
+        lua_remove(L2, top_L2 + 1);
         return 0;
     }
 
     // error -> pop everything from the target state stack
-    lua_settop( L2, top_L2);
-    STACK_CHECK( L2, 0);
+    lua_settop(L2, top_L2);
+    STACK_CHECK(L2, 0);
     return -2;
 }
 
 // #################################################################################################
 
-int luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
+[[nodiscard]] int luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_)
 {
-    int ret = luaG_inter_copy( U, L, L2, n, mode_);
-    lua_pop( L, (int) n);
+    int const ret{ luaG_inter_copy(U, L, L2, n, mode_) };
+    lua_pop( L, n);
     return ret;
 }
 
-int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_)
+[[nodiscard]] int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_)
 {
     DEBUGSPEW_CODE(fprintf(stderr, INDENT_BEGIN "luaG_inter_copy_package()\n" INDENT_END));
     DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
@@ -2080,7 +2084,7 @@ int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, Lo
             else
             {
                 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_add(1, std::memory_order_relaxed));
-                luaG_inter_move(U, L, L2, 1, mode_); // moves the entry to L2
+                std::ignore = luaG_inter_move(U, L, L2, 1, mode_); // moves the entry to L2
                 DEBUGSPEW_CODE(U->debugspew_indent_depth.fetch_sub(1, std::memory_order_relaxed));
                 lua_setfield(L2, -2, entry); // set package[entry]
             }
diff --git a/src/tools.h b/src/tools.h
index 8e95a4f..f0de7ec 100644
--- a/src/tools.h
+++ b/src/tools.h
@@ -25,16 +25,16 @@ enum class VT
     KEY,
     METATABLE
 };
-bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_);
+[[nodiscard]] bool inter_copy_one(Universe* U, Dest L2, int L2_cache_i, Source L, int i, VT vt_, LookupMode mode_, char const* upName_);
 
 // ################################################################################################
 
-int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_);
+[[nodiscard]] int luaG_inter_copy_package(Universe* U, Source L, Dest L2, int package_idx_, LookupMode mode_);
 
-int luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
-int luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
+[[nodiscard]] int luaG_inter_copy(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
+[[nodiscard]] int luaG_inter_move(Universe* U, Source L, Dest L2, int n, LookupMode mode_);
 
-int luaG_nameof(lua_State* L);
+[[nodiscard]] int luaG_nameof(lua_State* L);
 
 void populate_func_lookup_table(lua_State* L, int _i, char const* _name);
 void initialize_allocator_function(Universe* U, lua_State* L);
diff --git a/src/universe.h b/src/universe.h
index f4211af..113ed21 100644
--- a/src/universe.h
+++ b/src/universe.h
@@ -35,7 +35,7 @@ class AllocatorDefinition
     lua_Alloc m_allocF{ nullptr };
     void* m_allocUD{ nullptr };
 
-    static void* operator new(size_t size_, lua_State* L) noexcept { return lua_newuserdatauv(L, size_, 0); }
+    [[nodiscard]] static void* operator new(size_t size_, lua_State* L) noexcept { return lua_newuserdatauv(L, size_, 0); }
     // always embedded somewhere else or "in-place constructed" as a full userdata
     // can't actually delete the operator because the compiler generates stack unwinding code that could call it in case of exception
     static void operator delete([[maybe_unused]] void* p_, lua_State* L) { ASSERT_L(!"should never be called") };
@@ -81,7 +81,7 @@ class ProtectedAllocator : public AllocatorDefinition
 
     std::mutex m_lock;
 
-    static void* protected_lua_Alloc(void* ud_, void* ptr_, size_t osize_, size_t nsize_)
+    [[nodiscard]] static void* protected_lua_Alloc(void* ud_, void* ptr_, size_t osize_, size_t nsize_)
     {
         ProtectedAllocator* const allocator{ static_cast<ProtectedAllocator*>(ud_) };
         std::lock_guard<std::mutex> guard{ allocator->m_lock };
@@ -91,7 +91,7 @@ class ProtectedAllocator : public AllocatorDefinition
     public:
 
     // we are not like our base class: we can't be created inside a full userdata (or we would have to install a metatable and __gc handler to destroy ourselves properly)
-    static void* operator new(size_t size_, lua_State* L) noexcept = delete;
+    [[nodiscard]] static void* operator new(size_t size_, lua_State* L) noexcept = delete;
     static void operator delete(void* p_, lua_State* L) = delete;
 
     AllocatorDefinition makeDefinition()
@@ -185,6 +185,6 @@ class Universe
 
 // ################################################################################################
 
-Universe* universe_get(lua_State* L);
-Universe* universe_create(lua_State* L);
+[[nodiscard]] Universe* universe_get(lua_State* L);
+[[nodiscard]] Universe* universe_create(lua_State* L);
 void universe_store(lua_State* L, Universe* U);