Update to Allocgate + anyopaque changes

Some tests are still failing though
kristoff-it · Jan 4, 2022 · 55e2c8f · 55e2c8f
1 parent 1a929a4
commit 55e2c8f
Show file tree

Hide file tree

Showing 17 changed files with 36 additions and 36 deletions.
diff --git a/src/client.zig b/src/client.zig
@@ -93,7 +93,7 @@ pub fn RedisClient(buffering: Buffering, _: Logging) type {
         }
 
         /// Like `send`, can allocate memory.
-        pub fn sendAlloc(self: *Self, comptime T: type, allocator: *Allocator, cmd: anytype) !T {
+        pub fn sendAlloc(self: *Self, comptime T: type, allocator: Allocator, cmd: anytype) !T {
             return self.pipelineImpl(T, cmd, .{ .one = {}, .ptr = allocator });
         }
 
@@ -105,7 +105,7 @@ pub fn RedisClient(buffering: Buffering, _: Logging) type {
         }
 
         /// Like `trans`, but can allocate memory.
-        pub fn transAlloc(self: *Self, comptime Ts: type, allocator: *Allocator, cmds: anytype) !Ts {
+        pub fn transAlloc(self: *Self, comptime Ts: type, allocator: Allocator, cmds: anytype) !Ts {
             return transactionImpl(self, Ts, cmds, .{ .ptr = allocator });
         }
 
@@ -128,7 +128,7 @@ pub fn RedisClient(buffering: Buffering, _: Logging) type {
         }
 
         /// Like `pipe`, but can allocate memory.
-        pub fn pipeAlloc(self: *Self, comptime Ts: type, allocator: *Allocator, cmds: anytype) !Ts {
+        pub fn pipeAlloc(self: *Self, comptime Ts: type, allocator: Allocator, cmds: anytype) !Ts {
             return pipelineImpl(self, Ts, cmds, .{ .ptr = allocator });
         }
 

diff --git a/src/parser.zig b/src/parser.zig
@@ -29,12 +29,12 @@ pub const RESP3Parser = struct {
         return parseImpl(T, tag, .{}, msg);
     }
 
-    pub fn parseAlloc(comptime T: type, allocator: *Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, allocator: Allocator, msg: anytype) !T {
         const tag = try msg.readByte();
         return try parseImpl(T, tag, .{ .ptr = allocator }, msg);
     }
 
-    pub fn parseAllocFromTag(comptime T: type, tag: u8, allocator: *Allocator, msg: anytype) !T {
+    pub fn parseAllocFromTag(comptime T: type, tag: u8, allocator: Allocator, msg: anytype) !T {
         return parseImpl(T, tag, .{ .ptr = allocator }, msg);
     }
 
@@ -203,7 +203,7 @@ pub const RESP3Parser = struct {
     // Frees values created by `sendAlloc`.
     // If the top value is a pointer, it frees that too.
     // TODO: free stdlib types!
-    pub fn freeReply(val: anytype, allocator: *Allocator) void {
+    pub fn freeReply(val: anytype, allocator: Allocator) void {
         const T = @TypeOf(val);
 
         switch (@typeInfo(T)) {

diff --git a/src/parser/t_bignum.zig b/src/parser/t_bignum.zig
@@ -18,7 +18,7 @@ pub const BigNumParser = struct {
         return T == std.math.big.int.Managed or T == []u8;
     }
 
-    pub fn parseAlloc(comptime T: type, comptime _: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime _: type, allocator: std.mem.Allocator, msg: anytype) !T {
         // TODO: find a better max_size limit than a random 1k value
         const bigSlice = try msg.readUntilDelimiterAlloc(allocator, '\r', 1000);
         errdefer allocator.free(bigSlice);

diff --git a/src/parser/t_bool.zig b/src/parser/t_bool.zig
@@ -25,9 +25,9 @@ pub const BoolParser = struct {
         return isSupported(T);
     }
 
-    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: std.mem.Allocator, msg: anytype) !T {
         _ = allocator;
-        
+
         return parse(T, rootParser, msg);
     }
 };

diff --git a/src/parser/t_double.zig b/src/parser/t_double.zig
@@ -35,7 +35,7 @@ pub const DoubleParser = struct {
         return isSupported(T);
     }
 
-    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: std.mem.Allocator, msg: anytype) !T {
         _ = allocator;
         return parse(T, rootParser, msg);
     }

diff --git a/src/parser/t_list.zig b/src/parser/t_list.zig
@@ -23,7 +23,7 @@ pub const ListParser = struct {
     pub fn parse(comptime T: type, comptime rootParser: type, msg: anytype) !T {
         return parseImpl(T, rootParser, .{}, msg);
     }
-    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: std.mem.Allocator, msg: anytype) !T {
         return parseImpl(T, rootParser, .{ .ptr = allocator }, msg);
     }
 

diff --git a/src/parser/t_map.zig b/src/parser/t_map.zig
@@ -42,7 +42,7 @@ pub const MapParser = struct {
     pub fn parse(comptime T: type, comptime rootParser: type, msg: anytype) !T {
         return parseImpl(T, rootParser, .{}, msg);
     }
-    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: std.mem.Allocator, msg: anytype) !T {
         return parseImpl(T, rootParser, .{ .ptr = allocator }, msg);
     }
 

diff --git a/src/parser/t_number.zig b/src/parser/t_number.zig
@@ -36,7 +36,7 @@ pub const NumberParser = struct {
         return isSupported(T);
     }
 
-    pub fn parseAlloc(comptime T: type, comptime rootParser: type, _: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime rootParser: type, _: std.mem.Allocator, msg: anytype) !T {
         return parse(T, rootParser, msg); // TODO: before I passed down an empty struct type. Was I insane? Did I have a plan?
     }
 };
diff --git a/src/parser/t_set.zig b/src/parser/t_set.zig
@@ -28,7 +28,7 @@ pub const SetParser = struct {
         return parseImpl(T, rootParser, .{}, msg);
     }
 
-    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime rootParser: type, allocator: std.mem.Allocator, msg: anytype) !T {
         // HASHMAP
         if (@typeInfo(T) == .Struct and @hasDecl(T, "Entry")) {
             const isManaged = @typeInfo(@TypeOf(T.deinit)).Fn.args.len == 1;

diff --git a/src/parser/t_string_blob.zig b/src/parser/t_string_blob.zig
@@ -71,7 +71,7 @@ pub const BlobStringParser = struct {
         };
     }
 
-    pub fn parseAlloc(comptime T: type, comptime _: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime _: type, allocator: std.mem.Allocator, msg: anytype) !T {
         // @compileLog(@typeInfo(T));
         // std.debug.print("\n\nTYPE={}\n\n", .{@typeInfo(T)});
         switch (@typeInfo(T)) {

diff --git a/src/parser/t_string_simple.zig b/src/parser/t_string_simple.zig
@@ -73,7 +73,7 @@ pub const SimpleStringParser = struct {
         };
     }
 
-    pub fn parseAlloc(comptime T: type, comptime _: type, allocator: *std.mem.Allocator, msg: anytype) !T {
+    pub fn parseAlloc(comptime T: type, comptime _: type, allocator: std.mem.Allocator, msg: anytype) !T {
         switch (@typeInfo(T)) {
             .Pointer => |ptr| {
                 switch (ptr.size) {

diff --git a/src/traits.zig b/src/traits.zig
@@ -2,8 +2,8 @@
 /// It's expected to implement three functions:
 /// ```
 /// fn parse(tag: u8, comptime rootParser: type, msg: var) !Self
-/// fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: var) !Self
-/// fn destroy(self: Self, comptime rootParser: type, allocator: *Allocator) void
+/// fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: var) !Self
+/// fn destroy(self: Self, comptime rootParser: type, allocator: Allocator) void
 /// ```
 /// `rootParser` is a reference to the RESP3Parser, which contains the main
 /// parsing logic. It's passed to the type in order to allow it  to recursively
@@ -30,14 +30,14 @@ pub fn isParserType(comptime T: type) bool {
         if (!@hasDecl(T.Redis.Parser, "parseAlloc"))
             @compileError(
                 \\`Redis.Parser` trait requires implementing:
-                \\    fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: var) !Self
+                \\    fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: var) !Self
                 \\
             );
 
         if (!@hasDecl(T.Redis.Parser, "destroy"))
             @compileError(
                 \\`Redis.Parser` trait requires implementing:
-                \\    fn destroy(self: *Self, comptime rootParser: type, allocator: *Allocator) void
+                \\    fn destroy(self: *Self, comptime rootParser: type, allocator: Allocator) void
                 \\
             );
 

diff --git a/src/types/attributes.zig b/src/types/attributes.zig
@@ -21,12 +21,12 @@ pub fn WithAttribs(comptime T: type) type {
                     @compileError("WithAttribs requires an allocator. Use `sendAlloc`.");
                 }
 
-                pub fn destroy(self: Self, comptime rootParser: type, allocator: *Allocator) void {
+                pub fn destroy(self: Self, comptime rootParser: type, allocator: Allocator) void {
                     rootParser.freeReply(self.attribs, allocator);
                     rootParser.freeReply(self.data, allocator);
                 }
 
-                pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: anytype) !Self {
+                pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: anytype) !Self {
                     var itemTag = tag;
 
                     var res: Self = undefined;
@@ -101,12 +101,12 @@ fn MakeComplexListWithAttributes() std.io.FixedBufferStream([]const u8) {
                 ":20\r\n" ++
                 "|1\r\n" ++
                     "+ttl\r\n" ++
-                    ":128\r\n" ++ 
+                    ":128\r\n" ++
                 ":100\r\n" ++
             "*2\r\n" ++
                 "|1\r\n" ++
                     "+Banana\r\n" ++
-                    "#t\r\n" ++ 
+                    "#t\r\n" ++
                 ":123\r\n" ++
                 ":99\r\n"
     )[0..]);

diff --git a/src/types/error.zig b/src/types/error.zig
@@ -52,14 +52,14 @@ pub fn OrErr(comptime T: type) type {
                     };
                 }
 
-                pub fn destroy(self: Self, comptime rootParser: type, allocator: *Allocator) void {
+                pub fn destroy(self: Self, comptime rootParser: type, allocator: Allocator) void {
                     switch (self) {
                         .Ok => |ok| rootParser.freeReply(ok, allocator),
                         else => {},
                     }
                 }
 
-                pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: anytype) !Self {
+                pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: anytype) !Self {
                     return switch (tag) {
                         '_', '-', '!' => internalParse(tag, rootParser, msg),
                         else => return Self{ .Ok = try rootParser.parseAllocFromTag(T, tag, allocator, msg) },
@@ -174,15 +174,15 @@ pub fn OrFullErr(comptime T: type) type {
                     @compileError("OrFullErr requires an allocator, use `OrErr` to parse just the error code without the need of an allocator.");
                 }
 
-                pub fn destroy(self: Self, comptime rootParser: type, allocator: *Allocator) void {
+                pub fn destroy(self: Self, comptime rootParser: type, allocator: Allocator) void {
                     switch (self) {
                         .Ok => |ok| rootParser.freeReply(ok, allocator),
                         .Err => |err| allocator.free(err.message),
                         .Nil => {},
                     }
                 }
 
-                pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: anytype) !Self {
+                pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: anytype) !Self {
                     switch (tag) {
                         else => return Self{ .Ok = try rootParser.parseAllocFromTag(T, tag, allocator, msg) },
                         '_' => {
@@ -337,7 +337,7 @@ const fakeParser = struct {
         _ = rootParser;
         return error.Errror;
     }
-    pub inline fn parseAllocFromTag(comptime T: type, tag: u8, allocator: *Allocator, rootParser: anytype) !T {
+    pub inline fn parseAllocFromTag(comptime T: type, tag: u8, allocator: Allocator, rootParser: anytype) !T {
         _ = T;
         _ = rootParser;
         _ = tag;

diff --git a/src/types/fixbuf.zig b/src/types/fixbuf.zig
@@ -67,7 +67,7 @@ pub fn FixBuf(comptime size: usize) type {
                     }
                 }
 
-                pub fn destroy(_: Self, comptime _: type, _: *std.mem.Allocator) void {}
+                pub fn destroy(_: Self, comptime _: type, _: std.mem.Allocator) void {}
 
                 pub fn parseAlloc(tag: u8, comptime rootParser: type, msg: anytype) !Self {
                     return parse(tag, rootParser, msg);

diff --git a/src/types/reply.zig b/src/types/reply.zig
@@ -33,7 +33,7 @@ pub const DynamicReply = struct {
                 @compileError("DynamicReply requires an allocator. Use `sendAlloc`!");
             }
 
-            pub fn destroy(self: DynamicReply, comptime rootParser: type, allocator: *Allocator) void {
+            pub fn destroy(self: DynamicReply, comptime rootParser: type, allocator: Allocator) void {
                 rootParser.freeReply(self.attribs, allocator);
                 switch (self.data) {
                     .Nil, .Bool, .Number, .Double => {},
@@ -56,7 +56,7 @@ pub const DynamicReply = struct {
                 }
             }
 
-            pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: anytype) error{DynamicReplyError}!DynamicReply {
+            pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: anytype) error{DynamicReplyError}!DynamicReply {
                 var itemTag = tag;
 
                 var res: DynamicReply = undefined;
@@ -167,12 +167,12 @@ fn MakeComplexListWithAttributes() std.io.FixedBufferStream([]const u8) {
             "+Hello\r\n" ++
             "|1\r\n" ++
                 "+ttl\r\n" ++
-                ":100\r\n" ++ 
+                ":100\r\n" ++
             "#t\r\n" ++
             "*3\r\n" ++
                 "|1\r\n" ++
                     "+Banana\r\n" ++
-                    "#t\r\n" ++ 
+                    "#t\r\n" ++
                 ":123\r\n" ++
                 "(424242\r\n" ++
                 ",12.34\r\n")

diff --git a/src/types/verbatim.zig b/src/types/verbatim.zig
@@ -25,11 +25,11 @@ pub const Verbatim = struct {
                 @compileError("Verbatim requires an allocator, use `parseAlloc`.");
             }
 
-            pub fn destroy(self: Verbatim, comptime _: type, allocator: *Allocator) void {
+            pub fn destroy(self: Verbatim, comptime _: type, allocator: Allocator) void {
                 allocator.free(self.string);
             }
 
-            pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: *Allocator, msg: anytype) !Verbatim {
+            pub fn parseAlloc(tag: u8, comptime rootParser: type, allocator: Allocator, msg: anytype) !Verbatim {
                 switch (tag) {
                     else => return error.DecodingError,
                     '-', '!' => {