ComptimeStringMap: return a regular struct and optimize

this patch renames ComptimeStringMap to StaticStringMap, makes it
accept only a single type parameter, and return a known struct type
instead of an anonymous struct.  initial motivation for these changes
was to reduce the 'very long type names' issue described here
#19682.

this breaks the previous API.  users will now need to write:
`const map = std.StaticStringMap(T).initComptime(kvs_list);`

* move `kvs_list` param from type param to an `initComptime()` param
* new public methods
  * `keys()`, `values()` helpers
  * `init(allocator)`, `deinit(allocator)` for runtime data
  * `getLongestPrefix(str)`, `getLongestPrefixIndex(str)` - i'm not sure
     these belong but have left in for now incase they are deemed useful
* performance notes:
  * i posted some benchmarking results here:
    https://github.com/travisstaloch/comptime-string-map-revised/issues/1
  * i noticed a speedup reducing the size of the struct from 48 to 32
    bytes and thus use u32s instead of usize for all length fields
  * i noticed speedup storing KVs as a struct of arrays
  * latest benchmark shows these wall_time improvements for
    debug/safe/small/fast builds: -6.6% / -10.2% / -19.1% / -8.9%. full
    output in link above.

Author: travisstaloch

CMakeLists.txt

@@ -222,7 +222,7 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/std/c/linux.zig"
     "${CMAKE_SOURCE_DIR}/lib/std/child_process.zig"
     "${CMAKE_SOURCE_DIR}/lib/std/coff.zig"
-    "${CMAKE_SOURCE_DIR}/lib/std/comptime_string_map.zig"
+    "${CMAKE_SOURCE_DIR}/lib/std/static_string_map.zig"
     "${CMAKE_SOURCE_DIR}/lib/std/crypto.zig"
     "${CMAKE_SOURCE_DIR}/lib/std/crypto/blake3.zig"
     "${CMAKE_SOURCE_DIR}/lib/std/crypto/siphash.zig"

lib/compiler/aro/aro/LangOpts.zig

@@ -47,7 +47,7 @@ pub const Standard = enum {
     /// Working Draft for ISO C23 with GNU extensions
     gnu23,
 
-    const NameMap = std.ComptimeStringMap(Standard, .{
+    const NameMap = std.StaticStringMap(Standard).initComptime(.{
         .{ "c89", .c89 },                .{ "c90", .c89 },          .{ "iso9899:1990", .c89 },
         .{ "iso9899:199409", .iso9899 }, .{ "gnu89", .gnu89 },      .{ "gnu90", .gnu89 },
         .{ "c99", .c99 },                .{ "iso9899:1999", .c99 }, .{ "c9x", .c99 },

lib/compiler/aro/aro/Preprocessor.zig

@@ -1709,7 +1709,7 @@ fn expandFuncMacro(
                     }
                     if (!pp.comp.langopts.standard.atLeast(.c23)) break :res not_found;
 
-                    const attrs = std.ComptimeStringMap([]const u8, .{
+                    const attrs = std.StaticStringMap([]const u8).initComptime(.{
                         .{ "deprecated", "201904L\n" },
                         .{ "fallthrough", "201904L\n" },
                         .{ "maybe_unused", "201904L\n" },

lib/compiler/aro/aro/Tokenizer.zig

@@ -872,7 +872,7 @@ pub const Token = struct {
         };
     }
 
-    const all_kws = std.ComptimeStringMap(Id, .{
+    const all_kws = std.StaticStringMap(Id).initComptime(.{
         .{ "auto", auto: {
             @setEvalBranchQuota(3000);
             break :auto .keyword_auto;

lib/compiler/resinator/errors.zig

@@ -240,7 +240,7 @@ pub const ErrorDetails = struct {
         //       see https://github.com/ziglang/zig/issues/15395
         _: u26 = 0,
 
-        pub const strings = std.ComptimeStringMap([]const u8, .{
+        pub const strings = std.StaticStringMap([]const u8).initComptime(.{
             .{ "number", "number" },
             .{ "number_expression", "number expression" },
             .{ "string_literal", "quoted string literal" },

lib/compiler/resinator/rc.zig

@@ -47,7 +47,10 @@ pub const Resource = enum {
     fontdir_num,
     manifest_num,
 
-    const map = std.ComptimeStringMapWithEql(Resource, .{
+    const map = std.StaticStringMapWithEql(
+        Resource,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "ACCELERATORS", .accelerators },
         .{ "BITMAP", .bitmap },
         .{ "CURSOR", .cursor },
@@ -67,7 +70,7 @@ pub const Resource = enum {
         .{ "TOOLBAR", .toolbar },
         .{ "VERSIONINFO", .versioninfo },
         .{ "VXD", .vxd },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 
     pub fn fromString(bytes: SourceBytes) Resource {
         const maybe_ordinal = res.NameOrOrdinal.maybeOrdinalFromString(bytes);
@@ -157,20 +160,26 @@ pub const OptionalStatements = enum {
     menu,
     style,
 
-    pub const map = std.ComptimeStringMapWithEql(OptionalStatements, .{
+    pub const map = std.StaticStringMapWithEql(
+        OptionalStatements,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "CHARACTERISTICS", .characteristics },
         .{ "LANGUAGE", .language },
         .{ "VERSION", .version },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 
-    pub const dialog_map = std.ComptimeStringMapWithEql(OptionalStatements, .{
+    pub const dialog_map = std.StaticStringMapWithEql(
+        OptionalStatements,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "CAPTION", .caption },
         .{ "CLASS", .class },
         .{ "EXSTYLE", .exstyle },
         .{ "FONT", .font },
         .{ "MENU", .menu },
         .{ "STYLE", .style },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };
 
 pub const Control = enum {
@@ -197,7 +206,10 @@ pub const Control = enum {
     state3,
     userbutton,
 
-    pub const map = std.ComptimeStringMapWithEql(Control, .{
+    pub const map = std.StaticStringMapWithEql(
+        Control,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "AUTO3STATE", .auto3state },
         .{ "AUTOCHECKBOX", .autocheckbox },
         .{ "AUTORADIOBUTTON", .autoradiobutton },
@@ -220,7 +232,7 @@ pub const Control = enum {
         .{ "SCROLLBAR", .scrollbar },
         .{ "STATE3", .state3 },
         .{ "USERBUTTON", .userbutton },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 
     pub fn hasTextParam(control: Control) bool {
         switch (control) {
@@ -231,14 +243,17 @@ pub const Control = enum {
 };
 
 pub const ControlClass = struct {
-    pub const map = std.ComptimeStringMapWithEql(res.ControlClass, .{
+    pub const map = std.StaticStringMapWithEql(
+        res.ControlClass,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "BUTTON", .button },
         .{ "EDIT", .edit },
         .{ "STATIC", .static },
         .{ "LISTBOX", .listbox },
         .{ "SCROLLBAR", .scrollbar },
         .{ "COMBOBOX", .combobox },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 
     /// Like `map.get` but works on WTF16 strings, for use with parsed
     /// string literals ("BUTTON", or even "\x42UTTON")
@@ -280,10 +295,13 @@ pub const MenuItem = enum {
     menuitem,
     popup,
 
-    pub const map = std.ComptimeStringMapWithEql(MenuItem, .{
+    pub const map = std.StaticStringMapWithEql(
+        MenuItem,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "MENUITEM", .menuitem },
         .{ "POPUP", .popup },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 
     pub fn isSeparator(bytes: []const u8) bool {
         return std.ascii.eqlIgnoreCase(bytes, "SEPARATOR");
@@ -297,25 +315,31 @@ pub const MenuItem = enum {
         menubarbreak,
         menubreak,
 
-        pub const map = std.ComptimeStringMapWithEql(Option, .{
+        pub const map = std.StaticStringMapWithEql(
+            Option,
+            std.static_string_map.eqlAsciiIgnoreCase,
+        ).initComptime(.{
             .{ "CHECKED", .checked },
             .{ "GRAYED", .grayed },
             .{ "HELP", .help },
             .{ "INACTIVE", .inactive },
             .{ "MENUBARBREAK", .menubarbreak },
             .{ "MENUBREAK", .menubreak },
-        }, std.comptime_string_map.eqlAsciiIgnoreCase);
+        });
     };
 };
 
 pub const ToolbarButton = enum {
     button,
     separator,
 
-    pub const map = std.ComptimeStringMapWithEql(ToolbarButton, .{
+    pub const map = std.StaticStringMapWithEql(
+        ToolbarButton,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "BUTTON", .button },
         .{ "SEPARATOR", .separator },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };
 
 pub const VersionInfo = enum {
@@ -327,25 +351,31 @@ pub const VersionInfo = enum {
     file_type,
     file_subtype,
 
-    pub const map = std.ComptimeStringMapWithEql(VersionInfo, .{
+    pub const map = std.StaticStringMapWithEql(
+        VersionInfo,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "FILEVERSION", .file_version },
         .{ "PRODUCTVERSION", .product_version },
         .{ "FILEFLAGSMASK", .file_flags_mask },
         .{ "FILEFLAGS", .file_flags },
         .{ "FILEOS", .file_os },
         .{ "FILETYPE", .file_type },
         .{ "FILESUBTYPE", .file_subtype },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };
 
 pub const VersionBlock = enum {
     block,
     value,
 
-    pub const map = std.ComptimeStringMapWithEql(VersionBlock, .{
+    pub const map = std.StaticStringMapWithEql(
+        VersionBlock,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "BLOCK", .block },
         .{ "VALUE", .value },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };
 
 /// Keywords that are be the first token in a statement and (if so) dictate how the rest
@@ -356,12 +386,15 @@ pub const TopLevelKeywords = enum {
     characteristics,
     stringtable,
 
-    pub const map = std.ComptimeStringMapWithEql(TopLevelKeywords, .{
+    pub const map = std.StaticStringMapWithEql(
+        TopLevelKeywords,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "LANGUAGE", .language },
         .{ "VERSION", .version },
         .{ "CHARACTERISTICS", .characteristics },
         .{ "STRINGTABLE", .stringtable },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };
 
 pub const CommonResourceAttributes = enum {
@@ -375,7 +408,10 @@ pub const CommonResourceAttributes = enum {
     shared,
     nonshared,
 
-    pub const map = std.ComptimeStringMapWithEql(CommonResourceAttributes, .{
+    pub const map = std.StaticStringMapWithEql(
+        CommonResourceAttributes,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "PRELOAD", .preload },
         .{ "LOADONCALL", .loadoncall },
         .{ "FIXED", .fixed },
@@ -385,7 +421,7 @@ pub const CommonResourceAttributes = enum {
         .{ "IMPURE", .impure },
         .{ "SHARED", .shared },
         .{ "NONSHARED", .nonshared },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };
 
 pub const AcceleratorTypeAndOptions = enum {
@@ -396,12 +432,15 @@ pub const AcceleratorTypeAndOptions = enum {
     shift,
     control,
 
-    pub const map = std.ComptimeStringMapWithEql(AcceleratorTypeAndOptions, .{
+    pub const map = std.StaticStringMapWithEql(
+        AcceleratorTypeAndOptions,
+        std.static_string_map.eqlAsciiIgnoreCase,
+    ).initComptime(.{
         .{ "VIRTKEY", .virtkey },
         .{ "ASCII", .ascii },
         .{ "NOINVERT", .noinvert },
         .{ "ALT", .alt },
         .{ "SHIFT", .shift },
         .{ "CONTROL", .control },
-    }, std.comptime_string_map.eqlAsciiIgnoreCase);
+    });
 };