From f79dad493810e8c9338ccf3343468c001329e30f Mon Sep 17 00:00:00 2001 From: Martin <66840021+Mcrtin@users.noreply.github.com> Date: Sat, 17 Oct 2026 10:41:53 +0200 Subject: [PATCH] std.json: update usages of `array_list.Managed` to `ArrayList` --- lib/std/json/Scanner.zig | 58 +++++++++++++++++++---------------- lib/std/json/dynamic.zig | 14 ++++----- lib/std/json/dynamic_test.zig | 14 +-------- lib/std/json/static.zig | 16 +++++----- 4 files changed, 48 insertions(+), 54 deletions(-) diff --git a/lib/std/json/Scanner.zig b/lib/std/json/Scanner.zig index 08b218e816ee861e1b511390bc0c66ff4f19e939..0d515db4f92bb1c39d3ed976e01a47621ad71066 100644 --- a/lib/std/json/Scanner.zig +++ b/lib/std/json/Scanner.zig @@ -135,11 +135,11 @@ pub fn nextAllocMax(self: *@This(), allocator: Allocator, when: AllocWhen, max_v }; switch (token_type) { .number, .string => { - var value_list = std.array_list.Managed(u8).init(allocator); + var value_list: std.ArrayList(u8) = .empty; errdefer { - value_list.deinit(); + value_list.deinit(allocator); } - if (self.allocNextIntoArrayListMax(&value_list, when, max_value_len) catch |e| switch (e) { + if (self.allocNextIntoArrayListMax(allocator, &value_list, when, max_value_len) catch |e| switch (e) { error.BufferUnderrun => unreachable, else => |err| return err, }) |slice| { @@ -149,9 +149,9 @@ pub fn nextAllocMax(self: *@This(), allocator: Allocator, when: AllocWhen, max_v Token{ .string = slice }; } else { return if (token_type == .number) - Token{ .allocated_number = try value_list.toOwnedSlice() } + Token{ .allocated_number = try value_list.toOwnedSlice(allocator) } else - Token{ .allocated_string = try value_list.toOwnedSlice() }; + Token{ .allocated_string = try value_list.toOwnedSlice(allocator) }; } }, @@ -172,8 +172,8 @@ pub fn nextAllocMax(self: *@This(), allocator: Allocator, when: AllocWhen, max_v } /// Equivalent to `allocNextIntoArrayListMax(value_list, when, default_max_value_len);` -pub fn allocNextIntoArrayList(self: *@This(), value_list: *std.array_list.Managed(u8), when: AllocWhen) AllocIntoArrayListError!?[]const u8 { - return self.allocNextIntoArrayListMax(value_list, when, default_max_value_len); +pub fn allocNextIntoArrayList(self: *@This(), allocator: Allocator, value_list: *std.ArrayList(u8), when: AllocWhen) AllocIntoArrayListError!?[]const u8 { + return self.allocNextIntoArrayListMax(allocator, value_list, when, default_max_value_len); } /// The next token type must be either `.number` or `.string`. See `peekNextTokenType()`. /// When allocation is not necessary with `.alloc_if_needed`, @@ -185,25 +185,25 @@ pub fn allocNextIntoArrayList(self: *@This(), value_list: *std.array_list.Manage /// can be resumed by passing the same array list in again. /// This method does not indicate whether the token content being returned is for a `.number` or `.string` token type; /// the caller of this method is expected to know which type of token is being processed. -pub fn allocNextIntoArrayListMax(self: *@This(), value_list: *std.array_list.Managed(u8), when: AllocWhen, max_value_len: usize) AllocIntoArrayListError!?[]const u8 { +pub fn allocNextIntoArrayListMax(self: *@This(), allocator: Allocator, value_list: *std.ArrayList(u8), when: AllocWhen, max_value_len: usize) AllocIntoArrayListError!?[]const u8 { while (true) { const token = try self.next(); switch (token) { // Accumulate partial values. .partial_number, .partial_string => |slice| { - try appendSlice(value_list, slice, max_value_len); + try appendSlice(allocator, value_list, slice, max_value_len); }, .partial_string_escaped_1 => |buf| { - try appendSlice(value_list, buf[0..], max_value_len); + try appendSlice(allocator, value_list, buf[0..], max_value_len); }, .partial_string_escaped_2 => |buf| { - try appendSlice(value_list, buf[0..], max_value_len); + try appendSlice(allocator, value_list, buf[0..], max_value_len); }, .partial_string_escaped_3 => |buf| { - try appendSlice(value_list, buf[0..], max_value_len); + try appendSlice(allocator, value_list, buf[0..], max_value_len); }, .partial_string_escaped_4 => |buf| { - try appendSlice(value_list, buf[0..], max_value_len); + try appendSlice(allocator, value_list, buf[0..], max_value_len); }, // Return complete values. @@ -212,7 +212,7 @@ pub fn allocNextIntoArrayListMax(self: *@This(), value_list: *std.array_list.Man // No alloc necessary. return slice; } - try appendSlice(value_list, slice, max_value_len); + try appendSlice(allocator, value_list, slice, max_value_len); // The token is complete. return null; }, @@ -221,7 +221,7 @@ pub fn allocNextIntoArrayListMax(self: *@This(), value_list: *std.array_list.Man // No alloc necessary. return slice; } - try appendSlice(value_list, slice, max_value_len); + try appendSlice(allocator, value_list, slice, max_value_len); // The token is complete. return null; }, @@ -1607,20 +1607,20 @@ pub const Reader = struct { const token_type = try self.peekNextTokenType(); switch (token_type) { .number, .string => { - var value_list = std.array_list.Managed(u8).init(allocator); + var value_list: std.ArrayList(u8) = .empty; errdefer { - value_list.deinit(); + value_list.deinit(allocator); } - if (try self.allocNextIntoArrayListMax(&value_list, when, max_value_len)) |slice| { + if (try self.allocNextIntoArrayListMax(allocator, &value_list, when, max_value_len)) |slice| { return if (token_type == .number) Token{ .number = slice } else Token{ .string = slice }; } else { return if (token_type == .number) - Token{ .allocated_number = try value_list.toOwnedSlice() } + Token{ .allocated_number = try value_list.toOwnedSlice(allocator) } else - Token{ .allocated_string = try value_list.toOwnedSlice() }; + Token{ .allocated_string = try value_list.toOwnedSlice(allocator) }; } }, @@ -1638,13 +1638,19 @@ pub const Reader = struct { } /// Equivalent to `allocNextIntoArrayListMax(value_list, when, default_max_value_len);` - pub fn allocNextIntoArrayList(self: *@This(), value_list: *std.array_list.Managed(u8), when: AllocWhen) Reader.AllocError!?[]const u8 { - return self.allocNextIntoArrayListMax(value_list, when, default_max_value_len); + pub fn allocNextIntoArrayList(self: *@This(), allocator: Allocator, value_list: *std.ArrayList(u8), when: AllocWhen) Reader.AllocError!?[]const u8 { + return self.allocNextIntoArrayListMax(allocator, value_list, when, default_max_value_len); } /// Calls `std.json.Scanner.allocNextIntoArrayListMax` and handles `error.BufferUnderrun`. - pub fn allocNextIntoArrayListMax(self: *@This(), value_list: *std.array_list.Managed(u8), when: AllocWhen, max_value_len: usize) Reader.AllocError!?[]const u8 { + pub fn allocNextIntoArrayListMax( + self: *@This(), + allocator: Allocator, + value_list: *std.ArrayList(u8), + when: AllocWhen, + max_value_len: usize, + ) Reader.AllocError!?[]const u8 { while (true) { - return self.scanner.allocNextIntoArrayListMax(value_list, when, max_value_len) catch |err| switch (err) { + return self.scanner.allocNextIntoArrayListMax(allocator, value_list, when, max_value_len) catch |err| switch (err) { error.BufferUnderrun => { try self.refillBuffer(); continue; @@ -1745,10 +1751,10 @@ pub const Reader = struct { const OBJECT_MODE = 0; const ARRAY_MODE = 1; -fn appendSlice(list: *std.array_list.Managed(u8), buf: []const u8, max_value_len: usize) !void { +fn appendSlice(allocator: Allocator, list: *std.ArrayList(u8), buf: []const u8, max_value_len: usize) !void { const new_len = std.math.add(usize, list.items.len, buf.len) catch return error.ValueTooLong; if (new_len > max_value_len) return error.ValueTooLong; - try list.appendSlice(buf); + try list.appendSlice(allocator, buf); } /// For the slice you get from a `Token.number` or `Token.allocated_number`, diff --git a/lib/std/json/dynamic.zig b/lib/std/json/dynamic.zig index 8a31cb0f7ae03488cfc0a8a431ce068f3007077b..37b39565a461666ec28ff4ed5dc63274093c5d30 100644 --- a/lib/std/json/dynamic.zig +++ b/lib/std/json/dynamic.zig @@ -11,7 +11,7 @@ const ParseError = @import("./static.zig").ParseError; const isNumberFormattedLikeAnInteger = @import("Scanner.zig").isNumberFormattedLikeAnInteger; pub const ObjectMap = StringArrayHashMap(Value); -pub const Array = std.array_list.Managed(Value); +pub const Array = std.ArrayList(Value); /// Represents any JSON value, potentially containing other JSON values. /// A .float value may be an approximation of the original value. @@ -76,8 +76,8 @@ pub const Value = union(enum) { pub fn jsonParse(allocator: Allocator, source: anytype, options: ParseOptions) ParseError(@TypeOf(source.*))!@This() { // The grammar of the stack is: // (.array | .object .string)* - var stack = Array.init(allocator); - defer stack.deinit(); + var stack: Array = .empty; + defer stack.deinit(allocator); while (true) { // Assert the stack grammar at the top of the stack. @@ -105,7 +105,7 @@ pub const Value = union(enum) { switch (try source.nextAllocMax(allocator, .alloc_always, options.max_value_len.?)) { .object_end => return try handleCompleteValue(&stack, allocator, source, Value{ .object = .empty }, options) orelse continue, .allocated_string => |key| { - try stack.appendSlice(&[_]Value{ + try stack.appendSlice(allocator, &[_]Value{ Value{ .object = .empty }, Value{ .string = key }, }); @@ -114,7 +114,7 @@ pub const Value = union(enum) { } }, .array_begin => { - try stack.append(Value{ .array = Array.init(allocator) }); + try stack.append(allocator, Value{ .array = .empty }); }, .array_end => return try handleCompleteValue(&stack, allocator, source, stack.pop().?, options) orelse continue, @@ -170,7 +170,7 @@ fn handleCompleteValue(stack: *Array, allocator: Allocator, source: anytype, val }, .allocated_string => |next_key| { // We've got another key. - try stack.append(Value{ .string = next_key }); + try stack.append(allocator, Value{ .string = next_key }); // stack: [..., .object, .string] return null; }, @@ -179,7 +179,7 @@ fn handleCompleteValue(stack: *Array, allocator: Allocator, source: anytype, val }, .array => |*array| { // stack: [..., .array] - try array.append(value); + try array.append(allocator, value); return null; }, else => unreachable, diff --git a/lib/std/json/dynamic_test.zig b/lib/std/json/dynamic_test.zig index e392001c91c7c42948b4f856745d443e914b1435..d2caad711a5f11db2c88bb25ba460624b17355b6 100644 --- a/lib/std/json/dynamic_test.zig +++ b/lib/std/json/dynamic_test.zig @@ -122,18 +122,6 @@ test "parsing empty string gives appropriate error" { try testing.expectError(error.UnexpectedEndOfInput, testParse(arena_allocator.allocator(), "")); } -test "Value.array allocator should still be usable after parsing" { - var parsed = try parseFromSlice(Value, std.testing.allocator, "[]", .{}); - defer parsed.deinit(); - - // Allocation should succeed - var i: usize = 0; - while (i < 100) : (i += 1) { - try parsed.value.array.append(Value{ .integer = 100 }); - } - try testing.expectEqual(parsed.value.array.items.len, 100); -} - test "integer after float has proper type" { var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena_allocator.deinit(); @@ -236,7 +224,7 @@ test "Value.jsonStringify" { .{ .number_string = "43" }, .{ .float = 42 }, .{ .string = "weeee" }, - .{ .array = Array.fromOwnedSlice(undefined, &vals) }, + .{ .array = .fromOwnedSlice(&vals) }, .{ .object = obj }, }; var buffer: [0x1000]u8 = undefined; diff --git a/lib/std/json/static.zig b/lib/std/json/static.zig index fd140fc0f2325e25a6f83119e59c539007329442..3bd30481e79fd438a0720d95a74617021c37ded7 100644 --- a/lib/std/json/static.zig +++ b/lib/std/json/static.zig @@ -2,7 +2,7 @@ const std = @import("std"); const assert = std.debug.assert; const Allocator = std.mem.Allocator; const ArenaAllocator = std.heap.ArenaAllocator; -const ArrayList = std.array_list.Managed; +const ArrayList = std.ArrayList; const Scanner = @import("Scanner.zig"); const Token = Scanner.Token; @@ -469,7 +469,7 @@ pub fn innerParse( _ = try source.next(); // Typical array. - var arraylist = ArrayList(ptrInfo.child).init(allocator); + var arraylist: ArrayList(ptrInfo.child) = .empty; while (true) { switch (try source.peekNextTokenType()) { .array_end => { @@ -479,15 +479,15 @@ pub fn innerParse( else => {}, } - try arraylist.ensureUnusedCapacity(1); + try arraylist.ensureUnusedCapacity(allocator, 1); arraylist.appendAssumeCapacity(try innerParse(ptrInfo.child, allocator, source, options)); } if (ptrInfo.sentinel()) |s| { - return try arraylist.toOwnedSliceSentinel(s); + return try arraylist.toOwnedSliceSentinel(allocator, s); } - return try arraylist.toOwnedSlice(); + return try arraylist.toOwnedSlice(allocator); }, .string => { if (ptrInfo.child != u8) return error.UnexpectedToken; @@ -495,9 +495,9 @@ pub fn innerParse( // Dynamic length string. if (ptrInfo.sentinel()) |s| { // Use our own array list so we can append the sentinel. - var value_list = ArrayList(u8).init(allocator); - _ = try source.allocNextIntoArrayListMax(&value_list, .alloc_always, options.max_value_len.?); - return try value_list.toOwnedSliceSentinel(s); + var value_list: ArrayList(u8) = .empty; + _ = try source.allocNextIntoArrayListMax(allocator, &value_list, .alloc_always, options.max_value_len.?); + return try value_list.toOwnedSliceSentinel(allocator, s); } if (ptrInfo.attrs.@"const") { switch (try source.nextAllocMax(allocator, options.allocate.?, options.max_value_len.?)) { -- 2.54.0