More strong typing for UniqueKey::getSubTable() arguments

5 files changed, 10 insertions, 7 deletions

diff --git a/src/deep.cpp b/src/deep.cpp
index 0d801a3..bfadeac 100644
--- a/src/deep.cpp
+++ b/src/deep.cpp
@@ -342,7 +342,7 @@ void DeepFactory::storeDeepLookup(lua_State* const L_) const
     // the deep metatable is at the top of the stack                                               // L_: mt
     STACK_GROW(L_, 3);
     STACK_CHECK_START_REL(L_, 0);                                                                  // L_: mt
-    std::ignore = kDeepLookupRegKey.getSubTable(L_, 0, 0);                                         // L_: mt {}
+    std::ignore = kDeepLookupRegKey.getSubTable(L_, NArr{ 0 }, NRec{ 0 });                         // L_: mt {}
     lua_pushvalue(L_, -2);                                                                         // L_: mt {} mt
     lua_pushlightuserdata(L_, std::bit_cast<void*>(this));                                         // L_: mt {} mt factory
     lua_rawset(L_, -3);                                                                            // L_: mt {}
diff --git a/src/intercopycontext.cpp b/src/intercopycontext.cpp
index 5f3ce7d..7244ed8 100644
--- a/src/intercopycontext.cpp
+++ b/src/intercopycontext.cpp
@@ -148,7 +148,7 @@ static constexpr RegistryUniqueKey kMtIdRegKey{ 0xA8895DCF4EC3FE3Cull };
     STACK_GROW(L_, 3);
 
     STACK_CHECK_START_REL(L_, 0);
-    std::ignore = kMtIdRegKey.getSubTable(L_, 0, 0);                                               // L_: ... _R[kMtIdRegKey]
+    std::ignore = kMtIdRegKey.getSubTable(L_, NArr{ 0 }, NRec{ 0 });                               // L_: ... _R[kMtIdRegKey]
     lua_pushvalue(L_, _absidx);                                                                    // L_: ... _R[kMtIdRegKey] {mt}
     lua_rawget(L_, -2);                                                                            // L_: ... _R[kMtIdRegKey] mtk?
 
@@ -599,7 +599,7 @@ LuaType InterCopyContext::processConversion() const
     STACK_CHECK_START_REL(L2, 0);
     STACK_GROW(L2, 4);
     // do we already know this metatable?
-    std::ignore = kMtIdRegKey.getSubTable(L2, 0, 0);                                               //                                                L2: _R[kMtIdRegKey]
+    std::ignore = kMtIdRegKey.getSubTable(L2, NArr{ 0 }, NRec{ 0 });                               //                                                L2: _R[kMtIdRegKey]
     lua_pushinteger(L2, _mt_id);                                                                   //                                                L2: _R[kMtIdRegKey] id
     lua_rawget(L2, -2);                                                                            //                                                L2: _R[kMtIdRegKey] mt|nil
     STACK_CHECK(L2, 2);
diff --git a/src/lane.cpp b/src/lane.cpp
index d4d409f..29ad8bb 100644
--- a/src/lane.cpp
+++ b/src/lane.cpp
@@ -68,7 +68,7 @@ static LUAG_FUNC(set_finalizer)
     luaL_argcheck(L_, lua_gettop(L_) == 1, 1, "too many arguments");
     STACK_GROW(L_, 3);
     // Get the current finalizer table (if any), create one if it doesn't exist
-    std::ignore = kFinalizerRegKey.getSubTable(L_, 1, 0);                                          // L_: finalizer {finalisers}
+    std::ignore = kFinalizerRegKey.getSubTable(L_, NArr{ 1 }, NRec{ 0 });                          // L_: finalizer {finalisers}
     // must cast to int, not lua_Integer, because LuaJIT signature of lua_rawseti is not the same as PUC-Lua.
     int const _idx{ static_cast<int>(lua_rawlen(L_, kIdxTop) + 1) };
     lua_pushvalue(L_, 1);                                                                          // L_: finalizer {finalisers} finalizer
diff --git a/src/tools.cpp b/src/tools.cpp
index d0204a6..34b9faf 100644
--- a/src/tools.cpp
+++ b/src/tools.cpp
@@ -340,7 +340,7 @@ namespace tools {
                 STACK_CHECK(L_, 2);
             }
             // retrieve the cache, create it if we haven't done it yet
-            std::ignore = kLookupCacheRegKey.getSubTable(L_, 0, 0);                                // L_: {} {fqn} {cache}
+            std::ignore = kLookupCacheRegKey.getSubTable(L_, NArr{ 0 }, NRec{ 0 });                // L_: {} {fqn} {cache}
             // process everything we find in that table, filling in lookup data for all functions and tables we see there
             populate_func_lookup_table_recur(L_, _dbIdx, _in_base, _startDepth);
             lua_pop(L_, 3);                                                                        // L_:
diff --git a/src/uniquekey.h b/src/uniquekey.h
index c409048..ddc157b 100644
--- a/src/uniquekey.h
+++ b/src/uniquekey.h
@@ -45,6 +45,9 @@ class UniqueKey
 
 // #################################################################################################
 
+DECLARE_UNIQUE_TYPE(NArr, int);
+DECLARE_UNIQUE_TYPE(NRec, int);
+
 class RegistryUniqueKey
 : public UniqueKey
 {
@@ -93,7 +96,7 @@ class RegistryUniqueKey
     }
     // ---------------------------------------------------------------------------------------------
     // equivalent to luaL_getsubtable
-    [[nodiscard]] bool getSubTable(lua_State* const L_, int const narr_, int const nrec_) const
+    [[nodiscard]] bool getSubTable(lua_State* const L_, NArr const narr_, NRec const nrec_) const
     {
         STACK_CHECK_START_REL(L_, 0);
         pushValue(L_);                                                                             // L_: {}|nil
@@ -113,7 +116,7 @@ class RegistryUniqueKey
     void getSubTableMode(lua_State* const L_, std::string_view const& mode_) const
     {
         STACK_CHECK_START_REL(L_, 0);
-        if (!getSubTable(L_, 0, 0)) {                                                              // L_: {}
+        if (!getSubTable(L_, NArr{ 0 }, NRec{ 0 })) {                                              // L_: {}
             // Set its metatable if requested
             if (!mode_.empty()) {
                 STACK_GROW(L_, 3);