refactor(lua): take integer enum and constants entries as arrays

RegisterIntegerEnum and RegisterConstants took their entries with a
count beside them, written as sizeof(t) / sizeof(t[0]), std::size, or
a literal. They now take Game::ArrayRef<EnumIntegerEntry>, as
RegisterFrameMethods does, so the count comes from the array's type.
The documentation recorders RecordEnum and RecordConstants take the
same view.

All 34 call sites pass only the array. The six literal counts were
checked against their arrays first: each was the full length, so every
Enum.* and Constants.* table gets the same entries as before. Five
files that included <iterator> only for std::size drop it.

src/Game.cpp

@@ -437,17 +437,16 @@ static bool SetIntegerTable(const char *parent, const char *sub,
     return true;
 }
 
-void RegisterIntegerEnum(const char *parent, const char *sub,
-                         const EnumIntegerEntry *entries, int count,
+void RegisterIntegerEnum(const char *parent, const char *sub, ArrayRef<EnumIntegerEntry> entries,
                          const char *docSystem) {
-    if (SetIntegerTable(parent, sub, entries, count))
-        Api::Documentation::RecordEnum(parent, sub, entries, count, docSystem);
+    if (SetIntegerTable(parent, sub, entries.data, entries.count))
+        Api::Documentation::RecordEnum(parent, sub, entries, docSystem);
 }
 
-void RegisterConstants(const char *sub, const EnumIntegerEntry *entries, int count,
+void RegisterConstants(const char *sub, ArrayRef<EnumIntegerEntry> entries,
                        const char *docSystem) {
-    if (SetIntegerTable("Constants", sub, entries, count))
-        Api::Documentation::RecordConstants(sub, entries, count, docSystem);
+    if (SetIntegerTable("Constants", sub, entries.data, entries.count))
+        Api::Documentation::RecordConstants(sub, entries, docSystem);
 }
 
 void SetFieldNumber(void *L, const char *key, double value) {

src/Game.h

@@ -568,14 +568,14 @@ struct EnumIntegerEntry {
 // `Enum.AddOnSecurityStatus = { Secure=0, Insecure=1, ... }` shapes.
 // `docSystem` is the documentation System the enumeration belongs to
 // ("SpellBook", "Item", …); the entries themselves are the documentation.
-void RegisterIntegerEnum(const char *parent, const char *sub,
-                         const EnumIntegerEntry *entries, int count,
+// `entries` is a file-scope array.
+void RegisterIntegerEnum(const char *parent, const char *sub, ArrayRef<EnumIntegerEntry> entries,
                          const char *docSystem = nullptr);
 
 // Registers `Constants[sub] = { entries }`, Blizzard's engine constant
 // tables (`Constants.MoneyFormattingConstants`). Documented as a "Constants"
 // table of `docSystem`.
-void RegisterConstants(const char *sub, const EnumIntegerEntry *entries, int count,
+void RegisterConstants(const char *sub, ArrayRef<EnumIntegerEntry> entries,
                        const char *docSystem);
 
 // Set `t[key] = value` on the table currently at stack[-1] (the most

src/action/Find.cpp

@@ -170,9 +170,7 @@ static void RegisterLuaFunctions() {
                                      &Script_HasSpellActionButtons, &kHasSpellActionButtons);
     Game::Lua::RegisterTableFunction("C_ActionBar", "IsOnBarOrSpecialBar",
                                      &Script_IsOnBarOrSpecialBar, &kIsOnBarOrSpecialBar);
-    Game::Lua::RegisterIntegerEnum("Enum", "ActionBarSet", kActionBarSet,
-                                   static_cast<int>(sizeof(kActionBarSet) / sizeof(kActionBarSet[0])),
-                                   "ActionBar");
+    Game::Lua::RegisterIntegerEnum("Enum", "ActionBarSet", kActionBarSet, "ActionBar");
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/addons/Info.cpp

@@ -408,11 +408,7 @@ static void RegisterLuaFunctions() {
     Game::Lua::RegisterTableFunction("C_AddOns", "GetAddOnInterfaceVersion",
                                      &Script_GetAddOnInterfaceVersion,
                                      &kGetAddOnInterfaceVersion);
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "AddOnSecurityStatus",
-        kAddOnSecurityStatusEntries,
-        sizeof(kAddOnSecurityStatusEntries) /
-            sizeof(kAddOnSecurityStatusEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "AddOnSecurityStatus", kAddOnSecurityStatusEntries);
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/api/Documentation.cpp

@@ -725,14 +725,14 @@ void RecordValueTable(Kind kind, const char *parent, const char *sub,
 
 } // namespace
 
-void RecordEnum(const char *parent, const char *sub, const Game::Lua::EnumIntegerEntry *entries,
-                int count, const char *system) {
-    RecordValueTable(KIND_ENUM, parent, sub, entries, count, system);
+void RecordEnum(const char *parent, const char *sub,
+                Game::ArrayRef<Game::Lua::EnumIntegerEntry> entries, const char *system) {
+    RecordValueTable(KIND_ENUM, parent, sub, entries.data, entries.count, system);
 }
 
-void RecordConstants(const char *sub, const Game::Lua::EnumIntegerEntry *entries, int count,
+void RecordConstants(const char *sub, Game::ArrayRef<Game::Lua::EnumIntegerEntry> entries,
                      const char *system) {
-    RecordValueTable(KIND_CONSTANTS, "Constants", sub, entries, count, system);
+    RecordValueTable(KIND_CONSTANTS, "Constants", sub, entries.data, entries.count, system);
 }
 
 } // namespace Api::Documentation

src/api/Documentation.h

@@ -38,9 +38,9 @@ void RecordFrameMethods(const void *registry,
 // Names the widget system of a method hash this DLL owns (a frame class it
 // adds), alongside the engine registries the exporter already knows.
 void NameWidgetSystem(const void *registry, const char *system);
-void RecordEnum(const char *parent, const char *sub, const Game::Lua::EnumIntegerEntry *entries,
-                int count, const char *system);
-void RecordConstants(const char *sub, const Game::Lua::EnumIntegerEntry *entries, int count,
+void RecordEnum(const char *parent, const char *sub,
+                Game::ArrayRef<Game::Lua::EnumIntegerEntry> entries, const char *system);
+void RecordConstants(const char *sub, Game::ArrayRef<Game::Lua::EnumIntegerEntry> entries,
                      const char *system);
 
 } // namespace Api::Documentation

src/autocomplete/Names.cpp

@@ -457,12 +457,10 @@ static void RegisterLuaFunctions() {
                                      &Script_GetAutoCompleteResults, &kGetAutoCompleteResults);
     Game::Lua::RegisterTableFunction("C_AutoComplete", "IsRecognizedName", &Script_IsRecognizedName,
                                      &kIsRecognizedName);
-    Game::Lua::RegisterIntegerEnum("Enum", "AutoCompleteEntryFlag", kEntryFlagEntries,
-                                   sizeof(kEntryFlagEntries) / sizeof(kEntryFlagEntries[0]),
-                                   "AutoComplete");
-    Game::Lua::RegisterIntegerEnum("Enum", "AutoCompletePriority", kPriorityEntries,
-                                   sizeof(kPriorityEntries) / sizeof(kPriorityEntries[0]),
-                                   "AutoComplete");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "AutoCompleteEntryFlag", kEntryFlagEntries, "AutoComplete");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "AutoCompletePriority", kPriorityEntries, "AutoComplete");
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/combat/Swing.cpp

@@ -497,9 +497,7 @@ const Game::Lua::EnumIntegerEntry kSwingTypeEntries[] = {
 };
 
 void RegisterLuaFunctions() {
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "PlayerSwingType", kSwingTypeEntries,
-        sizeof(kSwingTypeEntries) / sizeof(kSwingTypeEntries[0]), "SwingTimer");
+    Game::Lua::RegisterIntegerEnum("Enum", "PlayerSwingType", kSwingTypeEntries, "SwingTimer");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/console/Commands.cpp

@@ -145,12 +145,8 @@ void RegisterLuaFunctions() {
     Game::Lua::RegisterGlobalFunction("ConsoleGetAllCommands", &Script_GetAllCommands);
     Game::Lua::RegisterGlobalFunction("ConsolePrintAllMatchingCommands",
                                       &Script_ConsolePrintAllMatchingCommands);
-    Game::Lua::RegisterIntegerEnum("Enum", "ConsoleCommandType", kCommandTypeEntries,
-                                   sizeof(kCommandTypeEntries) /
-                                       sizeof(kCommandTypeEntries[0]));
-    Game::Lua::RegisterIntegerEnum("Enum", "ConsoleCategory", kCategoryEntries,
-                                   sizeof(kCategoryEntries) /
-                                       sizeof(kCategoryEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "ConsoleCommandType", kCommandTypeEntries);
+    Game::Lua::RegisterIntegerEnum("Enum", "ConsoleCategory", kCategoryEntries);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/container/BagIndex.cpp

@@ -42,8 +42,7 @@ const Game::Lua::EnumIntegerEntry kEntries[] = {
 };
 
 void RegisterLuaFunctions() {
-    Game::Lua::RegisterIntegerEnum("Enum", "BagIndex", kEntries,
-                                   sizeof(kEntries) / sizeof(kEntries[0]), "BagIndexConstants");
+    Game::Lua::RegisterIntegerEnum("Enum", "BagIndex", kEntries, "BagIndexConstants");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/currency/MoneyConstants.cpp

@@ -27,10 +27,8 @@ const Game::Lua::EnumIntegerEntry kMoneyFormattingConstants[] = {
 };
 
 void RegisterLuaFunctions() {
-    Game::Lua::RegisterConstants("MoneyFormattingConstants", kMoneyFormattingConstants,
-                                 sizeof(kMoneyFormattingConstants) /
-                                     sizeof(kMoneyFormattingConstants[0]),
-                                 "MoneyConstants");
+    Game::Lua::RegisterConstants(
+        "MoneyFormattingConstants", kMoneyFormattingConstants, "MoneyConstants");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/cursor/Changed.cpp

@@ -119,9 +119,7 @@ void OnTick() {
 const Tick::WorldTick::AutoSubscribe _tick{&OnTick};
 
 void RegisterLuaFunctions() {
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "UICursorType", kCursorTypeEntries,
-        sizeof(kCursorTypeEntries) / sizeof(kCursorTypeEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "UICursorType", kCursorTypeEntries);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/death/SelfResurrect.cpp

@@ -206,9 +206,8 @@ void RegisterLuaFunctions() {
                                      &Script_GetSelfResurrectOptions, &kGetSelfResurrectOptions);
     Game::Lua::RegisterTableFunction("C_DeathInfo", "UseSelfResurrectOption",
                                      &Script_UseSelfResurrectOption, &kUseSelfResurrectOption);
-    Game::Lua::RegisterIntegerEnum("Enum", "SelfResurrectOptionType", kOptionTypeEntries,
-                                   sizeof(kOptionTypeEntries) / sizeof(kOptionTypeEntries[0]),
-                                   "DeathInfo");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "SelfResurrectOptionType", kOptionTypeEntries, "DeathInfo");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/duration/Object.cpp

@@ -47,7 +47,6 @@
 
 #include <cmath>
 #include <cstdio>
-#include <iterator>
 
 namespace Duration::Object {
 
@@ -451,8 +450,7 @@ const Game::Doc::Function kCreateDuration{"Creates a zero duration object that c
 void RegisterLuaFunctions() {
     CreateMetatable(Lua::State());
     Lua::RegisterTableFunction("C_DurationUtil", "CreateDuration", &Script_CreateDuration, &kCreateDuration);
-    Lua::RegisterIntegerEnum("Enum", "DurationTimeModifier", kModifiers, static_cast<int>(std::size(kModifiers)),
-                             "LuaDurationObjectShared");
+    Lua::RegisterIntegerEnum("Enum", "DurationTimeModifier", kModifiers, "LuaDurationObjectShared");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/duration/TextBinding.cpp

@@ -58,7 +58,6 @@
 #include <cmath>
 #include <cstdio>
 #include <cstring>
-#include <iterator>
 #include <string>
 #include <vector>
 
@@ -780,8 +779,8 @@ void RegisterLuaFunctions() {
     CreateMetatable(Lua::State());
     Lua::RegisterTableFunction("C_DurationUtil", "CreateDurationTextBinding", &Script_CreateDurationTextBinding,
                                &kCreateDurationTextBinding);
-    Lua::RegisterIntegerEnum("Enum", "DurationTextBindingProperty", kProperties,
-                             static_cast<int>(std::size(kProperties)), "DurationTextBindingShared");
+    Lua::RegisterIntegerEnum(
+        "Enum", "DurationTextBindingProperty", kProperties, "DurationTextBindingShared");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/editbox/InputContext.cpp

@@ -30,8 +30,7 @@ const Game::Lua::EnumIntegerEntry kEntries[] = {
 };
 
 void RegisterLuaFunctions() {
-    Game::Lua::RegisterIntegerEnum("Enum", "InputContext", kEntries,
-                                   sizeof(kEntries) / sizeof(kEntries[0]), "InputConstants");
+    Game::Lua::RegisterIntegerEnum("Enum", "InputContext", kEntries, "InputConstants");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/encoding/Base64.cpp

@@ -217,8 +217,7 @@ void Register() {
         {"Standard", static_cast<int>(Variant::Standard)},
         {"UrlSafe",  static_cast<int>(Variant::UrlSafe)},
     };
-    Game::Lua::RegisterIntegerEnum("Enum", "Base64Variant",
-                                   kBase64Variant, 2);
+    Game::Lua::RegisterIntegerEnum("Enum", "Base64Variant", kBase64Variant);
 }
 
 } // namespace

src/encoding/Compress.cpp

@@ -305,8 +305,7 @@ void Register() {
         {"Zlib",    static_cast<int>(Method::Zlib)},
         {"Gzip",    static_cast<int>(Method::Gzip)},
     };
-    Game::Lua::RegisterIntegerEnum("Enum", "CompressionMethod",
-                                   kCompressionMethod, 3);
+    Game::Lua::RegisterIntegerEnum("Enum", "CompressionMethod", kCompressionMethod);
 }
 
 } // namespace

src/item/TypeInfo.cpp

@@ -309,15 +309,9 @@ void RegisterLuaFunctions() {
                                      &Script_GetItemInventorySlotKey);
     Game::Lua::RegisterTableFunction("C_Item", "GetItemInventorySlotInfo",
                                      &Script_GetItemInventorySlotInfo);
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "InventoryType", kInventoryTypeEntries,
-        sizeof(kInventoryTypeEntries) / sizeof(kInventoryTypeEntries[0]));
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "ItemClass", kItemClassEntries,
-        sizeof(kItemClassEntries) / sizeof(kItemClassEntries[0]));
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "ItemQuality", kItemQualityEntries,
-        sizeof(kItemQualityEntries) / sizeof(kItemQualityEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "InventoryType", kInventoryTypeEntries);
+    Game::Lua::RegisterIntegerEnum("Enum", "ItemClass", kItemClassEntries);
+    Game::Lua::RegisterIntegerEnum("Enum", "ItemQuality", kItemQualityEntries);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/model/DressUp.cpp

@@ -641,9 +641,7 @@ void RegisterLuaFunctions() {
     Game::Lua::RegisterFrameMethods(
         reinterpret_cast<void *>(Offsets::VAR_DRESSUPMODEL_METHOD_REGISTRY), g_methods,
         g_methodDocs);
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "ItemTryOnReason", kItemTryOnReason,
-        static_cast<int>(sizeof(kItemTryOnReason) / sizeof(kItemTryOnReason[0])), "UIModelInfo");
+    Game::Lua::RegisterIntegerEnum("Enum", "ItemTryOnReason", kItemTryOnReason, "UIModelInfo");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/quest/Info.cpp

@@ -15,7 +15,6 @@
 #include "Offsets.h"
 
 #include <cstdint>
-#include <iterator>
 
 // `C_QuestLog.GetInfo(questLogIndex)` and `C_QuestLog.GetQuestLogTitle(
 // questLogIndex)` — the modern table and 17-tuple shapes of one quest-log row.
@@ -235,12 +234,9 @@ static void RegisterLuaFunctions() {
     Game::Lua::RegisterTableFunction("C_QuestLog", "GetInfo", &Script_GetInfo, &kGetInfo);
     Game::Lua::RegisterTableFunction("C_QuestLog", "GetQuestLogTitle",
                                      &Script_GetQuestLogTitle, &kGetQuestLogTitle);
-    Game::Lua::RegisterIntegerEnum("Enum", "QuestFrequency", kQuestFrequencyEntries,
-                                   static_cast<int>(std::size(kQuestFrequencyEntries)),
-                                   "QuestLog");
-    Game::Lua::RegisterIntegerEnum("Enum", "QuestClassification", kQuestClassificationEntries,
-                                   static_cast<int>(std::size(kQuestClassificationEntries)),
-                                   "QuestLog");
+    Game::Lua::RegisterIntegerEnum("Enum", "QuestFrequency", kQuestFrequencyEntries, "QuestLog");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "QuestClassification", kQuestClassificationEntries, "QuestLog");
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/sound/ItemSound.cpp

@@ -116,9 +116,7 @@ int __fastcall Script_PlayItemSound(void *L) {
 
 void RegisterLuaFunctions() {
     Game::Lua::RegisterTableFunction("C_Sound", "PlayItemSound", &Script_PlayItemSound);
-    Game::Lua::RegisterIntegerEnum("Enum", "ItemSoundType", kItemSoundTypeEntries,
-                                   sizeof(kItemSoundTypeEntries) /
-                                       sizeof(kItemSoundTypeEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "ItemSoundType", kItemSoundTypeEntries);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/sound/VocalError.cpp

@@ -174,9 +174,7 @@ int __fastcall Script_PlayVocalErrorSound(void *L) {
 void RegisterLuaFunctions() {
     Game::Lua::RegisterTableFunction("C_Sound", "PlayVocalErrorSound",
                                      &Script_PlayVocalErrorSound);
-    Game::Lua::RegisterIntegerEnum("Enum", "Vocalerrorsounds", kVocalErrorEntries,
-                                   sizeof(kVocalErrorEntries) /
-                                       sizeof(kVocalErrorEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "Vocalerrorsounds", kVocalErrorEntries);
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/spell/ActivationOverlay.cpp

@@ -387,9 +387,7 @@ static void RegisterLuaFunctions() {
     Game::Lua::RegisterTableFunction("C_SpellActivationOverlay", "IsSpellOverlayed",
                                      &Script_IsSpellOverlayed, &kIsSpellOverlayed);
     Game::Lua::RegisterIntegerEnum(
-        "Enum", "ScreenLocationType", kScreenLocationEntries,
-        sizeof(kScreenLocationEntries) / sizeof(kScreenLocationEntries[0]),
-        "ScreenLocationConstants");
+        "Enum", "ScreenLocationType", kScreenLocationEntries, "ScreenLocationConstants");
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/spell/Info.cpp

@@ -1036,10 +1036,10 @@ static void RegisterLuaFunctions() {
     Game::Lua::RegisterTableFunction("C_SpellBook", "ContainsAnyDisenchantSpell",
                                       &Script_ContainsAnyDisenchantSpell,
                                       &kContainsAnyDisenchantSpell);
-    Game::Lua::RegisterIntegerEnum("Enum", "SpellBookSpellBank",
-                                   kSpellBookSpellBankEntries, 2, "SpellBook");
-    Game::Lua::RegisterIntegerEnum("Enum", "SpellBookItemType",
-                                   kSpellBookItemTypeEntries, 5, "SpellBook");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "SpellBookSpellBank", kSpellBookSpellBankEntries, "SpellBook");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "SpellBookItemType", kSpellBookItemTypeEntries, "SpellBook");
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/statusbar/Display.cpp

@@ -82,7 +82,6 @@
 
 #include <cmath>
 #include <cstdint>
-#include <iterator>
 #include <unordered_map>
 
 namespace StatusBar::Display {
@@ -360,10 +359,10 @@ const Game::Doc::Method g_methodDocs[] = {
 void RegisterLuaFunctions() {
     Lua::RegisterFrameMethods(reinterpret_cast<void *>(Offsets::VAR_STATUSBAR_METHOD_REGISTRY), g_methods,
                               g_methodDocs);
-    Lua::RegisterIntegerEnum("Enum", "StatusBarTimerDirection", kDirectionEntries,
-                             static_cast<int>(std::size(kDirectionEntries)), "SimpleStatusBarConstants");
-    Lua::RegisterIntegerEnum("Enum", "StatusBarInterpolation", kInterpolationEntries,
-                             static_cast<int>(std::size(kInterpolationEntries)), "SimpleStatusBarConstants");
+    Lua::RegisterIntegerEnum(
+        "Enum", "StatusBarTimerDirection", kDirectionEntries, "SimpleStatusBarConstants");
+    Lua::RegisterIntegerEnum(
+        "Enum", "StatusBarInterpolation", kInterpolationEntries, "SimpleStatusBarConstants");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/statusbar/Fill.cpp

@@ -383,9 +383,8 @@ const Game::Doc::Method g_methodDocs[] = {
 void RegisterLuaFunctions() {
     Game::Lua::RegisterFrameMethods(
         reinterpret_cast<void *>(Offsets::VAR_STATUSBAR_METHOD_REGISTRY), g_methods, g_methodDocs);
-    Game::Lua::RegisterIntegerEnum("Enum", "StatusBarFillStyle", kFillStyleEntries,
-                                   static_cast<int>(sizeof(kFillStyleEntries) / sizeof(kFillStyleEntries[0])),
-                                   "SimpleStatusBarConstants");
+    Game::Lua::RegisterIntegerEnum(
+        "Enum", "StatusBarFillStyle", kFillStyleEntries, "SimpleStatusBarConstants");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/taxi/Map.cpp

@@ -434,14 +434,14 @@ void RegisterLuaFunctions() {
         {"Horde", FACTION_HORDE},
         {"Alliance", FACTION_ALLIANCE},
     };
-    Game::Lua::RegisterIntegerEnum("Enum", "FlightPathFaction", kFaction, 3);
+    Game::Lua::RegisterIntegerEnum("Enum", "FlightPathFaction", kFaction);
 
     static const Game::Lua::EnumIntegerEntry kState[] = {
         {"Current", STATE_CURRENT},
         {"Reachable", STATE_REACHABLE},
         {"Unreachable", STATE_UNREACHABLE},
     };
-    Game::Lua::RegisterIntegerEnum("Enum", "FlightPathState", kState, 3);
+    Game::Lua::RegisterIntegerEnum("Enum", "FlightPathState", kState);
 
     Game::Lua::RegisterTableFunction("C_TaxiMap", "GetTaxiNodesForMap",
                                      &Script_GetTaxiNodesForMap);

src/text/NumericFormatter.cpp

@@ -52,7 +52,6 @@
 #include <algorithm>
 #include <cmath>
 #include <cstdio>
-#include <iterator>
 #include <string>
 #include <vector>
 
@@ -521,8 +520,7 @@ void RegisterLuaFunctions() {
     CreateMetatable(Lua::State());
     Lua::RegisterTableFunction("C_StringUtil", "CreateNumericRuleFormatter",
                                &Script_CreateNumericRuleFormatter, &kCreateNumericRuleFormatter);
-    Lua::RegisterIntegerEnum("Enum", "NumericRuleFormatRounding", kRounding,
-                             static_cast<int>(std::size(kRounding)), "StringUtil");
+    Lua::RegisterIntegerEnum("Enum", "NumericRuleFormatRounding", kRounding, "StringUtil");
 }
 
 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

src/unit/Power.cpp

@@ -286,10 +286,7 @@ static void RegisterLuaFunctions() {
     Game::Lua::RegisterGlobalFunction("UnitPowerMax", &Script_UnitPowerMax);
     Game::Lua::RegisterGlobalFunction("UnitPowerMissing", &Script_UnitPowerMissing);
     Game::Lua::RegisterGlobalFunction("UnitPowerType", &Script_UnitPowerType);
-    Game::Lua::RegisterIntegerEnum(
-        "Enum", "PowerType",
-        kPowerTypeEntries,
-        sizeof(kPowerTypeEntries) / sizeof(kPowerTypeEntries[0]));
+    Game::Lua::RegisterIntegerEnum("Enum", "PowerType", kPowerTypeEntries);
 }
 
 static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};