Merge pull request #8975 from SpexGuy/hash-map-updates

Breaking hash map changes for 0.8.0

1 files changed, 27 insertions, 26 deletions

diff --git a/src/link/C.zig b/src/link/C.zig
index 5fb62c20af..6cb219db41 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -70,8 +70,8 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
 }
 
 pub fn deinit(self: *C) void {
-    for (self.decl_table.items()) |entry| {
-        self.freeDecl(entry.key);
+    for (self.decl_table.keys()) |key| {
+        deinitDecl(self.base.allocator, key);
     }
     self.decl_table.deinit(self.base.allocator);
 }
@@ -80,13 +80,17 @@ pub fn allocateDeclIndexes(self: *C, decl: *Module.Decl) !void {}
 
 pub fn freeDecl(self: *C, decl: *Module.Decl) void {
     _ = self.decl_table.swapRemove(decl);
-    decl.link.c.code.deinit(self.base.allocator);
-    decl.fn_link.c.fwd_decl.deinit(self.base.allocator);
-    var it = decl.fn_link.c.typedefs.iterator();
-    while (it.next()) |some| {
-        self.base.allocator.free(some.value.rendered);
+    deinitDecl(self.base.allocator, decl);
+}
+
+fn deinitDecl(gpa: *Allocator, decl: *Module.Decl) void {
+    decl.link.c.code.deinit(gpa);
+    decl.fn_link.c.fwd_decl.deinit(gpa);
+    var it = decl.fn_link.c.typedefs.valueIterator();
+    while (it.next()) |value| {
+        gpa.free(value.rendered);
     }
-    decl.fn_link.c.typedefs.deinit(self.base.allocator);
+    decl.fn_link.c.typedefs.deinit(gpa);
 }
 
 pub fn updateDecl(self: *C, module: *Module, decl: *Module.Decl) !void {
@@ -101,9 +105,9 @@ pub fn updateDecl(self: *C, module: *Module, decl: *Module.Decl) !void {
     const code = &decl.link.c.code;
     fwd_decl.shrinkRetainingCapacity(0);
     {
-        var it = typedefs.iterator();
-        while (it.next()) |entry| {
-            module.gpa.free(entry.value.rendered);
+        var it = typedefs.valueIterator();
+        while (it.next()) |value| {
+            module.gpa.free(value.rendered);
         }
     }
     typedefs.clearRetainingCapacity();
@@ -128,9 +132,9 @@ pub fn updateDecl(self: *C, module: *Module, decl: *Module.Decl) !void {
         object.blocks.deinit(module.gpa);
         object.code.deinit();
         object.dg.fwd_decl.deinit();
-        var it = object.dg.typedefs.iterator();
-        while (it.next()) |some| {
-            module.gpa.free(some.value.rendered);
+        var it = object.dg.typedefs.valueIterator();
+        while (it.next()) |value| {
+            module.gpa.free(value.rendered);
         }
         object.dg.typedefs.deinit();
     }
@@ -194,31 +198,30 @@ pub fn flushModule(self: *C, comp: *Compilation) !void {
         if (module.global_error_set.size == 0) break :render_errors;
         var it = module.global_error_set.iterator();
         while (it.next()) |entry| {
-            try err_typedef_writer.print("#define zig_error_{s} {d}\n", .{ entry.key, entry.value });
+            try err_typedef_writer.print("#define zig_error_{s} {d}\n", .{ entry.key_ptr.*, entry.value_ptr.* });
         }
         try err_typedef_writer.writeByte('\n');
     }
 
     var fn_count: usize = 0;
-    var typedefs = std.HashMap(Type, []const u8, Type.hash, Type.eql, std.hash_map.default_max_load_percentage).init(comp.gpa);
+    var typedefs = std.HashMap(Type, []const u8, Type.HashContext, std.hash_map.default_max_load_percentage).init(comp.gpa);
     defer typedefs.deinit();
 
     // Typedefs, forward decls and non-functions first.
     // TODO: performance investigation: would keeping a list of Decls that we should
     // generate, rather than querying here, be faster?
-    for (self.decl_table.items()) |kv| {
-        const decl = kv.key;
+    for (self.decl_table.keys()) |decl| {
         if (!decl.has_tv) continue;
         const buf = buf: {
             if (decl.val.castTag(.function)) |_| {
                 var it = decl.fn_link.c.typedefs.iterator();
                 while (it.next()) |new| {
-                    if (typedefs.get(new.key)) |previous| {
-                        try err_typedef_writer.print("typedef {s} {s};\n", .{ previous, new.value.name });
+                    if (typedefs.get(new.key_ptr.*)) |previous| {
+                        try err_typedef_writer.print("typedef {s} {s};\n", .{ previous, new.value_ptr.name });
                     } else {
                         try typedefs.ensureCapacity(typedefs.capacity() + 1);
-                        try err_typedef_writer.writeAll(new.value.rendered);
-                        typedefs.putAssumeCapacityNoClobber(new.key, new.value.name);
+                        try err_typedef_writer.writeAll(new.value_ptr.rendered);
+                        typedefs.putAssumeCapacityNoClobber(new.key_ptr.*, new.value_ptr.name);
                     }
                 }
                 fn_count += 1;
@@ -242,8 +245,7 @@ pub fn flushModule(self: *C, comp: *Compilation) !void {
 
     // Now the function bodies.
     try all_buffers.ensureCapacity(all_buffers.items.len + fn_count);
-    for (self.decl_table.items()) |kv| {
-        const decl = kv.key;
+    for (self.decl_table.keys()) |decl| {
         if (!decl.has_tv) continue;
         if (decl.val.castTag(.function)) |_| {
             const buf = decl.link.c.code.items;
@@ -278,8 +280,7 @@ pub fn flushEmitH(module: *Module) !void {
         .iov_len = zig_h.len,
     });
 
-    for (emit_h.decl_table.items()) |kv| {
-        const decl = kv.key;
+    for (emit_h.decl_table.keys()) |decl| {
         const decl_emit_h = decl.getEmitH(module);
         const buf = decl_emit_h.fwd_decl.items;
         all_buffers.appendAssumeCapacity(.{