Merge pull request #24505 from ziglang/json

update std.json and std.zon to new I/O API

Author: andrewrk

lib/compiler/resinator/main.zig

@@ -290,12 +290,14 @@ pub fn main() !void {
                     };
                     defer depfile.close();
 
-                    const depfile_writer = depfile.deprecatedWriter();
-                    var depfile_buffered_writer = std.io.bufferedWriter(depfile_writer);
+                    var depfile_buffer: [1024]u8 = undefined;
+                    var depfile_writer = depfile.writer(&depfile_buffer);
                     switch (options.depfile_fmt) {
                         .json => {
-                            var write_stream = std.json.writeStream(depfile_buffered_writer.writer(), .{ .whitespace = .indent_2 });
-                            defer write_stream.deinit();
+                            var write_stream: std.json.Stringify = .{
+                                .writer = &depfile_writer.interface,
+                                .options = .{ .whitespace = .indent_2 },
+                            };
 
                             try write_stream.beginArray();
                             for (dependencies_list.items) |dep_path| {
@@ -304,7 +306,7 @@ pub fn main() !void {
                             try write_stream.endArray();
                         },
                     }
-                    try depfile_buffered_writer.flush();
+                    try depfile_writer.interface.flush();
                 }
             }
 

lib/std/Build/Cache/Path.zig

@@ -161,17 +161,19 @@ pub fn formatEscapeString(path: Path, writer: *std.io.Writer) std.io.Writer.Erro
     }
 }
 
+/// Deprecated, use double quoted escape to print paths.
 pub fn fmtEscapeChar(path: Path) std.fmt.Formatter(Path, formatEscapeChar) {
     return .{ .data = path };
 }
 
+/// Deprecated, use double quoted escape to print paths.
 pub fn formatEscapeChar(path: Path, writer: *std.io.Writer) std.io.Writer.Error!void {
     if (path.root_dir.path) |p| {
-        try std.zig.charEscape(p, writer);
-        if (path.sub_path.len > 0) try std.zig.charEscape(fs.path.sep_str, writer);
+        for (p) |byte| try std.zig.charEscape(byte, writer);
+        if (path.sub_path.len > 0) try writer.writeByte(fs.path.sep);
     }
     if (path.sub_path.len > 0) {
-        try std.zig.charEscape(path.sub_path, writer);
+        for (path.sub_path) |byte| try std.zig.charEscape(byte, writer);
     }
 }
 

lib/std/Io/Reader.zig

@@ -990,9 +990,9 @@ pub fn discardDelimiterLimit(r: *Reader, delimiter: u8, limit: Limit) DiscardDel
 /// Returns `error.EndOfStream` if and only if there are fewer than `n` bytes
 /// remaining.
 ///
-/// Asserts buffer capacity is at least `n`.
+/// If the end of stream is not encountered, asserts buffer capacity is at
+/// least `n`.
 pub fn fill(r: *Reader, n: usize) Error!void {
-    assert(n <= r.buffer.len);
     if (r.seek + n <= r.end) {
         @branchHint(.likely);
         return;

lib/std/json.zig

@@ -10,8 +10,8 @@
 //! The high-level `stringify` serializes a Zig or `Value` type into JSON.
 
 const builtin = @import("builtin");
-const testing = @import("std").testing;
-const ArrayList = @import("std").ArrayList;
+const std = @import("std");
+const testing = std.testing;
 
 test Scanner {
     var scanner = Scanner.initCompleteInput(testing.allocator, "{\"foo\": 123}\n");
@@ -41,11 +41,13 @@ test Value {
     try testing.expectEqualSlices(u8, "goes", parsed.value.object.get("anything").?.string);
 }
 
-test writeStream {
-    var out = ArrayList(u8).init(testing.allocator);
+test Stringify {
+    var out: std.io.Writer.Allocating = .init(testing.allocator);
+    var write_stream: Stringify = .{
+        .writer = &out.writer,
+        .options = .{ .whitespace = .indent_2 },
+    };
     defer out.deinit();
-    var write_stream = writeStream(out.writer(), .{ .whitespace = .indent_2 });
-    defer write_stream.deinit();
     try write_stream.beginObject();
     try write_stream.objectField("foo");
     try write_stream.write(123);
@@ -55,16 +57,7 @@ test writeStream {
         \\  "foo": 123
         \\}
     ;
-    try testing.expectEqualSlices(u8, expected, out.items);
-}
-
-test stringify {
-    var out = ArrayList(u8).init(testing.allocator);
-    defer out.deinit();
-
-    const T = struct { a: i32, b: []const u8 };
-    try stringify(T{ .a = 123, .b = "xy" }, .{}, out.writer());
-    try testing.expectEqualSlices(u8, "{\"a\":123,\"b\":\"xy\"}", out.items);
+    try testing.expectEqualSlices(u8, expected, out.getWritten());
 }
 
 pub const ObjectMap = @import("json/dynamic.zig").ObjectMap;
@@ -73,18 +66,18 @@ pub const Value = @import("json/dynamic.zig").Value;
 
 pub const ArrayHashMap = @import("json/hashmap.zig").ArrayHashMap;
 
-pub const validate = @import("json/scanner.zig").validate;
-pub const Error = @import("json/scanner.zig").Error;
-pub const reader = @import("json/scanner.zig").reader;
-pub const default_buffer_size = @import("json/scanner.zig").default_buffer_size;
-pub const Token = @import("json/scanner.zig").Token;
-pub const TokenType = @import("json/scanner.zig").TokenType;
-pub const Diagnostics = @import("json/scanner.zig").Diagnostics;
-pub const AllocWhen = @import("json/scanner.zig").AllocWhen;
-pub const default_max_value_len = @import("json/scanner.zig").default_max_value_len;
-pub const Reader = @import("json/scanner.zig").Reader;
-pub const Scanner = @import("json/scanner.zig").Scanner;
-pub const isNumberFormattedLikeAnInteger = @import("json/scanner.zig").isNumberFormattedLikeAnInteger;
+pub const Scanner = @import("json/Scanner.zig");
+pub const validate = Scanner.validate;
+pub const Error = Scanner.Error;
+pub const reader = Scanner.reader;
+pub const default_buffer_size = Scanner.default_buffer_size;
+pub const Token = Scanner.Token;
+pub const TokenType = Scanner.TokenType;
+pub const Diagnostics = Scanner.Diagnostics;
+pub const AllocWhen = Scanner.AllocWhen;
+pub const default_max_value_len = Scanner.default_max_value_len;
+pub const Reader = Scanner.Reader;
+pub const isNumberFormattedLikeAnInteger = Scanner.isNumberFormattedLikeAnInteger;
 
 pub const ParseOptions = @import("json/static.zig").ParseOptions;
 pub const Parsed = @import("json/static.zig").Parsed;
@@ -99,27 +92,49 @@ pub const innerParseFromValue = @import("json/static.zig").innerParseFromValue;
 pub const ParseError = @import("json/static.zig").ParseError;
 pub const ParseFromValueError = @import("json/static.zig").ParseFromValueError;
 
-pub const StringifyOptions = @import("json/stringify.zig").StringifyOptions;
-pub const stringify = @import("json/stringify.zig").stringify;
-pub const stringifyMaxDepth = @import("json/stringify.zig").stringifyMaxDepth;
-pub const stringifyArbitraryDepth = @import("json/stringify.zig").stringifyArbitraryDepth;
-pub const stringifyAlloc = @import("json/stringify.zig").stringifyAlloc;
-pub const writeStream = @import("json/stringify.zig").writeStream;
-pub const writeStreamMaxDepth = @import("json/stringify.zig").writeStreamMaxDepth;
-pub const writeStreamArbitraryDepth = @import("json/stringify.zig").writeStreamArbitraryDepth;
-pub const WriteStream = @import("json/stringify.zig").WriteStream;
-pub const encodeJsonString = @import("json/stringify.zig").encodeJsonString;
-pub const encodeJsonStringChars = @import("json/stringify.zig").encodeJsonStringChars;
-
-pub const Formatter = @import("json/fmt.zig").Formatter;
-pub const fmt = @import("json/fmt.zig").fmt;
+pub const Stringify = @import("json/Stringify.zig");
+
+/// Returns a formatter that formats the given value using stringify.
+pub fn fmt(value: anytype, options: Stringify.Options) Formatter(@TypeOf(value)) {
+    return Formatter(@TypeOf(value)){ .value = value, .options = options };
+}
+
+test fmt {
+    const expectFmt = std.testing.expectFmt;
+    try expectFmt("123", "{f}", .{fmt(@as(u32, 123), .{})});
+    try expectFmt(
+        \\{"num":927,"msg":"hello","sub":{"mybool":true}}
+    , "{f}", .{fmt(struct {
+        num: u32,
+        msg: []const u8,
+        sub: struct {
+            mybool: bool,
+        },
+    }{
+        .num = 927,
+        .msg = "hello",
+        .sub = .{ .mybool = true },
+    }, .{})});
+}
+
+/// Formats the given value using stringify.
+pub fn Formatter(comptime T: type) type {
+    return struct {
+        value: T,
+        options: Stringify.Options,
+
+        pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void {
+            try Stringify.value(self.value, self.options, writer);
+        }
+    };
+}
 
 test {
     _ = @import("json/test.zig");
-    _ = @import("json/scanner.zig");
+    _ = Scanner;
     _ = @import("json/dynamic.zig");
     _ = @import("json/hashmap.zig");
     _ = @import("json/static.zig");
-    _ = @import("json/stringify.zig");
+    _ = Stringify;
     _ = @import("json/JSONTestSuite_test.zig");
 }