std.builtin.Type renames, and make it easier to modify std.builtin

[mlugg]

The main goal of this branch was to make it easier to modify std.builtin by loosening how the compiler converts between comptime-known interned values, and actual std.builtin.Xyz values known to the compiler. However, a zig1.wasm update is desirable for those changes, so I've bundled it together with #22496 to minimize zig1.wasm updates.

For instance, this PR makes it trivial to add/remove fields to/from std.builtin.CallingConvention (@alexrp), or to potentially remove std.builtin.AtomicOrder.unordered (@Rexicon226).

I've written up some guidance on how to do these kinds of std.builtin updates, which I'll put on the wiki shortly.

Supercedes #22496.

[mlugg]

https://github.com/ziglang/zig/wiki/How-and-When-to-Update-%60zig1.wasm%60 provides guidance on whether to and how to update zig1.wasm in various cases. Notably, in the case where you're just adding/removing enum/union fields, it's completely unnecessary (the page covers this).

[alexrp]

I think this can be flagged as fixing #21842.

[mlugg]

I think this can be flagged as fixing #21842.

Good point, flagged on the relevant commit.

[mlugg]

@andrewrk just pinging you to note the existence of the above wiki page, in case you ever find yourself needing to update zig1 for an awkward change.

[andrewrk]

Thanks for typing up the wiki page, that's some really nice documentation 👍

[mlugg]

Release Notes

These should be placed directly after the notes for #21225.

std.builtin.Type.Pointer.Size Field Renamed

The fields of the std.builtin.Type.Pointer.Size enum have been renamed to lowercase, just like the fields of std.builtin.Type. Again, this is a breaking change, but one which is very easily updated to:

test "pointer type info" {
    comptime assert(@typeInfo(*u8).pointer.size == .One);
}
test "reify pointer" {
    comptime assert(@Type(.{ .pointer = .{
        .size = .One,
        .is_const = false,
        .is_volatile = false,
        .alignment = 0,
        .address_space = .generic,
        .child = u8,
        .is_allowzero = false,
        .sentinel_ptr = null,
    } }) == *u8);
}
const assert = @import("std").debug.assert;

-->

test "pointer type info" {
    comptime assert(@typeInfo(*u8).pointer.size == .one);
}
test "reify pointer" {
    comptime assert(@Type(.{ .pointer = .{
        .size = .one,
        .is_const = false,
        .is_volatile = false,
        .alignment = 0,
        .address_space = .generic,
        .child = u8,
        .is_allowzero = false,
        .sentinel_ptr = null,
    } }) == *u8);
}
const assert = @import("std").debug.assert;

Simplify Usage Of ?*const anyopaque In std.builtin.Type

The default_value field on std.builtin.Type.StructField, and the sentinel fields on std.builtin.Type.Array and std.builtin.Type.Pointer, have to use ?*const anyopaque, because Zig does not provide a way for the struct's type to depend on a field's value. This isn't a problem; however, it isn't particularly ergonomic at times.

Zig 0.14.0 renames these fields to default_value_ptr and sentinel_ptr respectively, and adds helper methods defaultValue() and sentinel() to load the value with the correct type as an optional.

test "get pointer sentinel" {
    const T = [:0]const u8;
    const ptr = @typeInfo(T).pointer;
    const s = @as(*const ptr.child, @ptrCast(@alignCast(ptr.sentinel.?))).*;
    comptime assert(s == 0);
}
test "reify array" {
    comptime assert(@Type(.{ .array = .{ .len = 1, .child = u8, .sentinel = null } }) == [1]u8);
    comptime assert(@Type(.{ .array = .{ .len = 1, .child = u8, .sentinel = &@as(u8, 0) } }) == [1:0]u8);
}
const assert = @import("std").debug.assert;

-->

test "get pointer sentinel" {
    const T = [:0]const u8;
    const ptr = @typeInfo(T).pointer;
    const s = ptr.sentinel().?;
    comptime assert(s == 0);
}
test "reify array" {
    comptime assert(@Type(.{ .array = .{ .len = 1, .child = u8, .sentinel_ptr = null } }) == [1]u8);
    comptime assert(@Type(.{ .array = .{ .len = 1, .child = u8, .sentinel_ptr = &@as(u8, 0) } }) == [1:0]u8);
}
const assert = @import("std").debug.assert;

[jiacai2050]

because Zig does not provide a way for the struct's type to depend on a field's value.

Hi, how should I interpret this sentence?