Ran Zig fmt on dict.zig

compiler/builtins/bitcode/src/dict.zig

@@ -34,28 +34,17 @@ pub fn RocDict(
                 // two entries, and there is
                 // therefore an extra entry
                 // that needs to be stored
-                pub fn new(                    
+                pub fn new(index: u64, key_ptr: *Key, value_ptr: *Value) Overflow {
-                    index: u64,
-                    key_ptr: *Key, 
-                    value_ptr: *Value
-                ) Overflow {
                     var init_entries: [size]?*Entry = undefined;
 
-                    var new_overflow = Overflow {
+                    var new_overflow = Overflow{ .entries = &init_entries };
-                        .entries = &init_entries
-                    };
 
                     new_overflow.set_at_index(index, key_ptr, value_ptr);
 
                     return new_overflow;
                 }
 
-                pub fn set_at_index(
+                pub fn set_at_index(self: *Overflow, index: u64, key_ptr: *Key, value_ptr: *Value) void {
-                    self: *Overflow, 
-                    index: u64,
-                    key_ptr: *Key, 
-                    value_ptr: *Value
-                ) void {
                     var overflow = self.*;
                     var new_entry = Entry.new(key_ptr, value_ptr);
 
@@ -74,7 +63,7 @@ pub fn RocDict(
                 return Entry{
                     .value_ptr = value_ptr,
                     .key_ptr = key_ptr,
-                    .overflow = null
+                    .overflow = null,
                 };
             }
 
@@ -112,7 +101,6 @@ pub fn RocDict(
 
                             return next_entry.get(key, next_level);
                         }
-
                     }
                 }
             }
@@ -121,12 +109,7 @@ pub fn RocDict(
             // represents if an new entry was
             // added (true), or if an old one
             // was updated (false);
-            pub fn insert_into_overflow(
+            pub fn insert_into_overflow(self: *Entry, key_ptr: *Key, value_ptr: *Value, level: u64) bool {
-                self: *Entry, 
-                key_ptr: *Key, 
-                value_ptr: *Value, 
-                level: u64
-            ) bool {
                 const key = key_ptr.*;
 
                 const index = key_to_index_at_level(key, level);
@@ -165,11 +148,7 @@ pub fn RocDict(
                             overflow_entry.set_value(value_ptr);
                             return false;
                         } else {
-                            return overflow_entry.insert_into_overflow(
+                            return overflow_entry.insert_into_overflow(key_ptr, value_ptr, level + 1);
-                                key_ptr, 
-                                value_ptr, 
-                                level + 1
-                            );
                         }
                     }
                 }
@@ -222,9 +201,7 @@ pub fn RocDict(
             };
         }
 
-
         pub fn get(self: Self, key: Key) ?*Value {
-
             const q = self.query(key, 0);
 
             if (q.maybe_entry == null) {
@@ -252,13 +229,11 @@ pub fn RocDict(
             const index = key_to_index_at_level(key, level);
 
             if (q.maybe_entry == null) {
-
                 var new_entry = Entry.new(value_ptr, key_ptr);
 
                 self.entries[index] = new_entry;
 
                 self.*.len += 1;
-
             } else {
                 var entry = q.maybe_entry.?;
 
@@ -381,8 +356,6 @@ test "RocDict.eq" {
     assert(!fst.eq(trd));
 }
 
-
-
 test "RocDict.get_len" {
     var dict = RocDict(u64, u64).init(testing.allocator);
 
@@ -406,7 +379,6 @@ test "RocDict.get_len" {
     expectEqual(dict.get_len(), next_expected_len);
 }
 
-
 test "RocDict.insert" {
     var dict = RocDict(u64, u64).init(testing.allocator);
 
@@ -422,7 +394,6 @@ test "RocDict.insert" {
     expectEqual(dict.get_len(), expect_len);
 }
 
-
 test "RocDict.get" {
     const empty = RocDict(u64, u64).init(testing.allocator);
 
@@ -430,7 +401,6 @@ test "RocDict.get" {
     expectEqual(empty.get(29), expect);
 }
 
-
 test "RocDict.init" {
     const empty = RocDict(u64, u64).init(testing.allocator);
     expectEqual(empty.get_len(), 0);