ZON

build.zig

@@ -404,7 +404,7 @@ pub fn build(b: *std.Build) !void {
     const optimization_modes = chosen_opt_modes_buf[0..chosen_mode_index];
 
     const fmt_include_paths = &.{ "lib", "src", "test", "tools", "build.zig", "build.zig.zon" };
-    const fmt_exclude_paths = &.{"test/cases"};
+    const fmt_exclude_paths = &.{ "test/cases", "test/behavior/zon" };
     const do_fmt = b.addFmt(.{
         .paths = fmt_include_paths,
         .exclude_paths = fmt_exclude_paths,

lib/std/fmt.zig

@@ -1581,6 +1581,7 @@ test parseInt {
     try std.testing.expectEqual(@as(i5, -16), try std.fmt.parseInt(i5, "-10", 16));
 }
 
+/// Like `parseIntWithGenericCharacter`, but with a sign argument.
 fn parseIntWithSign(
     comptime Result: type,
     comptime Character: type,

lib/std/std.zig

@@ -44,6 +44,7 @@ pub const Thread = @import("Thread.zig");
 pub const Treap = @import("treap.zig").Treap;
 pub const Tz = tz.Tz;
 pub const Uri = @import("Uri.zig");
+pub const zon = @import("zon.zig");
 
 pub const array_hash_map = @import("array_hash_map.zig");
 pub const atomic = @import("atomic.zig");

lib/std/zig/Ast.zig

@@ -12,7 +12,7 @@ tokens: TokenList.Slice,
 /// references to the root node, this means 0 is available to indicate null.
 nodes: NodeList.Slice,
 extra_data: []Node.Index,
-mode: Mode = .zig,
+mode: Mode,
 
 errors: []const Error,
 

lib/std/zig/AstGen.zig

@@ -9304,7 +9304,18 @@ fn builtinCall(
             } else if (str.len == 0) {
                 return astgen.failTok(str_lit_token, "import path cannot be empty", .{});
             }
-            const result = try gz.addStrTok(.import, str.index, str_lit_token);
+            const res_ty = try ri.rl.resultType(gz, node) orelse .none;
+            const payload_index = try addExtra(gz.astgen, Zir.Inst.Import{
+                .res_ty = res_ty,
+                .path = str.index,
+            });
+            const result = try gz.add(.{
+                .tag = .import,
+                .data = .{ .pl_tok = .{
+                    .src_tok = gz.tokenIndexToRelative(str_lit_token),
+                    .payload_index = payload_index,
+                } },
+            });
             const gop = try astgen.imports.getOrPut(astgen.gpa, str.index);
             if (!gop.found_existing) {
                 gop.value_ptr.* = str_lit_token;

lib/std/zig/Zir.zig

@@ -1671,7 +1671,7 @@ pub const Inst = struct {
                 .func = .pl_node,
                 .func_inferred = .pl_node,
                 .func_fancy = .pl_node,
-                .import = .str_tok,
+                .import = .pl_tok,
                 .int = .int,
                 .int_big = .str,
                 .float = .float,
@@ -3542,6 +3542,13 @@ pub const Inst = struct {
         /// If `.none`, restore unconditionally.
         operand: Ref,
     };
+
+    pub const Import = struct {
+        /// The result type of the import, or `.none` if none was available.
+        res_ty: Ref,
+        /// The import path.
+        path: NullTerminatedString,
+    };
 };
 
 pub const SpecialProng = enum { none, @"else", under };

lib/std/zig/ZonGen.zig

@@ -250,7 +250,21 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
         .block_two_semicolon,
         .block,
         .block_semicolon,
-        => try zg.addErrorNode(node, "blocks are not allowed in ZON", .{}),
+        => {
+            const size = switch (node_tags[node]) {
+                .block_two, .block_two_semicolon => @intFromBool(node_datas[node].lhs != 0) + @intFromBool(node_datas[node].rhs != 0),
+                .block, .block_semicolon => node_datas[node].rhs - node_datas[node].lhs,
+                else => unreachable,
+            };
+            if (size == 0) {
+                try zg.addErrorNodeNotes(node, "void literals are not available in ZON", .{}, &.{
+                    try zg.errNoteNode(node, "void union payloads can be represented by enum literals", .{}),
+                    try zg.errNoteNode(node, "for example, `.{{ .foo = {{}} }}` becomes `.foo`", .{}),
+                });
+            } else {
+                try zg.addErrorNode(node, "blocks are not allowed in ZON", .{});
+            }
+        },
 
         .array_init_one,
         .array_init_one_comma,
@@ -540,7 +554,7 @@ fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index
             if (unsigned_num == 0 and sign == .negative) {
                 try zg.addErrorTokNotes(num_token, "integer literal '-0' is ambiguous", .{}, &.{
                     try zg.errNoteTok(num_token, "use '0' for an integer zero", .{}),
-                    try zg.errNoteTok(num_token, "use '-0.0' for a flaoting-point signed zero", .{}),
+                    try zg.errNoteTok(num_token, "use '-0.0' for a floating-point signed zero", .{}),
                 });
                 return;
             }

lib/std/zig/number_literal.zig

@@ -60,6 +60,11 @@ pub const Error = union(enum) {
     period_after_exponent: usize,
 };
 
+const FormatWithSource = struct {
+    bytes: []const u8,
+    err: Error,
+};
+
 /// Parse Zig number literal accepted by fmt.parseInt, fmt.parseFloat and big_int.setString.
 /// Valid for any input.
 pub fn parseNumberLiteral(bytes: []const u8) Result {

lib/std/zon.zig

@@ -0,0 +1,90 @@
+//! ZON serialization and deserialization.
+//!
+//! # ZON
+//! ZON, or Zig Object Notation, is a subset* of Zig used for data storage. ZON contains no type
+//! names.
+//!
+//! Supported Zig primitives:
+//! * boolean literals
+//! * number literals (including `nan` and `inf`)
+//! * character literals
+//! * enum literals
+//! * `null` literals
+//! * string literals
+//! * multiline string literals
+//!
+//! Supported Zig container types:
+//! * anonymous struct literals
+//! * anonymous tuple literals
+//!
+//! Here is an example ZON object:
+//! ```zon
+//! .{
+//!     .a = 1.5,
+//!     .b = "hello, world!",
+//!     .c = .{ true, false },
+//!     .d = .{ 1, 2, 3 },
+//! }
+//! ```
+//!
+//! Individual primitives are also valid ZON, for example:
+//! ```zon
+//! "This string is a valid ZON object."
+//! ```
+//!
+//! * ZON is not currently a true subset of Zig, because it supports `nan` and
+//!    `inf` literals, which Zig does not.
+//!
+//! # Deserialization
+//!
+//! The simplest way to deserialize ZON at runtime is `parseFromSlice`. (For parsing ZON at
+//! comptime, you can use `@import`.)
+//!
+//! Parsing from individual Zoir nodes is also available:
+//! * `parseFromZoir`
+//! * `parseFromZoirNode`
+//! * `parseFromZoirNode`
+//! * `parseFromZoirNodeNoAlloc`
+//!
+//! If you need lower level control than provided by this module, you can operate directly on the
+//! results of `std.zig.Zoir` directly. This module is a good example of how that can be done.
+//!
+//!
+//! # Serialization
+//!
+//! The simplest way to serialize to ZON is to call `stringify`.
+//!
+//! If you need to serialize recursive types, the following functions are also provided:
+//! * `stringifyMaxDepth`
+//! * `stringifyArbitraryDepth`
+//!
+//! If you need more control over the serialization process, for example to control which fields are
+//! serialized, configure fields individually, or to stringify ZON values that do not exist in
+//! memory, you can use `Stringifier`.
+//!
+//! Note that serializing floats with more than 64 bits may result in a loss of precision
+//! (see https://github.com/ziglang/zig/issues/1181).
+
+pub const ParseOptions = @import("zon/parse.zig").Options;
+pub const ParseStatus = @import("zon/parse.zig").Status;
+pub const parseFromSlice = @import("zon/parse.zig").parseFromSlice;
+pub const parseFromZoir = @import("zon/parse.zig").parseFromZoir;
+pub const parseFromZoirNoAlloc = @import("zon/parse.zig").parseFromZoirNoAlloc;
+pub const parseFromZoirNode = @import("zon/parse.zig").parseFromZoirNode;
+pub const parseFromZoirNodeNoAlloc = @import("zon/parse.zig").parseFromZoirNodeNoAlloc;
+pub const parseFree = @import("zon/parse.zig").parseFree;
+
+pub const StringifierOptions = @import("zon/stringify.zig").StringifierOptions;
+pub const StringifyValueOptions = @import("zon/stringify.zig").StringifyValueOptions;
+pub const StringifyOptions = @import("zon/stringify.zig").StringifyOptions;
+pub const StringifyContainerOptions = @import("zon/stringify.zig").StringifyContainerOptions;
+pub const Stringifier = @import("zon/stringify.zig").Stringifier;
+pub const stringify = @import("zon/stringify.zig").stringify;
+pub const stringifyMaxDepth = @import("zon/stringify.zig").stringifyMaxDepth;
+pub const stringifyArbitraryDepth = @import("zon/stringify.zig").stringifyArbitraryDepth;
+pub const stringifier = @import("zon/stringify.zig").stringifier;
+
+test {
+    _ = @import("zon/parse.zig");
+    _ = @import("zon/stringify.zig");
+}