screw up interface :D

(in a good way)

Author: RetroDev256

CMakeLists.txt

@@ -407,7 +407,7 @@ set(ZIG_STAGE2_SOURCES
     lib/std/c.zig
     lib/std/coff.zig
     lib/std/crypto.zig
-    lib/std/comptime_string_map.zig
+    lib/std/static_string_map.zig
     lib/std/crypto/blake3.zig
     lib/std/crypto/siphash.zig
     lib/std/debug.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 name_map = 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 },
@@ -141,7 +141,7 @@ preserve_comments_in_macros: bool = false,
 gnuc_version: u32 = 0,
 
 pub fn setStandard(self: *LangOpts, name: []const u8) error{InvalidStandard}!void {
-    self.standard = Standard.NameMap.get(name) orelse return error.InvalidStandard;
+    self.standard = Standard.name_map.get(name) orelse return error.InvalidStandard;
 }
 
 pub fn enableMSExtensions(self: *LangOpts) void {

lib/compiler/aro/aro/Preprocessor.zig

@@ -1745,7 +1745,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" },
@@ -1757,7 +1757,7 @@ fn expandFuncMacro(
                     });
 
                     const attr_str = Attribute.normalize(pp.expandedSlice(attr_ident.?));
-                    break :res Attrs.get(attr_str) orelse not_found;
+                    break :res attrs.get(attr_str) orelse not_found;
                 };
                 const start = pp.comp.generated_buf.items.len;
                 try pp.comp.generated_buf.appendSlice(pp.gpa, result);

lib/compiler/aro/aro/Tokenizer.zig

@@ -837,7 +837,7 @@ pub const Token = struct {
     /// belong to the implementation namespace, so we always convert them
     /// to keywords.
     pub fn getTokenId(langopts: LangOpts, str: []const u8) Token.Id {
-        const kw = AllKws.get(str) orelse return .identifier;
+        const kw = all_kws.get(str) orelse return .identifier;
         const standard = langopts.standard;
         return switch (kw) {
             .keyword_inline => if (standard.isGNU() or standard.atLeast(.c99)) kw else .identifier,
@@ -876,7 +876,7 @@ pub const Token = struct {
         };
     }
 
-    const AllKws = std.ComptimeStringMap(Id, .{
+    const all_kws = std.StaticStringMap(Id).initComptime(.{
         .{ "auto", .keyword_auto },
         .{ "break", .keyword_break },
         .{ "case", .keyword_case },

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" },
@@ -262,7 +262,7 @@ pub const ErrorDetails = struct {
                 if (field_info.type != bool) continue;
                 if (i == num_set_bits) return;
                 if (@field(self, field_info.name)) {
-                    try writer.writeAll(Strings.get(field_info.name).?);
+                    try writer.writeAll(strings.get(field_info.name).?);
                     i += 1;
                     if (num_set_bits > 2 and i != num_set_bits) {
                         try writer.writeAll(", ");

lib/compiler/resinator/rc.zig

@@ -47,7 +47,7 @@ pub const Resource = enum {
     fontdir_num,
     manifest_num,
 
-    const Map = std.ComptimeStringMapIgnoreCase(Resource, .{
+    const map = std.StaticStringMapIgnoreCase(Resource).initComptime(.{
         .{ "ACCELERATORS", .accelerators },
         .{ "BITMAP", .bitmap },
         .{ "CURSOR", .cursor },
@@ -75,7 +75,7 @@ pub const Resource = enum {
             if (ordinal.ordinal >= 256) return .user_defined;
             return fromRT(@enumFromInt(ordinal.ordinal));
         }
-        return Map.get(bytes.slice) orelse .user_defined;
+        return map.get(bytes.slice) orelse .user_defined;
     }
 
     // TODO: Some comptime validation that RT <-> Resource conversion is synced?
@@ -157,13 +157,13 @@ pub const OptionalStatements = enum {
     menu,
     style,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(OptionalStatements, .{
+    pub const map = std.StaticStringMapIgnoreCase(OptionalStatements).initComptime(.{
         .{ "CHARACTERISTICS", .characteristics },
         .{ "LANGUAGE", .language },
         .{ "VERSION", .version },
     });
 
-    pub const DialogMap = std.ComptimeStringMapIgnoreCase(OptionalStatements, .{
+    pub const dialog_map = std.StaticStringMapIgnoreCase(OptionalStatements).initComptime(.{
         .{ "CAPTION", .caption },
         .{ "CLASS", .class },
         .{ "EXSTYLE", .exstyle },
@@ -197,7 +197,7 @@ pub const Control = enum {
     state3,
     userbutton,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(Control, .{
+    pub const map = std.StaticStringMapIgnoreCase(Control).initComptime(.{
         .{ "AUTO3STATE", .auto3state },
         .{ "AUTOCHECKBOX", .autocheckbox },
         .{ "AUTORADIOBUTTON", .autoradiobutton },
@@ -231,7 +231,7 @@ pub const Control = enum {
 };
 
 pub const ControlClass = struct {
-    pub const Map = std.ComptimeStringMapIgnoreCase(res.ControlClass, .{
+    pub const map = std.StaticStringMapIgnoreCase(res.ControlClass).initComptime(.{
         .{ "BUTTON", .button },
         .{ "EDIT", .edit },
         .{ "STATIC", .static },
@@ -280,7 +280,7 @@ pub const MenuItem = enum {
     menuitem,
     popup,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(MenuItem, .{
+    pub const map = std.StaticStringMapIgnoreCase(MenuItem).initComptime(.{
         .{ "MENUITEM", .menuitem },
         .{ "POPUP", .popup },
     });
@@ -297,7 +297,7 @@ pub const MenuItem = enum {
         menubarbreak,
         menubreak,
 
-        pub const Map = std.ComptimeStringMapIgnoreCase(Option, .{
+        pub const map = std.StaticStringMapIgnoreCase(Option).initComptime(.{
             .{ "CHECKED", .checked },
             .{ "GRAYED", .grayed },
             .{ "HELP", .help },
@@ -312,7 +312,7 @@ pub const ToolbarButton = enum {
     button,
     separator,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(ToolbarButton, .{
+    pub const map = std.StaticStringMapIgnoreCase(ToolbarButton).initComptime(.{
         .{ "BUTTON", .button },
         .{ "SEPARATOR", .separator },
     });
@@ -327,7 +327,7 @@ pub const VersionInfo = enum {
     file_type,
     file_subtype,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(VersionInfo, .{
+    pub const map = std.StaticStringMapIgnoreCase(VersionInfo).initComptime(.{
         .{ "FILEVERSION", .file_version },
         .{ "PRODUCTVERSION", .product_version },
         .{ "FILEFLAGSMASK", .file_flags_mask },
@@ -342,7 +342,7 @@ pub const VersionBlock = enum {
     block,
     value,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(VersionBlock, .{
+    pub const map = std.StaticStringMapIgnoreCase(VersionBlock).initComptime(.{
         .{ "BLOCK", .block },
         .{ "VALUE", .value },
     });
@@ -356,7 +356,7 @@ pub const TopLevelKeywords = enum {
     characteristics,
     stringtable,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(TopLevelKeywords, .{
+    pub const map = std.StaticStringMapIgnoreCase(TopLevelKeywords).initComptime(.{
         .{ "LANGUAGE", .language },
         .{ "VERSION", .version },
         .{ "CHARACTERISTICS", .characteristics },
@@ -375,7 +375,7 @@ pub const CommonResourceAttributes = enum {
     shared,
     nonshared,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(CommonResourceAttributes, .{
+    pub const map = std.StaticStringMapIgnoreCase(CommonResourceAttributes).initComptime(.{
         .{ "PRELOAD", .preload },
         .{ "LOADONCALL", .loadoncall },
         .{ "FIXED", .fixed },
@@ -396,7 +396,7 @@ pub const AcceleratorTypeAndOptions = enum {
     shift,
     control,
 
-    pub const Map = std.ComptimeStringMapIgnoreCase(AcceleratorTypeAndOptions, .{
+    pub const map = std.StaticStringMapIgnoreCase(AcceleratorTypeAndOptions).initComptime(.{
         .{ "VIRTKEY", .virtkey },
         .{ "ASCII", .ascii },
         .{ "NOINVERT", .noinvert },

lib/std/crypto/Certificate.zig

@@ -19,7 +19,7 @@ pub const Algorithm = enum {
     md5WithRSAEncryption,
     curveEd25519,
 
-    pub const Map = std.ComptimeStringMap(Algorithm, .{
+    pub const map = std.StaticStringMap(Algorithm).initComptime(.{
         .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05 }, .sha1WithRSAEncryption },
         .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0B }, .sha256WithRSAEncryption },
         .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0C }, .sha384WithRSAEncryption },
@@ -52,7 +52,7 @@ pub const AlgorithmCategory = enum {
     X9_62_id_ecPublicKey,
     curveEd25519,
 
-    pub const Map = std.ComptimeStringMap(AlgorithmCategory, .{
+    pub const map = std.StaticStringMap(AlgorithmCategory).initComptime(.{
         .{ &[_]u8{ 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01 }, .rsaEncryption },
         .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01 }, .X9_62_id_ecPublicKey },
         .{ &[_]u8{ 0x2B, 0x65, 0x70 }, .curveEd25519 },
@@ -73,7 +73,7 @@ pub const Attribute = enum {
     pkcs9_emailAddress,
     domainComponent,
 
-    pub const Map = std.ComptimeStringMap(Attribute, .{
+    pub const map = std.StaticStringMap(Attribute).initComptime(.{
         .{ &[_]u8{ 0x55, 0x04, 0x03 }, .commonName },
         .{ &[_]u8{ 0x55, 0x04, 0x05 }, .serialNumber },
         .{ &[_]u8{ 0x55, 0x04, 0x06 }, .countryName },
@@ -94,7 +94,7 @@ pub const NamedCurve = enum {
     secp521r1,
     X9_62_prime256v1,
 
-    pub const Map = std.ComptimeStringMap(NamedCurve, .{
+    pub const map = std.StaticStringMap(NamedCurve).initComptime(.{
         .{ &[_]u8{ 0x2B, 0x81, 0x04, 0x00, 0x22 }, .secp384r1 },
         .{ &[_]u8{ 0x2B, 0x81, 0x04, 0x00, 0x23 }, .secp521r1 },
         .{ &[_]u8{ 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 }, .X9_62_prime256v1 },
@@ -130,7 +130,7 @@ pub const ExtensionId = enum {
     netscape_cert_type,
     netscape_comment,
 
-    pub const Map = std.ComptimeStringMap(ExtensionId, .{
+    pub const map = std.StaticStringMap(ExtensionId).initComptime(.{
         .{ &[_]u8{ 0x55, 0x04, 0x03 }, .commonName },
         .{ &[_]u8{ 0x55, 0x1D, 0x01 }, .authority_key_identifier },
         .{ &[_]u8{ 0x55, 0x1D, 0x07 }, .subject_alt_name },

lib/std/fs/test.zig

@@ -1655,7 +1655,7 @@ test "walker" {
 
     // iteration order of walker is undefined, so need lookup maps to check against
 
-    const ExpectedPaths = std.ComptimeStringMap(void, .{
+    const expected_paths = std.StaticStringMap(void).initComptime(.{
         .{ "dir1", {} },
         .{ "dir2", {} },
         .{ "dir3", {} },
@@ -1665,7 +1665,7 @@ test "walker" {
         .{ "dir3" ++ fs.path.sep_str ++ "sub2" ++ fs.path.sep_str ++ "subsub1", {} },
     });
 
-    const ExpectedBasename = std.ComptimeStringMap(void, .{
+    const expected_basename = std.StaticStringMap(void).initComptime(.{
         .{ "dir1", {} },
         .{ "dir2", {} },
         .{ "dir3", {} },
@@ -1675,7 +1675,7 @@ test "walker" {
         .{ "subsub1", {} },
     });
 
-    for (ExpectedPaths.keys()) |key| {
+    for (expected_paths.keys()) |key| {
         try tmp.dir.makePath(key);
     }
 
@@ -1684,11 +1684,11 @@ test "walker" {
 
     var num_walked: usize = 0;
     while (try walker.next()) |entry| {
-        testing.expect(ExpectedBasename.has(entry.basename)) catch |err| {
+        testing.expect(expected_basename.has(entry.basename)) catch |err| {
             std.debug.print("found unexpected basename: {s}\n", .{std.fmt.fmtSliceEscapeLower(entry.basename)});
             return err;
         };
-        testing.expect(ExpectedPaths.has(entry.path)) catch |err| {
+        testing.expect(expected_paths.has(entry.path)) catch |err| {
             std.debug.print("found unexpected path: {s}\n", .{std.fmt.fmtSliceEscapeLower(entry.path)});
             return err;
         };
@@ -1697,7 +1697,7 @@ test "walker" {
         defer entry_dir.close();
         num_walked += 1;
     }
-    try testing.expectEqual(ExpectedPaths.kvs.len, num_walked);
+    try testing.expectEqual(expected_paths.kvs.len, num_walked);
 }
 
 test "walker without fully iterating" {

lib/std/http/Client.zig

@@ -1570,13 +1570,13 @@ pub const RequestOptions = struct {
 };
 
 fn validateUri(uri: Uri, arena: Allocator) !struct { Connection.Protocol, Uri } {
-    const ProtocolMap = std.ComptimeStringMap(Connection.Protocol, .{
+    const protocol_map = std.StaticStringMap(Connection.Protocol).initComptime(.{
         .{ "http", .plain },
         .{ "ws", .plain },
         .{ "https", .tls },
         .{ "wss", .tls },
     });
-    const protocol = ProtocolMap.get(uri.scheme) orelse return error.UnsupportedUriScheme;
+    const protocol = protocol_map.get(uri.scheme) orelse return error.UnsupportedUriScheme;
     var valid_uri = uri;
     // The host is always going to be needed as a raw string for hostname resolution anyway.
     valid_uri.host = .{

lib/std/meta.zig

@@ -15,22 +15,22 @@ test {
 
 /// Returns the variant of an enum type, `T`, which is named `str`, or `null` if no such variant exists.
 pub fn stringToEnum(comptime T: type, str: []const u8) ?T {
-    // Using ComptimeStringMap here is more performant, but it will start to take too
+    // Using StaticStringMap here is more performant, but it will start to take too
     // long to compile if the enum is large enough, due to the current limits of comptime
     // performance when doing things like constructing lookup maps at comptime.
     // TODO The '100' here is arbitrary and should be increased when possible:
     // - https://github.com/ziglang/zig/issues/4055
     // - https://github.com/ziglang/zig/issues/3863
     if (@typeInfo(T).@"enum".fields.len <= 100) {
-        const Map = comptime build_kvs: {
+        const map = comptime build_kvs: {
             const EnumKV = struct { []const u8, T };
             var kvs_array: [@typeInfo(T).@"enum".fields.len]EnumKV = undefined;
             for (@typeInfo(T).@"enum".fields, 0..) |enumField, i| {
                 kvs_array[i] = .{ enumField.name, @field(T, enumField.name) };
             }
-            break :build_kvs std.ComptimeStringMap(T, kvs_array);
+            break :build_kvs std.StaticStringMap(T).initComptime(kvs_array);
         };
-        return Map.get(str);
+        return map.get(str);
     } else {
         inline for (@typeInfo(T).@"enum".fields) |enumField| {
             if (mem.eql(u8, str, enumField.name)) {