table: add table.count(tbl)

Backport of retail's table.count (added 11.2.5): returns
(numTableNodes, numArrayNodes, maxArrayIndex) -- total entries, entries
with an integer key in [1..numTableNodes], and the largest positive
integral key (0 if none). Pure lua_next walk, no Lua-internal layout
dependency; keys read via ToNumber only (ToString on a numeric key
would corrupt traversal). All five cases verified to match retail,
including negative-key handling ({[-3]=x} -> 1, 0, 0).

Author: brues-code

README.md

@@ -47,7 +47,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [Loot](docs/API.md#loot) | `C_Loot.GetNearbyLootableUnits`, `C_Loot.GetLastScanResults`, `C_Loot.IsScanInProgress`, `C_Loot.LootUnit`, `C_Loot.LootUnitItem`, `C_Loot.ScanNearbyLoot` |
 | [LootHistory](docs/API.md#loothistory) | `C_LootHistory.GetNumItems`, `C_LootHistory.GetItem`, `C_LootHistory.GetPlayerInfo`, `C_LootHistory.Clear` |
 | [LossOfControl](docs/API.md#lossofcontrol) | `C_LossOfControl.GetActiveLossOfControlData`, `C_LossOfControl.GetActiveLossOfControlDataCount` |
-| [Lua](docs/API.md#lua) | `coroutine.create`, `coroutine.resume`, `coroutine.status`, `coroutine.wrap`, `coroutine.yield`, `CreateFromMixins`, `math.fmod`, `math.huge`, `math.modf`, `Mixin`, `select`, `string.gmatch`, `string.match`, `string.reverse`, `strjoin`, `strreplace`, `strrev`, `strsplit`, `strtrim`, `table.wipe` |
+| [Lua](docs/API.md#lua) | `coroutine.create`, `coroutine.resume`, `coroutine.status`, `coroutine.wrap`, `coroutine.yield`, `CreateFromMixins`, `math.fmod`, `math.huge`, `math.modf`, `Mixin`, `select`, `string.gmatch`, `string.match`, `string.reverse`, `strjoin`, `strreplace`, `strrev`, `strsplit`, `strtrim`, `table.count`, `table.wipe` |
 | [Macros](docs/API.md#macros) | `GetLooseMacroIcons`, `GetLooseMacroItemIcons`, `GetMacroIcons`, `GetMacroItemIcons`, `GetMacroSpell` |
 | [Mail](docs/API.md#mail) | `GetInboxItemLink`, `GetSendMailItemLink` |
 | [Map](docs/API.md#map) | `C_Map.GetAreaInfo`, `C_Map.GetAreas`, `C_Map.GetAreaTriggerInfo`, `C_Map.GetAreaTriggers`, `C_Map.GetBestMapForUnit`, `C_Map.GetMapAreaIDs`, `C_Map.GetMapOverlays`, `C_Map.GetMapWorldSize` |

docs/API.md

@@ -300,6 +300,7 @@ build instructions.
 - [Lua](#lua)
   - [`select(index, ...)`](#selectindex-)
   - [`table.wipe(t)`](#tablewipet)
+  - [`table.count(tbl)`](#tablecounttbl)
   - [`Mixin(object, ...)` / `CreateFromMixins(...)`](#mixinobject--createfrommixins)
   - [`string.match` / `string.gmatch`](#stringmatch--stringgmatch)
   - [`strsplit(sep, str [, pieces])`](#strsplitsep-str--pieces)
@@ -7215,6 +7216,29 @@ undefined per the Lua reference manual.
 
 Errors on non-table input.
 
+### `table.count(tbl)`
+
+Returns `(numTableNodes, numArrayNodes, maxArrayIndex)` describing how a table
+is populated (a modern WoW diagnostic, added retail 11.2.5). These are counts
+of live entries, **not** the table's allocated capacity:
+
+- **`numTableNodes`** — total number of key/value pairs.
+- **`numArrayNodes`** — how many of those have an integer key in the range
+  `[1..numTableNodes]` (the "contiguous array part" heuristic).
+- **`maxArrayIndex`** — the largest positive integral key (`>= 1`), or `0` if
+  there is none. Negative/zero integral keys don't count.
+
+```lua
+table.count({ 10, 20, 30 })           -- 3, 3, 3
+table.count({ a = 1, b = 2 })         -- 2, 0, 0
+table.count({ [1] = "x", foo = "y" }) -- 2, 1, 1
+table.count({ [100] = "x" })          -- 1, 0, 100
+table.count({ [-3] = "x" })           -- 1, 0, 0
+```
+
+Pure iteration over the table (`lua_next`), so no dependency on Lua's internal
+storage layout. Errors on non-table input.
+
 ### `Mixin(object, ...)` / `CreateFromMixins(...)`
 
 The FrameXML table-mixin primitives, provided as engine C functions.

src/table/Count.cpp

@@ -0,0 +1,77 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#include "Game.h"
+
+#include <cmath>
+#include <vector>
+
+namespace Table::Count {
+
+// `numTableNodes, numArrayNodes, maxArrayIndex = table.count(tbl)` — a modern
+// WoW diagnostic (added retail 11.2.5) reporting how a table is populated.
+// These are COUNTS of live entries, not the table's allocated capacity:
+//
+//   numTableNodes  total number of key/value pairs.
+//   numArrayNodes  count of pairs whose key is an integer in [1..numTableNodes]
+//                  (the "looks like a contiguous array part" heuristic).
+//   maxArrayIndex  the largest positive integral key (>= 1), or 0 if none.
+//                  Verified against retail: negative/zero integral keys do
+//                  NOT count ({[-3]=x} -> 1, 0, 0).
+//
+// Pure iteration — no Lua-internal struct layout needed. Note we only ever
+// read a key via ToNumber, never ToString: lua_tostring on a NUMERIC key
+// rewrites it to a string in place and corrupts lua_next's traversal.
+static int __fastcall Script_table_count(void *L) {
+    if (Game::Lua::Type(L, 1) != Game::Lua::TYPE_TABLE) {
+        Game::Lua::Error(L, "Usage: table.count(table)");
+        return 0;
+    }
+
+    std::vector<double> integralKeys;
+    int total = 0;
+    double maxKey = 0.0; // largest positive integral key seen; 0 = none
+
+    Game::Lua::PushNil(L);
+    while (Game::Lua::Next(L, 1) != 0) {
+        ++total;
+        // key at -2, value at -1.
+        if (Game::Lua::Type(L, -2) == Game::Lua::TYPE_NUMBER) {
+            const double k = Game::Lua::ToNumber(L, -2);
+            if (k == std::floor(k)) { // integral key
+                integralKeys.push_back(k);
+                if (k >= 1.0 && k > maxKey) // only positive keys count
+                    maxKey = k;
+            }
+        }
+        Game::Lua::SetTop(L, -2); // pop value, keep key for the next Next()
+    }
+
+    int numArray = 0;
+    for (double k : integralKeys)
+        if (k >= 1.0 && k <= static_cast<double>(total))
+            ++numArray;
+
+    Game::Lua::PushNumber(L, static_cast<double>(total));
+    Game::Lua::PushNumber(L, static_cast<double>(numArray));
+    Game::Lua::PushNumber(L, maxKey);
+    return 3;
+}
+
+static void RegisterLuaFunctions() {
+    Game::Lua::RegisterTableFunction("table", "count", &Script_table_count);
+}
+
+static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace Table::Count