Sprinkling StackIndex all over the place

1 files changed, 26 insertions, 26 deletions

diff --git a/src/linda.cpp b/src/linda.cpp
index 3f5fd33..bd40f5e 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -280,7 +280,7 @@ void Linda::setName(std::string_view const& name_)
 LUAG_FUNC(linda_cancel)
 {
     Linda* const _linda{ ToLinda<false>(L_, StackIndex{ 1 }) };
-    std::string_view const _who{ luaG_optstring(L_, 2, "both") };
+    std::string_view const _who{ luaG_optstring(L_, StackIndex{ 2 }, "both") };
     // make sure we got 2 arguments: the linda and the cancellation mode
     luaL_argcheck(L_, lua_gettop(L_) <= 2, 2, "wrong number of arguments");
 
@@ -371,7 +371,7 @@ LUAG_FUNC(linda_count)
             CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ lua_gettop(L_) });
 
             Keeper* const _keeper{ _linda->whichKeeper() };
-            KeeperCallResult const _pushed{ keeper_call(_keeper->K, KEEPER_API(count), L_, _linda, 2) };
+            KeeperCallResult const _pushed{ keeper_call(_keeper->K, KEEPER_API(count), L_, _linda, StackIndex{ 2 }) };
             return OptionalValue(_pushed, L_, "tried to count an invalid key");
         }
     };
@@ -435,7 +435,7 @@ LUAG_FUNC(linda_get)
             KeeperCallResult _pushed;
             if (_linda->cancelRequest == CancelRequest::None) {
                 Keeper* const _keeper{ _linda->whichKeeper() };
-                _pushed = keeper_call(_keeper->K, KEEPER_API(get), L_, _linda, 2);
+                _pushed = keeper_call(_keeper->K, KEEPER_API(get), L_, _linda, StackIndex{ 2 });
             } else { // linda is cancelled
                 // do nothing and return nil,lanes.cancel_error
                 lua_pushnil(L_);
@@ -468,10 +468,10 @@ LUAG_FUNC(linda_limit)
             int const _nargs{ lua_gettop(L_) };
             luaL_argcheck(L_, _nargs == 2 || _nargs == 3, 2, "wrong number of arguments");
             // make sure we got a numeric limit, or "unlimited", (or nothing)
-            bool const _unlimited{ luaG_tostring(L_, 3) == "unlimited" };
+            bool const _unlimited{ luaG_tostring(L_, StackIndex{ 3 }) == "unlimited" };
             LindaLimit const _val{ _unlimited ? std::numeric_limits<LindaLimit::type>::max() : LindaLimit{ static_cast<LindaLimit::type>(luaL_optinteger(L_, 3, 0)) } };
             if (_val < 0) {
-                raise_luaL_argerror(L_, 3, "limit must be >= 0");
+                raise_luaL_argerror(L_, StackIndex{ 3 }, "limit must be >= 0");
             }
             // make sure the key is of a valid type
             CheckKeyTypes(L_, StackIndex{ 2 }, StackIndex{ 2 });
@@ -479,23 +479,23 @@ LUAG_FUNC(linda_limit)
             KeeperCallResult _pushed;
             if (_linda->cancelRequest == CancelRequest::None) {
                 if (_unlimited) {
-                    LUA_ASSERT(L_, lua_gettop(L_) == 3 && luaG_tostring(L_, 3) == "unlimited");
+                    LUA_ASSERT(L_, lua_gettop(L_) == 3 && luaG_tostring(L_, StackIndex{ 3 }) == "unlimited");
                     // inside the Keeper, unlimited is signified with a -1 limit (can't use nil because of nil kNilSentinel conversions!)
                     lua_pop(L_, 1);                                                                // L_: linda key
                     lua_pushinteger(L_, -1);                                                       // L_: linda key nil
                 }
                 Keeper* const _keeper{ _linda->whichKeeper() };
-                _pushed = keeper_call(_keeper->K, KEEPER_API(limit), L_, _linda, 2);
-                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 2) && luaG_type(L_, -1) == LuaType::STRING);
+                _pushed = keeper_call(_keeper->K, KEEPER_API(limit), L_, _linda, StackIndex{ 2 });
+                LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 2) && luaG_type(L_, kIdxTop) == LuaType::STRING);
                 if (_nargs == 3) { // 3 args: setting the limit
                     // changing the limit: no error, boolean value saying if we should wake blocked writer threads
-                    LUA_ASSERT(L_, luaG_type(L_, -2) == LuaType::BOOLEAN);                         // L_: bool string
+                    LUA_ASSERT(L_, luaG_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);           // L_: bool string
                     if (lua_toboolean(L_, -2)) {
                         _linda->readHappened.notify_all(); // To be done from within the 'K' locking area
                     }
                 } else { // 2 args: reading the limit
                     // reading the limit: a number >=0 or "unlimited"
-                    LUA_ASSERT(L_, luaG_type(L_, -2) == LuaType::NUMBER || luaG_tostring(L_, -2) == "unlimited");
+                    LUA_ASSERT(L_, luaG_type(L_, StackIndex{ -2 }) == LuaType::NUMBER || luaG_tostring(L_, StackIndex{ -2 }) == "unlimited");
                 }
             } else { // linda is cancelled
                 // do nothing and return nil,lanes.cancel_error
@@ -530,12 +530,12 @@ LUAG_FUNC(linda_receive)
             StackIndex _key_i{ 2 }; // index of first key, if timeout not there
 
             std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
-            if (luaG_type(L_, 2) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
+            if (luaG_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
                 lua_Duration const _duration{ lua_tonumber(L_, 2) };
                 if (_duration.count() >= 0.0) {
                     _until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(_duration);
                 } else {
-                    raise_luaL_argerror(L_, 2, "duration cannot be < 0");
+                    raise_luaL_argerror(L_, StackIndex{ 2 }, "duration cannot be < 0");
                 }
                 ++_key_i;
             } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
@@ -555,14 +555,14 @@ LUAG_FUNC(linda_receive)
                 // we expect a user-defined amount of return value
                 _expected_pushed_min = (int) luaL_checkinteger(L_, _key_i + 1);
                 if (_expected_pushed_min < 1) {
-                    raise_luaL_argerror(L_, _key_i + 1, "bad min count");
+                    raise_luaL_argerror(L_, StackIndex{ _key_i + 1 }, "bad min count");
                 }
                 _expected_pushed_max = (int) luaL_optinteger(L_, _key_i + 2, _expected_pushed_min);
                 // don't forget to count the key in addition to the values
                 ++_expected_pushed_min;
                 ++_expected_pushed_max;
                 if (_expected_pushed_min > _expected_pushed_max) {
-                    raise_luaL_argerror(L_, _key_i + 2, "batched min/max error");
+                    raise_luaL_argerror(L_, StackIndex{ _key_i + 2 }, "batched min/max error");
                 }
             } else {
                 // make sure the keys are of a valid type
@@ -686,12 +686,12 @@ LUAG_FUNC(linda_send)
             StackIndex _key_i{ 2 }; // index of first key, if timeout not there
 
             std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
-            if (luaG_type(L_, 2) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
+            if (luaG_type(L_, StackIndex{ 2 }) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
                 lua_Duration const _duration{ lua_tonumber(L_, 2) };
                 if (_duration.count() >= 0.0) {
                     _until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(_duration);
                 } else {
-                    raise_luaL_argerror(L_, 2, "duration cannot be < 0");
+                    raise_luaL_argerror(L_, StackIndex{ 2 }, "duration cannot be < 0");
                 }
                 ++_key_i;
             } else if (lua_isnil(L_, 2)) { // alternate explicit "infinite timeout" by passing nil before the key
@@ -828,9 +828,9 @@ LUAG_FUNC(linda_set)
             KeeperCallResult _pushed;
             if (_linda->cancelRequest == CancelRequest::None) {
                 Keeper* const _keeper{ _linda->whichKeeper() };
-                _pushed = keeper_call(_keeper->K, KEEPER_API(set), L_, _linda, 2);
+                _pushed = keeper_call(_keeper->K, KEEPER_API(set), L_, _linda, StackIndex{ 2 });
                 if (_pushed.has_value()) { // no error?
-                    LUA_ASSERT(L_, _pushed.value() == 2 && luaG_type(L_, -1) == LuaType::STRING && luaG_type(L_, -2) == LuaType::BOOLEAN);
+                    LUA_ASSERT(L_, _pushed.value() == 2 && luaG_type(L_, kIdxTop) == LuaType::STRING && luaG_type(L_, StackIndex{ -2 }) == LuaType::BOOLEAN);
 
                     if (_has_data) {
                         // we put some data in the slot, tell readers that they should wake
@@ -922,13 +922,13 @@ namespace {
  */
 LUAG_FUNC(linda)
 {
-    static constexpr int kLastArg{ LUA_VERSION_NUM >= 504 ? 3 : 2};
-    int const _top{ lua_gettop(L_) };
+    static constexpr StackIndex kLastArg{ LUA_VERSION_NUM >= 504 ? 3 : 2 };
+    StackIndex const _top{ lua_gettop(L_) };
     luaL_argcheck(L_, _top <= kLastArg, _top, "too many arguments");
-    int _closeHandlerIdx{};
-    int _nameIdx{};
-    int _groupIdx{};
-    for (int const _i : std::ranges::iota_view{ 1, _top + 1 }) {
+    StackIndex _closeHandlerIdx{};
+    StackIndex _nameIdx{};
+    StackIndex _groupIdx{};
+    for (StackIndex const _i : std::ranges::iota_view{ StackIndex{ 1 }, StackIndex{ _top + 1 }}) {
         switch (luaG_type(L_, _i)) {
 #if LUA_VERSION_NUM >= 504 // to-be-closed support starts with Lua 5.4
         case LuaType::FUNCTION:
@@ -985,11 +985,11 @@ LUAG_FUNC(linda)
         LindaFactory::Instance.pushDeepUserdata(DestState{ L_ }, _nuv);                            // L_: name group close_handler linda
         if (_closeHandlerIdx != 0) {
             lua_replace(L_, 2);                                                                    // L_: name linda close_handler
-            lua_setiuservalue(L_, 2, 1);                                                           // L_: name linda
+            lua_setiuservalue(L_, StackIndex{ 2 }, 1);                                             // L_: name linda
         }
         // depending on whether we have a handler or not, the stack is not in the same state at this point
         // just make sure we have our Linda at the top
-        LUA_ASSERT(L_, ToLinda<true>(L_, StackIndex{ -1 }));
+        LUA_ASSERT(L_, ToLinda<true>(L_, kIdxTop));
         return 1;
     } else { // no to-be-closed support
         // ensure we have name, group in that order on the stack