Skip to content
Standard libraryZig 0.17.0Official documentation
Sourcestd/zon/parse.zig

Source line 1

Use fromSlice/fromSlice to parse a ZON string into a Zig value. Human readable errors are written to an out parameter.

If your data is already available in tree form, consider fromZoir/fromZoir.

To parse into an existing value, see the updateFrom* variants. For lower level control over parsing, see std.zig.ZonGen. For importing ZON at compile time, use @import.

std.zon.parse.AddressMode

container

Source line 220

Fields

clamp
reflect
wrap
zero

std.zon.parse.Allocator

alias

Source line 11

Alias of std.mem.Allocator

std.zon.parse.ArenaAllocator

alias

Source line 21

Alias of std.heap.ArenaAllocator

std.zon.parse.ArrayList

alias

Source line 20

Alias of std.ArrayList

std.zon.parse.assert

alias

Source line 19

Alias of std.debug.assert

std.zon.parse.Ast

alias

Source line 12

Alias of std.zig.Ast

std.zon.parse.Base

alias

Source line 16

Alias of std.zig.number_literal.Base

std.zon.parse.builtin

constant

Source line 10

std.zon.parse.canParseType

function

Source line 1238

fn canParseType(T: type) bool

Parameters

T: type

std.zon.parse.canParseTypeInner

function

Source line 1242

fn canParseTypeInner( T: type, visited: []const type, parent_is_optional: bool, ) bool

Parameters

T: type
visited: []const type

Visited structs and unions, to avoid infinite recursion. Tracking more types is unnecessary, and a little complex due to optional nesting.

parent_is_optional: bool

std.zon.parse.Diagnostics

container

Source line 27

Errors encountered while parsing ZON. See log and fatal for reporting errors to the user.

Fields

errors: []const Error

std.zon.parse.Diagnostics.astLoc

function

Source line 99

fn astLoc( ast: *const Ast, maybe_token: Ast.OptionalTokenIndex, node_or_offset: u32, ) Ast.Location

Parameters

ast: *const Ast
maybe_token: Ast.OptionalTokenIndex
node_or_offset: u32

std.zon.parse.Diagnostics.Error

container

Source line 140

Fields

msg: []const u8
loc: Ast.Location
token: Ast.OptionalTokenIndex
node_or_offset: u32

If token == .none, this is an Ast.Node.Index. Otherwise, this is a byte offset into token.

notes: []Note

std.zon.parse.Diagnostics.Error.init

function

Source line 156

fn init(ast: *const Ast, options: Error.Options) Error

Parameters

ast: *const Ast
options: Error.Options

std.zon.parse.Diagnostics.Error.Options

container

Source line 149

Fields

msg: []const u8
token: Ast.OptionalTokenIndex
node_or_offset: u32
notes: []Note

std.zon.parse.Diagnostics.fatal

function

Source line 63

Log the failure with std.log.err, and then terminate the process with exit code 1.

pub fn fatal(self: *const Diagnostics, path: []const u8) noreturn

Parameters

self: *const Diagnostics
path: []const u8

Example usage

test fatal {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const MyType = struct {
        foo: u32,
        bar: u32,
    };

    const parsed = fromSliceNoAlloc(MyType, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .foo = 1, .bar = 2 }",
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return error.OutOfMemory,
        error.ParseZon => diagnostics.fatal("input.zon"),
    };
    _ = parsed;
}

std.zon.parse.Diagnostics.fmt

function

Source line 92

Formats a human readable description of any errors.

pub fn fmt(self: *const Diagnostics, path: []const u8) Formatter

Parameters

self: *const Diagnostics
path: []const u8

std.zon.parse.Diagnostics.Formatter

container

Source line 115

Fields

path: []const u8
errors: []const Error

std.zon.parse.Diagnostics.Formatter.format

function

Source line 119

pub fn format(self: *const @This(), w: *std.Io.Writer) std.Io.Writer.Error!void

Parameters

self: *const @This()
w: *std.Io.Writer

Errors

WriteFailed

See the Writer implementation for detailed diagnostics.

std.zon.parse.Diagnostics.log

function

Source line 31

Log the failure with std.log.err.

pub fn log(self: *const Diagnostics, path: []const u8) void

Parameters

self: *const Diagnostics
path: []const u8

Example usage

test log {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const MyType = struct {
        foo: u32,
        bar: u32,
    };

    const parsed: MyType = fromSliceNoAlloc(MyType, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .foo = 1, .bar = 2 }",
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return error.OutOfMemory,
        error.ParseZon => b: {
            diagnostics.log("input.zon");
            break :b .{ .foo = 0, .bar = 0 };
        },
    };
    _ = parsed;
}

std.zon.parse.Diagnostics.Note

container

Source line 167

Fields

msg: []const u8
loc: Ast.Location
token: Ast.OptionalTokenIndex
node_or_offset: u32

If token == .none, this is an Ast.Node.Index. Otherwise, this is a byte offset into token.

std.zon.parse.Diagnostics.Note.init

function

Source line 181

fn init(ast: *const Ast, options: Note.Options) @This()

Parameters

ast: *const Ast
options: Note.Options

std.zon.parse.Diagnostics.Note.Options

container

Source line 175

Fields

msg: []const u8
token: Ast.OptionalTokenIndex
node_or_offset: u32

std.zon.parse.fromSlice

function

Source line 207

Parses the given slice as ZON, writing any errors to options.diagnostics.

pub fn fromSlice(T: type, options: Options) error{ OutOfMemory, ParseZon }!T

Parameters

T: type
options: Options

Errors

OutOfMemory
ParseZon

Example usage

test fromSlice {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();

    const TextureOptions = struct {
        const AddressMode = enum { clamp, reflect, wrap, zero };
        address_mode: struct { u: AddressMode = .wrap, v: AddressMode = .wrap },
        mipmaps: bool = true,
        premultiply: bool = true,
    };

    const source =
        \\.{
        \\    .address_mode = .{ .u = .clamp },
        \\    .mipmaps = false,
        \\}
    ;

    var diagnostics: Diagnostics = undefined;
    const options = fromSlice(TextureOptions, .{
        .gpa = gpa,
        .arena = arena,
        .source = source,
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return err,
        error.ParseZon => {
            diagnostics.log("texture_options.zon");
            return err;
        },
    };

    try std.testing.expectEqualDeep(TextureOptions{
        .address_mode = .{ .u = .clamp, .v = .wrap },
        .mipmaps = false,
        .premultiply = true,
    }, options);
}

std.zon.parse.fromSliceInner

function

Source line 353

fn fromSliceInner( T: type, value: *T, initialized: bool, options: Options, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
initialized: bool
options: Options

Errors

OutOfMemory
ParseZon

std.zon.parse.fromSliceNoAlloc

function

Source line 256

Like fromSlice but the result type may not contain pointers, allowing it to outlive options.arena.

pub fn fromSliceNoAlloc(T: type, options: Options) error{ OutOfMemory, ParseZon }!T

Parameters

T: type
options: Options

Errors

OutOfMemory
ParseZon

std.zon.parse.fromZoir

function

Source line 395

Like fromSlice, but operates on Zoir instead of ZON source.

pub fn fromZoir(T: type, options: FromZoirOptions) error{ OutOfMemory, ParseZon }!T

Parameters

T: type
options: FromZoirOptions

Errors

OutOfMemory
ParseZon

std.zon.parse.fromZoirInner

function

Source line 426

fn fromZoirInner( T: type, value: *T, initialized: bool, options: FromZoirOptions, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
initialized: bool
options: FromZoirOptions

Errors

OutOfMemory
ParseZon

std.zon.parse.fromZoirNoAlloc

function

Source line 402

Like fromSliceNoAlloc, but operates on Zoir instead of ZON source.

pub fn fromZoirNoAlloc(T: type, options: FromZoirOptions) error{ OutOfMemory, ParseZon }!T

Parameters

T: type
options: FromZoirOptions

Errors

OutOfMemory
ParseZon

std.zon.parse.FromZoirOptions

container

Source line 378

Fields

arena: Allocator

Used for allocating diagnostics and results.

ast: *const Ast

The AST for this ZON value.

zoir: *const Zoir

The zig object intermediate representation of this ZON value.

node: Zoir.Node.Index = .root

The node to start parsing at.

diagnostics: *Diagnostics

Initialized by the callee with a human readable description of any parse errors that occured.

ignore_unknown_fields: bool = false

If true, unknown fields do not error.

std.zon.parse.inner

function

Source line 452

fn inner( T: type, value: *T, initialized: bool, options: InnerOptions, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
initialized: bool
options: InnerOptions

Errors

OutOfMemory
ParseZon

std.zon.parse.InnerOptions

container

Source line 443

Fields

arena: Allocator
ast: *const Ast
zoir: *const Zoir
node: Zoir.Node.Index = .root
errors: *std.ArrayList(Diagnostics.Error)
ignore_unknown_fields: bool

std.zon.parse.intFromFloatExact

function

Source line 1224

fn intFromFloatExact(T: type, value: anytype) ?T

Parameters

T: type

std.zon.parse.NumberLiteralError

alias

Source line 18

Alias of std.zig.number_literal.Error

std.zon.parse.Options

container

Source line 192

Fields

gpa: Allocator

Used for scratch allocations.

arena: Allocator

Used for allocating diagnostics and results.

source: [:0]const u8

The ZON source to parse.

diagnostics: *Diagnostics

Initialized by the callee with a human readable description of any parse errors that occured.

ignore_unknown_fields: bool = false

If true, unknown fields do not error.

std.zon.parse.Parser

container

Source line 512

Fields

arena: Allocator
ast: *const Ast
zoir: *const Zoir
errors: *std.ArrayList(Diagnostics.Error)
ignore_unknown_fields: bool

std.zon.parse.Parser.failCannotRepresent

type-function

Source line 1135

fn failCannotRepresent( self: Parser, T: type, node: Zoir.Node.Index, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
T: type
node: Zoir.Node.Index

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failComptimeField

type-function

Source line 1199

fn failComptimeField( self: Parser, node: Zoir.Node.Index, field: usize, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
node: Zoir.Node.Index
field: usize

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failExpectedType

type-function

Source line 608

Prints a message of the form expected T where T is first converted to a ZON type. For example, **?**u8 becomes ?u8, and types that involve user specified type names are just referred to by the type of container.

fn failExpectedType( self: Parser, T: type, node: Zoir.Node.Index, ) error{ ParseZon, OutOfMemory }

Parameters

self: Parser
T: type
node: Zoir.Node.Index

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failExpectedTypeInner

type-function

Source line 617

fn failExpectedTypeInner( self: Parser, T: type, opt: bool, node: Zoir.Node.Index, ) error{ ParseZon, OutOfMemory }

Parameters

self: Parser
T: type
opt: bool
node: Zoir.Node.Index

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failNode

type-function

Source line 1120

fn failNode( self: Parser, node: Zoir.Node.Index, msg: []const u8, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
node: Zoir.Node.Index
msg: []const u8

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failNodeFmt

type-function

Source line 1100

fn failNodeFmt( self: Parser, node: Zoir.Node.Index, comptime fmt: []const u8, args: anytype, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
node: Zoir.Node.Index
fmt: []const u8

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failToken

type-function

Source line 1111

fn failToken( self: Parser, failure: Diagnostics.Error, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
failure: Diagnostics.Error

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failTokenFmt

type-function

Source line 1070

fn failTokenFmt( self: Parser, token: Ast.TokenIndex, offset: u32, comptime fmt: []const u8, args: anytype, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
token: Ast.TokenIndex
offset: u32
fmt: []const u8

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failTokenFmtNote

type-function

Source line 1081

fn failTokenFmtNote( self: Parser, token: Ast.TokenIndex, offset: u32, comptime fmt: []const u8, args: anytype, notes: []Diagnostics.Note, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
token: Ast.TokenIndex
offset: u32
fmt: []const u8
notes: []Diagnostics.Note

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.failUnexpected

type-function

Source line 1144

fn failUnexpected( self: Parser, T: type, item_kind: []const u8, node: Zoir.Node.Index, field: ?usize, name: []const u8, ) error{ OutOfMemory, ParseZon }

Parameters

self: Parser
T: type
item_kind: []const u8
node: Zoir.Node.Index
field: ?usize
name: []const u8

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.parseArrayInto

function

Source line 817

fn parseArrayInto(self: *Parser, node: Zoir.Node.Index, out: anytype) !void

Parameters

self: *Parser
node: Zoir.Node.Index

std.zon.parse.Parser.parseBool

function

Source line 688

fn parseBool(self: Parser, node: Zoir.Node.Index) !bool

Parameters

self: Parser
node: Zoir.Node.Index

std.zon.parse.Parser.parseEnumLiteral

function

Source line 728

fn parseEnumLiteral(self: Parser, T: type, node: Zoir.Node.Index) !T

Parameters

self: Parser
T: type
node: Zoir.Node.Index

std.zon.parse.Parser.ParseExprError

error-set

Source line 519

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.ParseExprInnerError

error-set

Source line 533

Errors

OutOfMemory
ParseZon
WrongType

std.zon.parse.Parser.parseExprInto

function

Source line 521

fn parseExprInto( self: *Parser, node: Zoir.Node.Index, out: anytype, initialized: bool, ) ParseExprError!void

Parameters

self: *Parser
node: Zoir.Node.Index
initialized: bool

Errors

OutOfMemory
ParseZon

std.zon.parse.Parser.parseExprIntoInner

function

Source line 535

fn parseExprIntoInner( self: *@This(), node: Zoir.Node.Index, out: anytype, initialized: bool, ) ParseExprInnerError!void

Parameters

self: *@This()
node: Zoir.Node.Index
initialized: bool

Errors

OutOfMemory
ParseZon
WrongType

std.zon.parse.Parser.parseFloat

function

Source line 713

fn parseFloat(self: Parser, T: type, node: Zoir.Node.Index) !T

Parameters

self: Parser
T: type
node: Zoir.Node.Index

std.zon.parse.Parser.parseInt

function

Source line 696

fn parseInt(self: Parser, T: type, node: Zoir.Node.Index) !T

Parameters

self: Parser
T: type
node: Zoir.Node.Index

std.zon.parse.Parser.parseSlice

function

Source line 792

fn parseSlice(self: *Parser, T: type, nodes: Zoir.Node.Index.Range) !T

Parameters

self: *Parser
T: type
nodes: Zoir.Node.Index.Range

std.zon.parse.Parser.parseSlicePointer

function

Source line 748

fn parseSlicePointer(self: *Parser, T: type, node: Zoir.Node.Index) ParseExprInnerError!T

Parameters

self: *Parser
T: type
node: Zoir.Node.Index

Errors

OutOfMemory
ParseZon
WrongType

std.zon.parse.Parser.parseString

function

Source line 757

fn parseString(self: *Parser, T: type, node: Zoir.Node.Index) ParseExprInnerError!T

Parameters

self: *Parser
T: type
node: Zoir.Node.Index

Errors

OutOfMemory
ParseZon
WrongType

std.zon.parse.Parser.parseStructInto

function

Source line 858

fn parseStructInto( self: *Parser, node: Zoir.Node.Index, out: anytype, initialized: bool, ) !void

Parameters

self: *Parser
node: Zoir.Node.Index
initialized: bool

std.zon.parse.Parser.parseTupleInto

function

Source line 933

fn parseTupleInto(self: *Parser, node: Zoir.Node.Index, out: anytype) !void

Parameters

self: *Parser
node: Zoir.Node.Index

std.zon.parse.Parser.parseUnionInto

function

Source line 968

fn parseUnionInto( self: *Parser, node: Zoir.Node.Index, out: anytype, initialized: bool, ) !void

Parameters

self: *Parser
node: Zoir.Node.Index
initialized: bool

std.zon.parse.Parser.parseVectorInto

function

Source line 851

fn parseVectorInto(self: *Parser, node: Zoir.Node.Index, out: anytype) !void

Parameters

self: *Parser
node: Zoir.Node.Index

std.zon.parse.requiresAllocator

function

Source line 491

fn requiresAllocator(T: type) bool

Parameters

T: type

std.zon.parse.std

alias

Source line 9

Alias of std

std.zon.parse.StrLitErr

alias

Source line 17

Alias of std.zig.string_literal.Error

std.zon.parse.TokenIndex

alias

Source line 15

Alias of std.zig.Ast.TokenIndex

std.zon.parse.updateFromSlice

function

Source line 267

Similar to fromSlice, but updates the existing contents of value in place. Fields unspecified by ZON are left unchanged.

Assumes that value points to a fully initialized value prior to this call. Slices and untagged unions are replaced in their entirey when specified. On error, value remains valid, but may be partially updated.

pub fn updateFromSlice( T: type, value: *T, options: Options, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
options: Options

Errors

OutOfMemory
ParseZon

Example usage

test updateFromSlice {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();

    const MyTextEditorConfig = struct {
        indentation: enum { spaces, tabs },
        columns: []const u16,
        dark_mode: enum { auto, dark, light },
        theme: []const u8,
    };

    const global_config =
        \\.{
        \\    .indentation = .spaces,
        \\    .columns = .{ 100 },
        \\    .dark_mode = .dark,
        \\}
    ;
    const project_config =
        \\.{
        \\    .indentation = .tabs,
        \\}
    ;

    var config: MyTextEditorConfig = .{
        .indentation = .spaces,
        .columns = &.{},
        .dark_mode = .auto,
        .theme = "default",
    };

    var diagnostics: Diagnostics = undefined;
    updateFromSlice(MyTextEditorConfig, &config, .{
        .gpa = gpa,
        .arena = arena,
        .source = global_config,
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return err,
        error.ParseZon => {
            diagnostics.log("global_config.zon");
            return err;
        },
    };
    updateFromSlice(MyTextEditorConfig, &config, .{
        .gpa = gpa,
        .arena = arena,
        .source = project_config,
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return err,
        error.ParseZon => {
            diagnostics.log("project_config.zon");
            return err;
        },
    };

    try std.testing.expectEqualDeep(MyTextEditorConfig{
        .indentation = .tabs,
        .columns = &.{100},
        .dark_mode = .dark,
        .theme = "default",
    }, config);
}

std.zon.parse.updateFromSliceNoAlloc

function

Source line 344

Like updateFromSlice but the T may not contain pointers, allowing value to outlive options.arena.

pub fn updateFromSliceNoAlloc( T: type, value: *T, options: Options, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
options: Options

Errors

OutOfMemory
ParseZon

std.zon.parse.updateFromZoir

function

Source line 408

Like updateFromSlice, but operates on Zoir instead of ZON source.

pub fn updateFromZoir( T: type, value: *T, options: FromZoirOptions, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
options: FromZoirOptions

Errors

OutOfMemory
ParseZon

std.zon.parse.updateFromZoirNoAlloc

function

Source line 417

Like updateFromSliceNoAlloc, but operates on Zoir instead of ZON source.

pub fn updateFromZoirNoAlloc( T: type, value: *T, options: FromZoirOptions, ) error{ OutOfMemory, ParseZon }!void

Parameters

T: type
value: *T
options: FromZoirOptions

Errors

OutOfMemory
ParseZon

std.zon.parse.valid_types

constant

Source line 24

Rename when adding or removing support for a type.

std.zon.parse.Zoir

alias

Source line 13

Alias of std.zig.Zoir

std.zon.parse.ZonGen

alias

Source line 14

Alias of std.zig.ZonGen

Source code

std/zon/parse.zig

//! Use `fromSlice`/`fromSlice` to parse a ZON string into a Zig value. Human readable errors
//! are written to an out parameter.
//!
//! If your data is already available in tree form, consider `fromZoir`/`fromZoir`.
//!
//! To parse into an existing value, see the `updateFrom*` variants. For lower level control over
//! parsing, see `std.zig.ZonGen`. For importing ZON at compile time, use `@import`.

const std = @import("std");
const builtin = @import("builtin");
const Allocator = std.mem.Allocator;
const Ast = std.zig.Ast;
const Zoir = std.zig.Zoir;
const ZonGen = std.zig.ZonGen;
const TokenIndex = std.zig.Ast.TokenIndex;
const Base = std.zig.number_literal.Base;
const StrLitErr = std.zig.string_literal.Error;
const NumberLiteralError = std.zig.number_literal.Error;
const assert = std.debug.assert;
const ArrayList = std.ArrayList;
const ArenaAllocator = std.heap.ArenaAllocator;

/// Rename when adding or removing support for a type.
const valid_types = {};

/// Errors encountered while parsing ZON. See `log` and `fatal` for reporting errors to the user.
pub const Diagnostics = struct {
    errors: []const Error,

    /// Log the failure with `std.log.err`.
    pub fn log(self: *const Diagnostics, path: []const u8) void {
        std.log.err("{f}", .{self.fmt(path)});
    }

    test log {
        const gpa = std.testing.allocator;
        var arena_allocator: ArenaAllocator = .init(gpa);
        defer arena_allocator.deinit();
        const arena = arena_allocator.allocator();
        var diagnostics: Diagnostics = undefined;

        const MyType = struct {
            foo: u32,
            bar: u32,
        };

        const parsed: MyType = fromSliceNoAlloc(MyType, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = 1, .bar = 2 }",
            .diagnostics = &diagnostics,
        }) catch |err| switch (err) {
            error.OutOfMemory => return error.OutOfMemory,
            error.ParseZon => b: {
                diagnostics.log("input.zon");
                break :b .{ .foo = 0, .bar = 0 };
            },
        };
        _ = parsed;
    }

    /// Log the failure with `std.log.err`, and then terminate the process with exit code 1.
    pub fn fatal(self: *const Diagnostics, path: []const u8) noreturn {
        std.process.fatal("{f}", .{self.fmt(path)});
    }

    test fatal {
        const gpa = std.testing.allocator;
        var arena_allocator: ArenaAllocator = .init(gpa);
        defer arena_allocator.deinit();
        const arena = arena_allocator.allocator();
        var diagnostics: Diagnostics = undefined;

        const MyType = struct {
            foo: u32,
            bar: u32,
        };

        const parsed = fromSliceNoAlloc(MyType, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = 1, .bar = 2 }",
            .diagnostics = &diagnostics,
        }) catch |err| switch (err) {
            error.OutOfMemory => return error.OutOfMemory,
            error.ParseZon => diagnostics.fatal("input.zon"),
        };
        _ = parsed;
    }

    /// Formats a human readable description of any errors.
    pub fn fmt(self: *const Diagnostics, path: []const u8) Formatter {
        return .{
            .errors = self.errors,
            .path = path,
        };
    }

    fn astLoc(
        ast: *const Ast,
        maybe_token: Ast.OptionalTokenIndex,
        node_or_offset: u32,
    ) Ast.Location {
        if (maybe_token.unwrap()) |token| {
            var loc = ast.tokenLocation(0, token);
            loc.column += node_or_offset;
            return loc;
        } else {
            const ast_node: Ast.Node.Index = @fromBackingInt(@intCast(node_or_offset));
            const token = ast.nodeMainToken(ast_node);
            return ast.tokenLocation(0, token);
        }
    }

    pub const Formatter = struct {
        path: []const u8,
        errors: []const Error,

        pub fn format(self: *const @This(), w: *std.Io.Writer) std.Io.Writer.Error!void {
            for (self.errors) |e| {
                try w.print("{s}:", .{self.path});
                try w.print("{d}:{d}: error: {s}\n", .{
                    e.loc.line + 1,
                    e.loc.column + 1,
                    e.msg,
                });

                for (e.notes) |note| {
                    try w.print("{s}:", .{self.path});
                    try w.print("{d}:{d}: note: {s}\n", .{
                        note.loc.line + 1,
                        note.loc.column + 1,
                        note.msg,
                    });
                }
            }
        }
    };

    pub const Error = struct {
        msg: []const u8,
        loc: Ast.Location,
        token: Ast.OptionalTokenIndex,
        /// If `token == .none`, this is an `Ast.Node.Index`.
        /// Otherwise, this is a byte offset into `token`.
        node_or_offset: u32,
        notes: []Note,

        const Options = struct {
            msg: []const u8,
            token: Ast.OptionalTokenIndex,
            node_or_offset: u32,
            notes: []Note,
        };

        fn init(ast: *const Ast, options: Error.Options) Error {
            return .{
                .msg = options.msg,
                .loc = astLoc(ast, options.token, options.node_or_offset),
                .token = options.token,
                .node_or_offset = options.node_or_offset,
                .notes = options.notes,
            };
        }
    };

    pub const Note = struct {
        msg: []const u8,
        loc: Ast.Location,
        token: Ast.OptionalTokenIndex,
        /// If `token == .none`, this is an `Ast.Node.Index`.
        /// Otherwise, this is a byte offset into `token`.
        node_or_offset: u32,

        const Options = struct {
            msg: []const u8,
            token: Ast.OptionalTokenIndex,
            node_or_offset: u32,
        };

        fn init(ast: *const Ast, options: Note.Options) @This() {
            return .{
                .msg = options.msg,
                .loc = astLoc(ast, options.token, options.node_or_offset),
                .token = options.token,
                .node_or_offset = options.node_or_offset,
            };
        }
    };
};

pub const Options = struct {
    /// Used for scratch allocations.
    gpa: Allocator,
    /// Used for allocating diagnostics and results.
    arena: Allocator,
    /// The ZON source to parse.
    source: [:0]const u8,
    /// Initialized by the callee with a human readable description of any parse errors that
    /// occured.
    diagnostics: *Diagnostics,
    /// If true, unknown fields do not error.
    ignore_unknown_fields: bool = false,
};

/// Parses the given slice as ZON, writing any errors to `options.diagnostics`.
pub fn fromSlice(T: type, options: Options) error{ OutOfMemory, ParseZon }!T {
    var value: T = undefined;
    try fromSliceInner(T, &value, false, options);
    return value;
}

test fromSlice {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();

    const TextureOptions = struct {
        const AddressMode = enum { clamp, reflect, wrap, zero };
        address_mode: struct { u: AddressMode = .wrap, v: AddressMode = .wrap },
        mipmaps: bool = true,
        premultiply: bool = true,
    };

    const source =
        \\.{
        \\    .address_mode = .{ .u = .clamp },
        \\    .mipmaps = false,
        \\}
    ;

    var diagnostics: Diagnostics = undefined;
    const options = fromSlice(TextureOptions, .{
        .gpa = gpa,
        .arena = arena,
        .source = source,
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return err,
        error.ParseZon => {
            diagnostics.log("texture_options.zon");
            return err;
        },
    };

    try std.testing.expectEqualDeep(TextureOptions{
        .address_mode = .{ .u = .clamp, .v = .wrap },
        .mipmaps = false,
        .premultiply = true,
    }, options);
}

/// Like `fromSlice` but the result type may not contain pointers, allowing it to outlive
/// `options.arena`.
pub fn fromSliceNoAlloc(T: type, options: Options) error{ OutOfMemory, ParseZon }!T {
    comptime assert(!requiresAllocator(T));
    return fromSlice(T, options);
}

/// Similar to `fromSlice`, but updates the existing contents of `value` in place. Fields
/// unspecified by ZON are left unchanged.
///
/// Assumes that `value` points to a fully initialized value prior to this call. Slices and untagged
/// unions are replaced in their entirey when specified. On error, `value` remains valid, but may be
/// partially updated.
pub fn updateFromSlice(
    T: type,
    value: *T,
    options: Options,
) error{ OutOfMemory, ParseZon }!void {
    try fromSliceInner(T, value, true, options);
}

test updateFromSlice {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();

    const MyTextEditorConfig = struct {
        indentation: enum { spaces, tabs },
        columns: []const u16,
        dark_mode: enum { auto, dark, light },
        theme: []const u8,
    };

    const global_config =
        \\.{
        \\    .indentation = .spaces,
        \\    .columns = .{ 100 },
        \\    .dark_mode = .dark,
        \\}
    ;
    const project_config =
        \\.{
        \\    .indentation = .tabs,
        \\}
    ;

    var config: MyTextEditorConfig = .{
        .indentation = .spaces,
        .columns = &.{},
        .dark_mode = .auto,
        .theme = "default",
    };

    var diagnostics: Diagnostics = undefined;
    updateFromSlice(MyTextEditorConfig, &config, .{
        .gpa = gpa,
        .arena = arena,
        .source = global_config,
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return err,
        error.ParseZon => {
            diagnostics.log("global_config.zon");
            return err;
        },
    };
    updateFromSlice(MyTextEditorConfig, &config, .{
        .gpa = gpa,
        .arena = arena,
        .source = project_config,
        .diagnostics = &diagnostics,
    }) catch |err| switch (err) {
        error.OutOfMemory => return err,
        error.ParseZon => {
            diagnostics.log("project_config.zon");
            return err;
        },
    };

    try std.testing.expectEqualDeep(MyTextEditorConfig{
        .indentation = .tabs,
        .columns = &.{100},
        .dark_mode = .dark,
        .theme = "default",
    }, config);
}

/// Like `updateFromSlice` but the `T` may not contain pointers, allowing `value` to outlive
/// `options.arena`.
pub fn updateFromSliceNoAlloc(
    T: type,
    value: *T,
    options: Options,
) error{ OutOfMemory, ParseZon }!void {
    comptime assert(!requiresAllocator(T));
    try fromSliceInner(T, value, true, options);
}

fn fromSliceInner(
    T: type,
    value: *T,
    initialized: bool,
    options: Options,
) error{ OutOfMemory, ParseZon }!void {
    var errors: std.ArrayList(Diagnostics.Error) = .empty;
    defer options.diagnostics.* = .{ .errors = errors.items };

    var ast = try std.zig.Ast.parse(options.gpa, options.source, .{ .mode = .zon });
    defer ast.deinit(options.gpa);

    var zoir = try ZonGen.generate(options.gpa, ast, .{ .parse_str_lits = false });
    defer zoir.deinit(options.gpa);

    try inner(T, value, initialized, .{
        .arena = options.arena,
        .ast = &ast,
        .zoir = &zoir,
        .node = .root,
        .errors = &errors,
        .ignore_unknown_fields = options.ignore_unknown_fields,
    });
}

pub const FromZoirOptions = struct {
    /// Used for allocating diagnostics and results.
    arena: Allocator,
    /// The AST for this ZON value.
    ast: *const Ast,
    /// The zig object intermediate representation of this ZON value.
    zoir: *const Zoir,
    /// The node to start parsing at.
    node: Zoir.Node.Index = .root,
    /// Initialized by the callee with a human readable description of any parse errors that
    /// occured.
    diagnostics: *Diagnostics,
    /// If true, unknown fields do not error.
    ignore_unknown_fields: bool = false,
};

/// Like `fromSlice`, but operates on `Zoir` instead of ZON source.
pub fn fromZoir(T: type, options: FromZoirOptions) error{ OutOfMemory, ParseZon }!T {
    var value: T = undefined;
    try fromZoirInner(T, &value, false, options);
    return value;
}

/// Like `fromSliceNoAlloc`, but operates on `Zoir` instead of ZON source.
pub fn fromZoirNoAlloc(T: type, options: FromZoirOptions) error{ OutOfMemory, ParseZon }!T {
    comptime assert(!requiresAllocator(T));
    return fromZoir(T, options);
}

/// Like `updateFromSlice`, but operates on `Zoir` instead of ZON source.
pub fn updateFromZoir(
    T: type,
    value: *T,
    options: FromZoirOptions,
) error{ OutOfMemory, ParseZon }!void {
    return fromZoirInner(T, value, true, options);
}

/// Like `updateFromSliceNoAlloc`, but operates on `Zoir` instead of ZON source.
pub fn updateFromZoirNoAlloc(
    T: type,
    value: *T,
    options: FromZoirOptions,
) error{ OutOfMemory, ParseZon }!void {
    comptime assert(!requiresAllocator(T));
    return updateFromZoir(T, value, options);
}

fn fromZoirInner(
    T: type,
    value: *T,
    initialized: bool,
    options: FromZoirOptions,
) error{ OutOfMemory, ParseZon }!void {
    var errors: std.ArrayList(Diagnostics.Error) = .empty;
    defer options.diagnostics.* = .{ .errors = errors.items };
    return inner(T, value, initialized, .{
        .arena = options.arena,
        .ast = options.ast,
        .zoir = options.zoir,
        .errors = &errors,
        .ignore_unknown_fields = options.ignore_unknown_fields,
    });
}

const InnerOptions = struct {
    arena: Allocator,
    ast: *const Ast,
    zoir: *const Zoir,
    node: Zoir.Node.Index = .root,
    errors: *std.ArrayList(Diagnostics.Error),
    ignore_unknown_fields: bool,
};

fn inner(
    T: type,
    value: *T,
    initialized: bool,
    options: InnerOptions,
) error{ OutOfMemory, ParseZon }!void {
    comptime assert(canParseType(T));

    if (options.zoir.hasCompileErrors()) {
        for (options.zoir.compile_errors) |e| {
            var notes: std.ArrayList(Diagnostics.Note) = .empty;
            for (e.getNotes(options.zoir)) |note| {
                try notes.append(options.arena, .init(options.ast, .{
                    .msg = try options.arena.dupe(u8, note.msg.get(options.zoir)),
                    .token = note.token,
                    .node_or_offset = note.node_or_offset,
                }));
            }
            try options.errors.append(options.arena, .init(options.ast, .{
                .msg = try options.arena.dupe(u8, e.msg.get(options.zoir)),
                .token = e.token,
                .node_or_offset = e.node_or_offset,
                .notes = notes.items,
            }));
        }
        return error.ParseZon;
    }

    var parser: Parser = .{
        .arena = options.arena,
        .ast = options.ast,
        .zoir = options.zoir,
        .ignore_unknown_fields = options.ignore_unknown_fields,
        .errors = options.errors,
    };

    try parser.parseExprInto(options.node, value, initialized);
}

fn requiresAllocator(T: type) bool {
    _ = valid_types;
    return switch (@typeInfo(T)) {
        .pointer => true,
        .array => |array| return array.len > 0 and requiresAllocator(array.child),
        .@"struct" => |@"struct"| inline for (@"struct".field_types) |field_type| {
            if (requiresAllocator(field_type)) {
                break true;
            }
        } else false,
        .@"union" => |@"union"| inline for (@"union".field_types) |field_type| {
            if (requiresAllocator(field_type)) {
                break true;
            }
        } else false,
        .optional => |optional| requiresAllocator(optional.child),
        .vector => |vector| return vector.len > 0 and requiresAllocator(vector.child),
        else => false,
    };
}

const Parser = struct {
    arena: Allocator,
    ast: *const Ast,
    zoir: *const Zoir,
    errors: *std.ArrayList(Diagnostics.Error),
    ignore_unknown_fields: bool,

    const ParseExprError = error{ ParseZon, OutOfMemory };

    fn parseExprInto(
        self: *Parser,
        node: Zoir.Node.Index,
        out: anytype,
        initialized: bool,
    ) ParseExprError!void {
        return self.parseExprIntoInner(node, out, initialized) catch |err| switch (err) {
            error.WrongType => return self.failExpectedType(@TypeOf(out.*), node),
            else => |e| return e,
        };
    }

    const ParseExprInnerError = error{ ParseZon, OutOfMemory, WrongType };

    fn parseExprIntoInner(
        self: *@This(),
        node: Zoir.Node.Index,
        out: anytype,
        initialized: bool,
    ) ParseExprInnerError!void {
        if (@TypeOf(out.*) == Zoir.Node.Index) {
            out.* = node;
            return;
        }

        switch (@typeInfo(@TypeOf(out.*))) {
            .optional => |optional| if (node.get(self.zoir) == .null) {
                out.* = null;
            } else if (initialized and out.* != null) {
                try self.parseExprIntoInner(node, &out.*.?, true);
            } else {
                var some: optional.child = undefined;
                try self.parseExprIntoInner(node, &some, false);
                out.* = some;
            },
            .bool => out.* = try self.parseBool(node),
            .int => out.* = try self.parseInt(@TypeOf(out.*), node),
            .float => out.* = try self.parseFloat(@TypeOf(out.*), node),
            .@"enum" => out.* = try self.parseEnumLiteral(@TypeOf(out.*), node),
            .pointer => |pointer| switch (pointer.size) {
                .one => {
                    // Get a pointer to update
                    const new = b: {
                        // If the existing value is initialized and non const, use it
                        if (initialized and !pointer.attrs.@"const") break :b out.*;
                        // Otherwise, allocate new memory
                        const new = try self.arena.alignedCreate(
                            pointer.child,
                            if (pointer.attrs.@"align") |a| .fromByteUnits(a) else null,
                        );
                        // If the original value was initialized, dupe it into the new memory
                        if (initialized) new.* = out.*.*;
                        break :b new;
                    };
                    try self.parseExprIntoInner(
                        node,
                        new,
                        initialized,
                    );
                    out.* = new;
                },
                .slice => {
                    // Slices are replaced wholesale since ZON doesn't have syntax for specifying
                    // just a part of a slice.
                    const new = b: {
                        const new = try self.parseSlicePointer(@TypeOf(out.*), node);
                        break :b new;
                    };
                    out.* = new;
                },
                else => comptime unreachable,
            },
            .array => try self.parseArrayInto(node, out),
            .vector => try self.parseVectorInto(node, out),
            .@"struct" => |@"struct"| if (@"struct".is_tuple)
                try self.parseTupleInto(node, out)
            else
                try self.parseStructInto(node, out, initialized),
            .@"union" => try self.parseUnionInto(node, out, initialized),

            else => comptime unreachable,
        }
    }

    /// Prints a message of the form `expected T` where T is first converted to a ZON type. For
    /// example, `**?**u8` becomes `?u8`, and types that involve user specified type names are just
    /// referred to by the type of container.
    fn failExpectedType(
        self: Parser,
        T: type,
        node: Zoir.Node.Index,
    ) error{ ParseZon, OutOfMemory } {
        @branchHint(.cold);
        return self.failExpectedTypeInner(T, false, node);
    }

    fn failExpectedTypeInner(
        self: Parser,
        T: type,
        opt: bool,
        node: Zoir.Node.Index,
    ) error{ ParseZon, OutOfMemory } {
        _ = valid_types;
        switch (@typeInfo(T)) {
            .@"struct" => |@"struct"| if (@"struct".is_tuple) {
                if (opt) {
                    return self.failNode(node, "expected optional tuple");
                } else {
                    return self.failNode(node, "expected tuple");
                }
            } else {
                if (opt) {
                    return self.failNode(node, "expected optional struct");
                } else {
                    return self.failNode(node, "expected struct");
                }
            },
            .@"union" => if (opt) {
                return self.failNode(node, "expected optional union");
            } else {
                return self.failNode(node, "expected union");
            },
            .array => if (opt) {
                return self.failNode(node, "expected optional array");
            } else {
                return self.failNode(node, "expected array");
            },
            .pointer => |pointer| switch (pointer.size) {
                .one => return self.failExpectedTypeInner(pointer.child, opt, node),
                .slice => {
                    if (pointer.child == u8 and
                        pointer.attrs.@"const" and
                        (pointer.sentinel() == null or pointer.sentinel() == 0) and
                        (pointer.attrs.@"align" == null or pointer.attrs.@"align" == 1))
                    {
                        if (opt) {
                            return self.failNode(node, "expected optional string");
                        } else {
                            return self.failNode(node, "expected string");
                        }
                    } else {
                        if (opt) {
                            return self.failNode(node, "expected optional array");
                        } else {
                            return self.failNode(node, "expected array");
                        }
                    }
                },
                else => comptime unreachable,
            },
            .vector, .bool, .int, .float => if (opt) {
                return self.failNodeFmt(node, "expected type '{s}'", .{@typeName(?T)});
            } else {
                return self.failNodeFmt(node, "expected type '{s}'", .{@typeName(T)});
            },
            .@"enum" => if (opt) {
                return self.failNode(node, "expected optional enum literal");
            } else {
                return self.failNode(node, "expected enum literal");
            },
            .optional => |optional| {
                return self.failExpectedTypeInner(optional.child, true, node);
            },
            else => comptime unreachable,
        }
    }

    fn parseBool(self: Parser, node: Zoir.Node.Index) !bool {
        switch (node.get(self.zoir)) {
            .true => return true,
            .false => return false,
            else => return error.WrongType,
        }
    }

    fn parseInt(self: Parser, T: type, node: Zoir.Node.Index) !T {
        switch (node.get(self.zoir)) {
            .int_literal => |int| switch (int) {
                .small => |val| return std.math.cast(T, val) orelse
                    self.failCannotRepresent(T, node),
                .big => |val| return val.toInt(T) catch
                    self.failCannotRepresent(T, node),
            },
            .float_literal => |val| return intFromFloatExact(T, val) orelse
                self.failCannotRepresent(T, node),

            .char_literal => |val| return std.math.cast(T, val) orelse
                self.failCannotRepresent(T, node),
            else => return error.WrongType,
        }
    }

    fn parseFloat(self: Parser, T: type, node: Zoir.Node.Index) !T {
        switch (node.get(self.zoir)) {
            .int_literal => |int| switch (int) {
                .small => |val| return @floatFromInt(val),
                .big => |val| return val.toFloat(T, .nearest_even)[0],
            },
            .float_literal => |val| return @floatCast(val),
            .pos_inf => return std.math.inf(T),
            .neg_inf => return -std.math.inf(T),
            .nan => return std.math.nan(T),
            .char_literal => |val| return @floatFromInt(val),
            else => return error.WrongType,
        }
    }

    fn parseEnumLiteral(self: Parser, T: type, node: Zoir.Node.Index) !T {
        switch (node.get(self.zoir)) {
            .enum_literal => |field_name| {
                // Create a comptime string map for the enum fields
                const enum_info = @typeInfo(T).@"enum";
                comptime var kvs_list: [enum_info.field_names.len]struct { []const u8, T } = undefined;
                inline for (enum_info.field_names, enum_info.field_values, 0..) |enum_field_name, enum_field_value, i| {
                    kvs_list[i] = .{ enum_field_name, @fromBackingInt(@intCast(enum_field_value)) };
                }
                const enum_tags = std.StaticStringMap(T).initComptime(kvs_list);

                // Get the tag if it exists
                const field_name_str = field_name.get(self.zoir);
                return enum_tags.get(field_name_str) orelse
                    self.failUnexpected(T, "enum literal", node, null, field_name_str);
            },
            else => return error.WrongType,
        }
    }

    fn parseSlicePointer(self: *Parser, T: type, node: Zoir.Node.Index) ParseExprInnerError!T {
        switch (node.get(self.zoir)) {
            .string_literal => return self.parseString(T, node),
            .array_literal => |nodes| return self.parseSlice(T, nodes),
            .empty_literal => return self.parseSlice(T, .{ .start = node, .len = 0 }),
            else => return error.WrongType,
        }
    }

    fn parseString(self: *Parser, T: type, node: Zoir.Node.Index) ParseExprInnerError!T {
        const ast_node = node.getAstNode(self.zoir);
        const pointer = @typeInfo(T).pointer;
        var size_hint = ZonGen.strLitSizeHint(self.ast, ast_node);
        if (pointer.sentinel() != null) size_hint += 1;

        var aw: std.Io.Writer.Allocating = .init(self.arena);
        try aw.ensureUnusedCapacity(size_hint);
        defer aw.deinit();
        const result = ZonGen.parseStrLit(self.ast, ast_node, &aw.writer) catch return error.OutOfMemory;
        switch (result) {
            .success => {},
            .failure => |err| {
                const token = self.ast.nodeMainToken(ast_node);
                const raw_string = self.ast.tokenSlice(token);
                return self.failTokenFmt(token, @intCast(err.offset()), "{f}", .{err.fmt(raw_string)});
            },
        }

        if (pointer.child != u8 or
            pointer.size != .slice or
            !pointer.attrs.@"const" or
            (pointer.sentinel() != null and pointer.sentinel() != 0) or
            (pointer.attrs.@"align" != null and pointer.attrs.@"align" != 1))
        {
            return error.WrongType;
        }

        if (pointer.sentinel() != null) {
            return aw.toOwnedSliceSentinel(0);
        } else {
            return aw.toOwnedSlice();
        }
    }

    fn parseSlice(self: *Parser, T: type, nodes: Zoir.Node.Index.Range) !T {
        const pointer = @typeInfo(T).pointer;

        // Make sure we're working with a slice
        switch (pointer.size) {
            .slice => {},
            .one, .many, .c => comptime unreachable,
        }

        // Allocate the slice
        const slice = try self.arena.allocWithOptions(
            pointer.child,
            nodes.len,
            .fromByteUnitsOptional(pointer.attrs.@"align"),
            pointer.sentinel(),
        );

        // Parse the elements and return the slice
        for (slice, 0..) |*elem, i| {
            try self.parseExprInto(nodes.at(@intCast(i)), elem, false);
        }

        return slice;
    }

    fn parseArrayInto(self: *Parser, node: Zoir.Node.Index, out: anytype) !void {
        const nodes: Zoir.Node.Index.Range = switch (node.get(self.zoir)) {
            .array_literal => |nodes| nodes,
            .empty_literal => .{ .start = node, .len = 0 },
            else => return error.WrongType,
        };

        const array = @typeInfo(@TypeOf(out.*)).array;

        // Check if the size matches
        if (nodes.len < array.len) {
            return self.failNodeFmt(
                node,
                "expected {} array elements; found {}",
                .{ array.len, nodes.len },
            );
        } else if (nodes.len > array.len) {
            return self.failNodeFmt(
                nodes.at(array.len),
                "index {} outside of array of length {}",
                .{ array.len, array.len },
            );
        }

        // Parse the elements and return the array
        for (out, 0..) |*elem, i| {
            try self.parseExprInto(nodes.at(@intCast(i)), elem, false);
        }

        if (array.sentinel()) |s| {
            out[array.len] = s;
        }
    }

    fn parseVectorInto(self: *Parser, node: Zoir.Node.Index, out: anytype) !void {
        const vector = @typeInfo(@TypeOf(out.*)).vector;
        var array: [vector.len]vector.child = undefined;
        try self.parseArrayInto(node, &array);
        out.* = array;
    }

    fn parseStructInto(
        self: *Parser,
        node: Zoir.Node.Index,
        out: anytype,
        initialized: bool,
    ) !void {
        const repr = node.get(self.zoir);
        const fields: @FieldType(Zoir.Node, "struct_literal") = switch (repr) {
            .struct_literal => |nodes| nodes,
            .empty_literal => .{ .names = &.{}, .vals = .{ .start = node, .len = 0 } },
            else => return error.WrongType,
        };

        const info = @typeInfo(@TypeOf(out.*)).@"struct";

        // Build a map from field name to index.
        // The special value `comptime_field` indicates that this is actually a comptime field.
        const comptime_field = std.math.maxInt(usize);
        const field_indices: std.StaticStringMap(usize) = comptime b: {
            var kvs_list: [info.field_names.len]struct { []const u8, usize } = undefined;
            for (&kvs_list, info.field_names, info.field_attrs, 0..) |*kv, field_name, field_attrs, i| {
                kv.* = .{ field_name, if (field_attrs.@"comptime") comptime_field else i };
            }
            break :b .initComptime(kvs_list);
        };

        // Parse the struct
        var field_found: [info.field_names.len]bool = @splat(false);
        for (0..fields.names.len) |i| {
            const name = fields.names[i].get(self.zoir);
            const field_index = field_indices.get(name) orelse {
                if (self.ignore_unknown_fields) continue;
                return self.failUnexpected(@TypeOf(out.*), "field", node, i, name);
            };
            if (field_index == comptime_field) {
                return self.failComptimeField(node, i);
            }

            // Mark the field as found. Assert that the found array is not zero length to satisfy
            // the type checker (it can't be since we made it into an iteration of this loop.)
            if (field_found.len == 0) unreachable;
            field_found[field_index] = true;

            switch (field_index) {
                inline 0...(info.field_names.len - 1) => |j| {
                    if (info.field_attrs[j].@"comptime") unreachable;
                    try self.parseExprInto(
                        fields.vals.at(@intCast(i)),
                        &@field(out, info.field_names[j]),
                        initialized,
                    );
                },
                else => unreachable, // Can't be out of bounds
            }
        }

        // Fill in any missing default fields
        if (!initialized) {
            inline for (field_found, 0..) |found, i| {
                if (!found) {
                    const field_attrs = info.field_attrs[i];
                    if (field_attrs.defaultValue(info.field_types[i])) |default| {
                        @field(out, info.field_names[i]) = default;
                    } else {
                        return self.failNodeFmt(
                            node,
                            "missing required field {s}",
                            .{info.field_names[i]},
                        );
                    }
                }
            }
        }
    }

    fn parseTupleInto(self: *Parser, node: Zoir.Node.Index, out: anytype) !void {
        const nodes: Zoir.Node.Index.Range = switch (node.get(self.zoir)) {
            .array_literal => |nodes| nodes,
            .empty_literal => .{ .start = node, .len = 0 },
            else => return error.WrongType,
        };

        const info = @typeInfo(@TypeOf(out.*)).@"struct";

        if (nodes.len > info.field_names.len) {
            return self.failNodeFmt(
                nodes.at(info.field_names.len),
                "index {} outside of tuple length {}",
                .{ info.field_names.len, info.field_names.len },
            );
        }

        inline for (0..info.field_names.len) |i| {
            // Check if we're out of bounds
            if (i >= nodes.len) {
                if (info.field_attrs[i].defaultValue(info.field_types[i])) |default| {
                    @field(out.*, info.field_names[i]) = default;
                } else {
                    return self.failNodeFmt(node, "missing tuple field with index {}", .{i});
                }
            } else {
                if (info.field_attrs[i].@"comptime") {
                    return self.failComptimeField(node, i);
                } else {
                    try self.parseExprInto(nodes.at(i), &out[i], false);
                }
            }
        }
    }

    fn parseUnionInto(
        self: *Parser,
        node: Zoir.Node.Index,
        out: anytype,
        initialized: bool,
    ) !void {
        const @"union" = @typeInfo(@TypeOf(out.*)).@"union";

        if (@"union".field_names.len == 0) comptime unreachable;

        // Gather info on the fields
        const field_indices = b: {
            comptime var kvs_list: [@"union".field_names.len]struct {
                []const u8,
                usize,
            } = undefined;
            inline for (@"union".field_names, 0..) |field_name, i| {
                kvs_list[i] = .{ field_name, i };
            }
            break :b std.StaticStringMap(usize).initComptime(kvs_list);
        };

        // Parse the union
        switch (node.get(self.zoir)) {
            .enum_literal => |field_name| {
                // The union must be tagged for an enum literal to coerce to it
                if (@"union".tag_type == null) {
                    return error.WrongType;
                }

                // Get the index of the named field. We don't use `parseEnum` here as
                // the order of the enum and the order of the union might not match!
                const field_index = b: {
                    const field_name_str = field_name.get(self.zoir);
                    break :b field_indices.get(field_name_str) orelse
                        return self.failUnexpected(
                            @TypeOf(out.*),
                            "field",
                            node,
                            null,
                            field_name_str,
                        );
                };

                // Initialize the union from the given field.
                switch (field_index) {
                    inline 0...@"union".field_names.len - 1 => |i| {
                        // Fail if the field is not void
                        if (@"union".field_types[i] != void)
                            return self.failNode(node, "expected union");

                        // Instantiate the union
                        out.* = @unionInit(@TypeOf(out.*), @"union".field_names[i], {});
                    },
                    else => unreachable, // Can't be out of bounds
                }
            },
            .struct_literal => |struct_fields| {
                if (struct_fields.names.len != 1) {
                    return error.WrongType;
                }

                // Fill in the field we found
                const field_name = struct_fields.names[0];
                const field_name_str = field_name.get(self.zoir);
                const field_val = struct_fields.vals.at(0);
                const field_index = field_indices.get(field_name_str) orelse
                    return self.failUnexpected(@TypeOf(out.*), "field", node, 0, field_name_str);

                switch (field_index) {
                    inline 0...@"union".field_names.len - 1 => |i| {
                        if (@"union".field_types[i] == void) {
                            return self.failNode(field_val, "expected type 'void'");
                        } else {
                            const field_initialized = b: {
                                if (!initialized) break :b false;
                                if (@"union".tag_type == null) break :b false;
                                const tag = @field(@"union".tag_type.?, @"union".field_names[i]);
                                if (out.* != tag) break :b false;
                                break :b true;
                            };
                            if (!field_initialized) {
                                out.* = @unionInit(
                                    @TypeOf(out.*),
                                    @"union".field_names[i],
                                    undefined,
                                );
                            }
                            try self.parseExprInto(
                                field_val,
                                &@field(out.*, @"union".field_names[i]),
                                field_initialized,
                            );
                        }
                    },
                    else => unreachable, // Can't be out of bounds
                }
            },
            else => return error.WrongType,
        }
    }

    fn failTokenFmt(
        self: Parser,
        token: Ast.TokenIndex,
        offset: u32,
        comptime fmt: []const u8,
        args: anytype,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        return self.failTokenFmtNote(token, offset, fmt, args, &.{});
    }

    fn failTokenFmtNote(
        self: Parser,
        token: Ast.TokenIndex,
        offset: u32,
        comptime fmt: []const u8,
        args: anytype,
        notes: []Diagnostics.Note,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        comptime assert(args.len > 0);
        try self.errors.append(self.arena, .init(self.ast, .{
            .token = .fromToken(token),
            .node_or_offset = offset,
            .msg = try std.fmt.allocPrint(self.arena, fmt, args),
            .notes = notes,
        }));
        return error.ParseZon;
    }

    fn failNodeFmt(
        self: Parser,
        node: Zoir.Node.Index,
        comptime fmt: []const u8,
        args: anytype,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        const token = self.ast.nodeMainToken(node.getAstNode(self.zoir));
        return self.failTokenFmt(token, 0, fmt, args);
    }

    fn failToken(
        self: Parser,
        failure: Diagnostics.Error,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        try self.errors.append(self.arena, failure);
        return error.ParseZon;
    }

    fn failNode(
        self: Parser,
        node: Zoir.Node.Index,
        msg: []const u8,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        const token = self.ast.nodeMainToken(node.getAstNode(self.zoir));
        return self.failToken(.init(self.ast, .{
            .token = .fromToken(token),
            .node_or_offset = 0,
            .msg = msg,
            .notes = &.{},
        }));
    }

    fn failCannotRepresent(
        self: Parser,
        T: type,
        node: Zoir.Node.Index,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        return self.failNodeFmt(node, "type '{s}' cannot represent value", .{@typeName(T)});
    }

    fn failUnexpected(
        self: Parser,
        T: type,
        item_kind: []const u8,
        node: Zoir.Node.Index,
        field: ?usize,
        name: []const u8,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        const token = if (field) |f| b: {
            var buf: [2]Ast.Node.Index = undefined;
            const struct_init = self.ast.fullStructInit(&buf, node.getAstNode(self.zoir)).?;
            const field_node = struct_init.ast.fields[f];
            break :b self.ast.firstToken(field_node) - 2;
        } else self.ast.nodeMainToken(node.getAstNode(self.zoir));
        switch (@typeInfo(T)) {
            inline .@"struct", .@"union", .@"enum" => |info| {
                var notes: std.ArrayList(Diagnostics.Note) = .empty;
                if (info.field_names.len == 0) {
                    try notes.append(self.arena, .init(self.ast, .{
                        .token = .fromToken(token),
                        .node_or_offset = 0,
                        .msg = "none expected",
                    }));
                } else {
                    var aw: std.Io.Writer.Allocating = .init(self.arena);
                    aw.writer.writeAll("supported: ") catch return error.OutOfMemory;
                    inline for (info.field_names, 0..) |field_name, i| {
                        if (i != 0) aw.writer.writeAll(", ") catch return error.OutOfMemory;
                        aw.writer.print("'{f}'", .{std.zig.fmtIdFlags(field_name, .{
                            .allow_primitive = true,
                            .allow_underscore = true,
                        })}) catch return error.OutOfMemory;
                    }
                    try notes.append(self.arena, .init(self.ast, .{
                        .token = .fromToken(token),
                        .node_or_offset = 0,
                        .msg = try aw.toOwnedSlice(),
                    }));
                }
                return self.failTokenFmtNote(
                    token,
                    0,
                    "unexpected {s} '{s}'",
                    .{ item_kind, name },
                    notes.items,
                );
            },
            else => comptime unreachable,
        }
    }

    // Technically we could do this if we were willing to do a deep equal to verify
    // the value matched, but doing so doesn't seem to support any real use cases
    // so isn't worth the complexity at the moment.
    fn failComptimeField(
        self: Parser,
        node: Zoir.Node.Index,
        field: usize,
    ) error{ OutOfMemory, ParseZon } {
        @branchHint(.cold);
        const ast_node = node.getAstNode(self.zoir);
        var buf: [2]Ast.Node.Index = undefined;
        const token = if (self.ast.fullStructInit(&buf, ast_node)) |struct_init| b: {
            const field_node = struct_init.ast.fields[field];
            break :b self.ast.firstToken(field_node);
        } else b: {
            const array_init = self.ast.fullArrayInit(&buf, ast_node).?;
            const value_node = array_init.ast.elements[field];
            break :b self.ast.firstToken(value_node);
        };
        return self.failToken(.init(self.ast, .{
            .token = .fromToken(token),
            .node_or_offset = 0,
            .msg = "cannot initialize comptime field",
            .notes = &.{},
        }));
    }
};

fn intFromFloatExact(T: type, value: anytype) ?T {
    const max: @TypeOf(value) = @floatFromInt(std.math.maxInt(T));
    const min: @TypeOf(value) = @floatFromInt(std.math.minInt(T));
    if (value > max or value < min) {
        return null;
    }

    if (std.math.isNan(value) or std.math.trunc(value) != value) {
        return null;
    }

    return @intFromFloat(value);
}

fn canParseType(T: type) bool {
    comptime return canParseTypeInner(T, &.{}, false);
}

fn canParseTypeInner(
    T: type,
    /// Visited structs and unions, to avoid infinite recursion.
    /// Tracking more types is unnecessary, and a little complex due to optional nesting.
    visited: []const type,
    parent_is_optional: bool,
) bool {
    return switch (@typeInfo(T)) {
        .bool,
        .int,
        .float,
        .null,
        .@"enum",
        => true,

        .noreturn,
        .void,
        .type,
        .undefined,
        .error_union,
        .error_set,
        .@"fn",
        .frame,
        .@"anyframe",
        .@"opaque",
        .spirv,
        .comptime_int,
        .comptime_float,
        .enum_literal,
        => false,

        .pointer => |pointer| switch (pointer.size) {
            .one => canParseTypeInner(pointer.child, visited, parent_is_optional),
            .slice => canParseTypeInner(pointer.child, visited, false),
            .many, .c => false,
        },

        .optional => |optional| if (parent_is_optional)
            false
        else
            canParseTypeInner(optional.child, visited, true),

        .array => |array| canParseTypeInner(array.child, visited, false),
        .vector => |vector| canParseTypeInner(vector.child, visited, false),

        .@"struct" => |@"struct"| {
            for (visited) |V| if (T == V) return true;
            const new_visited = visited ++ .{T};
            for (@"struct".field_types, @"struct".field_attrs) |field_type, field_attrs| {
                if (!field_attrs.@"comptime" and !canParseTypeInner(field_type, new_visited, false)) {
                    return false;
                }
            }
            return true;
        },
        .@"union" => |@"union"| {
            for (visited) |V| if (T == V) return true;
            const new_visited = visited ++ .{T};
            for (@"union".field_types) |field_type| {
                if (field_type != void and !canParseTypeInner(field_type, new_visited, false)) {
                    return false;
                }
            }
            return true;
        },
    };
}

test "std.zon parse canParseType" {
    try std.testing.expect(!comptime canParseType(void));
    try std.testing.expect(!comptime canParseType(struct { f: [*]u8 }));
    try std.testing.expect(!comptime canParseType(struct { error{foo} }));
    try std.testing.expect(!comptime canParseType(union(enum) { a: void, b: [*c]u8 }));
    try std.testing.expect(!comptime canParseType(@Vector(0, [*c]u8)));
    try std.testing.expect(!comptime canParseType(*?[*c]u8));
    try std.testing.expect(comptime canParseType(enum(u8) { _ }));
    try std.testing.expect(comptime canParseType(union { foo: void }));
    try std.testing.expect(comptime canParseType(union(enum) { foo: void }));
    try std.testing.expect(!comptime canParseType(comptime_float));
    try std.testing.expect(!comptime canParseType(comptime_int));
    try std.testing.expect(comptime canParseType(struct { comptime foo: ??u8 = null }));
    try std.testing.expect(!comptime canParseType(@TypeOf(.foo)));
    try std.testing.expect(comptime canParseType(?u8));
    try std.testing.expect(comptime canParseType(*?*u8));
    try std.testing.expect(comptime canParseType(?struct {
        foo: ?struct {
            ?union(enum) {
                a: ?@Vector(0, ?*u8),
            },
            ?struct {
                f: ?[]?u8,
            },
        },
    }));
    try std.testing.expect(!comptime canParseType(??u8));
    try std.testing.expect(!comptime canParseType(?*?u8));
    try std.testing.expect(!comptime canParseType(*?*?*u8));
    try std.testing.expect(!comptime canParseType(struct { x: comptime_int = 2 }));
    try std.testing.expect(!comptime canParseType(struct { x: comptime_float = 2 }));
    try std.testing.expect(comptime canParseType(struct { comptime x: @TypeOf(.foo) = .foo }));
    try std.testing.expect(!comptime canParseType(struct { comptime_int }));
    const Recursive = struct { foo: ?*@This() };
    try std.testing.expect(comptime canParseType(Recursive));

    // Make sure we validate nested optional before we early out due to already having seen
    // a type recursion!
    try std.testing.expect(!comptime canParseType(struct {
        add_to_visited: ?u8,
        retrieve_from_visited: ??u8,
    }));
}

test "std.zon requiresAllocator" {
    try std.testing.expect(!requiresAllocator(u8));
    try std.testing.expect(!requiresAllocator(f32));
    try std.testing.expect(!requiresAllocator(enum { foo }));
    try std.testing.expect(!requiresAllocator(struct { f32 }));
    try std.testing.expect(!requiresAllocator(struct { x: f32 }));
    try std.testing.expect(!requiresAllocator([0][]const u8));
    try std.testing.expect(!requiresAllocator([2]u8));
    try std.testing.expect(!requiresAllocator(union { x: f32, y: f32 }));
    try std.testing.expect(!requiresAllocator(union(enum) { x: f32, y: f32 }));
    try std.testing.expect(!requiresAllocator(?f32));
    try std.testing.expect(!requiresAllocator(void));
    try std.testing.expect(!requiresAllocator(@TypeOf(null)));
    try std.testing.expect(!requiresAllocator(@Vector(3, u8)));
    try std.testing.expect(!requiresAllocator(@Vector(0, *const u8)));

    try std.testing.expect(requiresAllocator([]u8));
    try std.testing.expect(requiresAllocator(*struct { u8, u8 }));
    try std.testing.expect(requiresAllocator([1][]const u8));
    try std.testing.expect(requiresAllocator(struct { x: i32, y: []u8 }));
    try std.testing.expect(requiresAllocator(union { x: i32, y: []u8 }));
    try std.testing.expect(requiresAllocator(union(enum) { x: i32, y: []u8 }));
    try std.testing.expect(requiresAllocator(?[]u8));
    try std.testing.expect(requiresAllocator(@Vector(3, *const u8)));
}

test "std.zon ast errors" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;
    try std.testing.expectError(
        error.ParseZon,
        fromSliceNoAlloc(struct {}, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1 .y = 2}",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectFmt(
        \\input.zon:1:13: error: expected ',' after initializer
        \\
    , "{f}", .{diagnostics.fmt("input.zon")});
}

test "std.zon comments" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    try std.testing.expectEqual(@as(u8, 10), fromSliceNoAlloc(u8, .{
        .gpa = gpa,
        .arena = arena,
        .source =
        \\// comment
        \\10 // comment
        \\// comment
        ,
        .diagnostics = &diagnostics,
    }));

    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source =
            \\//! comment
            \\10 // comment
            \\// comment
            ,
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected expression, found 'a document comment'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon failure/oom formatting" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    try std.testing.expectError(error.OutOfMemory, fromSlice([]const u8, .{
        .gpa = .failing,
        .arena = arena,
        .source = "\"foo\"",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectFmt(
        \\
    , "{f}", .{diagnostics.fmt("input.zon")});
}

test "std.zon fromSlice syntax error" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;
    try std.testing.expectError(
        error.ParseZon,
        fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectFmt(
        \\input.zon:1:3: error: expected expression, found 'EOF'
        \\
    , "{f}", .{diagnostics.fmt("input.zon")});
}

test "std.zon optional" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Basic usage
    {
        const none = try fromSliceNoAlloc(?u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expect(none == null);
        const some = try fromSliceNoAlloc(?u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "1",
            .diagnostics = &diagnostics,
        });
        try std.testing.expect(some.? == 1);
    }

    // Deep free
    {
        const none = try fromSlice(?[]const u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expect(none == null);
        const some = try fromSlice(?[]const u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "\"foo\"",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualStrings("foo", some.?);
    }
}

test "std.zon unions" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Unions
    {
        const Tagged = union(enum) { x: f32, @"y y": bool, z, @"z z" };
        const Untagged = union { x: f32, @"y y": bool, z: void, @"z z": void };

        const tagged_x = try fromSliceNoAlloc(Tagged, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.5}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Tagged{ .x = 1.5 }, tagged_x);
        const tagged_y = try fromSliceNoAlloc(Tagged, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.@\"y y\" = true}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Tagged{ .@"y y" = true }, tagged_y);
        const tagged_z_shorthand = try fromSliceNoAlloc(Tagged, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".z",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(Tagged, .z), tagged_z_shorthand);
        const tagged_zz_shorthand = try fromSliceNoAlloc(Tagged, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".@\"z z\"",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(Tagged, .@"z z"), tagged_zz_shorthand);

        const untagged_x = try fromSliceNoAlloc(Untagged, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.5}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expect(untagged_x.x == 1.5);
        const untagged_y = try fromSliceNoAlloc(Untagged, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.@\"y y\" = true}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expect(untagged_y.@"y y");
    }

    // Deep free
    {
        const Union = union(enum) { bar: []const u8, baz: bool };

        const noalloc = try fromSlice(Union, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.baz = false}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Union{ .baz = false }, noalloc);

        const alloc = try fromSlice(Union, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.bar = \"qux\"}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualDeep(Union{ .bar = "qux" }, alloc);
    }

    // Unknown field
    {
        const Union = union { x: f32, y: f32 };
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(Union, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.z=2.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:4: error: unexpected field 'z'
            \\input.zon:1:4: note: supported: 'x', 'y'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Explicit void field
    {
        const Union = union(enum) { x: void };
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(Union, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.x=1}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:6: error: expected type 'void'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Extra field
    {
        const Union = union { x: f32, y: bool };
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(Union, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.x = 1.5, .y = true}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected union
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // No fields
    {
        const Union = union { x: f32, y: bool };
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(Union, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected union
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Enum literals cannot coerce into untagged unions
    {
        const Union = union { x: void };
        try std.testing.expectError(error.ParseZon, fromSlice(Union, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".x",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected union
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Unknown field for enum literal coercion
    {
        const Union = union(enum) { x: void };
        try std.testing.expectError(error.ParseZon, fromSlice(Union, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".y",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:2: error: unexpected field 'y'
            \\input.zon:1:2: note: supported: 'x'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Non void field for enum literal coercion
    {
        const Union = union(enum) { x: f32 };
        try std.testing.expectError(error.ParseZon, fromSlice(Union, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".x",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected union
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon structs" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Structs (various sizes tested since they're parsed differently)
    {
        const Vec0 = struct {};
        const Vec1 = struct { x: f32 };
        const Vec2 = struct { x: f32, y: f32 };
        const Vec3 = struct { x: f32, y: f32, z: f32 };

        const zero = try fromSliceNoAlloc(Vec0, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec0{}, zero);

        const one = try fromSliceNoAlloc(Vec1, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.2}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec1{ .x = 1.2 }, one);

        const two = try fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.2, .y = 3.4}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec2{ .x = 1.2, .y = 3.4 }, two);

        const three = try fromSliceNoAlloc(Vec3, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.2, .y = 3.4, .z = 5.6}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec3{ .x = 1.2, .y = 3.4, .z = 5.6 }, three);
    }

    // Deep free (structs and arrays)
    {
        const Foo = struct { bar: []const u8, baz: []const []const u8 };

        const parsed = try fromSlice(Foo, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.bar = \"qux\", .baz = .{\"a\", \"b\"}}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualDeep(Foo{ .bar = "qux", .baz = &.{ "a", "b" } }, parsed);
    }

    // Unknown field
    {
        const Vec2 = struct { x: f32, y: f32 };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Vec2, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.x=1.5, .z=2.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:12: error: unexpected field 'z'
            \\input.zon:1:12: note: supported: 'x', 'y'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Duplicate field
    {
        const Vec2 = struct { x: f32, y: f32 };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Vec2, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.x=1.5, .x=2.5, .x=3.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:4: error: duplicate struct field name
            \\input.zon:1:12: note: duplicate name here
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Ignore unknown fields
    {
        const Vec2 = struct { x: f32, y: f32 = 2.0 };
        const parsed = try fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .x = 1.0, .z = 3.0 }",
            .ignore_unknown_fields = true,
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec2{ .x = 1.0, .y = 2.0 }, parsed);
    }

    // Unknown field when struct has no fields (regression test)
    {
        const Vec2 = struct {};
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Vec2, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.x=1.5, .z=2.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:4: error: unexpected field 'x'
            \\input.zon:1:4: note: none expected
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Missing field
    {
        const Vec2 = struct { x: f32, y: f32 };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Vec2, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.x=1.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: missing required field y
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Default field
    {
        const Vec2 = struct { x: f32, y: f32 = 1.5 };
        const parsed = try fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.2}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec2{ .x = 1.2, .y = 1.5 }, parsed);
    }

    // Comptime field
    {
        const Vec2 = struct { x: f32, comptime y: f32 = 1.5 };
        const parsed = try fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.2}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec2{ .x = 1.2, .y = 1.5 }, parsed);
    }

    // Comptime field assignment
    {
        const Vec2 = struct { x: f32, comptime y: f32 = 1.5 };
        const parsed = fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{.x = 1.2, .y = 1.5}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectError(error.ParseZon, parsed);
        try std.testing.expectFmt(
            \\input.zon:1:18: error: cannot initialize comptime field
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Enum field (regression test, we were previously getting the field name in an
    // incorrect way that broke for enum values)
    {
        const Vec0 = struct { x: enum { x } };
        const parsed = try fromSliceNoAlloc(Vec0, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .x = .x }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec0{ .x = .x }, parsed);
    }

    // Enum field and struct field with @
    {
        const Vec0 = struct { @"x x": enum { @"x x" } };
        const parsed = try fromSliceNoAlloc(Vec0, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .@\"x x\" = .@\"x x\" }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec0{ .@"x x" = .@"x x" }, parsed);
    }

    // Type expressions are not allowed
    {
        // Structs
        {
            const parsed = fromSliceNoAlloc(struct {}, .{
                .gpa = gpa,
                .arena = arena,
                .source = "Empty{}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectError(error.ParseZon, parsed);
            try std.testing.expectFmt(
                \\input.zon:1:1: error: types are not available in ZON
                \\input.zon:1:1: note: replace the type with '.'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        // Arrays
        {
            const parsed = fromSliceNoAlloc([3]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "[3]u8{1, 2, 3}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectError(error.ParseZon, parsed);
            try std.testing.expectFmt(
                \\input.zon:1:1: error: types are not available in ZON
                \\input.zon:1:1: note: replace the type with '.'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        // Slices
        {
            const parsed = fromSlice([]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "[]u8{1, 2, 3}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectError(error.ParseZon, parsed);
            try std.testing.expectFmt(
                \\input.zon:1:1: error: types are not available in ZON
                \\input.zon:1:1: note: replace the type with '.'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        // Tuples
        {
            const parsed = fromSliceNoAlloc(struct { u8, u8, u8 }, .{
                .gpa = gpa,
                .arena = arena,
                .source = "Tuple{1, 2, 3}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectError(error.ParseZon, parsed);
            try std.testing.expectFmt(
                \\input.zon:1:1: error: types are not available in ZON
                \\input.zon:1:1: note: replace the type with '.'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        // Nested
        {
            const parsed = fromSliceNoAlloc(struct {}, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{ .x = Tuple{1, 2, 3} }",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectError(error.ParseZon, parsed);
            try std.testing.expectFmt(
                \\input.zon:1:9: error: types are not available in ZON
                \\input.zon:1:9: note: replace the type with '.'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }
}

test "std.zon tuples" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Structs (various sizes tested since they're parsed differently)
    {
        const Tuple0 = struct {};
        const Tuple1 = struct { f32 };
        const Tuple2 = struct { f32, bool };
        const Tuple3 = struct { f32, bool, u8 };

        const zero = try fromSliceNoAlloc(Tuple0, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Tuple0{}, zero);

        const one = try fromSliceNoAlloc(Tuple1, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{1.2}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Tuple1{1.2}, one);

        const two = try fromSliceNoAlloc(Tuple2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{1.2, true}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Tuple2{ 1.2, true }, two);

        const three = try fromSliceNoAlloc(Tuple3, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{1.2, false, 3}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Tuple3{ 1.2, false, 3 }, three);
    }

    // Deep free
    {
        const Tuple = struct { []const u8, []const u8 };
        const parsed = try fromSlice(Tuple, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{\"hello\", \"world\"}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualDeep(Tuple{ "hello", "world" }, parsed);
    }

    // Extra field
    {
        const Tuple = struct { f32, bool };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Tuple, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{0.5, true, 123}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:14: error: index 2 outside of tuple length 2
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Extra field
    {
        const Tuple = struct { f32, bool };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Tuple, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{0.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: missing tuple field with index 1
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Tuple with unexpected field names
    {
        const Tuple = struct { f32 };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Tuple, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{.foo = 10.0}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected tuple
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Struct with missing field names
    {
        const Struct = struct { foo: f32 };
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Struct, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{10.0}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected struct
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Comptime field
    {
        const Vec2 = struct { f32, comptime f32 = 1.5 };
        const parsed = try fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ 1.2 }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Vec2{ 1.2, 1.5 }, parsed);
    }

    // Comptime field assignment
    {
        const Vec2 = struct { f32, comptime f32 = 1.5 };
        const parsed = fromSliceNoAlloc(Vec2, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ 1.2, 1.5}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectError(error.ParseZon, parsed);
        try std.testing.expectFmt(
            \\input.zon:1:9: error: cannot initialize comptime field
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

// Test sizes 0 to 3 since small sizes get parsed differently
test "std.zon arrays and slices" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Literals
    {
        // Arrays
        {
            const zero = try fromSliceNoAlloc([0]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &@as([0]u8, .{}), &zero);

            const one = try fromSliceNoAlloc([1]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a'}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &@as([1]u8, .{'a'}), &one);

            const two = try fromSliceNoAlloc([2]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b'}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &@as([2]u8, .{ 'a', 'b' }), &two);

            const two_comma = try fromSliceNoAlloc([2]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b',}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &@as([2]u8, .{ 'a', 'b' }), &two_comma);

            const three = try fromSliceNoAlloc([3]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b', 'c'}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &.{ 'a', 'b', 'c' }, &three);

            const sentinel = try fromSliceNoAlloc([3:'z']u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b', 'c'}",
                .diagnostics = &diagnostics,
            });
            const expected_sentinel: [3:'z']u8 = .{ 'a', 'b', 'c' };
            try std.testing.expectEqualSlices(u8, &expected_sentinel, &sentinel);
        }

        // Slice literals
        {
            const zero = try fromSlice([]const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, @as([]const u8, &.{}), zero);

            const one = try fromSlice([]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a'}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &.{'a'}, one);

            const two = try fromSlice([]const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b'}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &.{ 'a', 'b' }, two);

            const two_comma = try fromSlice([]const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b',}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &.{ 'a', 'b' }, two_comma);

            const three = try fromSlice([]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b', 'c'}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualSlices(u8, &.{ 'a', 'b', 'c' }, three);

            const sentinel = try fromSlice([:'z']const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b', 'c'}",
                .diagnostics = &diagnostics,
            });
            const expected_sentinel: [:'z']const u8 = &.{ 'a', 'b', 'c' };
            try std.testing.expectEqualSlices(u8, expected_sentinel, sentinel);
        }
    }

    // Deep free
    {
        // Arrays
        {
            const parsed = try fromSlice([1][]const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{\"abc\"}",
                .diagnostics = &diagnostics,
            });
            const expected: [1][]const u8 = .{"abc"};
            try std.testing.expectEqualDeep(expected, parsed);
        }

        // Slice literals
        {
            const parsed = try fromSlice([]const []const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{\"abc\"}",
                .diagnostics = &diagnostics,
            });
            const expected: []const []const u8 = &.{"abc"};
            try std.testing.expectEqualDeep(expected, parsed);
        }
    }

    // Sentinels and alignment
    {
        // Arrays
        {
            const sentinel = try fromSliceNoAlloc([1:2]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{1}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqual(@as(usize, 1), sentinel.len);
            try std.testing.expectEqual(@as(u8, 1), sentinel[0]);
            try std.testing.expectEqual(@as(u8, 2), sentinel[1]);
        }

        // Slice literals
        {
            const sentinel = try fromSlice([:2]align(4) u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{1}",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqual(@as(usize, 1), sentinel.len);
            try std.testing.expectEqual(@as(u8, 1), sentinel[0]);
            try std.testing.expectEqual(@as(u8, 2), sentinel[1]);
        }
    }

    // Expect 0 find 3
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc([0]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b', 'c'}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:3: error: index 0 outside of array of length 0
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Expect 1 find 2
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc([1]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a', 'b'}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:8: error: index 1 outside of array of length 1
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Expect 2 find 1
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc([2]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{'a'}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected 2 array elements; found 1
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Expect 3 find 0
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc([3]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected 3 array elements; found 0
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Wrong inner type
    {
        // Array
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSliceNoAlloc([3]bool, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = ".{'a', 'b', 'c'}",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:3: error: expected type 'bool'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        // Slice
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]bool, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = ".{'a', 'b', 'c'}",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:3: error: expected type 'bool'
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Complete wrong type
    {
        // Array
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSliceNoAlloc([3]u8, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = "'a'",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        // Slice
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]u8, .{ .gpa = gpa, .arena = arena, .source = "'a'", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Address of is not allowed (indirection for slices in ZON is implicit)
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice([]u8, .{ .gpa = gpa, .arena = arena, .source = "  &.{'a', 'b', 'c'}", .diagnostics = &diagnostics }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:3: error: pointers are not available in ZON
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon string literal" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Basic string literal
    {
        const parsed = try fromSlice([]const u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "\"abc\"",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualStrings(@as([]const u8, "abc"), parsed);
    }

    // String literal with escape characters
    {
        const parsed = try fromSlice([]const u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "\"ab\\nc\"",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualStrings(@as([]const u8, "ab\nc"), parsed);
    }

    // String literal with embedded null
    {
        const parsed = try fromSlice([]const u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "\"ab\\x00c\"",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualStrings(@as([]const u8, "ab\x00c"), parsed);
    }

    // Passing string literal to a mutable slice
    {
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]u8, .{ .gpa = gpa, .arena = arena, .source = "\"abcd\"", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]u8, .{ .gpa = gpa, .arena = arena, .source = "\\\\abcd", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Passing string literal to a array
    {
        {
            var ast = try std.zig.Ast.parse(gpa, "\"abcd\"", .{ .mode = .zon });
            defer ast.deinit(gpa);
            var zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
            defer zoir.deinit(gpa);
            try std.testing.expectError(
                error.ParseZon,
                fromSliceNoAlloc([4:0]u8, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = "\"abcd\"",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        {
            try std.testing.expectError(
                error.ParseZon,
                fromSliceNoAlloc([4:0]u8, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = "\\\\abcd",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Zero terminated slices
    {
        {
            const parsed: [:0]const u8 = try fromSlice([:0]const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "\"abc\"",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualStrings("abc", parsed);
            try std.testing.expectEqual(@as(u8, 0), parsed[3]);
        }

        {
            const parsed: [:0]const u8 = try fromSlice([:0]const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "\\\\abc",
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualStrings("abc", parsed);
            try std.testing.expectEqual(@as(u8, 0), parsed[3]);
        }
    }

    // Other value terminated slices
    {
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([:1]const u8, .{ .gpa = gpa, .arena = arena, .source = "\"foo\"", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([:1]const u8, .{ .gpa = gpa, .arena = arena, .source = "\\\\foo", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Expecting string literal, getting something else
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice([]const u8, .{ .gpa = gpa, .arena = arena, .source = "true", .diagnostics = &diagnostics }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected string
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Expecting string literal, getting an incompatible tuple
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice([]const u8, .{ .gpa = gpa, .arena = arena, .source = ".{false}", .diagnostics = &diagnostics }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:3: error: expected type 'u8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Invalid string literal
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice([]const i8, .{ .gpa = gpa, .arena = arena, .source = "\"\\a\"", .diagnostics = &diagnostics }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:3: error: invalid escape character: 'a'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Slice wrong child type
    {
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]const i8, .{ .gpa = gpa, .arena = arena, .source = "\"a\"", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]const i8, .{ .gpa = gpa, .arena = arena, .source = "\\\\a", .diagnostics = &diagnostics }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Bad alignment
    {
        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]align(2) const u8, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = "\"abc\"",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }

        {
            try std.testing.expectError(
                error.ParseZon,
                fromSlice([]align(2) const u8, .{
                    .gpa = gpa,
                    .arena = arena,
                    .source = "\\\\abc",
                    .diagnostics = &diagnostics,
                }),
            );
            try std.testing.expectFmt(
                \\input.zon:1:1: error: expected array
                \\
            , "{f}", .{diagnostics.fmt("input.zon")});
        }
    }

    // Multi line strings
    inline for (.{ []const u8, [:0]const u8 }) |String| {
        // Nested
        {
            const S = struct {
                message: String,
                message2: String,
                message3: String,
            };
            const parsed = try fromSlice(S, .{
                .gpa = gpa,
                .arena = arena,
                .source =
                \\.{
                \\    .message =
                \\        \\hello, world!
                \\
                \\        \\this is a multiline string!
                \\        \\
                \\        \\...
                \\
                \\    ,
                \\    .message2 =
                \\        \\this too...sort of.
                \\    ,
                \\    .message3 =
                \\        \\
                \\        \\and this.
                \\}
                ,
                .diagnostics = &diagnostics,
            });
            try std.testing.expectEqualStrings(
                "hello, world!\nthis is a multiline string!\n\n...",
                parsed.message,
            );
            try std.testing.expectEqualStrings("this too...sort of.", parsed.message2);
            try std.testing.expectEqualStrings("\nand this.", parsed.message3);
        }
    }
}

test "std.zon enum literals" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const Enum = enum {
        foo,
        bar,
        baz,
        @"ab\nc",
    };

    // Tags that exist
    try std.testing.expectEqual(Enum.foo, try fromSliceNoAlloc(Enum, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".foo",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(Enum.bar, try fromSliceNoAlloc(Enum, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".bar",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(Enum.baz, try fromSliceNoAlloc(Enum, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".baz",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(
        Enum.@"ab\nc",
        try fromSliceNoAlloc(Enum, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".@\"ab\\nc\"",
            .diagnostics = &diagnostics,
        }),
    );

    // Bad tag
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Enum, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".qux",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: unexpected enum literal 'qux'
            \\input.zon:1:2: note: supported: 'foo', 'bar', 'baz', '@"ab\nc"'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Bad tag that's too long for parser
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Enum, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".@\"foobarbaz\"",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: unexpected enum literal 'foobarbaz'
            \\input.zon:1:2: note: supported: 'foo', 'bar', 'baz', '@"ab\nc"'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Bad type
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Enum, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected enum literal
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Test embedded nulls in an identifier
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(Enum, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".@\"\\x00\"",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: identifier cannot contain null bytes
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon parse bool" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Correct bools
    try std.testing.expectEqual(true, try fromSliceNoAlloc(bool, .{
        .gpa = gpa,
        .arena = arena,
        .source = "true",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(false, try fromSliceNoAlloc(bool, .{
        .gpa = gpa,
        .arena = arena,
        .source = "false",
        .diagnostics = &diagnostics,
    }));

    // Errors
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(bool, .{
                .gpa = gpa,
                .arena = arena,
                .source = " foo",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: invalid expression
            \\input.zon:1:2: note: ZON allows identifiers 'true', 'false', 'null', 'inf', and 'nan'
            \\input.zon:1:2: note: precede identifier with '.' for an enum literal
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(bool, .{
            .gpa = gpa,
            .arena = arena,
            .source = "123",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'bool'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon intFromFloatExact" {
    // Valid conversions
    try std.testing.expectEqual(@as(u8, 10), intFromFloatExact(u8, @as(f32, 10.0)).?);
    try std.testing.expectEqual(@as(i8, -123), intFromFloatExact(i8, @as(f64, @as(f64, -123.0))).?);
    try std.testing.expectEqual(@as(i16, 45), intFromFloatExact(i16, @as(f128, @as(f128, 45.0))).?);
    try std.testing.expectEqual(@as(u128, 67), intFromFloatExact(u128, @as(f128, @as(f128, 67.0))).?);

    // Out of range
    try std.testing.expectEqual(@as(?u4, null), intFromFloatExact(u4, @as(f32, 16.0)));
    try std.testing.expectEqual(@as(?i4, null), intFromFloatExact(i4, @as(f64, -17.0)));
    try std.testing.expectEqual(@as(?u8, null), intFromFloatExact(u8, @as(f128, -2.0)));

    // Not a whole number
    try std.testing.expectEqual(@as(?u8, null), intFromFloatExact(u8, @as(f32, 0.5)));
    try std.testing.expectEqual(@as(?i8, null), intFromFloatExact(i8, @as(f64, 0.01)));

    // Infinity and NaN
    try std.testing.expectEqual(@as(?u8, null), intFromFloatExact(u8, std.math.inf(f32)));
    try std.testing.expectEqual(@as(?u8, null), intFromFloatExact(u8, -std.math.inf(f32)));
    try std.testing.expectEqual(@as(?u8, null), intFromFloatExact(u8, std.math.nan(f32)));
}

test "std.zon parse int" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Test various numbers and types
    try std.testing.expectEqual(@as(u8, 10), try fromSliceNoAlloc(u8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "10",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i16, 24), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "24",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i14, -4), try fromSliceNoAlloc(i14, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-4",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i32, -123), try fromSliceNoAlloc(i32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-123",
        .diagnostics = &diagnostics,
    }));

    // Test limits
    try std.testing.expectEqual(@as(i8, 127), try fromSliceNoAlloc(i8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "127",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i8, -128), try fromSliceNoAlloc(i8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-128",
        .diagnostics = &diagnostics,
    }));

    // Test characters
    try std.testing.expectEqual(@as(u8, 'a'), try fromSliceNoAlloc(u8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "'a'",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(u8, 'z'), try fromSliceNoAlloc(u8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "'z'",
        .diagnostics = &diagnostics,
    }));

    // Test big integers
    try std.testing.expectEqual(
        @as(u65, 36893488147419103231),
        try fromSliceNoAlloc(u65, .{
            .gpa = gpa,
            .arena = arena,
            .source = "36893488147419103231",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(u65, 36893488147419103231),
        try fromSliceNoAlloc(u65, .{
            .gpa = gpa,
            .arena = arena,
            .source = "368934_881_474191032_31",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(u128, 340282366920938463463374607431768211455),
        try fromSliceNoAlloc(u128, .{
            .gpa = gpa,
            .arena = arena,
            .source = "340282366920938463463374607431768211455",
            .diagnostics = &diagnostics,
        }),
    );

    // Test big integer limits
    try std.testing.expectEqual(
        @as(i66, 36893488147419103231),
        try fromSliceNoAlloc(i66, .{
            .gpa = gpa,
            .arena = arena,
            .source = "36893488147419103231",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(i66, -36893488147419103232),
        try fromSliceNoAlloc(i66, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-36893488147419103232",
            .diagnostics = &diagnostics,
        }),
    );
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i66, .{
            .gpa = gpa,
            .arena = arena,
            .source = "36893488147419103232",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'i66' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i66, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-36893488147419103233",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'i66' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Test parsing whole number floats as integers
    try std.testing.expectEqual(@as(i8, -1), try fromSliceNoAlloc(i8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-1.0",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i8, 123), try fromSliceNoAlloc(i8, .{
        .gpa = gpa,
        .arena = arena,
        .source = "123.0",
        .diagnostics = &diagnostics,
    }));

    // Test non-decimal integers
    try std.testing.expectEqual(@as(i16, 0xff), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0xff",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i16, -0xff), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-0xff",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i16, 0o77), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0o77",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i16, -0o77), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-0o77",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i16, 0b11), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0b11",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i16, -0b11), try fromSliceNoAlloc(i16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-0b11",
        .diagnostics = &diagnostics,
    }));

    // Test non-decimal big integers
    try std.testing.expectEqual(@as(u65, 0x1ffffffffffffffff), try fromSliceNoAlloc(u65, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0x1ffffffffffffffff",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i66, 0x1ffffffffffffffff), try fromSliceNoAlloc(i66, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0x1ffffffffffffffff",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i66, -0x1ffffffffffffffff), try fromSliceNoAlloc(i66, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-0x1ffffffffffffffff",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(u65, 0x1ffffffffffffffff), try fromSliceNoAlloc(u65, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0o3777777777777777777777",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i66, 0x1ffffffffffffffff), try fromSliceNoAlloc(i66, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0o3777777777777777777777",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i66, -0x1ffffffffffffffff), try fromSliceNoAlloc(i66, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-0o3777777777777777777777",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(u65, 0x1ffffffffffffffff), try fromSliceNoAlloc(u65, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0b11111111111111111111111111111111111111111111111111111111111111111",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i66, 0x1ffffffffffffffff), try fromSliceNoAlloc(i66, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0b11111111111111111111111111111111111111111111111111111111111111111",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(i66, -0x1ffffffffffffffff), try fromSliceNoAlloc(i66, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-0b11111111111111111111111111111111111111111111111111111111111111111",
        .diagnostics = &diagnostics,
    }));

    // Number with invalid character in the middle
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "32a32",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:3: error: invalid digit 'a' for decimal base
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Failing to parse as int
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "true",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'u8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Failing because an int is out of range
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "256",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'u8' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Failing because a negative int is out of range
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-129",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'i8' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Failing because an unsigned int is negative
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-1",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'u8' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Failing because a float is non-whole
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "1.5",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'u8' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Failing because a float is negative
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-1.0",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: type 'u8' cannot represent value
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Negative integer zero
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-0",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:2: error: integer literal '-0' is ambiguous
            \\input.zon:1:2: note: use '0' for an integer zero
            \\input.zon:1:2: note: use '-0.0' for a floating-point signed zero
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Negative integer zero casted to float
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-0",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:2: error: integer literal '-0' is ambiguous
            \\input.zon:1:2: note: use '0' for an integer zero
            \\input.zon:1:2: note: use '-0.0' for a floating-point signed zero
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Negative float 0 is allowed
    try std.testing.expect(
        std.math.isNegativeZero(try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-0.0",
            .diagnostics = &diagnostics,
        })),
    );
    try std.testing.expect(std.math.isPositiveZero(try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0.0",
        .diagnostics = &diagnostics,
    })));

    // Double negation is not allowed
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "--2",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected number or 'inf' after '-'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(f32, .{
                .gpa = gpa,
                .arena = arena,
                .source = "--2.0",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected number or 'inf' after '-'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Invalid int literal
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "0xg",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:3: error: invalid digit 'g' for hex base
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Notes on invalid int literal
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "0123",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: number '0123' has leading zero
            \\input.zon:1:1: note: use '0o' prefix for octal literals
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon negative char" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-'a'",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected number or 'inf' after '-'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i16, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-'a'",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected number or 'inf' after '-'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon parse float" {
    if (builtin.cpu.arch == .x86) return error.SkipZigTest;

    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Test decimals
    try std.testing.expectEqual(@as(f16, 0.5), try fromSliceNoAlloc(f16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0.5",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(
        @as(f32, 123.456),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "123.456",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(f64, -123.456),
        try fromSliceNoAlloc(f64, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-123.456",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(@as(f128, 42.5), try fromSliceNoAlloc(f128, .{
        .gpa = gpa,
        .arena = arena,
        .source = "42.5",
        .diagnostics = &diagnostics,
    }));

    // Test whole numbers with and without decimals
    try std.testing.expectEqual(@as(f16, 5.0), try fromSliceNoAlloc(f16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "5.0",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(f16, 5.0), try fromSliceNoAlloc(f16, .{
        .gpa = gpa,
        .arena = arena,
        .source = "5",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(f32, -102), try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-102.0",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(f32, -102), try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-102",
        .diagnostics = &diagnostics,
    }));

    // Test characters and negated characters
    try std.testing.expectEqual(@as(f32, 'a'), try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "'a'",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(f32, 'z'), try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "'z'",
        .diagnostics = &diagnostics,
    }));

    // Test big integers
    try std.testing.expectEqual(
        @as(f32, 36893488147419103231.0),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "36893488147419103231",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(f32, -36893488147419103231.0),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-36893488147419103231",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(@as(f128, 0x1ffffffffffffffff), try fromSliceNoAlloc(f128, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0x1ffffffffffffffff",
        .diagnostics = &diagnostics,
    }));
    try std.testing.expectEqual(@as(f32, @floatFromInt(0x1ffffffffffffffff)), try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "0x1ffffffffffffffff",
        .diagnostics = &diagnostics,
    }));

    // Exponents, underscores
    try std.testing.expectEqual(
        @as(f32, 123.0E+77),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "12_3.0E+77",
            .diagnostics = &diagnostics,
        }),
    );

    // Hexadecimal
    try std.testing.expectEqual(
        @as(f32, 0x103.70p-5),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "0x103.70p-5",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(f32, -0x103.70),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-0x103.70",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @as(f32, 0x1234_5678.9ABC_CDEFp-10),
        try fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "0x1234_5678.9ABC_CDEFp-10",
            .diagnostics = &diagnostics,
        }),
    );

    // inf, nan
    try std.testing.expect(std.math.isPositiveInf(try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "inf",
        .diagnostics = &diagnostics,
    })));
    try std.testing.expect(std.math.isNegativeInf(try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "-inf",
        .diagnostics = &diagnostics,
    })));
    try std.testing.expect(std.math.isNan(try fromSliceNoAlloc(f32, .{
        .gpa = gpa,
        .arena = arena,
        .source = "nan",
        .diagnostics = &diagnostics,
    })));

    // Negative nan not allowed
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-nan",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected number or 'inf' after '-'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // nan as int not allowed
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "nan",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'i8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // nan as int not allowed
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "nan",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'i8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // inf as int not allowed
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "inf",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'i8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // -inf as int not allowed
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(i8, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-inf",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'i8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Bad identifier as float
    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "foo",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: invalid expression
            \\input.zon:1:1: note: ZON allows identifiers 'true', 'false', 'null', 'inf', and 'nan'
            \\input.zon:1:1: note: precede identifier with '.' for an enum literal
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(error.ParseZon, fromSliceNoAlloc(f32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "-foo",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected number or 'inf' after '-'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Non float as float
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(f32, .{
                .gpa = gpa,
                .arena = arena,
                .source = "\"foo\"",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type 'f32'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon free on error" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Test freeing partially allocated structs
    {
        const Struct = struct {
            x: []const u8,
            y: []const u8,
            z: bool,
        };
        try std.testing.expectError(error.ParseZon, fromSlice(Struct, .{
            .gpa = gpa,
            .arena = arena,
            .source =
            \\.{
            \\    .x = "hello",
            \\    .y = "world",
            \\    .z = "fail",
            \\}
            ,
            .diagnostics = &diagnostics,
        }));
    }

    // Test freeing partially allocated tuples
    {
        const Struct = struct {
            []const u8,
            []const u8,
            bool,
        };
        try std.testing.expectError(error.ParseZon, fromSlice(Struct, .{
            .gpa = gpa,
            .arena = arena,
            .source =
            \\.{
            \\    "hello",
            \\    "world",
            \\    "fail",
            \\}
            ,
            .diagnostics = &diagnostics,
        }));
    }

    // Test freeing structs with missing fields
    const Struct = struct {
        x: []const u8,
        y: bool,
    };
    try std.testing.expectError(error.ParseZon, fromSlice(Struct, .{
        .gpa = gpa,
        .arena = arena,
        .source =
        \\.{
        \\    .x = "hello",
        \\}
        ,
        .diagnostics = &diagnostics,
    }));

    // Test freeing partially allocated arrays
    try std.testing.expectError(error.ParseZon, fromSlice([3][]const u8, .{
        .gpa = gpa,
        .arena = arena,
        .source =
        \\.{
        \\    "hello",
        \\    false,
        \\    false,
        \\}
        ,
        .diagnostics = &diagnostics,
    }));

    // Test freeing partially allocated slices
    try std.testing.expectError(error.ParseZon, fromSlice([][]const u8, .{
        .gpa = gpa,
        .arena = arena,
        .source =
        \\.{
        \\    "hello",
        \\    "world",
        \\    false,
        \\}
        ,
        .diagnostics = &diagnostics,
    }));

    // We can parse types that can't be freed, as long as they contain no allocations, e.g. untagged
    // unions.
    try std.testing.expectEqual(
        @as(f32, 1.5),
        (try fromSliceNoAlloc(union { x: f32 }, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .x = 1.5 }",
            .diagnostics = &diagnostics,
        })).x,
    );

    // We can also parse types that can't be freed if it's impossible for an error to occur after
    // the allocation, as is the case here.
    {
        const result = try fromSlice(union { x: []const u8 }, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .x = \"foo\" }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualStrings("foo", result.x);
    }
}

test "std.zon vector" {
    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/15330
    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .s390x) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/25957

    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Passing cases
    try std.testing.expectEqual(
        @Vector(0, bool){},
        try fromSliceNoAlloc(@Vector(0, bool), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{}",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @Vector(3, bool){ true, false, true },
        try fromSliceNoAlloc(@Vector(3, bool), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{true, false, true}",
            .diagnostics = &diagnostics,
        }),
    );

    try std.testing.expectEqual(
        @Vector(0, f32){},
        try fromSliceNoAlloc(@Vector(0, f32), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{}",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @Vector(3, f32){ 1.5, 2.5, 3.5 },
        try fromSliceNoAlloc(@Vector(3, f32), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{1.5, 2.5, 3.5}",
            .diagnostics = &diagnostics,
        }),
    );

    try std.testing.expectEqual(
        @Vector(0, u8){},
        try fromSliceNoAlloc(@Vector(0, u8), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{}",
            .diagnostics = &diagnostics,
        }),
    );
    try std.testing.expectEqual(
        @Vector(3, u8){ 2, 4, 6 },
        try fromSliceNoAlloc(@Vector(3, u8), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{2, 4, 6}",
            .diagnostics = &diagnostics,
        }),
    );

    {
        try std.testing.expectEqual(
            @Vector(0, *const u8){},
            try fromSlice(@Vector(0, *const u8), .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{}",
                .diagnostics = &diagnostics,
            }),
        );
        const pointers = try fromSlice(@Vector(3, *const u8), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{2, 4, 6}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualDeep(@Vector(3, *const u8){ &2, &4, &6 }, pointers);
    }

    {
        try std.testing.expectEqual(
            @Vector(0, ?*const u8){},
            try fromSlice(@Vector(0, ?*const u8), .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{}",
                .diagnostics = &diagnostics,
            }),
        );
        const pointers = try fromSlice(@Vector(3, ?*const u8), .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{2, null, 6}",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqualDeep(@Vector(3, ?*const u8){ &2, null, &6 }, pointers);
    }

    // Too few fields
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(@Vector(2, f32), .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{0.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:2: error: expected 2 array elements; found 1
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Too many fields
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(@Vector(2, f32), .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{0.5, 1.5, 2.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:13: error: index 2 outside of array of length 2
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Wrong type fields
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(@Vector(3, f32), .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{0.5, true, 2.5}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:8: error: expected type 'f32'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Wrong type
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSliceNoAlloc(@Vector(3, u8), .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type '@Vector(3, u8)'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Elements should get freed on error
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(@Vector(3, *u8), .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{1, true, 3}",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:6: error: expected type 'u8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon add pointers" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Primitive with varying levels of pointers
    {
        const result = try fromSlice(*u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), result.*);
    }

    {
        const result = try fromSlice(**u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), result.*.*);
    }

    {
        const result = try fromSlice(***u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), result.*.*.*);
    }

    // Primitive optional with varying levels of pointers
    {
        const some = try fromSlice(?*u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), some.?.*);

        const none = try fromSlice(?*u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(null, none);
    }

    {
        const some = try fromSlice(*?u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), some.*.?);

        const none = try fromSlice(*?u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(null, none.*);
    }

    {
        const some = try fromSlice(?**u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), some.?.*.*);

        const none = try fromSlice(?**u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(null, none);
    }

    {
        const some = try fromSlice(*?*u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), some.*.?.*);

        const none = try fromSlice(*?*u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(null, none.*);
    }

    {
        const some = try fromSlice(**?u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "10",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(@as(u32, 10), some.*.*.?);

        const none = try fromSlice(**?u32, .{
            .gpa = gpa,
            .arena = arena,
            .source = "null",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(null, none.*.*);
    }

    // Pointer to an array
    {
        const result = try fromSlice(*[3]u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ 1, 2, 3 }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual([3]u8{ 1, 2, 3 }, result.*);
    }

    // A complicated type with nested internal pointers and string allocations
    {
        const Inner = struct {
            f1: *const ?*const []const u8,
            f2: *const ?*const []const u8,
        };
        const Outer = struct {
            f1: *const ?*const Inner,
            f2: *const ?*const Inner,
        };
        const expected: Outer = .{
            .f1 = &&.{
                .f1 = &null,
                .f2 = &&"foo",
            },
            .f2 = &null,
        };

        const found = try fromSlice(?*Outer, .{
            .gpa = gpa,
            .arena = arena,
            .source =
            \\.{
            \\    .f1 = .{
            \\        .f1 = null,
            \\        .f2 = "foo",
            \\    },
            \\    .f2 = null,
            \\}
            ,
            .diagnostics = &diagnostics,
        });

        try std.testing.expectEqualDeep(expected, found.?.*);
    }

    // Test that optional types are flattened correctly in errors
    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type '?u8'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const f32, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type '?f32'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const @Vector(3, u8), .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type '?@Vector(3, u8)'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const bool, .{
                .gpa = gpa,
                .arena = arena,
                .source = "10",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected type '?bool'
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const struct { a: i32 }, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional struct
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const struct { i32 }, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional tuple
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const union { x: void }, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional union
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const [3]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional array
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(?[3]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional array
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const []u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional array
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(?[]u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional array
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const []const u8, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional string
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    {
        try std.testing.expectError(
            error.ParseZon,
            fromSlice(*const ?*const enum { foo }, .{
                .gpa = gpa,
                .arena = arena,
                .source = "true",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectFmt(
            \\input.zon:1:1: error: expected optional enum literal
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }
}

test "std.zon stop on node" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    {
        const Vec2 = struct {
            x: Zoir.Node.Index,
            y: f32,
        };

        var ast = try std.zig.Ast.parse(gpa, ".{ .x = 1.5, .y = 2.5 }", .{ .mode = .zon });
        defer ast.deinit(gpa);

        var zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
        defer zoir.deinit(gpa);

        const result = try fromZoirNoAlloc(Vec2, .{
            .arena = arena,
            .ast = &ast,
            .zoir = &zoir,
            .diagnostics = &diagnostics,
        });

        try std.testing.expectEqual(result.y, 2.5);
        try std.testing.expectEqual(Zoir.Node{ .float_literal = 1.5 }, result.x.get(&zoir));
    }

    {
        var ast = try std.zig.Ast.parse(gpa, "1.23", .{ .mode = .zon });
        defer ast.deinit(gpa);

        var zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
        defer zoir.deinit(gpa);

        const result = try fromZoirNoAlloc(Zoir.Node.Index, .{
            .arena = arena,
            .ast = &ast,
            .zoir = &zoir,
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(Zoir.Node{ .float_literal = 1.23 }, result.get(&zoir));
    }
}

test "std.zon no alloc" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    try std.testing.expectEqual(
        [3]u8{ 1, 2, 3 },
        try fromSliceNoAlloc([3]u8, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ 1, 2, 3 }",
            .diagnostics = &diagnostics,
        }),
    );

    const Nested = struct { u8, u8, struct { u8, u8 } };

    var ast = try std.zig.Ast.parse(gpa, ".{ 1, 2, .{ 3, 4 } }", .{ .mode = .zon });
    defer ast.deinit(gpa);

    var zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
    defer zoir.deinit(gpa);

    try std.testing.expectEqual(
        Nested{ 1, 2, .{ 3, 4 } },
        try fromZoirNoAlloc(Nested, .{
            .arena = arena,
            .ast = &ast,
            .zoir = &zoir,
            .diagnostics = &diagnostics,
        }),
    );
}

test "std.zon aligned pointers" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const n: u8 align(8) = 10;
    const Foo = struct {
        inner: *align(8) const u8,
    };

    const expected: Foo = .{
        .inner = &n,
    };
    const found = try fromSlice(Foo, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .inner = 10 }",
        .diagnostics = &diagnostics,
    });
    try std.testing.expectEqualDeep(expected.inner, found.inner);
}

test "std.zon update basic" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const Vector = struct { x: f32, y: f32, z: f32 };
    const MyStruct = struct {
        foo: u32 = 123,
        bar: bool,
        baz: struct {
            a: [2]u32,
            b: enum { c, d } = .d,
        },
        ptr: *Vector,
        optional: ?u32 = null,
        str: []const u8,
    };

    var v1: Vector = .{ .x = 1, .y = 2, .z = 3 };
    var expected: MyStruct = .{
        .foo = 10,
        .bar = true,
        .baz = .{ .a = .{ 1, 2 }, .b = .c },
        .ptr = &v1,
        .str = "hello, world",
    };
    var v2: Vector = .{ .x = 1, .y = 2, .z = 3 };
    var found: MyStruct = .{
        .foo = 10,
        .bar = true,
        .baz = .{ .a = .{ 1, 2 }, .b = .c },
        .ptr = &v2,
        .str = "hello, world",
    };

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{}",
        .diagnostics = &diagnostics,
    });
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .bar = false }",
        .diagnostics = &diagnostics,
    });
    expected.bar = false;
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .baz = .{ .a = .{ 2, 4 } } }",
        .diagnostics = &diagnostics,
    });
    expected.baz.a[0] = 2;
    expected.baz.a[1] = 4;
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .foo = 11, .baz = .{ .b = .d } }",
        .diagnostics = &diagnostics,
    });
    expected.foo = 11;
    expected.baz.b = .d;
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .optional = 10 }",
        .diagnostics = &diagnostics,
    });
    expected.optional = 10;
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .optional = null }",
        .diagnostics = &diagnostics,
    });
    expected.optional = null;
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .ptr = .{ .x = 10, .y = 20, .z = 30 } }",
        .diagnostics = &diagnostics,
    });
    expected.ptr.x = 10;
    expected.ptr.y = 20;
    expected.ptr.z = 30;
    try std.testing.expectEqualDeep(expected, found);

    try updateFromSlice(MyStruct, &found, .{
        .gpa = gpa,
        .arena = arena,
        .source = ".{ .str = \"foo\" }",
        .diagnostics = &diagnostics,
    });
    expected.str = "foo";
    try std.testing.expectEqualDeep(expected, found);
}

test "std.zon update optionals" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const MyStruct = struct {
        foo: ?struct { bar: u32 = 1, baz: u32 = 2, qux: u32 },
    };

    // Updating an optional that starts out null should fill in any default fields we left off
    {
        var expected: MyStruct = .{ .foo = null };
        var found = expected;
        try updateFromSliceNoAlloc(MyStruct, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .qux = 3 } }",
            .diagnostics = &diagnostics,
        });
        expected.foo = .{ .qux = 3 };
        try std.testing.expectEqual(expected, found);
    }

    // Updating an optional that starts out null should error if we leave off required fields.
    {
        var found: MyStruct = .{ .foo = null };
        try std.testing.expectError(error.ParseZon, updateFromSliceNoAlloc(MyStruct, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{} }",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:12: error: missing required field qux
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Updating an optional that starts out non-null should preserve any values we leave off. It's
    // also okay to leave off required fields since they were already set.
    {
        var expected: MyStruct = .{
            .foo = .{ .bar = 10, .baz = 20, .qux = 30 },
        };
        var found = expected;
        try updateFromSliceNoAlloc(MyStruct, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .baz = 200 } }",
            .diagnostics = &diagnostics,
        });
        expected.foo.?.baz = 200;
        try std.testing.expectEqual(expected, found);
    }
}

test "std.zon update optional pointers" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const MyStruct = struct {
        foo: ?*const struct { bar: u32 = 1, baz: u32 = 2, qux: u32 },
    };

    // Just a smoke test since its the combination of behavior we've already tested separately
    {
        var expected: MyStruct = .{ .foo = null };
        var found = expected;
        try updateFromSlice(MyStruct, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .qux = 3 } }",
            .diagnostics = &diagnostics,
        });
        expected.foo = &.{ .qux = 3 };
        try std.testing.expectEqualDeep(expected, found);
    }
}

test "std.zon update pointers" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    // Updating a pointer should leave fields we don't specify unchanged
    {
        const MyStruct = struct {
            foo: *struct { bar: u32 = 10, baz: u32 = 20, qux: u32 },
        };
        var ptr: @typeInfo(@FieldType(MyStruct, "foo")).pointer.child = .{ .qux = 3 };
        var expected: MyStruct = .{ .foo = &ptr };
        var found = expected;
        try updateFromSlice(MyStruct, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .bar = 100 } }",
            .diagnostics = &diagnostics,
        });
        expected.foo.bar = 100;
        try std.testing.expectEqualDeep(expected, found);
    }

    // Same thing, but for const pointers
    {
        const MyStruct = struct {
            foo: *const struct { bar: u32 = 10, baz: u32 = 20, qux: u32 },
        };
        var expected: MyStruct = .{ .foo = &.{ .qux = 3 } };
        var found = expected;
        try updateFromSlice(MyStruct, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .bar = 100 } }",
            .diagnostics = &diagnostics,
        });
        expected.foo = &.{ .bar = 100, .baz = 20, .qux = 3 };
        try std.testing.expectEqualDeep(expected, found);
    }
}

test "std.zon update unions" {
    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const MyUnion = union(enum) {
        none: void,
        foo: struct { bar: u32 = 10, baz: u32 = 20, qux: u32 },
    };

    // Updating a union to a new field should fill in any default sub-fields we left off
    {
        var expected: MyUnion = .none;
        var found = expected;
        try updateFromSliceNoAlloc(MyUnion, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .qux = 3 } }",
            .diagnostics = &diagnostics,
        });
        expected = .{ .foo = .{ .qux = 3 } };
        try std.testing.expectEqual(expected, found);
    }

    // Updating a union to a new field should error if we leave off required sub-fields
    {
        var found: MyUnion = .none;
        try std.testing.expectError(error.ParseZon, updateFromSliceNoAlloc(MyUnion, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{} }",
            .diagnostics = &diagnostics,
        }));
        try std.testing.expectFmt(
            \\input.zon:1:12: error: missing required field qux
            \\
        , "{f}", .{diagnostics.fmt("input.zon")});
    }

    // Updating a union should preseve any sub-fields that we left off. It's also okay to leave off
    // required fields since they were already set.
    {
        var expected: MyUnion = .{
            .foo = .{ .bar = 10, .baz = 20, .qux = 30 },
        };
        var found = expected;
        try updateFromSliceNoAlloc(MyUnion, &found, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .foo = .{ .baz = 200 } }",
            .diagnostics = &diagnostics,
        });
        expected.foo.baz = 200;
        try std.testing.expectEqual(expected, found);
    }
}

test "std.zon variants" {
    // Just a smoke test, we don't need to test each variant thoroughly because they all call into
    // the same code.

    const gpa = std.testing.allocator;
    var arena_allocator: ArenaAllocator = .init(gpa);
    defer arena_allocator.deinit();
    const arena = arena_allocator.allocator();
    var diagnostics: Diagnostics = undefined;

    const Struct = struct { a: u32, b: u32 };
    const start: Struct = .{ .a = 10, .b = 20 };
    const end: Struct = .{ .a = 100, .b = 20 };

    // Update
    {
        var ast = try std.zig.Ast.parse(gpa, ".{ .a = 100 }", .{ .mode = .zon });
        defer ast.deinit(gpa);
        const zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
        defer zoir.deinit(gpa);

        var curr = start;
        try updateFromSliceNoAlloc(Struct, &curr, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .a = 100 }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(end, curr);

        curr = start;
        try updateFromSlice(Struct, &curr, .{
            .gpa = gpa,
            .arena = arena,
            .source = ".{ .a = 100 }",
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(end, curr);

        curr = start;
        try updateFromZoirNoAlloc(Struct, &curr, .{
            .arena = arena,
            .ast = &ast,
            .zoir = &zoir,
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(end, curr);

        curr = start;
        try updateFromZoir(Struct, &curr, .{
            .arena = arena,
            .ast = &ast,
            .zoir = &zoir,
            .diagnostics = &diagnostics,
        });
        try std.testing.expectEqual(end, curr);
    }

    // From
    {
        var ast = try std.zig.Ast.parse(gpa, ".{ .a = 100, .b = 20 }", .{ .mode = .zon });
        defer ast.deinit(gpa);
        const zoir = try ZonGen.generate(gpa, ast, .{ .parse_str_lits = false });
        defer zoir.deinit(gpa);

        try std.testing.expectEqual(
            end,
            try fromSliceNoAlloc(Struct, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{ .a = 100, .b = 20 }",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectEqual(
            end,
            try fromSlice(Struct, .{
                .gpa = gpa,
                .arena = arena,
                .source = ".{ .a = 100, .b = 20 }",
                .diagnostics = &diagnostics,
            }),
        );
        try std.testing.expectEqual(
            try fromZoirNoAlloc(Struct, .{
                .arena = arena,
                .ast = &ast,
                .zoir = &zoir,
                .diagnostics = &diagnostics,
            }),
            end,
        );
        try std.testing.expectEqual(
            try fromZoir(Struct, .{
                .arena = arena,
                .ast = &ast,
                .zoir = &zoir,
                .diagnostics = &diagnostics,
            }),
            end,
        );
    }
}

test {
    _ = Diagnostics;
}