Commit 4a6ca735d9b3d466aba37c4488c1235b06a0bc84 | zig

build.zig+7-1

...	...	@@ -123,7 +123,13 @@ pub fn build(b: *Builder) !void {
123	123	.source_dir = "lib",
124	124	.install_dir = .Lib,
125	125	.install_subdir = "zig",
126		.exclude_extensions = &[_][]const u8{ "test.zig", "README.md" },
	126	.exclude_extensions = &[_][]const u8{
	127	"test.zig",
	128	"README.md",
	129	".z.0",
	130	".z.9",
	131	"rfc1951.txt",
	132	},
127	133	});
128	134
129	135	const test_filter = b.option([]const u8, "test-filter", "Skip tests that do not match filter");

doc/langref.html.in+15-15

...	...	@@ -2156,7 +2156,7 @@ test "pointer casting" {
2156	2156
2157	2157	test "pointer child type" {
2158	2158	// pointer types have a `child` field which tells you the type they point to.
2159		assert((*u32).Child == u32);
	2159	assert(@typeInfo(*u32).Pointer.child == u32);
2160	2160	}
2161	2161	{#code_end#}
2162	2162	{#header_open\|Alignment#}
...	...	@@ -2184,7 +2184,7 @@ test "variable alignment" {
2184	2184	assert(@TypeOf(&x) == *i32);
2185	2185	assert(i32 == align(align_of_i32) i32);
2186	2186	if (std.Target.current.cpu.arch == .x86_64) {
2187		assert((*i32).alignment == 4);
	2187	assert(@typeInfo(*i32).Pointer.alignment == 4);
2188	2188	}
2189	2189	}
2190	2190	{#code_end#}
...	...	@@ -2202,7 +2202,7 @@ const assert = @import("std").debug.assert;
2202	2202	var foo: u8 align(4) = 100;
2203	2203
2204	2204	test "global variable alignment" {
2205		assert(@TypeOf(&foo).alignment == 4);
	2205	assert(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
2206	2206	assert(@TypeOf(&foo) == *align(4) u8);
2207	2207	const as_pointer_to_array: *[1]u8 = &foo;
2208	2208	const as_slice: []u8 = as_pointer_to_array;
...	...	@@ -4310,8 +4310,8 @@ test "fn type inference" {
4310	4310	const assert = @import("std").debug.assert;
4311	4311
4312	4312	test "fn reflection" {
4313		assert(@TypeOf(assert).ReturnType == void);
4314		assert(@TypeOf(assert).is_var_args == false);
	4313	assert(@typeInfo(@TypeOf(assert)).Fn.return_type.? == void);
	4314	assert(@typeInfo(@TypeOf(assert)).Fn.is_var_args == false);
4315	4315	}
4316	4316	{#code_end#}
4317	4317	{#header_close#}
...	...	@@ -4611,10 +4611,10 @@ test "error union" {
4611	4611	foo = error.SomeError;
4612	4612
4613	4613	// Use compile-time reflection to access the payload type of an error union:
4614		comptime assert(@TypeOf(foo).Payload == i32);
	4614	comptime assert(@typeInfo(@TypeOf(foo)).ErrorUnion.payload == i32);
4615	4615
4616	4616	// Use compile-time reflection to access the error set type of an error union:
4617		comptime assert(@TypeOf(foo).ErrorSet == anyerror);
	4617	comptime assert(@typeInfo(@TypeOf(foo)).ErrorUnion.error_set == anyerror);
4618	4618	}
4619	4619	{#code_end#}
4620	4620	{#header_open\|Merging Error Sets#}
...	...	@@ -4991,7 +4991,7 @@ test "optional type" {
4991	4991	foo = 1234;
4992	4992
4993	4993	// Use compile-time reflection to access the child type of the optional:
4994		comptime assert(@TypeOf(foo).Child == i32);
	4994	comptime assert(@typeInfo(@TypeOf(foo)).Optional.child == i32);
4995	4995	}
4996	4996	{#code_end#}
4997	4997	{#header_close#}
...	...	@@ -6889,7 +6889,7 @@ fn func(y: *i32) void {
6889	6889	This builtin function atomically dereferences a pointer and returns the value.
6890	6890	</p>
6891	6891	<p>
6892		{#syntax#}T{#endsyntax#} must be a {#syntax#}bool{#endsyntax#}, a float,
	6892	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
6893	6893	an integer or an enum.
6894	6894	</p>
6895	6895	{#header_close#}
...	...	@@ -6899,7 +6899,7 @@ fn func(y: *i32) void {
6899	6899	This builtin function atomically modifies memory and then returns the previous value.
6900	6900	</p>
6901	6901	<p>
6902		{#syntax#}T{#endsyntax#} must be a {#syntax#}bool{#endsyntax#}, a float,
	6902	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
6903	6903	an integer or an enum.
6904	6904	</p>
6905	6905	<p>
...	...	@@ -6925,7 +6925,7 @@ fn func(y: *i32) void {
6925	6925	This builtin function atomically stores a value.
6926	6926	</p>
6927	6927	<p>
6928		{#syntax#}T{#endsyntax#} must be a {#syntax#}bool{#endsyntax#}, a float,
	6928	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
6929	6929	an integer or an enum.
6930	6930	</p>
6931	6931	{#header_close#}
...	...	@@ -7208,10 +7208,10 @@ fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_v
7208	7208	more efficiently in machine instructions.
7209	7209	</p>
7210	7210	<p>
7211		{#syntax#}T{#endsyntax#} must be a {#syntax#}bool{#endsyntax#}, a float,
	7211	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
7212	7212	an integer or an enum.
7213	7213	</p>
7214		<p>{#syntax#}@TypeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
	7214	<p>{#syntax#}@typeInfo(@TypeOf(ptr)).Pointer.alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
7215	7215	{#see_also\|Compile Variables\|cmpxchgWeak#}
7216	7216	{#header_close#}
7217	7217	{#header_open\|@cmpxchgWeak#}
...	...	@@ -7237,10 +7237,10 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
7237	7237	However if you need a stronger guarantee, use {#link\|@cmpxchgStrong#}.
7238	7238	</p>
7239	7239	<p>
7240		{#syntax#}T{#endsyntax#} must be a {#syntax#}bool{#endsyntax#}, a float,
	7240	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
7241	7241	an integer or an enum.
7242	7242	</p>
7243		<p>{#syntax#}@TypeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
	7243	<p>{#syntax#}@typeInfo(@TypeOf(ptr)).Pointer.alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
7244	7244	{#see_also\|Compile Variables\|cmpxchgStrong#}
7245	7245	{#header_close#}
7246	7246

lib/std/array_list.zig+10-2

...	...	@@ -46,7 +46,11 @@ pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
46	46	/// Deinitialize with `deinit` or use `toOwnedSlice`.
47	47	pub fn initCapacity(allocator: *Allocator, num: usize) !Self {
48	48	var self = Self.init(allocator);
49		try self.ensureCapacity(num);
	49
	50	const new_memory = try self.allocator.allocAdvanced(T, alignment, num, .at_least);
	51	self.items.ptr = new_memory.ptr;
	52	self.capacity = new_memory.len;
	53
50	54	return self;
51	55	}
52	56
...	...	@@ -366,7 +370,11 @@ pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) typ
366	370	/// Deinitialize with `deinit` or use `toOwnedSlice`.
367	371	pub fn initCapacity(allocator: *Allocator, num: usize) !Self {
368	372	var self = Self{};
369		try self.ensureCapacity(allocator, num);
	373
	374	const new_memory = try self.allocator.allocAdvanced(T, alignment, num, .at_least);
	375	self.items.ptr = new_memory.ptr;
	376	self.capacity = new_memory.len;
	377
370	378	return self;
371	379	}
372	380

lib/std/c.zig+5

...	...	@@ -330,3 +330,8 @@ pub const FILE = @Type(.Opaque);
330	330	pub extern "c" fn dlopen(path: [:0]const u8, mode: c_int) ?c_void;
331	331	pub extern "c" fn dlclose(handle: *c_void) c_int;
332	332	pub extern "c" fn dlsym(handle: ?c_void, symbol: [:0]const u8) ?*c_void;
	333
	334	pub extern "c" fn sync() void;
	335	pub extern "c" fn syncfs(fd: c_int) c_int;
	336	pub extern "c" fn fsync(fd: c_int) c_int;
	337	pub extern "c" fn fdatasync(fd: c_int) c_int;

lib/std/child_process.zig+5-7

...	...	@@ -44,10 +44,10 @@ pub const ChildProcess = struct {
44	44	stderr_behavior: StdIo,
45	45
46	46	/// Set to change the user id when spawning the child process.
47		uid: if (builtin.os.tag == .windows) void else ?u32,
	47	uid: if (builtin.os.tag == .windows or builtin.os.tag == .wasi) void else ?os.uid_t,
48	48
49	49	/// Set to change the group id when spawning the child process.
50		gid: if (builtin.os.tag == .windows) void else ?u32,
	50	gid: if (builtin.os.tag == .windows or builtin.os.tag == .wasi) void else ?os.gid_t,
51	51
52	52	/// Set to change the current working directory when spawning the child process.
53	53	cwd: ?[]const u8,
...	...	@@ -275,9 +275,7 @@ pub const ChildProcess = struct {
275	275	}
276	276
277	277	fn handleWaitResult(self: *ChildProcess, status: u32) void {
278		// TODO https://github.com/ziglang/zig/issues/3190
279		var term = self.cleanupAfterWait(status);
280		self.term = term;
	278	self.term = self.cleanupAfterWait(status);
281	279	}
282	280
283	281	fn cleanupStreams(self: *ChildProcess) void {
...	...	@@ -487,8 +485,8 @@ pub const ChildProcess = struct {
487	485	const any_ignore = (self.stdin_behavior == StdIo.Ignore or self.stdout_behavior == StdIo.Ignore or self.stderr_behavior == StdIo.Ignore);
488	486
489	487	const nul_handle = if (any_ignore)
490		windows.OpenFile(&[_]u16{ 'N', 'U', 'L' }, .{
491		.dir = std.fs.cwd().fd,
	488	// "\Device\Null" or "\??\NUL"
	489	windows.OpenFile(&[_]u16{ '\\', 'D', 'e', 'v', 'i', 'c', 'e', '\\', 'N', 'u', 'l', 'l' }, .{
492	490	.access_mask = windows.GENERIC_READ \| windows.SYNCHRONIZE,
493	491	.share_access = windows.FILE_SHARE_READ,
494	492	.creation = windows.OPEN_EXISTING,

lib/std/coff.zig+66

...	...	@@ -18,11 +18,77 @@ const IMAGE_FILE_MACHINE_I386 = 0x014c;
18	18	const IMAGE_FILE_MACHINE_IA64 = 0x0200;
19	19	const IMAGE_FILE_MACHINE_AMD64 = 0x8664;
20	20
	21	pub const MachineType = enum(u16) {
	22	Unknown = 0x0,
	23	/// Matsushita AM33
	24	AM33 = 0x1d3,
	25	/// x64
	26	X64 = 0x8664,
	27	/// ARM little endian
	28	ARM = 0x1c0,
	29	/// ARM64 little endian
	30	ARM64 = 0xaa64,
	31	/// ARM Thumb-2 little endian
	32	ARMNT = 0x1c4,
	33	/// EFI byte code
	34	EBC = 0xebc,
	35	/// Intel 386 or later processors and compatible processors
	36	I386 = 0x14c,
	37	/// Intel Itanium processor family
	38	IA64 = 0x200,
	39	/// Mitsubishi M32R little endian
	40	M32R = 0x9041,
	41	/// MIPS16
	42	MIPS16 = 0x266,
	43	/// MIPS with FPU
	44	MIPSFPU = 0x366,
	45	/// MIPS16 with FPU
	46	MIPSFPU16 = 0x466,
	47	/// Power PC little endian
	48	POWERPC = 0x1f0,
	49	/// Power PC with floating point support
	50	POWERPCFP = 0x1f1,
	51	/// MIPS little endian
	52	R4000 = 0x166,
	53	/// RISC-V 32-bit address space
	54	RISCV32 = 0x5032,
	55	/// RISC-V 64-bit address space
	56	RISCV64 = 0x5064,
	57	/// RISC-V 128-bit address space
	58	RISCV128 = 0x5128,
	59	/// Hitachi SH3
	60	SH3 = 0x1a2,
	61	/// Hitachi SH3 DSP
	62	SH3DSP = 0x1a3,
	63	/// Hitachi SH4
	64	SH4 = 0x1a6,
	65	/// Hitachi SH5
	66	SH5 = 0x1a8,
	67	/// Thumb
	68	Thumb = 0x1c2,
	69	/// MIPS little-endian WCE v2
	70	WCEMIPSV2 = 0x169,
	71	};
	72
21	73	// OptionalHeader.magic values
22	74	// see https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx
23	75	const IMAGE_NT_OPTIONAL_HDR32_MAGIC = 0x10b;
24	76	const IMAGE_NT_OPTIONAL_HDR64_MAGIC = 0x20b;
25	77
	78	// Image Characteristics
	79	pub const IMAGE_FILE_RELOCS_STRIPPED = 0x1;
	80	pub const IMAGE_FILE_DEBUG_STRIPPED = 0x200;
	81	pub const IMAGE_FILE_EXECUTABLE_IMAGE = 0x2;
	82	pub const IMAGE_FILE_32BIT_MACHINE = 0x100;
	83	pub const IMAGE_FILE_LARGE_ADDRESS_AWARE = 0x20;
	84
	85	// Section flags
	86	pub const IMAGE_SCN_CNT_INITIALIZED_DATA = 0x40;
	87	pub const IMAGE_SCN_MEM_READ = 0x40000000;
	88	pub const IMAGE_SCN_CNT_CODE = 0x20;
	89	pub const IMAGE_SCN_MEM_EXECUTE = 0x20000000;
	90	pub const IMAGE_SCN_MEM_WRITE = 0x80000000;
	91
26	92	const IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
27	93	const IMAGE_DEBUG_TYPE_CODEVIEW = 2;
28	94	const DEBUG_DIRECTORY = 6;

lib/std/compress.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	// SPDX-License-Identifier: MIT
	2	// Copyright (c) 2015-2020 Zig Contributors
	3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
	4	// The MIT license requires this copyright notice to be included in all copies
	5	// and substantial portions of the software.
	6	const std = @import("std.zig");
	7
	8	pub const deflate = @import("compress/deflate.zig");
	9	pub const zlib = @import("compress/zlib.zig");
	10
	11	test "" {
	12	_ = zlib;
	13	}

lib/std/compress/deflate.zig created+521

...	...	@@ -0,0 +1,521 @@
	1	// SPDX-License-Identifier: MIT
	2	// Copyright (c) 2015-2020 Zig Contributors
	3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
	4	// The MIT license requires this copyright notice to be included in all copies
	5	// and substantial portions of the software.
	6	//
	7	// Decompressor for DEFLATE data streams (RFC1951)
	8	//
	9	// Heavily inspired by the simple decompressor puff.c by Mark Adler
	10
	11	const std = @import("std");
	12	const io = std.io;
	13	const math = std.math;
	14	const mem = std.mem;
	15
	16	const assert = std.debug.assert;
	17
	18	const MAXBITS = 15;
	19	const MAXLCODES = 286;
	20	const MAXDCODES = 30;
	21	const MAXCODES = MAXLCODES + MAXDCODES;
	22	const FIXLCODES = 288;
	23
	24	const Huffman = struct {
	25	count: [MAXBITS + 1]u16,
	26	symbol: [MAXCODES]u16,
	27
	28	fn construct(self: *Huffman, length: []const u16) !void {
	29	for (self.count) \|*val\| {
	30	val.* = 0;
	31	}
	32
	33	for (length) \|val\| {
	34	self.count[val] += 1;
	35	}
	36
	37	if (self.count[0] == length.len)
	38	return;
	39
	40	var left: isize = 1;
	41	for (self.count[1..]) \|val\| {
	42	left *= 2;
	43	left -= @as(isize, @bitCast(i16, val));
	44	if (left < 0)
	45	return error.InvalidTree;
	46	}
	47
	48	var offs: [MAXBITS + 1]u16 = undefined;
	49	{
	50	var len: usize = 1;
	51	offs[1] = 0;
	52	while (len < MAXBITS) : (len += 1) {
	53	offs[len + 1] = offs[len] + self.count[len];
	54	}
	55	}
	56
	57	for (length) \|val, symbol\| {
	58	if (val != 0) {
	59	self.symbol[offs[val]] = @truncate(u16, symbol);
	60	offs[val] += 1;
	61	}
	62	}
	63	}
	64	};
	65
	66	pub fn InflateStream(comptime ReaderType: type) type {
	67	return struct {
	68	const Self = @This();
	69
	70	pub const Error = ReaderType.Error \|\| error{
	71	EndOfStream,
	72	BadCounts,
	73	InvalidBlockType,
	74	InvalidDistance,
	75	InvalidFixedCode,
	76	InvalidLength,
	77	InvalidStoredSize,
	78	InvalidSymbol,
	79	InvalidTree,
	80	MissingEOBCode,
	81	NoLastLength,
	82	OutOfCodes,
	83	};
	84	pub const Reader = io.Reader(*Self, Error, read);
	85
	86	bit_reader: io.BitReader(.Little, ReaderType),
	87
	88	// True if the decoder met the end of the compressed stream, no further
	89	// data can be decompressed
	90	seen_eos: bool,
	91
	92	state: union(enum) {
	93	// Parse a compressed block header and set up the internal state for
	94	// decompressing its contents.
	95	DecodeBlockHeader: void,
	96	// Decode all the symbols in a compressed block.
	97	DecodeBlockData: void,
	98	// Copy N bytes of uncompressed data from the underlying stream into
	99	// the window.
	100	Copy: usize,
	101	// Copy 1 byte into the window.
	102	CopyLit: u8,
	103	// Copy L bytes from the window itself, starting from D bytes
	104	// behind.
	105	CopyFrom: struct { distance: u16, length: u16 },
	106	},
	107
	108	// Sliding window for the LZ77 algorithm
	109	window: struct {
	110	const WSelf = @This();
	111
	112	// invariant: buffer length is always a power of 2
	113	buf: []u8,
	114	// invariant: ri <= wi
	115	wi: usize = 0, // Write index
	116	ri: usize = 0, // Read index
	117	el: usize = 0, // Number of readable elements
	118
	119	fn readable(self: *WSelf) usize {
	120	return self.el;
	121	}
	122
	123	fn writable(self: *WSelf) usize {
	124	return self.buf.len - self.el;
	125	}
	126
	127	// Insert a single byte into the window.
	128	// Returns 1 if there's enough space for the new byte and 0
	129	// otherwise.
	130	fn append(self: *WSelf, value: u8) usize {
	131	if (self.writable() < 1) return 0;
	132	self.appendUnsafe(value);
	133	return 1;
	134	}
	135
	136	// Insert a single byte into the window.
	137	// Assumes there's enough space.
	138	fn appendUnsafe(self: *WSelf, value: u8) void {
	139	self.buf[self.wi] = value;
	140	self.wi = (self.wi + 1) & (self.buf.len - 1);
	141	self.el += 1;
	142	}
	143
	144	// Fill dest[] with data from the window, starting from the read
	145	// position. This updates the read pointer.
	146	// Returns the number of read bytes or 0 if there's nothing to read
	147	// yet.
	148	fn read(self: *WSelf, dest: []u8) usize {
	149	const N = math.min(dest.len, self.readable());
	150
	151	if (N == 0) return 0;
	152
	153	if (self.ri + N < self.buf.len) {
	154	// The data doesn't wrap around
	155	mem.copy(u8, dest, self.buf[self.ri .. self.ri + N]);
	156	} else {
	157	// The data wraps around the buffer, split the copy
	158	std.mem.copy(u8, dest, self.buf[self.ri..]);
	159	// How much data we've copied from `ri` to the end
	160	const r = self.buf.len - self.ri;
	161	std.mem.copy(u8, dest[r..], self.buf[0 .. N - r]);
	162	}
	163
	164	self.ri = (self.ri + N) & (self.buf.len - 1);
	165	self.el -= N;
	166
	167	return N;
	168	}
	169
	170	// Copy `length` bytes starting from `distance` bytes behind the
	171	// write pointer.
	172	// Be careful as the length may be greater than the distance, that's
	173	// how the compressor encodes run-length encoded sequences.
	174	fn copyFrom(self: *WSelf, distance: usize, length: usize) usize {
	175	const N = math.min(length, self.writable());
	176
	177	if (N == 0) return 0;
	178
	179	// TODO: Profile and, if needed, replace with smarter juggling
	180	// of the window memory for the non-overlapping case.
	181	var i: usize = 0;
	182	while (i < N) : (i += 1) {
	183	const index = (self.wi -% distance) % self.buf.len;
	184	self.appendUnsafe(self.buf[index]);
	185	}
	186
	187	return N;
	188	}
	189	},
	190
	191	// Compressor-local Huffman tables used to decompress blocks with
	192	// dynamic codes.
	193	huffman_tables: [2]Huffman = undefined,
	194
	195	// Huffman tables used for decoding length/distance pairs.
	196	hdist: *Huffman,
	197	hlen: *Huffman,
	198
	199	fn stored(self: *Self) !void {
	200	// Discard the remaining bits, the lenght field is always
	201	// byte-aligned (and so is the data)
	202	self.bit_reader.alignToByte();
	203
	204	const length = (try self.bit_reader.readBitsNoEof(u16, 16));
	205	const length_cpl = (try self.bit_reader.readBitsNoEof(u16, 16));
	206
	207	if (length != ~length_cpl)
	208	return error.InvalidStoredSize;
	209
	210	self.state = .{ .Copy = length };
	211	}
	212
	213	fn fixed(self: *Self) !void {
	214	comptime var lencode: Huffman = undefined;
	215	comptime var distcode: Huffman = undefined;
	216
	217	// The Huffman codes are specified in the RFC1951, section 3.2.6
	218	comptime {
	219	@setEvalBranchQuota(100000);
	220
	221	const len_lengths = //
	222	[_]u16{8} ** 144 ++
	223	[_]u16{9} ** 112 ++
	224	[_]u16{7} ** 24 ++
	225	[_]u16{8} ** 8;
	226	assert(len_lengths.len == FIXLCODES);
	227	try lencode.construct(len_lengths[0..]);
	228
	229	const dist_lengths = [_]u16{5} ** MAXDCODES;
	230	try distcode.construct(dist_lengths[0..]);
	231	}
	232
	233	self.hlen = &lencode;
	234	self.hdist = &distcode;
	235	self.state = .DecodeBlockData;
	236	}
	237
	238	fn dynamic(self: *Self) !void {
	239	// Number of length codes
	240	const nlen = (try self.bit_reader.readBitsNoEof(usize, 5)) + 257;
	241	// Number of distance codes
	242	const ndist = (try self.bit_reader.readBitsNoEof(usize, 5)) + 1;
	243	// Number of code length codes
	244	const ncode = (try self.bit_reader.readBitsNoEof(usize, 4)) + 4;
	245
	246	if (nlen > MAXLCODES or ndist > MAXDCODES)
	247	return error.BadCounts;
	248
	249	// Permutation of code length codes
	250	const ORDER = [19]u16{
	251	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4,
	252	12, 3, 13, 2, 14, 1, 15,
	253	};
	254
	255	// Build the Huffman table to decode the code length codes
	256	var lencode: Huffman = undefined;
	257	{
	258	var lengths = std.mem.zeroes([19]u16);
	259
	260	// Read the code lengths, missing ones are left as zero
	261	for (ORDER[0..ncode]) \|val\| {
	262	lengths[val] = try self.bit_reader.readBitsNoEof(u16, 3);
	263	}
	264
	265	try lencode.construct(lengths[0..]);
	266	}
	267
	268	// Read the length/literal and distance code length tables.
	269	// Zero the table by default so we can avoid explicitly writing out
	270	// zeros for codes 17 and 18
	271	var lengths = std.mem.zeroes([MAXCODES]u16);
	272
	273	var i: usize = 0;
	274	while (i < nlen + ndist) {
	275	const symbol = try self.decode(&lencode);
	276
	277	switch (symbol) {
	278	0...15 => {
	279	lengths[i] = symbol;
	280	i += 1;
	281	},
	282	16 => {
	283	// repeat last length 3..6 times
	284	if (i == 0) return error.NoLastLength;
	285
	286	const last_length = lengths[i - 1];
	287	const repeat = 3 + (try self.bit_reader.readBitsNoEof(usize, 2));
	288	const last_index = i + repeat;
	289	while (i < last_index) : (i += 1) {
	290	lengths[i] = last_length;
	291	}
	292	},
	293	17 => {
	294	// repeat zero 3..10 times
	295	i += 3 + (try self.bit_reader.readBitsNoEof(usize, 3));
	296	},
	297	18 => {
	298	// repeat zero 11..138 times
	299	i += 11 + (try self.bit_reader.readBitsNoEof(usize, 7));
	300	},
	301	else => return error.InvalidSymbol,
	302	}
	303	}
	304
	305	if (i > nlen + ndist)
	306	return error.InvalidLength;
	307
	308	// Check if the end of block code is present
	309	if (lengths[256] == 0)
	310	return error.MissingEOBCode;
	311
	312	try self.huffman_tables[0].construct(lengths[0..nlen]);
	313	try self.huffman_tables[1].construct(lengths[nlen .. nlen + ndist]);
	314
	315	self.hlen = &self.huffman_tables[0];
	316	self.hdist = &self.huffman_tables[1];
	317	self.state = .DecodeBlockData;
	318	}
	319
	320	fn codes(self: Self, lencode: Huffman, distcode: *Huffman) !bool {
	321	// Size base for length codes 257..285
	322	const LENS = [29]u16{
	323	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
	324	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258,
	325	};
	326	// Extra bits for length codes 257..285
	327	const LEXT = [29]u16{
	328	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
	329	3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,
	330	};
	331	// Offset base for distance codes 0..29
	332	const DISTS = [30]u16{
	333	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
	334	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577,
	335	};
	336	// Extra bits for distance codes 0..29
	337	const DEXT = [30]u16{
	338	0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
	339	7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
	340	};
	341
	342	while (true) {
	343	const symbol = try self.decode(lencode);
	344
	345	switch (symbol) {
	346	0...255 => {
	347	// Literal value
	348	const c = @truncate(u8, symbol);
	349	if (self.window.append(c) == 0) {
	350	self.state = .{ .CopyLit = c };
	351	return false;
	352	}
	353	},
	354	256 => {
	355	// End of block symbol
	356	return true;
	357	},
	358	257...285 => {
	359	// Length/distance pair
	360	const length_symbol = symbol - 257;
	361	const length = LENS[length_symbol] +
	362	try self.bit_reader.readBitsNoEof(u16, LEXT[length_symbol]);
	363
	364	const distance_symbol = try self.decode(distcode);
	365	const distance = DISTS[distance_symbol] +
	366	try self.bit_reader.readBitsNoEof(u16, DEXT[distance_symbol]);
	367
	368	if (distance > self.window.buf.len)
	369	return error.InvalidDistance;
	370
	371	const written = self.window.copyFrom(distance, length);
	372	if (written != length) {
	373	self.state = .{
	374	.CopyFrom = .{
	375	.distance = distance,
	376	.length = length - @truncate(u16, written),
	377	},
	378	};
	379	return false;
	380	}
	381	},
	382	else => return error.InvalidFixedCode,
	383	}
	384	}
	385	}
	386
	387	fn decode(self: Self, h: Huffman) !u16 {
	388	var len: usize = 1;
	389	var code: usize = 0;
	390	var first: usize = 0;
	391	var index: usize = 0;
	392
	393	while (len <= MAXBITS) : (len += 1) {
	394	code \|= try self.bit_reader.readBitsNoEof(usize, 1);
	395	const count = h.count[len];
	396	if (code < first + count)
	397	return h.symbol[index + (code - first)];
	398	index += count;
	399	first += count;
	400	first <<= 1;
	401	code <<= 1;
	402	}
	403
	404	return error.OutOfCodes;
	405	}
	406
	407	fn step(self: *Self) !void {
	408	while (true) {
	409	switch (self.state) {
	410	.DecodeBlockHeader => {
	411	// The compressed stream is done
	412	if (self.seen_eos) return;
	413
	414	const last = try self.bit_reader.readBitsNoEof(u1, 1);
	415	const kind = try self.bit_reader.readBitsNoEof(u2, 2);
	416
	417	self.seen_eos = last != 0;
	418
	419	// The next state depends on the block type
	420	switch (kind) {
	421	0 => try self.stored(),
	422	1 => try self.fixed(),
	423	2 => try self.dynamic(),
	424	3 => return error.InvalidBlockType,
	425	}
	426	},
	427	.DecodeBlockData => {
	428	if (!try self.codes(self.hlen, self.hdist)) {
	429	return;
	430	}
	431
	432	self.state = .DecodeBlockHeader;
	433	},
	434	.Copy => \|*length\| {
	435	const N = math.min(self.window.writable(), length.*);
	436
	437	// TODO: This loop can be more efficient. On the other
	438	// hand uncompressed blocks are not that common so...
	439	var i: usize = 0;
	440	while (i < N) : (i += 1) {
	441	var tmp: [1]u8 = undefined;
	442	if ((try self.bit_reader.read(&tmp)) != 1) {
	443	// Unexpected end of stream, keep this error
	444	// consistent with the use of readBitsNoEof
	445	return error.EndOfStream;
	446	}
	447	self.window.appendUnsafe(tmp[0]);
	448	}
	449
	450	if (N != length.*) {
	451	length.* -= N;
	452	return;
	453	}
	454
	455	self.state = .DecodeBlockHeader;
	456	},
	457	.CopyLit => \|c\| {
	458	if (self.window.append(c) == 0) {
	459	return;
	460	}
	461
	462	self.state = .DecodeBlockData;
	463	},
	464	.CopyFrom => \|*info\| {
	465	const written = self.window.copyFrom(info.distance, info.length);
	466	if (written != info.length) {
	467	info.length -= @truncate(u16, written);
	468	return;
	469	}
	470
	471	self.state = .DecodeBlockData;
	472	},
	473	}
	474	}
	475	}
	476
	477	fn init(source: ReaderType, window_slice: []u8) Self {
	478	assert(math.isPowerOfTwo(window_slice.len));
	479
	480	return Self{
	481	.bit_reader = io.bitReader(.Little, source),
	482	.window = .{ .buf = window_slice },
	483	.seen_eos = false,
	484	.state = .DecodeBlockHeader,
	485	.hdist = undefined,
	486	.hlen = undefined,
	487	};
	488	}
	489
	490	// Implements the io.Reader interface
	491	pub fn read(self: *Self, buffer: []u8) Error!usize {
	492	if (buffer.len == 0)
	493	return 0;
	494
	495	// Try reading as much as possible from the window
	496	var read_amt: usize = self.window.read(buffer);
	497	while (read_amt < buffer.len) {
	498	// Run the state machine, we can detect the "effective" end of
	499	// stream condition by checking if any progress was made.
	500	// Why "effective"? Because even though `seen_eos` is true we
	501	// may still have to finish processing other decoding steps.
	502	try self.step();
	503	// No progress was made
	504	if (self.window.readable() == 0)
	505	break;
	506
	507	read_amt += self.window.read(buffer[read_amt..]);
	508	}
	509
	510	return read_amt;
	511	}
	512
	513	pub fn reader(self: *Self) Reader {
	514	return .{ .context = self };
	515	}
	516	};
	517	}
	518
	519	pub fn inflateStream(reader: anytype, window_slice: []u8) InflateStream(@TypeOf(reader)) {
	520	return InflateStream(@TypeOf(reader)).init(reader, window_slice);
	521	}

lib/std/compress/rfc1951.txt created+955

...	...	@@ -0,0 +1,955 @@
	1
	2
	3
	4
	5
	6
	7	Network Working Group P. Deutsch
	8	Request for Comments: 1951 Aladdin Enterprises
	9	Category: Informational May 1996
	10
	11
	12	DEFLATE Compressed Data Format Specification version 1.3
	13
	14	Status of This Memo
	15
	16	This memo provides information for the Internet community. This memo
	17	does not specify an Internet standard of any kind. Distribution of
	18	this memo is unlimited.
	19
	20	IESG Note:
	21
	22	The IESG takes no position on the validity of any Intellectual
	23	Property Rights statements contained in this document.
	24
	25	Notices
	26
	27	Copyright (c) 1996 L. Peter Deutsch
	28
	29	Permission is granted to copy and distribute this document for any
	30	purpose and without charge, including translations into other
	31	languages and incorporation into compilations, provided that the
	32	copyright notice and this notice are preserved, and that any
	33	substantive changes or deletions from the original are clearly
	34	marked.
	35
	36	A pointer to the latest version of this and related documentation in
	37	HTML format can be found at the URL
	38	<ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
	39
	40	Abstract
	41
	42	This specification defines a lossless compressed data format that
	43	compresses data using a combination of the LZ77 algorithm and Huffman
	44	coding, with efficiency comparable to the best currently available
	45	general-purpose compression methods. The data can be produced or
	46	consumed, even for an arbitrarily long sequentially presented input
	47	data stream, using only an a priori bounded amount of intermediate
	48	storage. The format can be implemented readily in a manner not
	49	covered by patents.
	50
	51
	52
	53
	54
	55
	56
	57
	58	Deutsch Informational [Page 1]
	59
	60	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	61
	62
	63	Table of Contents
	64
	65	1. Introduction ................................................... 2
	66	1.1. Purpose ................................................... 2
	67	1.2. Intended audience ......................................... 3
	68	1.3. Scope ..................................................... 3
	69	1.4. Compliance ................................................ 3
	70	1.5. Definitions of terms and conventions used ................ 3
	71	1.6. Changes from previous versions ............................ 4
	72	2. Compressed representation overview ............................. 4
	73	3. Detailed specification ......................................... 5
	74	3.1. Overall conventions ....................................... 5
	75	3.1.1. Packing into bytes .................................. 5
	76	3.2. Compressed block format ................................... 6
	77	3.2.1. Synopsis of prefix and Huffman coding ............... 6
	78	3.2.2. Use of Huffman coding in the "deflate" format ....... 7
	79	3.2.3. Details of block format ............................. 9
	80	3.2.4. Non-compressed blocks (BTYPE=00) ................... 11
	81	3.2.5. Compressed blocks (length and distance codes) ...... 11
	82	3.2.6. Compression with fixed Huffman codes (BTYPE=01) .... 12
	83	3.2.7. Compression with dynamic Huffman codes (BTYPE=10) .. 13
	84	3.3. Compliance ............................................... 14
	85	4. Compression algorithm details ................................. 14
	86	5. References .................................................... 16
	87	6. Security Considerations ....................................... 16
	88	7. Source code ................................................... 16
	89	8. Acknowledgements .............................................. 16
	90	9. Author's Address .............................................. 17
	91
	92	1. Introduction
	93
	94	1.1. Purpose
	95
	96	The purpose of this specification is to define a lossless
	97	compressed data format that:
	98	* Is independent of CPU type, operating system, file system,
	99	and character set, and hence can be used for interchange;
	100	* Can be produced or consumed, even for an arbitrarily long
	101	sequentially presented input data stream, using only an a
	102	priori bounded amount of intermediate storage, and hence
	103	can be used in data communications or similar structures
	104	such as Unix filters;
	105	* Compresses data with efficiency comparable to the best
	106	currently available general-purpose compression methods,
	107	and in particular considerably better than the "compress"
	108	program;
	109	* Can be implemented readily in a manner not covered by
	110	patents, and hence can be practiced freely;
	111
	112
	113
	114	Deutsch Informational [Page 2]
	115
	116	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	117
	118
	119	* Is compatible with the file format produced by the current
	120	widely used gzip utility, in that conforming decompressors
	121	will be able to read data produced by the existing gzip
	122	compressor.
	123
	124	The data format defined by this specification does not attempt to:
	125
	126	* Allow random access to compressed data;
	127	* Compress specialized data (e.g., raster graphics) as well
	128	as the best currently available specialized algorithms.
	129
	130	A simple counting argument shows that no lossless compression
	131	algorithm can compress every possible input data set. For the
	132	format defined here, the worst case expansion is 5 bytes per 32K-
	133	byte block, i.e., a size increase of 0.015% for large data sets.
	134	English text usually compresses by a factor of 2.5 to 3;
	135	executable files usually compress somewhat less; graphical data
	136	such as raster images may compress much more.
	137
	138	1.2. Intended audience
	139
	140	This specification is intended for use by implementors of software
	141	to compress data into "deflate" format and/or decompress data from
	142	"deflate" format.
	143
	144	The text of the specification assumes a basic background in
	145	programming at the level of bits and other primitive data
	146	representations. Familiarity with the technique of Huffman coding
	147	is helpful but not required.
	148
	149	1.3. Scope
	150
	151	The specification specifies a method for representing a sequence
	152	of bytes as a (usually shorter) sequence of bits, and a method for
	153	packing the latter bit sequence into bytes.
	154
	155	1.4. Compliance
	156
	157	Unless otherwise indicated below, a compliant decompressor must be
	158	able to accept and decompress any data set that conforms to all
	159	the specifications presented here; a compliant compressor must
	160	produce data sets that conform to all the specifications presented
	161	here.
	162
	163	1.5. Definitions of terms and conventions used
	164
	165	Byte: 8 bits stored or transmitted as a unit (same as an octet).
	166	For this specification, a byte is exactly 8 bits, even on machines
	167
	168
	169
	170	Deutsch Informational [Page 3]
	171
	172	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	173
	174
	175	which store a character on a number of bits different from eight.
	176	See below, for the numbering of bits within a byte.
	177
	178	String: a sequence of arbitrary bytes.
	179
	180	1.6. Changes from previous versions
	181
	182	There have been no technical changes to the deflate format since
	183	version 1.1 of this specification. In version 1.2, some
	184	terminology was changed. Version 1.3 is a conversion of the
	185	specification to RFC style.
	186
	187	2. Compressed representation overview
	188
	189	A compressed data set consists of a series of blocks, corresponding
	190	to successive blocks of input data. The block sizes are arbitrary,
	191	except that non-compressible blocks are limited to 65,535 bytes.
	192
	193	Each block is compressed using a combination of the LZ77 algorithm
	194	and Huffman coding. The Huffman trees for each block are independent
	195	of those for previous or subsequent blocks; the LZ77 algorithm may
	196	use a reference to a duplicated string occurring in a previous block,
	197	up to 32K input bytes before.
	198
	199	Each block consists of two parts: a pair of Huffman code trees that
	200	describe the representation of the compressed data part, and a
	201	compressed data part. (The Huffman trees themselves are compressed
	202	using Huffman encoding.) The compressed data consists of a series of
	203	elements of two types: literal bytes (of strings that have not been
	204	detected as duplicated within the previous 32K input bytes), and
	205	pointers to duplicated strings, where a pointer is represented as a
	206	pair <length, backward distance>. The representation used in the
	207	"deflate" format limits distances to 32K bytes and lengths to 258
	208	bytes, but does not limit the size of a block, except for
	209	uncompressible blocks, which are limited as noted above.
	210
	211	Each type of value (literals, distances, and lengths) in the
	212	compressed data is represented using a Huffman code, using one code
	213	tree for literals and lengths and a separate code tree for distances.
	214	The code trees for each block appear in a compact form just before
	215	the compressed data for that block.
	216
	217
	218
	219
	220
	221
	222
	223
	224
	225
	226	Deutsch Informational [Page 4]
	227
	228	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	229
	230
	231	3. Detailed specification
	232
	233	3.1. Overall conventions In the diagrams below, a box like this:
	234
	235	+---+
	236	\| \| <-- the vertical bars might be missing
	237	+---+
	238
	239	represents one byte; a box like this:
	240
	241	+==============+
	242	\| \|
	243	+==============+
	244
	245	represents a variable number of bytes.
	246
	247	Bytes stored within a computer do not have a "bit order", since
	248	they are always treated as a unit. However, a byte considered as
	249	an integer between 0 and 255 does have a most- and least-
	250	significant bit, and since we write numbers with the most-
	251	significant digit on the left, we also write bytes with the most-
	252	significant bit on the left. In the diagrams below, we number the
	253	bits of a byte so that bit 0 is the least-significant bit, i.e.,
	254	the bits are numbered:
	255
	256	+--------+
	257	\|76543210\|
	258	+--------+
	259
	260	Within a computer, a number may occupy multiple bytes. All
	261	multi-byte numbers in the format described here are stored with
	262	the least-significant byte first (at the lower memory address).
	263	For example, the decimal number 520 is stored as:
	264
	265	0 1
	266	+--------+--------+
	267	\|00001000\|00000010\|
	268	+--------+--------+
	269	^ ^
	270	\| \|
	271	\| + more significant byte = 2 x 256
	272	+ less significant byte = 8
	273
	274	3.1.1. Packing into bytes
	275
	276	This document does not address the issue of the order in which
	277	bits of a byte are transmitted on a bit-sequential medium,
	278	since the final data format described here is byte- rather than
	279
	280
	281
	282	Deutsch Informational [Page 5]
	283
	284	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	285
	286
	287	bit-oriented. However, we describe the compressed block format
	288	in below, as a sequence of data elements of various bit
	289	lengths, not a sequence of bytes. We must therefore specify
	290	how to pack these data elements into bytes to form the final
	291	compressed byte sequence:
	292
	293	* Data elements are packed into bytes in order of
	294	increasing bit number within the byte, i.e., starting
	295	with the least-significant bit of the byte.
	296	* Data elements other than Huffman codes are packed
	297	starting with the least-significant bit of the data
	298	element.
	299	* Huffman codes are packed starting with the most-
	300	significant bit of the code.
	301
	302	In other words, if one were to print out the compressed data as
	303	a sequence of bytes, starting with the first byte at the
	304	right margin and proceeding to the left, with the most-
	305	significant bit of each byte on the left as usual, one would be
	306	able to parse the result from right to left, with fixed-width
	307	elements in the correct MSB-to-LSB order and Huffman codes in
	308	bit-reversed order (i.e., with the first bit of the code in the
	309	relative LSB position).
	310
	311	3.2. Compressed block format
	312
	313	3.2.1. Synopsis of prefix and Huffman coding
	314
	315	Prefix coding represents symbols from an a priori known
	316	alphabet by bit sequences (codes), one code for each symbol, in
	317	a manner such that different symbols may be represented by bit
	318	sequences of different lengths, but a parser can always parse
	319	an encoded string unambiguously symbol-by-symbol.
	320
	321	We define a prefix code in terms of a binary tree in which the
	322	two edges descending from each non-leaf node are labeled 0 and
	323	1 and in which the leaf nodes correspond one-for-one with (are
	324	labeled with) the symbols of the alphabet; then the code for a
	325	symbol is the sequence of 0's and 1's on the edges leading from
	326	the root to the leaf labeled with that symbol. For example:
	327
	328
	329
	330
	331
	332
	333
	334
	335
	336
	337
	338	Deutsch Informational [Page 6]
	339
	340	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	341
	342
	343	/\ Symbol Code
	344	0 1 ------ ----
	345	/ \ A 00
	346	/\ B B 1
	347	0 1 C 011
	348	/ \ D 010
	349	A /\
	350	0 1
	351	/ \
	352	D C
	353
	354	A parser can decode the next symbol from an encoded input
	355	stream by walking down the tree from the root, at each step
	356	choosing the edge corresponding to the next input bit.
	357
	358	Given an alphabet with known symbol frequencies, the Huffman
	359	algorithm allows the construction of an optimal prefix code
	360	(one which represents strings with those symbol frequencies
	361	using the fewest bits of any possible prefix codes for that
	362	alphabet). Such a code is called a Huffman code. (See
	363	reference [1] in Chapter 5, references for additional
	364	information on Huffman codes.)
	365
	366	Note that in the "deflate" format, the Huffman codes for the
	367	various alphabets must not exceed certain maximum code lengths.
	368	This constraint complicates the algorithm for computing code
	369	lengths from symbol frequencies. Again, see Chapter 5,
	370	references for details.
	371
	372	3.2.2. Use of Huffman coding in the "deflate" format
	373
	374	The Huffman codes used for each alphabet in the "deflate"
	375	format have two additional rules:
	376
	377	* All codes of a given bit length have lexicographically
	378	consecutive values, in the same order as the symbols
	379	they represent;
	380
	381	* Shorter codes lexicographically precede longer codes.
	382
	383
	384
	385
	386
	387
	388
	389
	390
	391
	392
	393
	394	Deutsch Informational [Page 7]
	395
	396	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	397
	398
	399	We could recode the example above to follow this rule as
	400	follows, assuming that the order of the alphabet is ABCD:
	401
	402	Symbol Code
	403	------ ----
	404	A 10
	405	B 0
	406	C 110
	407	D 111
	408
	409	I.e., 0 precedes 10 which precedes 11x, and 110 and 111 are
	410	lexicographically consecutive.
	411
	412	Given this rule, we can define the Huffman code for an alphabet
	413	just by giving the bit lengths of the codes for each symbol of
	414	the alphabet in order; this is sufficient to determine the
	415	actual codes. In our example, the code is completely defined
	416	by the sequence of bit lengths (2, 1, 3, 3). The following
	417	algorithm generates the codes as integers, intended to be read
	418	from most- to least-significant bit. The code lengths are
	419	initially in tree[I].Len; the codes are produced in
	420	tree[I].Code.
	421
	422	1) Count the number of codes for each code length. Let
	423	bl_count[N] be the number of codes of length N, N >= 1.
	424
	425	2) Find the numerical value of the smallest code for each
	426	code length:
	427
	428	code = 0;
	429	bl_count[0] = 0;
	430	for (bits = 1; bits <= MAX_BITS; bits++) {
	431	code = (code + bl_count[bits-1]) << 1;
	432	next_code[bits] = code;
	433	}
	434
	435	3) Assign numerical values to all codes, using consecutive
	436	values for all codes of the same length with the base
	437	values determined at step 2. Codes that are never used
	438	(which have a bit length of zero) must not be assigned a
	439	value.
	440
	441	for (n = 0; n <= max_code; n++) {
	442	len = tree[n].Len;
	443	if (len != 0) {
	444	tree[n].Code = next_code[len];
	445	next_code[len]++;
	446	}
	447
	448
	449
	450	Deutsch Informational [Page 8]
	451
	452	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	453
	454
	455	}
	456
	457	Example:
	458
	459	Consider the alphabet ABCDEFGH, with bit lengths (3, 3, 3, 3,
	460	3, 2, 4, 4). After step 1, we have:
	461
	462	N bl_count[N]
	463	- -----------
	464	2 1
	465	3 5
	466	4 2
	467
	468	Step 2 computes the following next_code values:
	469
	470	N next_code[N]
	471	- ------------
	472	1 0
	473	2 0
	474	3 2
	475	4 14
	476
	477	Step 3 produces the following code values:
	478
	479	Symbol Length Code
	480	------ ------ ----
	481	A 3 010
	482	B 3 011
	483	C 3 100
	484	D 3 101
	485	E 3 110
	486	F 2 00
	487	G 4 1110
	488	H 4 1111
	489
	490	3.2.3. Details of block format
	491
	492	Each block of compressed data begins with 3 header bits
	493	containing the following data:
	494
	495	first bit BFINAL
	496	next 2 bits BTYPE
	497
	498	Note that the header bits do not necessarily begin on a byte
	499	boundary, since a block does not necessarily occupy an integral
	500	number of bytes.
	501
	502
	503
	504
	505
	506	Deutsch Informational [Page 9]
	507
	508	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	509
	510
	511	BFINAL is set if and only if this is the last block of the data
	512	set.
	513
	514	BTYPE specifies how the data are compressed, as follows:
	515
	516	00 - no compression
	517	01 - compressed with fixed Huffman codes
	518	10 - compressed with dynamic Huffman codes
	519	11 - reserved (error)
	520
	521	The only difference between the two compressed cases is how the
	522	Huffman codes for the literal/length and distance alphabets are
	523	defined.
	524
	525	In all cases, the decoding algorithm for the actual data is as
	526	follows:
	527
	528	do
	529	read block header from input stream.
	530	if stored with no compression
	531	skip any remaining bits in current partially
	532	processed byte
	533	read LEN and NLEN (see next section)
	534	copy LEN bytes of data to output
	535	otherwise
	536	if compressed with dynamic Huffman codes
	537	read representation of code trees (see
	538	subsection below)
	539	loop (until end of block code recognized)
	540	decode literal/length value from input stream
	541	if value < 256
	542	copy value (literal byte) to output stream
	543	otherwise
	544	if value = end of block (256)
	545	break from loop
	546	otherwise (value = 257..285)
	547	decode distance from input stream
	548
	549	move backwards distance bytes in the output
	550	stream, and copy length bytes from this
	551	position to the output stream.
	552	end loop
	553	while not last block
	554
	555	Note that a duplicated string reference may refer to a string
	556	in a previous block; i.e., the backward distance may cross one
	557	or more block boundaries. However a distance cannot refer past
	558	the beginning of the output stream. (An application using a
	559
	560
	561
	562	Deutsch Informational [Page 10]
	563
	564	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	565
	566
	567	preset dictionary might discard part of the output stream; a
	568	distance can refer to that part of the output stream anyway)
	569	Note also that the referenced string may overlap the current
	570	position; for example, if the last 2 bytes decoded have values
	571	X and Y, a string reference with <length = 5, distance = 2>
	572	adds X,Y,X,Y,X to the output stream.
	573
	574	We now specify each compression method in turn.
	575
	576	3.2.4. Non-compressed blocks (BTYPE=00)
	577
	578	Any bits of input up to the next byte boundary are ignored.
	579	The rest of the block consists of the following information:
	580
	581	0 1 2 3 4...
	582	+---+---+---+---+================================+
	583	\| LEN \| NLEN \|... LEN bytes of literal data...\|
	584	+---+---+---+---+================================+
	585
	586	LEN is the number of data bytes in the block. NLEN is the
	587	one's complement of LEN.
	588
	589	3.2.5. Compressed blocks (length and distance codes)
	590
	591	As noted above, encoded data blocks in the "deflate" format
	592	consist of sequences of symbols drawn from three conceptually
	593	distinct alphabets: either literal bytes, from the alphabet of
	594	byte values (0..255), or <length, backward distance> pairs,
	595	where the length is drawn from (3..258) and the distance is
	596	drawn from (1..32,768). In fact, the literal and length
	597	alphabets are merged into a single alphabet (0..285), where
	598	values 0..255 represent literal bytes, the value 256 indicates
	599	end-of-block, and values 257..285 represent length codes
	600	(possibly in conjunction with extra bits following the symbol
	601	code) as follows:
	602
	603
	604
	605
	606
	607
	608
	609
	610
	611
	612
	613
	614
	615
	616
	617
	618	Deutsch Informational [Page 11]
	619
	620	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	621
	622
	623	Extra Extra Extra
	624	Code Bits Length(s) Code Bits Lengths Code Bits Length(s)
	625	---- ---- ------ ---- ---- ------- ---- ---- -------
	626	257 0 3 267 1 15,16 277 4 67-82
	627	258 0 4 268 1 17,18 278 4 83-98
	628	259 0 5 269 2 19-22 279 4 99-114
	629	260 0 6 270 2 23-26 280 4 115-130
	630	261 0 7 271 2 27-30 281 5 131-162
	631	262 0 8 272 2 31-34 282 5 163-194
	632	263 0 9 273 3 35-42 283 5 195-226
	633	264 0 10 274 3 43-50 284 5 227-257
	634	265 1 11,12 275 3 51-58 285 0 258
	635	266 1 13,14 276 3 59-66
	636
	637	The extra bits should be interpreted as a machine integer
	638	stored with the most-significant bit first, e.g., bits 1110
	639	represent the value 14.
	640
	641	Extra Extra Extra
	642	Code Bits Dist Code Bits Dist Code Bits Distance
	643	---- ---- ---- ---- ---- ------ ---- ---- --------
	644	0 0 1 10 4 33-48 20 9 1025-1536
	645	1 0 2 11 4 49-64 21 9 1537-2048
	646	2 0 3 12 5 65-96 22 10 2049-3072
	647	3 0 4 13 5 97-128 23 10 3073-4096
	648	4 1 5,6 14 6 129-192 24 11 4097-6144
	649	5 1 7,8 15 6 193-256 25 11 6145-8192
	650	6 2 9-12 16 7 257-384 26 12 8193-12288
	651	7 2 13-16 17 7 385-512 27 12 12289-16384
	652	8 3 17-24 18 8 513-768 28 13 16385-24576
	653	9 3 25-32 19 8 769-1024 29 13 24577-32768
	654
	655	3.2.6. Compression with fixed Huffman codes (BTYPE=01)
	656
	657	The Huffman codes for the two alphabets are fixed, and are not
	658	represented explicitly in the data. The Huffman code lengths
	659	for the literal/length alphabet are:
	660
	661	Lit Value Bits Codes
	662	--------- ---- -----
	663	0 - 143 8 00110000 through
	664	10111111
	665	144 - 255 9 110010000 through
	666	111111111
	667	256 - 279 7 0000000 through
	668	0010111
	669	280 - 287 8 11000000 through
	670	11000111
	671
	672
	673
	674	Deutsch Informational [Page 12]
	675
	676	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	677
	678
	679	The code lengths are sufficient to generate the actual codes,
	680	as described above; we show the codes in the table for added
	681	clarity. Literal/length values 286-287 will never actually
	682	occur in the compressed data, but participate in the code
	683	construction.
	684
	685	Distance codes 0-31 are represented by (fixed-length) 5-bit
	686	codes, with possible additional bits as shown in the table
	687	shown in Paragraph 3.2.5, above. Note that distance codes 30-
	688	31 will never actually occur in the compressed data.
	689
	690	3.2.7. Compression with dynamic Huffman codes (BTYPE=10)
	691
	692	The Huffman codes for the two alphabets appear in the block
	693	immediately after the header bits and before the actual
	694	compressed data, first the literal/length code and then the
	695	distance code. Each code is defined by a sequence of code
	696	lengths, as discussed in Paragraph 3.2.2, above. For even
	697	greater compactness, the code length sequences themselves are
	698	compressed using a Huffman code. The alphabet for code lengths
	699	is as follows:
	700
	701	0 - 15: Represent code lengths of 0 - 15
	702	16: Copy the previous code length 3 - 6 times.
	703	The next 2 bits indicate repeat length
	704	(0 = 3, ... , 3 = 6)
	705	Example: Codes 8, 16 (+2 bits 11),
	706	16 (+2 bits 10) will expand to
	707	12 code lengths of 8 (1 + 6 + 5)
	708	17: Repeat a code length of 0 for 3 - 10 times.
	709	(3 bits of length)
	710	18: Repeat a code length of 0 for 11 - 138 times
	711	(7 bits of length)
	712
	713	A code length of 0 indicates that the corresponding symbol in
	714	the literal/length or distance alphabet will not occur in the
	715	block, and should not participate in the Huffman code
	716	construction algorithm given earlier. If only one distance
	717	code is used, it is encoded using one bit, not zero bits; in
	718	this case there is a single code length of one, with one unused
	719	code. One distance code of zero bits means that there are no
	720	distance codes used at all (the data is all literals).
	721
	722	We can now define the format of the block:
	723
	724	5 Bits: HLIT, # of Literal/Length codes - 257 (257 - 286)
	725	5 Bits: HDIST, # of Distance codes - 1 (1 - 32)
	726	4 Bits: HCLEN, # of Code Length codes - 4 (4 - 19)
	727
	728
	729
	730	Deutsch Informational [Page 13]
	731
	732	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	733
	734
	735	(HCLEN + 4) x 3 bits: code lengths for the code length
	736	alphabet given just above, in the order: 16, 17, 18,
	737	0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
	738
	739	These code lengths are interpreted as 3-bit integers
	740	(0-7); as above, a code length of 0 means the
	741	corresponding symbol (literal/length or distance code
	742	length) is not used.
	743
	744	HLIT + 257 code lengths for the literal/length alphabet,
	745	encoded using the code length Huffman code
	746
	747	HDIST + 1 code lengths for the distance alphabet,
	748	encoded using the code length Huffman code
	749
	750	The actual compressed data of the block,
	751	encoded using the literal/length and distance Huffman
	752	codes
	753
	754	The literal/length symbol 256 (end of data),
	755	encoded using the literal/length Huffman code
	756
	757	The code length repeat codes can cross from HLIT + 257 to the
	758	HDIST + 1 code lengths. In other words, all code lengths form
	759	a single sequence of HLIT + HDIST + 258 values.
	760
	761	3.3. Compliance
	762
	763	A compressor may limit further the ranges of values specified in
	764	the previous section and still be compliant; for example, it may
	765	limit the range of backward pointers to some value smaller than
	766	32K. Similarly, a compressor may limit the size of blocks so that
	767	a compressible block fits in memory.
	768
	769	A compliant decompressor must accept the full range of possible
	770	values defined in the previous section, and must accept blocks of
	771	arbitrary size.
	772
	773	4. Compression algorithm details
	774
	775	While it is the intent of this document to define the "deflate"
	776	compressed data format without reference to any particular
	777	compression algorithm, the format is related to the compressed
	778	formats produced by LZ77 (Lempel-Ziv 1977, see reference [2] below);
	779	since many variations of LZ77 are patented, it is strongly
	780	recommended that the implementor of a compressor follow the general
	781	algorithm presented here, which is known not to be patented per se.
	782	The material in this section is not part of the definition of the
	783
	784
	785
	786	Deutsch Informational [Page 14]
	787
	788	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	789
	790
	791	specification per se, and a compressor need not follow it in order to
	792	be compliant.
	793
	794	The compressor terminates a block when it determines that starting a
	795	new block with fresh trees would be useful, or when the block size
	796	fills up the compressor's block buffer.
	797
	798	The compressor uses a chained hash table to find duplicated strings,
	799	using a hash function that operates on 3-byte sequences. At any
	800	given point during compression, let XYZ be the next 3 input bytes to
	801	be examined (not necessarily all different, of course). First, the
	802	compressor examines the hash chain for XYZ. If the chain is empty,
	803	the compressor simply writes out X as a literal byte and advances one
	804	byte in the input. If the hash chain is not empty, indicating that
	805	the sequence XYZ (or, if we are unlucky, some other 3 bytes with the
	806	same hash function value) has occurred recently, the compressor
	807	compares all strings on the XYZ hash chain with the actual input data
	808	sequence starting at the current point, and selects the longest
	809	match.
	810
	811	The compressor searches the hash chains starting with the most recent
	812	strings, to favor small distances and thus take advantage of the
	813	Huffman encoding. The hash chains are singly linked. There are no
	814	deletions from the hash chains; the algorithm simply discards matches
	815	that are too old. To avoid a worst-case situation, very long hash
	816	chains are arbitrarily truncated at a certain length, determined by a
	817	run-time parameter.
	818
	819	To improve overall compression, the compressor optionally defers the
	820	selection of matches ("lazy matching"): after a match of length N has
	821	been found, the compressor searches for a longer match starting at
	822	the next input byte. If it finds a longer match, it truncates the
	823	previous match to a length of one (thus producing a single literal
	824	byte) and then emits the longer match. Otherwise, it emits the
	825	original match, and, as described above, advances N bytes before
	826	continuing.
	827
	828	Run-time parameters also control this "lazy match" procedure. If
	829	compression ratio is most important, the compressor attempts a
	830	complete second search regardless of the length of the first match.
	831	In the normal case, if the current match is "long enough", the
	832	compressor reduces the search for a longer match, thus speeding up
	833	the process. If speed is most important, the compressor inserts new
	834	strings in the hash table only when no match was found, or when the
	835	match is not "too long". This degrades the compression ratio but
	836	saves time since there are both fewer insertions and fewer searches.
	837
	838
	839
	840
	841
	842	Deutsch Informational [Page 15]
	843
	844	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	845
	846
	847	5. References
	848
	849	[1] Huffman, D. A., "A Method for the Construction of Minimum
	850	Redundancy Codes", Proceedings of the Institute of Radio
	851	Engineers, September 1952, Volume 40, Number 9, pp. 1098-1101.
	852
	853	[2] Ziv J., Lempel A., "A Universal Algorithm for Sequential Data
	854	Compression", IEEE Transactions on Information Theory, Vol. 23,
	855	No. 3, pp. 337-343.
	856
	857	[3] Gailly, J.-L., and Adler, M., ZLIB documentation and sources,
	858	available in ftp://ftp.uu.net/pub/archiving/zip/doc/
	859
	860	[4] Gailly, J.-L., and Adler, M., GZIP documentation and sources,
	861	available as gzip-*.tar in ftp://prep.ai.mit.edu/pub/gnu/
	862
	863	[5] Schwartz, E. S., and Kallick, B. "Generating a canonical prefix
	864	encoding." Comm. ACM, 7,3 (Mar. 1964), pp. 166-169.
	865
	866	[6] Hirschberg and Lelewer, "Efficient decoding of prefix codes,"
	867	Comm. ACM, 33,4, April 1990, pp. 449-459.
	868
	869	6. Security Considerations
	870
	871	Any data compression method involves the reduction of redundancy in
	872	the data. Consequently, any corruption of the data is likely to have
	873	severe effects and be difficult to correct. Uncompressed text, on
	874	the other hand, will probably still be readable despite the presence
	875	of some corrupted bytes.
	876
	877	It is recommended that systems using this data format provide some
	878	means of validating the integrity of the compressed data. See
	879	reference [3], for example.
	880
	881	7. Source code
	882
	883	Source code for a C language implementation of a "deflate" compliant
	884	compressor and decompressor is available within the zlib package at
	885	ftp://ftp.uu.net/pub/archiving/zip/zlib/.
	886
	887	8. Acknowledgements
	888
	889	Trademarks cited in this document are the property of their
	890	respective owners.
	891
	892	Phil Katz designed the deflate format. Jean-Loup Gailly and Mark
	893	Adler wrote the related software described in this specification.
	894	Glenn Randers-Pehrson converted this document to RFC and HTML format.
	895
	896
	897
	898	Deutsch Informational [Page 16]
	899
	900	RFC 1951 DEFLATE Compressed Data Format Specification May 1996
	901
	902
	903	9. Author's Address
	904
	905	L. Peter Deutsch
	906	Aladdin Enterprises
	907	203 Santa Margarita Ave.
	908	Menlo Park, CA 94025
	909
	910	Phone: (415) 322-0103 (AM only)
	911	FAX: (415) 322-1734
	912	EMail: <ghost@aladdin.com>
	913
	914	Questions about the technical content of this specification can be
	915	sent by email to:
	916
	917	Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
	918	Mark Adler <madler@alumni.caltech.edu>
	919
	920	Editorial comments on this specification can be sent by email to:
	921
	922	L. Peter Deutsch <ghost@aladdin.com> and
	923	Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
	924
	925
	926
	927
	928
	929
	930
	931
	932
	933
	934
	935
	936
	937
	938
	939
	940
	941
	942
	943
	944
	945
	946
	947
	948
	949
	950
	951
	952
	953
	954	Deutsch Informational [Page 17]
	955

lib/std/compress/rfc1951.txt.fixed.z.9 created

Binary files /dev/null and b/lib/std/compress/rfc1951.txt.fixed.z.9 differ

lib/std/compress/rfc1951.txt.z.0 created

Binary files /dev/null and b/lib/std/compress/rfc1951.txt.z.0 differ

lib/std/compress/rfc1951.txt.z.9 created

Binary files /dev/null and b/lib/std/compress/rfc1951.txt.z.9 differ

lib/std/compress/zlib.zig created+178

...	...	@@ -0,0 +1,178 @@
	1	// SPDX-License-Identifier: MIT
	2	// Copyright (c) 2015-2020 Zig Contributors
	3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
	4	// The MIT license requires this copyright notice to be included in all copies
	5	// and substantial portions of the software.
	6	//
	7	// Decompressor for ZLIB data streams (RFC1950)
	8
	9	const std = @import("std");
	10	const io = std.io;
	11	const fs = std.fs;
	12	const testing = std.testing;
	13	const mem = std.mem;
	14	const deflate = std.compress.deflate;
	15
	16	pub fn ZlibStream(comptime ReaderType: type) type {
	17	return struct {
	18	const Self = @This();
	19
	20	pub const Error = ReaderType.Error \|\|
	21	deflate.InflateStream(ReaderType).Error \|\|
	22	error{ WrongChecksum, Unsupported };
	23	pub const Reader = io.Reader(*Self, Error, read);
	24
	25	allocator: *mem.Allocator,
	26	inflater: deflate.InflateStream(ReaderType),
	27	in_reader: ReaderType,
	28	hasher: std.hash.Adler32,
	29	window_slice: []u8,
	30
	31	fn init(allocator: *mem.Allocator, source: ReaderType) !Self {
	32	// Zlib header format is specified in RFC1950
	33	const header = try source.readBytesNoEof(2);
	34
	35	const CM = @truncate(u4, header[0]);
	36	const CINFO = @truncate(u4, header[0] >> 4);
	37	const FCHECK = @truncate(u5, header[1]);
	38	const FDICT = @truncate(u1, header[1] >> 5);
	39
	40	if ((@as(u16, header[0]) << 8 \| header[1]) % 31 != 0)
	41	return error.BadHeader;
	42
	43	// The CM field must be 8 to indicate the use of DEFLATE
	44	if (CM != 8) return error.InvalidCompression;
	45	// CINFO is the base-2 logarithm of the window size, minus 8.
	46	// Values above 7 are unspecified and therefore rejected.
	47	if (CINFO > 7) return error.InvalidWindowSize;
	48	const window_size: u16 = @as(u16, 1) << (CINFO + 8);
	49
	50	// TODO: Support this case
	51	if (FDICT != 0)
	52	return error.Unsupported;
	53
	54	var window_slice = try allocator.alloc(u8, window_size);
	55
	56	return Self{
	57	.allocator = allocator,
	58	.inflater = deflate.inflateStream(source, window_slice),
	59	.in_reader = source,
	60	.hasher = std.hash.Adler32.init(),
	61	.window_slice = window_slice,
	62	};
	63	}
	64
	65	fn deinit(self: *Self) void {
	66	self.allocator.free(self.window_slice);
	67	}
	68
	69	// Implements the io.Reader interface
	70	pub fn read(self: *Self, buffer: []u8) Error!usize {
	71	if (buffer.len == 0)
	72	return 0;
	73
	74	// Read from the compressed stream and update the computed checksum
	75	const r = try self.inflater.read(buffer);
	76	if (r != 0) {
	77	self.hasher.update(buffer[0..r]);
	78	return r;
	79	}
	80
	81	// We've reached the end of stream, check if the checksum matches
	82	const hash = try self.in_reader.readIntBig(u32);
	83	if (hash != self.hasher.final())
	84	return error.WrongChecksum;
	85
	86	return 0;
	87	}
	88
	89	pub fn reader(self: *Self) Reader {
	90	return .{ .context = self };
	91	}
	92	};
	93	}
	94
	95	pub fn zlibStream(allocator: *mem.Allocator, reader: anytype) !ZlibStream(@TypeOf(reader)) {
	96	return ZlibStream(@TypeOf(reader)).init(allocator, reader);
	97	}
	98
	99	fn testReader(data: []const u8, comptime expected: []const u8) !void {
	100	var in_stream = io.fixedBufferStream(data);
	101
	102	var zlib_stream = try zlibStream(testing.allocator, in_stream.reader());
	103	defer zlib_stream.deinit();
	104
	105	// Read and decompress the whole file
	106	const buf = try zlib_stream.reader().readAllAlloc(testing.allocator, std.math.maxInt(usize));
	107	defer testing.allocator.free(buf);
	108	// Calculate its SHA256 hash and check it against the reference
	109	var hash: [32]u8 = undefined;
	110	std.crypto.hash.sha2.Sha256.hash(buf, hash[0..], .{});
	111
	112	assertEqual(expected, &hash);
	113	}
	114
	115	// Assert `expected` == `input` where `input` is a bytestring.
	116	pub fn assertEqual(comptime expected: []const u8, input: []const u8) void {
	117	var expected_bytes: [expected.len / 2]u8 = undefined;
	118	for (expected_bytes) \|*r, i\| {
	119	r.* = std.fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;
	120	}
	121
	122	testing.expectEqualSlices(u8, &expected_bytes, input);
	123	}
	124
	125	// All the test cases are obtained by compressing the RFC1950 text
	126	//
	127	// https://tools.ietf.org/rfc/rfc1950.txt length=36944 bytes
	128	// SHA256=5ebf4b5b7fe1c3a0c0ab9aa3ac8c0f3853a7dc484905e76e03b0b0f301350009
	129	test "compressed data" {
	130	// Compressed with compression level = 0
	131	try testReader(
	132	@embedFile("rfc1951.txt.z.0"),
	133	"5ebf4b5b7fe1c3a0c0ab9aa3ac8c0f3853a7dc484905e76e03b0b0f301350009",
	134	);
	135	// Compressed with compression level = 9
	136	try testReader(
	137	@embedFile("rfc1951.txt.z.9"),
	138	"5ebf4b5b7fe1c3a0c0ab9aa3ac8c0f3853a7dc484905e76e03b0b0f301350009",
	139	);
	140	// Compressed with compression level = 9 and fixed Huffman codes
	141	try testReader(
	142	@embedFile("rfc1951.txt.fixed.z.9"),
	143	"5ebf4b5b7fe1c3a0c0ab9aa3ac8c0f3853a7dc484905e76e03b0b0f301350009",
	144	);
	145	}
	146
	147	test "sanity checks" {
	148	// Truncated header
	149	testing.expectError(
	150	error.EndOfStream,
	151	testReader(&[_]u8{0x78}, ""),
	152	);
	153	// Failed FCHECK check
	154	testing.expectError(
	155	error.BadHeader,
	156	testReader(&[_]u8{ 0x78, 0x9D }, ""),
	157	);
	158	// Wrong CM
	159	testing.expectError(
	160	error.InvalidCompression,
	161	testReader(&[_]u8{ 0x79, 0x94 }, ""),
	162	);
	163	// Wrong CINFO
	164	testing.expectError(
	165	error.InvalidWindowSize,
	166	testReader(&[_]u8{ 0x88, 0x98 }, ""),
	167	);
	168	// Wrong checksum
	169	testing.expectError(
	170	error.WrongChecksum,
	171	testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, ""),
	172	);
	173	// Truncated checksum
	174	testing.expectError(
	175	error.EndOfStream,
	176	testReader(&[_]u8{ 0x78, 0xda, 0x03, 0x00, 0x00 }, ""),
	177	);
	178	}

lib/std/debug/leb128.zig+24-23

...	...	@@ -9,10 +9,10 @@ const testing = std.testing;
9	9	/// Read a single unsigned LEB128 value from the given reader as type T,
10	10	/// or error.Overflow if the value cannot fit.
11	11	pub fn readULEB128(comptime T: type, reader: anytype) !T {
12		const U = if (T.bit_count < 8) u8 else T;
	12	const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
13	13	const ShiftT = std.math.Log2Int(U);
14	14
15		const max_group = (U.bit_count + 6) / 7;
	15	const max_group = (@typeInfo(U).Int.bits + 6) / 7;
16	16
17	17	var value = @as(U, 0);
18	18	var group = @as(ShiftT, 0);
...	...	@@ -40,7 +40,7 @@ pub fn readULEB128(comptime T: type, reader: anytype) !T {
40	40	/// Write a single unsigned integer as unsigned LEB128 to the given writer.
41	41	pub fn writeULEB128(writer: anytype, uint_value: anytype) !void {
42	42	const T = @TypeOf(uint_value);
43		const U = if (T.bit_count < 8) u8 else T;
	43	const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
44	44	var value = @intCast(U, uint_value);
45	45
46	46	while (true) {
...	...	@@ -68,7 +68,7 @@ pub fn readULEB128Mem(comptime T: type, ptr: *[]const u8) !T {
68	68	/// returning the number of bytes written.
69	69	pub fn writeULEB128Mem(ptr: []u8, uint_value: anytype) !usize {
70	70	const T = @TypeOf(uint_value);
71		const max_group = (T.bit_count + 6) / 7;
	71	const max_group = (@typeInfo(T).Int.bits + 6) / 7;
72	72	var buf = std.io.fixedBufferStream(ptr);
73	73	try writeULEB128(buf.writer(), uint_value);
74	74	return buf.pos;
...	...	@@ -77,11 +77,11 @@ pub fn writeULEB128Mem(ptr: []u8, uint_value: anytype) !usize {
77	77	/// Read a single signed LEB128 value from the given reader as type T,
78	78	/// or error.Overflow if the value cannot fit.
79	79	pub fn readILEB128(comptime T: type, reader: anytype) !T {
80		const S = if (T.bit_count < 8) i8 else T;
81		const U = std.meta.Int(false, S.bit_count);
	80	const S = if (@typeInfo(T).Int.bits < 8) i8 else T;
	81	const U = std.meta.Int(false, @typeInfo(S).Int.bits);
82	82	const ShiftU = std.math.Log2Int(U);
83	83
84		const max_group = (U.bit_count + 6) / 7;
	84	const max_group = (@typeInfo(U).Int.bits + 6) / 7;
85	85
86	86	var value = @as(U, 0);
87	87	var group = @as(ShiftU, 0);
...	...	@@ -97,7 +97,7 @@ pub fn readILEB128(comptime T: type, reader: anytype) !T {
97	97	if (@bitCast(S, temp) >= 0) return error.Overflow;
98	98
99	99	// and all the overflowed bits are 1
100		const remaining_shift = @intCast(u3, U.bit_count - @as(u16, shift));
	100	const remaining_shift = @intCast(u3, @typeInfo(U).Int.bits - @as(u16, shift));
101	101	const remaining_bits = @bitCast(i8, byte \| 0x80) >> remaining_shift;
102	102	if (remaining_bits != -1) return error.Overflow;
103	103	}
...	...	@@ -127,8 +127,8 @@ pub fn readILEB128(comptime T: type, reader: anytype) !T {
127	127	/// Write a single signed integer as signed LEB128 to the given writer.
128	128	pub fn writeILEB128(writer: anytype, int_value: anytype) !void {
129	129	const T = @TypeOf(int_value);
130		const S = if (T.bit_count < 8) i8 else T;
131		const U = std.meta.Int(false, S.bit_count);
	130	const S = if (@typeInfo(T).Int.bits < 8) i8 else T;
	131	const U = std.meta.Int(false, @typeInfo(S).Int.bits);
132	132
133	133	var value = @intCast(S, int_value);
134	134
...	...	@@ -173,7 +173,7 @@ pub fn writeILEB128Mem(ptr: []u8, int_value: anytype) !usize {
173	173	/// different value without shifting all the following code.
174	174	pub fn writeUnsignedFixed(comptime l: usize, ptr: [l]u8, int: std.meta.Int(false, l 7)) void {
175	175	const T = @TypeOf(int);
176		const U = if (T.bit_count < 8) u8 else T;
	176	const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
177	177	var value = @intCast(U, int);
178	178
179	179	comptime var i = 0;
...	...	@@ -346,28 +346,29 @@ test "deserialize unsigned LEB128" {
346	346
347	347	fn test_write_leb128(value: anytype) !void {
348	348	const T = @TypeOf(value);
	349	const t_signed = @typeInfo(T).Int.is_signed;
349	350
350		const writeStream = if (T.is_signed) writeILEB128 else writeULEB128;
351		const writeMem = if (T.is_signed) writeILEB128Mem else writeULEB128Mem;
352		const readStream = if (T.is_signed) readILEB128 else readULEB128;
353		const readMem = if (T.is_signed) readILEB128Mem else readULEB128Mem;
	351	const writeStream = if (t_signed) writeILEB128 else writeULEB128;
	352	const writeMem = if (t_signed) writeILEB128Mem else writeULEB128Mem;
	353	const readStream = if (t_signed) readILEB128 else readULEB128;
	354	const readMem = if (t_signed) readILEB128Mem else readULEB128Mem;
354	355
355	356	// decode to a larger bit size too, to ensure sign extension
356	357	// is working as expected
357		const larger_type_bits = ((T.bit_count + 8) / 8) * 8;
358		const B = std.meta.Int(T.is_signed, larger_type_bits);
	358	const larger_type_bits = ((@typeInfo(T).Int.bits + 8) / 8) * 8;
	359	const B = std.meta.Int(t_signed, larger_type_bits);
359	360
360	361	const bytes_needed = bn: {
361		const S = std.meta.Int(T.is_signed, @sizeOf(T) * 8);
362		if (T.bit_count <= 7) break :bn @as(u16, 1);
	362	const S = std.meta.Int(t_signed, @sizeOf(T) * 8);
	363	if (@typeInfo(T).Int.bits <= 7) break :bn @as(u16, 1);
363	364
364	365	const unused_bits = if (value < 0) @clz(T, ~value) else @clz(T, value);
365		const used_bits: u16 = (T.bit_count - unused_bits) + @boolToInt(T.is_signed);
	366	const used_bits: u16 = (@typeInfo(T).Int.bits - unused_bits) + @boolToInt(t_signed);
366	367	if (used_bits <= 7) break :bn @as(u16, 1);
367	368	break :bn ((used_bits + 6) / 7);
368	369	};
369	370
370		const max_groups = if (T.bit_count == 0) 1 else (T.bit_count + 6) / 7;
	371	const max_groups = if (@typeInfo(T).Int.bits == 0) 1 else (@typeInfo(T).Int.bits + 6) / 7;
371	372
372	373	var buf: [max_groups]u8 = undefined;
373	374	var fbs = std.io.fixedBufferStream(&buf);
...	...	@@ -414,7 +415,7 @@ test "serialize unsigned LEB128" {
414	415	const T = std.meta.Int(false, t);
415	416	const min = std.math.minInt(T);
416	417	const max = std.math.maxInt(T);
417		var i = @as(std.meta.Int(false, T.bit_count + 1), min);
	418	var i = @as(std.meta.Int(false, @typeInfo(T).Int.bits + 1), min);
418	419
419	420	while (i <= max) : (i += 1) try test_write_leb128(@intCast(T, i));
420	421	}
...	...	@@ -432,7 +433,7 @@ test "serialize signed LEB128" {
432	433	const T = std.meta.Int(true, t);
433	434	const min = std.math.minInt(T);
434	435	const max = std.math.maxInt(T);
435		var i = @as(std.meta.Int(true, T.bit_count + 1), min);
	436	var i = @as(std.meta.Int(true, @typeInfo(T).Int.bits + 1), min);
436	437
437	438	while (i <= max) : (i += 1) try test_write_leb128(@intCast(T, i));
438	439	}

lib/std/fmt.zig+30-10

...	...	@@ -66,6 +66,7 @@ fn peekIsAlign(comptime fmt: []const u8) bool {
66	66	/// - output numeric value in hexadecimal notation
67	67	/// - `s`: print a pointer-to-many as a c-string, use zero-termination
68	68	/// - `B` and `Bi`: output a memory size in either metric (1000) or power-of-two (1024) based notation. works for both float and integer values.
	69	/// - `e` and `E`: if printing a string, escape non-printable characters
69	70	/// - `e`: output floating point value in scientific notation
70	71	/// - `d`: output numeric value in decimal notation
71	72	/// - `b`: output integer value in binary notation
...	...	@@ -81,6 +82,8 @@ fn peekIsAlign(comptime fmt: []const u8) bool {
81	82	/// This allows user types to be formatted in a logical manner instead of dumping all fields of the type.
82	83	///
83	84	/// A user type may be a `struct`, `vector`, `union` or `enum` type.
	85	///
	86	/// To print literal curly braces, escape them by writing them twice, e.g. `{{` or `}}`.
84	87	pub fn format(
85	88	writer: anytype,
86	89	comptime fmt: []const u8,
...	...	@@ -90,7 +93,7 @@ pub fn format(
90	93	if (@typeInfo(@TypeOf(args)) != .Struct) {
91	94	@compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(args)));
92	95	}
93		if (args.len > ArgSetType.bit_count) {
	96	if (args.len > @typeInfo(ArgSetType).Int.bits) {
94	97	@compileError("32 arguments max are supported per format call");
95	98	}
96	99
...	...	@@ -324,7 +327,7 @@ pub fn formatType(
324	327	max_depth: usize,
325	328	) @TypeOf(writer).Error!void {
326	329	if (comptime std.mem.eql(u8, fmt, "*")) {
327		try writer.writeAll(@typeName(@TypeOf(value).Child));
	330	try writer.writeAll(@typeName(@typeInfo(@TypeOf(value)).Pointer.child));
328	331	try writer.writeAll("@");
329	332	try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, writer);
330	333	return;
...	...	@@ -429,12 +432,12 @@ pub fn formatType(
429	432	if (info.child == u8) {
430	433	return formatText(value, fmt, options, writer);
431	434	}
432		return format(writer, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
	435	return format(writer, "{}@{x}", .{ @typeName(@typeInfo(T).Pointer.child), @ptrToInt(value) });
433	436	},
434	437	.Enum, .Union, .Struct => {
435	438	return formatType(value.*, fmt, options, writer, max_depth);
436	439	},
437		else => return format(writer, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) }),
	440	else => return format(writer, "{}@{x}", .{ @typeName(@typeInfo(T).Pointer.child), @ptrToInt(value) }),
438	441	},
439	442	.Many, .C => {
440	443	if (ptr_info.sentinel) \|sentinel\| {
...	...	@@ -445,7 +448,7 @@ pub fn formatType(
445	448	return formatText(mem.span(value), fmt, options, writer);
446	449	}
447	450	}
448		return format(writer, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
	451	return format(writer, "{}@{x}", .{ @typeName(@typeInfo(T).Pointer.child), @ptrToInt(value) });
449	452	},
450	453	.Slice => {
451	454	if (fmt.len > 0 and ((fmt[0] == 'x') or (fmt[0] == 'X'))) {
...	...	@@ -535,7 +538,7 @@ pub fn formatIntValue(
535	538	radix = 10;
536	539	uppercase = false;
537	540	} else if (comptime std.mem.eql(u8, fmt, "c")) {
538		if (@TypeOf(int_value).bit_count <= 8) {
	541	if (@typeInfo(@TypeOf(int_value)).Int.bits <= 8) {
539	542	return formatAsciiChar(@as(u8, int_value), options, writer);
540	543	} else {
541	544	@compileError("Cannot print integer that is larger than 8 bits as a ascii");
...	...	@@ -599,6 +602,16 @@ pub fn formatText(
599	602	try formatInt(c, 16, fmt[0] == 'X', FormatOptions{ .width = 2, .fill = '0' }, writer);
600	603	}
601	604	return;
	605	} else if (comptime (std.mem.eql(u8, fmt, "e") or std.mem.eql(u8, fmt, "E"))) {
	606	for (bytes) \|c\| {
	607	if (std.ascii.isPrint(c)) {
	608	try writer.writeByte(c);
	609	} else {
	610	try writer.writeAll("\\x");
	611	try formatInt(c, 16, fmt[0] == 'E', FormatOptions{ .width = 2, .fill = '0' }, writer);
	612	}
	613	}
	614	return;
602	615	} else {
603	616	@compileError("Unknown format string: '" ++ fmt ++ "'");
604	617	}
...	...	@@ -934,7 +947,7 @@ pub fn formatInt(
934	947	} else
935	948	value;
936	949
937		if (@TypeOf(int_value).is_signed) {
	950	if (@typeInfo(@TypeOf(int_value)).Int.is_signed) {
938	951	return formatIntSigned(int_value, base, uppercase, options, writer);
939	952	} else {
940	953	return formatIntUnsigned(int_value, base, uppercase, options, writer);
...	...	@@ -976,9 +989,10 @@ fn formatIntUnsigned(
976	989	writer: anytype,
977	990	) !void {
978	991	assert(base >= 2);
979		var buf: [math.max(@TypeOf(value).bit_count, 1)]u8 = undefined;
980		const min_int_bits = comptime math.max(@TypeOf(value).bit_count, @TypeOf(base).bit_count);
981		const MinInt = std.meta.Int(@TypeOf(value).is_signed, min_int_bits);
	992	const value_info = @typeInfo(@TypeOf(value)).Int;
	993	var buf: [math.max(value_info.bits, 1)]u8 = undefined;
	994	const min_int_bits = comptime math.max(value_info.bits, @typeInfo(@TypeOf(base)).Int.bits);
	995	const MinInt = std.meta.Int(value_info.is_signed, min_int_bits);
982	996	var a: MinInt = value;
983	997	var index: usize = buf.len;
984	998
...	...	@@ -1319,6 +1333,12 @@ test "slice" {
1319	1333	try testFmt("buf: Test\n Other text", "buf: {s}\n Other text", .{"Test"});
1320	1334	}
1321	1335
	1336	test "escape non-printable" {
	1337	try testFmt("abc", "{e}", .{"abc"});
	1338	try testFmt("ab\\xffc", "{e}", .{"ab\xffc"});
	1339	try testFmt("ab\\xFFc", "{E}", .{"ab\xffc"});
	1340	}
	1341
1322	1342	test "pointer" {
1323	1343	{
1324	1344	const value = @intToPtr(*align(1) i32, 0xdeadbeef);

lib/std/fmt/parse_float.zig+5-2

...	...	@@ -37,7 +37,9 @@
37	37	const std = @import("../std.zig");
38	38	const ascii = std.ascii;
39	39
40		const max_digits = 25;
	40	// The mantissa field in FloatRepr is 64bit wide and holds only 19 digits
	41	// without overflowing
	42	const max_digits = 19;
41	43
42	44	const f64_plus_zero: u64 = 0x0000000000000000;
43	45	const f64_minus_zero: u64 = 0x8000000000000000;
...	...	@@ -372,7 +374,7 @@ test "fmt.parseFloat" {
372	374	const epsilon = 1e-7;
373	375
374	376	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
375		const Z = std.meta.Int(false, T.bit_count);
	377	const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
376	378
377	379	testing.expectError(error.InvalidCharacter, parseFloat(T, ""));
378	380	testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));
...	...	@@ -409,6 +411,7 @@ test "fmt.parseFloat" {
409	411	expect(approxEq(T, try parseFloat(T, "123142.1"), 123142.1, epsilon));
410	412	expect(approxEq(T, try parseFloat(T, "-123142.1124"), @as(T, -123142.1124), epsilon));
411	413	expect(approxEq(T, try parseFloat(T, "0.7062146892655368"), @as(T, 0.7062146892655368), epsilon));
	414	expect(approxEq(T, try parseFloat(T, "2.71828182845904523536"), @as(T, 2.718281828459045), epsilon));
412	415	}
413	416	}
414	417	}

lib/std/fs.zig+9-3

...	...	@@ -1437,26 +1437,32 @@ pub const Dir = struct {
1437	1437	/// On success, caller owns returned buffer.
1438	1438	/// If the file is larger than `max_bytes`, returns `error.FileTooBig`.
1439	1439	pub fn readFileAlloc(self: Dir, allocator: *mem.Allocator, file_path: []const u8, max_bytes: usize) ![]u8 {
1440		return self.readFileAllocOptions(allocator, file_path, max_bytes, @alignOf(u8), null);
	1440	return self.readFileAllocOptions(allocator, file_path, max_bytes, null, @alignOf(u8), null);
1441	1441	}
1442	1442
1443	1443	/// On success, caller owns returned buffer.
1444	1444	/// If the file is larger than `max_bytes`, returns `error.FileTooBig`.
	1445	/// If `size_hint` is specified the initial buffer size is calculated using
	1446	/// that value, otherwise the effective file size is used instead.
1445	1447	/// Allows specifying alignment and a sentinel value.
1446	1448	pub fn readFileAllocOptions(
1447	1449	self: Dir,
1448	1450	allocator: *mem.Allocator,
1449	1451	file_path: []const u8,
1450	1452	max_bytes: usize,
	1453	size_hint: ?usize,
1451	1454	comptime alignment: u29,
1452	1455	comptime optional_sentinel: ?u8,
1453	1456	) !(if (optional_sentinel) \|s\| [:s]align(alignment) u8 else []align(alignment) u8) {
1454	1457	var file = try self.openFile(file_path, .{});
1455	1458	defer file.close();
1456	1459
1457		const stat_size = try file.getEndPos();
	1460	// If the file size doesn't fit a usize it'll be certainly greater than
	1461	// `max_bytes`
	1462	const stat_size = size_hint orelse math.cast(usize, try file.getEndPos()) catch
	1463	return error.FileTooBig;
1458	1464
1459		return file.readAllAllocOptions(allocator, stat_size, max_bytes, alignment, optional_sentinel);
	1465	return file.readToEndAllocOptions(allocator, max_bytes, stat_size, alignment, optional_sentinel);
1460	1466	}
1461	1467
1462	1468	pub const DeleteTreeError = error{

lib/std/fs/file.zig+29-11

...	...	@@ -363,31 +363,49 @@ pub const File = struct {
363	363	try os.futimens(self.handle, &times);
364	364	}
365	365
	366	/// Reads all the bytes from the current position to the end of the file.
366	367	/// On success, caller owns returned buffer.
367	368	/// If the file is larger than `max_bytes`, returns `error.FileTooBig`.
368		pub fn readAllAlloc(self: File, allocator: *mem.Allocator, stat_size: u64, max_bytes: usize) ![]u8 {
369		return self.readAllAllocOptions(allocator, stat_size, max_bytes, @alignOf(u8), null);
	369	pub fn readToEndAlloc(self: File, allocator: *mem.Allocator, max_bytes: usize) ![]u8 {
	370	return self.readToEndAllocOptions(allocator, max_bytes, null, @alignOf(u8), null);
370	371	}
371	372
	373	/// Reads all the bytes from the current position to the end of the file.
372	374	/// On success, caller owns returned buffer.
373	375	/// If the file is larger than `max_bytes`, returns `error.FileTooBig`.
	376	/// If `size_hint` is specified the initial buffer size is calculated using
	377	/// that value, otherwise an arbitrary value is used instead.
374	378	/// Allows specifying alignment and a sentinel value.
375		pub fn readAllAllocOptions(
	379	pub fn readToEndAllocOptions(
376	380	self: File,
377	381	allocator: *mem.Allocator,
378		stat_size: u64,
379	382	max_bytes: usize,
	383	size_hint: ?usize,
380	384	comptime alignment: u29,
381	385	comptime optional_sentinel: ?u8,
382	386	) !(if (optional_sentinel) \|s\| [:s]align(alignment) u8 else []align(alignment) u8) {
383		const size = math.cast(usize, stat_size) catch math.maxInt(usize);
384		if (size > max_bytes) return error.FileTooBig;
385
386		const buf = try allocator.allocWithOptions(u8, size, alignment, optional_sentinel);
387		errdefer allocator.free(buf);
	387	// If no size hint is provided fall back to the size=0 code path
	388	const size = size_hint orelse 0;
	389
	390	// The file size returned by stat is used as hint to set the buffer
	391	// size. If the reported size is zero, as it happens on Linux for files
	392	// in /proc, a small buffer is allocated instead.
	393	const initial_cap = (if (size > 0) size else 1024) + @boolToInt(optional_sentinel != null);
	394	var array_list = try std.ArrayListAligned(u8, alignment).initCapacity(allocator, initial_cap);
	395	defer array_list.deinit();
	396
	397	self.reader().readAllArrayList(&array_list, max_bytes) catch \|err\| switch (err) {
	398	error.StreamTooLong => return error.FileTooBig,
	399	else => \|e\| return e,
	400	};
388	401
389		try self.reader().readNoEof(buf);
390		return buf;
	402	if (optional_sentinel) \|sentinel\| {
	403	try array_list.append(sentinel);
	404	const buf = array_list.toOwnedSlice();
	405	return buf[0 .. buf.len - 1 :sentinel];
	406	} else {
	407	return array_list.toOwnedSlice();
	408	}
391	409	}
392	410
393	411	pub const ReadError = os.ReadError;

lib/std/fs/test.zig+5-5

...	...	@@ -188,30 +188,30 @@ test "readAllAlloc" {
188	188	var file = try tmp_dir.dir.createFile("test_file", .{ .read = true });
189	189	defer file.close();
190	190
191		const buf1 = try file.readAllAlloc(testing.allocator, 0, 1024);
	191	const buf1 = try file.readToEndAlloc(testing.allocator, 1024);
192	192	defer testing.allocator.free(buf1);
193	193	testing.expect(buf1.len == 0);
194	194
195	195	const write_buf: []const u8 = "this is a test.\nthis is a test.\nthis is a test.\nthis is a test.\n";
196	196	try file.writeAll(write_buf);
197	197	try file.seekTo(0);
198		const file_size = try file.getEndPos();
199	198
200	199	// max_bytes > file_size
201		const buf2 = try file.readAllAlloc(testing.allocator, file_size, 1024);
	200	const buf2 = try file.readToEndAlloc(testing.allocator, 1024);
202	201	defer testing.allocator.free(buf2);
203	202	testing.expectEqual(write_buf.len, buf2.len);
204	203	testing.expect(std.mem.eql(u8, write_buf, buf2));
205	204	try file.seekTo(0);
206	205
207	206	// max_bytes == file_size
208		const buf3 = try file.readAllAlloc(testing.allocator, file_size, write_buf.len);
	207	const buf3 = try file.readToEndAlloc(testing.allocator, write_buf.len);
209	208	defer testing.allocator.free(buf3);
210	209	testing.expectEqual(write_buf.len, buf3.len);
211	210	testing.expect(std.mem.eql(u8, write_buf, buf3));
	211	try file.seekTo(0);
212	212
213	213	// max_bytes < file_size
214		testing.expectError(error.FileTooBig, file.readAllAlloc(testing.allocator, file_size, write_buf.len - 1));
	214	testing.expectError(error.FileTooBig, file.readToEndAlloc(testing.allocator, write_buf.len - 1));
215	215	}
216	216
217	217	test "directory operations on files" {

lib/std/hash/auto_hash.zig+1-1

...	...	@@ -113,7 +113,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
113	113	.Array => hashArray(hasher, key, strat),
114	114
115	115	.Vector => \|info\| {
116		if (info.child.bit_count % 8 == 0) {
	116	if (std.meta.bitCount(info.child) % 8 == 0) {
117	117	// If there's no unused bits in the child type, we can just hash
118	118	// this as an array of bytes.
119	119	hasher.update(mem.asBytes(&key));

lib/std/heap.zig+5-1

...	...	@@ -915,6 +915,10 @@ pub fn testAllocator(base_allocator: *mem.Allocator) !void {
915	915	testing.expect(slice.len == 10);
916	916
917	917	allocator.free(slice);
	918
	919	const zero_bit_ptr = try allocator.create(u0);
	920	zero_bit_ptr.* = 0;
	921	allocator.destroy(zero_bit_ptr);
918	922	}
919	923
920	924	pub fn testAllocatorAligned(base_allocator: *mem.Allocator, comptime alignment: u29) !void {
...	...	@@ -952,7 +956,7 @@ pub fn testAllocatorLargeAlignment(base_allocator: *mem.Allocator) mem.Allocator
952	956	// very near usize?
953	957	if (mem.page_size << 2 > maxInt(usize)) return;
954	958
955		const USizeShift = std.meta.Int(false, std.math.log2(usize.bit_count));
	959	const USizeShift = std.meta.Int(false, std.math.log2(std.meta.bitCount(usize)));
956	960	const large_align = @as(u29, mem.page_size << 2);
957	961
958	962	var align_mask: usize = undefined;

lib/std/io.zig+9

...	...	@@ -169,6 +169,15 @@ pub const BitOutStream = BitWriter;
169	169	/// Deprecated: use `bitWriter`
170	170	pub const bitOutStream = bitWriter;
171	171
	172	pub const AutoIndentingStream = @import("io/auto_indenting_stream.zig").AutoIndentingStream;
	173	pub const autoIndentingStream = @import("io/auto_indenting_stream.zig").autoIndentingStream;
	174
	175	pub const ChangeDetectionStream = @import("io/change_detection_stream.zig").ChangeDetectionStream;
	176	pub const changeDetectionStream = @import("io/change_detection_stream.zig").changeDetectionStream;
	177
	178	pub const FindByteOutStream = @import("io/find_byte_out_stream.zig").FindByteOutStream;
	179	pub const findByteOutStream = @import("io/find_byte_out_stream.zig").findByteOutStream;
	180
172	181	pub const Packing = @import("io/serialization.zig").Packing;
173	182
174	183	pub const Serializer = @import("io/serialization.zig").Serializer;

lib/std/io/auto_indenting_stream.zig created+148

...	...	@@ -0,0 +1,148 @@
	1	const std = @import("../std.zig");
	2	const io = std.io;
	3	const mem = std.mem;
	4	const assert = std.debug.assert;
	5
	6	/// Automatically inserts indentation of written data by keeping
	7	/// track of the current indentation level
	8	pub fn AutoIndentingStream(comptime UnderlyingWriter: type) type {
	9	return struct {
	10	const Self = @This();
	11	pub const Error = UnderlyingWriter.Error;
	12	pub const Writer = io.Writer(*Self, Error, write);
	13
	14	underlying_writer: UnderlyingWriter,
	15
	16	indent_count: usize = 0,
	17	indent_delta: usize,
	18	current_line_empty: bool = true,
	19	indent_one_shot_count: usize = 0, // automatically popped when applied
	20	applied_indent: usize = 0, // the most recently applied indent
	21	indent_next_line: usize = 0, // not used until the next line
	22
	23	pub fn writer(self: *Self) Writer {
	24	return .{ .context = self };
	25	}
	26
	27	pub fn write(self: *Self, bytes: []const u8) Error!usize {
	28	if (bytes.len == 0)
	29	return @as(usize, 0);
	30
	31	try self.applyIndent();
	32	return self.writeNoIndent(bytes);
	33	}
	34
	35	// Change the indent delta without changing the final indentation level
	36	pub fn setIndentDelta(self: *Self, indent_delta: usize) void {
	37	if (self.indent_delta == indent_delta) {
	38	return;
	39	} else if (self.indent_delta > indent_delta) {
	40	assert(self.indent_delta % indent_delta == 0);
	41	self.indent_count = self.indent_count * (self.indent_delta / indent_delta);
	42	} else {
	43	// assert that the current indentation (in spaces) in a multiple of the new delta
	44	assert((self.indent_count * self.indent_delta) % indent_delta == 0);
	45	self.indent_count = self.indent_count / (indent_delta / self.indent_delta);
	46	}
	47	self.indent_delta = indent_delta;
	48	}
	49
	50	fn writeNoIndent(self: *Self, bytes: []const u8) Error!usize {
	51	if (bytes.len == 0)
	52	return @as(usize, 0);
	53
	54	try self.underlying_writer.writeAll(bytes);
	55	if (bytes[bytes.len - 1] == '\n')
	56	self.resetLine();
	57	return bytes.len;
	58	}
	59
	60	pub fn insertNewline(self: *Self) Error!void {
	61	_ = try self.writeNoIndent("\n");
	62	}
	63
	64	fn resetLine(self: *Self) void {
	65	self.current_line_empty = true;
	66	self.indent_next_line = 0;
	67	}
	68
	69	/// Insert a newline unless the current line is blank
	70	pub fn maybeInsertNewline(self: *Self) Error!void {
	71	if (!self.current_line_empty)
	72	try self.insertNewline();
	73	}
	74
	75	/// Push default indentation
	76	pub fn pushIndent(self: *Self) void {
	77	// Doesn't actually write any indentation.
	78	// Just primes the stream to be able to write the correct indentation if it needs to.
	79	self.indent_count += 1;
	80	}
	81
	82	/// Push an indent that is automatically popped after being applied
	83	pub fn pushIndentOneShot(self: *Self) void {
	84	self.indent_one_shot_count += 1;
	85	self.pushIndent();
	86	}
	87
	88	/// Turns all one-shot indents into regular indents
	89	/// Returns number of indents that must now be manually popped
	90	pub fn lockOneShotIndent(self: *Self) usize {
	91	var locked_count = self.indent_one_shot_count;
	92	self.indent_one_shot_count = 0;
	93	return locked_count;
	94	}
	95
	96	/// Push an indent that should not take effect until the next line
	97	pub fn pushIndentNextLine(self: *Self) void {
	98	self.indent_next_line += 1;
	99	self.pushIndent();
	100	}
	101
	102	pub fn popIndent(self: *Self) void {
	103	assert(self.indent_count != 0);
	104	self.indent_count -= 1;
	105
	106	if (self.indent_next_line > 0)
	107	self.indent_next_line -= 1;
	108	}
	109
	110	/// Writes ' ' bytes if the current line is empty
	111	fn applyIndent(self: *Self) Error!void {
	112	const current_indent = self.currentIndent();
	113	if (self.current_line_empty and current_indent > 0) {
	114	try self.underlying_writer.writeByteNTimes(' ', current_indent);
	115	self.applied_indent = current_indent;
	116	}
	117
	118	self.indent_count -= self.indent_one_shot_count;
	119	self.indent_one_shot_count = 0;
	120	self.current_line_empty = false;
	121	}
	122
	123	/// Checks to see if the most recent indentation exceeds the currently pushed indents
	124	pub fn isLineOverIndented(self: *Self) bool {
	125	if (self.current_line_empty) return false;
	126	return self.applied_indent > self.currentIndent();
	127	}
	128
	129	fn currentIndent(self: *Self) usize {
	130	var indent_current: usize = 0;
	131	if (self.indent_count > 0) {
	132	const indent_count = self.indent_count - self.indent_next_line;
	133	indent_current = indent_count * self.indent_delta;
	134	}
	135	return indent_current;
	136	}
	137	};
	138	}
	139
	140	pub fn autoIndentingStream(
	141	indent_delta: usize,
	142	underlying_writer: anytype,
	143	) AutoIndentingStream(@TypeOf(underlying_writer)) {
	144	return AutoIndentingStream(@TypeOf(underlying_writer)){
	145	.underlying_writer = underlying_writer,
	146	.indent_delta = indent_delta,
	147	};
	148	}

lib/std/io/change_detection_stream.zig created+55

...	...	@@ -0,0 +1,55 @@
	1	const std = @import("../std.zig");
	2	const io = std.io;
	3	const mem = std.mem;
	4	const assert = std.debug.assert;
	5
	6	/// Used to detect if the data written to a stream differs from a source buffer
	7	pub fn ChangeDetectionStream(comptime WriterType: type) type {
	8	return struct {
	9	const Self = @This();
	10	pub const Error = WriterType.Error;
	11	pub const Writer = io.Writer(*Self, Error, write);
	12
	13	anything_changed: bool,
	14	underlying_writer: WriterType,
	15	source_index: usize,
	16	source: []const u8,
	17
	18	pub fn writer(self: *Self) Writer {
	19	return .{ .context = self };
	20	}
	21
	22	fn write(self: *Self, bytes: []const u8) Error!usize {
	23	if (!self.anything_changed) {
	24	const end = self.source_index + bytes.len;
	25	if (end > self.source.len) {
	26	self.anything_changed = true;
	27	} else {
	28	const src_slice = self.source[self.source_index..end];
	29	self.source_index += bytes.len;
	30	if (!mem.eql(u8, bytes, src_slice)) {
	31	self.anything_changed = true;
	32	}
	33	}
	34	}
	35
	36	return self.underlying_writer.write(bytes);
	37	}
	38
	39	pub fn changeDetected(self: *Self) bool {
	40	return self.anything_changed or (self.source_index != self.source.len);
	41	}
	42	};
	43	}
	44
	45	pub fn changeDetectionStream(
	46	source: []const u8,
	47	underlying_writer: anytype,
	48	) ChangeDetectionStream(@TypeOf(underlying_writer)) {
	49	return ChangeDetectionStream(@TypeOf(underlying_writer)){
	50	.anything_changed = false,
	51	.underlying_writer = underlying_writer,
	52	.source_index = 0,
	53	.source = source,
	54	};
	55	}

lib/std/io/find_byte_out_stream.zig created+40

...	...	@@ -0,0 +1,40 @@
	1	const std = @import("../std.zig");
	2	const io = std.io;
	3	const assert = std.debug.assert;
	4
	5	/// An OutStream that returns whether the given character has been written to it.
	6	/// The contents are not written to anything.
	7	pub fn FindByteOutStream(comptime UnderlyingWriter: type) type {
	8	return struct {
	9	const Self = @This();
	10	pub const Error = UnderlyingWriter.Error;
	11	pub const Writer = io.Writer(*Self, Error, write);
	12
	13	underlying_writer: UnderlyingWriter,
	14	byte_found: bool,
	15	byte: u8,
	16
	17	pub fn writer(self: *Self) Writer {
	18	return .{ .context = self };
	19	}
	20
	21	fn write(self: *Self, bytes: []const u8) Error!usize {
	22	if (!self.byte_found) {
	23	self.byte_found = blk: {
	24	for (bytes) \|b\|
	25	if (b == self.byte) break :blk true;
	26	break :blk false;
	27	};
	28	}
	29	return self.underlying_writer.write(bytes);
	30	}
	31	};
	32	}
	33
	34	pub fn findByteOutStream(byte: u8, underlying_writer: anytype) FindByteOutStream(@TypeOf(underlying_writer)) {
	35	return FindByteOutStream(@TypeOf(underlying_writer)){
	36	.underlying_writer = underlying_writer,
	37	.byte = byte,
	38	.byte_found = false,
	39	};
	40	}

lib/std/io/reader.zig+5-5

...	...	@@ -198,28 +198,28 @@ pub fn Reader(
198	198
199	199	/// Reads a native-endian integer
200	200	pub fn readIntNative(self: Self, comptime T: type) !T {
201		const bytes = try self.readBytesNoEof((T.bit_count + 7) / 8);
	201	const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
202	202	return mem.readIntNative(T, &bytes);
203	203	}
204	204
205	205	/// Reads a foreign-endian integer
206	206	pub fn readIntForeign(self: Self, comptime T: type) !T {
207		const bytes = try self.readBytesNoEof((T.bit_count + 7) / 8);
	207	const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
208	208	return mem.readIntForeign(T, &bytes);
209	209	}
210	210
211	211	pub fn readIntLittle(self: Self, comptime T: type) !T {
212		const bytes = try self.readBytesNoEof((T.bit_count + 7) / 8);
	212	const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
213	213	return mem.readIntLittle(T, &bytes);
214	214	}
215	215
216	216	pub fn readIntBig(self: Self, comptime T: type) !T {
217		const bytes = try self.readBytesNoEof((T.bit_count + 7) / 8);
	217	const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
218	218	return mem.readIntBig(T, &bytes);
219	219	}
220	220
221	221	pub fn readInt(self: Self, comptime T: type, endian: builtin.Endian) !T {
222		const bytes = try self.readBytesNoEof((T.bit_count + 7) / 8);
	222	const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
223	223	return mem.readInt(T, &bytes, endian);
224	224	}
225	225

lib/std/io/serialization.zig+3-3

...	...	@@ -60,7 +60,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
60	60
61	61	const U = std.meta.Int(false, t_bit_count);
62	62	const Log2U = math.Log2Int(U);
63		const int_size = (U.bit_count + 7) / 8;
	63	const int_size = (t_bit_count + 7) / 8;
64	64
65	65	if (packing == .Bit) {
66	66	const result = try self.in_stream.readBitsNoEof(U, t_bit_count);
...	...	@@ -73,7 +73,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
73	73
74	74	if (int_size == 1) {
75	75	if (t_bit_count == 8) return @bitCast(T, buffer[0]);
76		const PossiblySignedByte = std.meta.Int(T.is_signed, 8);
	76	const PossiblySignedByte = std.meta.Int(@typeInfo(T).Int.is_signed, 8);
77	77	return @truncate(T, @bitCast(PossiblySignedByte, buffer[0]));
78	78	}
79	79
...	...	@@ -247,7 +247,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
247	247
248	248	const U = std.meta.Int(false, t_bit_count);
249	249	const Log2U = math.Log2Int(U);
250		const int_size = (U.bit_count + 7) / 8;
	250	const int_size = (t_bit_count + 7) / 8;
251	251
252	252	const u_value = @bitCast(U, value);
253	253

lib/std/io/writer.zig+5-5

...	...	@@ -53,7 +53,7 @@ pub fn Writer(
53	53	/// Write a native-endian integer.
54	54	/// TODO audit non-power-of-two int sizes
55	55	pub fn writeIntNative(self: Self, comptime T: type, value: T) Error!void {
56		var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
	56	var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
57	57	mem.writeIntNative(T, &bytes, value);
58	58	return self.writeAll(&bytes);
59	59	}
...	...	@@ -61,28 +61,28 @@ pub fn Writer(
61	61	/// Write a foreign-endian integer.
62	62	/// TODO audit non-power-of-two int sizes
63	63	pub fn writeIntForeign(self: Self, comptime T: type, value: T) Error!void {
64		var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
	64	var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
65	65	mem.writeIntForeign(T, &bytes, value);
66	66	return self.writeAll(&bytes);
67	67	}
68	68
69	69	/// TODO audit non-power-of-two int sizes
70	70	pub fn writeIntLittle(self: Self, comptime T: type, value: T) Error!void {
71		var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
	71	var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
72	72	mem.writeIntLittle(T, &bytes, value);
73	73	return self.writeAll(&bytes);
74	74	}
75	75
76	76	/// TODO audit non-power-of-two int sizes
77	77	pub fn writeIntBig(self: Self, comptime T: type, value: T) Error!void {
78		var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
	78	var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
79	79	mem.writeIntBig(T, &bytes, value);
80	80	return self.writeAll(&bytes);
81	81	}
82	82
83	83	/// TODO audit non-power-of-two int sizes
84	84	pub fn writeInt(self: Self, comptime T: type, value: T, endian: builtin.Endian) Error!void {
85		var bytes: [(T.bit_count + 7) / 8]u8 = undefined;
	85	var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
86	86	mem.writeInt(T, &bytes, value, endian);
87	87	return self.writeAll(&bytes);
88	88	}

lib/std/log.zig+4

...	...	@@ -127,6 +127,10 @@ fn log(
127	127	if (@enumToInt(message_level) <= @enumToInt(level)) {
128	128	if (@hasDecl(root, "log")) {
129	129	root.log(message_level, scope, format, args);
	130	} else if (std.Target.current.os.tag == .freestanding) {
	131	// On freestanding one must provide a log function; we do not have
	132	// any I/O configured.
	133	return;
130	134	} else if (builtin.mode != .ReleaseSmall) {
131	135	const held = std.debug.getStderrMutex().acquire();
132	136	defer held.release();

lib/std/math.zig+32-31

...	...	@@ -195,7 +195,7 @@ test "" {
195	195	pub fn floatMantissaBits(comptime T: type) comptime_int {
196	196	assert(@typeInfo(T) == .Float);
197	197
198		return switch (T.bit_count) {
	198	return switch (@typeInfo(T).Float.bits) {
199	199	16 => 10,
200	200	32 => 23,
201	201	64 => 52,
...	...	@@ -208,7 +208,7 @@ pub fn floatMantissaBits(comptime T: type) comptime_int {
208	208	pub fn floatExponentBits(comptime T: type) comptime_int {
209	209	assert(@typeInfo(T) == .Float);
210	210
211		return switch (T.bit_count) {
	211	return switch (@typeInfo(T).Float.bits) {
212	212	16 => 5,
213	213	32 => 8,
214	214	64 => 11,
...	...	@@ -347,9 +347,9 @@ pub fn shlExact(comptime T: type, a: T, shift_amt: Log2Int(T)) !T {
347	347	/// A negative shift amount results in a right shift.
348	348	pub fn shl(comptime T: type, a: T, shift_amt: anytype) T {
349	349	const abs_shift_amt = absCast(shift_amt);
350		const casted_shift_amt = if (abs_shift_amt >= T.bit_count) return 0 else @intCast(Log2Int(T), abs_shift_amt);
	350	const casted_shift_amt = if (abs_shift_amt >= @typeInfo(T).Int.bits) return 0 else @intCast(Log2Int(T), abs_shift_amt);
351	351
352		if (@TypeOf(shift_amt) == comptime_int or @TypeOf(shift_amt).is_signed) {
	352	if (@TypeOf(shift_amt) == comptime_int or @typeInfo(@TypeOf(shift_amt)).Int.is_signed) {
353	353	if (shift_amt < 0) {
354	354	return a >> casted_shift_amt;
355	355	}
...	...	@@ -373,9 +373,9 @@ test "math.shl" {
373	373	/// A negative shift amount results in a left shift.
374	374	pub fn shr(comptime T: type, a: T, shift_amt: anytype) T {
375	375	const abs_shift_amt = absCast(shift_amt);
376		const casted_shift_amt = if (abs_shift_amt >= T.bit_count) return 0 else @intCast(Log2Int(T), abs_shift_amt);
	376	const casted_shift_amt = if (abs_shift_amt >= @typeInfo(T).Int.bits) return 0 else @intCast(Log2Int(T), abs_shift_amt);
377	377
378		if (@TypeOf(shift_amt) == comptime_int or @TypeOf(shift_amt).is_signed) {
	378	if (@TypeOf(shift_amt) == comptime_int or @typeInfo(@TypeOf(shift_amt)).Int.is_signed) {
379	379	if (shift_amt >= 0) {
380	380	return a >> casted_shift_amt;
381	381	} else {
...	...	@@ -400,11 +400,11 @@ test "math.shr" {
400	400	/// Rotates right. Only unsigned values can be rotated.
401	401	/// Negative shift values results in shift modulo the bit count.
402	402	pub fn rotr(comptime T: type, x: T, r: anytype) T {
403		if (T.is_signed) {
	403	if (@typeInfo(T).Int.is_signed) {
404	404	@compileError("cannot rotate signed integer");
405	405	} else {
406		const ar = @mod(r, T.bit_count);
407		return shr(T, x, ar) \| shl(T, x, T.bit_count - ar);
	406	const ar = @mod(r, @typeInfo(T).Int.bits);
	407	return shr(T, x, ar) \| shl(T, x, @typeInfo(T).Int.bits - ar);
408	408	}
409	409	}
410	410
...	...	@@ -419,11 +419,11 @@ test "math.rotr" {
419	419	/// Rotates left. Only unsigned values can be rotated.
420	420	/// Negative shift values results in shift modulo the bit count.
421	421	pub fn rotl(comptime T: type, x: T, r: anytype) T {
422		if (T.is_signed) {
	422	if (@typeInfo(T).Int.is_signed) {
423	423	@compileError("cannot rotate signed integer");
424	424	} else {
425		const ar = @mod(r, T.bit_count);
426		return shl(T, x, ar) \| shr(T, x, T.bit_count - ar);
	425	const ar = @mod(r, @typeInfo(T).Int.bits);
	426	return shl(T, x, ar) \| shr(T, x, @typeInfo(T).Int.bits - ar);
427	427	}
428	428	}
429	429
...	...	@@ -438,7 +438,7 @@ test "math.rotl" {
438	438	pub fn Log2Int(comptime T: type) type {
439	439	// comptime ceil log2
440	440	comptime var count = 0;
441		comptime var s = T.bit_count - 1;
	441	comptime var s = @typeInfo(T).Int.bits - 1;
442	442	inline while (s != 0) : (s >>= 1) {
443	443	count += 1;
444	444	}
...	...	@@ -524,7 +524,7 @@ fn testOverflow() void {
524	524	pub fn absInt(x: anytype) !@TypeOf(x) {
525	525	const T = @TypeOf(x);
526	526	comptime assert(@typeInfo(T) == .Int); // must pass an integer to absInt
527		comptime assert(T.is_signed); // must pass a signed integer to absInt
	527	comptime assert(@typeInfo(T).Int.is_signed); // must pass a signed integer to absInt
528	528
529	529	if (x == minInt(@TypeOf(x))) {
530	530	return error.Overflow;
...	...	@@ -557,7 +557,7 @@ fn testAbsFloat() void {
557	557	pub fn divTrunc(comptime T: type, numerator: T, denominator: T) !T {
558	558	@setRuntimeSafety(false);
559	559	if (denominator == 0) return error.DivisionByZero;
560		if (@typeInfo(T) == .Int and T.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
	560	if (@typeInfo(T) == .Int and @typeInfo(T).Int.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
561	561	return @divTrunc(numerator, denominator);
562	562	}
563	563
...	...	@@ -578,7 +578,7 @@ fn testDivTrunc() void {
578	578	pub fn divFloor(comptime T: type, numerator: T, denominator: T) !T {
579	579	@setRuntimeSafety(false);
580	580	if (denominator == 0) return error.DivisionByZero;
581		if (@typeInfo(T) == .Int and T.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
	581	if (@typeInfo(T) == .Int and @typeInfo(T).Int.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
582	582	return @divFloor(numerator, denominator);
583	583	}
584	584
...	...	@@ -652,7 +652,7 @@ fn testDivCeil() void {
652	652	pub fn divExact(comptime T: type, numerator: T, denominator: T) !T {
653	653	@setRuntimeSafety(false);
654	654	if (denominator == 0) return error.DivisionByZero;
655		if (@typeInfo(T) == .Int and T.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
	655	if (@typeInfo(T) == .Int and @typeInfo(T).Int.is_signed and numerator == minInt(T) and denominator == -1) return error.Overflow;
656	656	const result = @divTrunc(numerator, denominator);
657	657	if (result * denominator != numerator) return error.UnexpectedRemainder;
658	658	return result;
...	...	@@ -757,10 +757,10 @@ test "math.absCast" {
757	757
758	758	/// Returns the negation of the integer parameter.
759	759	/// Result is a signed integer.
760		pub fn negateCast(x: anytype) !std.meta.Int(true, @TypeOf(x).bit_count) {
761		if (@TypeOf(x).is_signed) return negate(x);
	760	pub fn negateCast(x: anytype) !std.meta.Int(true, std.meta.bitCount(@TypeOf(x))) {
	761	if (@typeInfo(@TypeOf(x)).Int.is_signed) return negate(x);
762	762
763		const int = std.meta.Int(true, @TypeOf(x).bit_count);
	763	const int = std.meta.Int(true, std.meta.bitCount(@TypeOf(x)));
764	764	if (x > -minInt(int)) return error.Overflow;
765	765
766	766	if (x == -minInt(int)) return minInt(int);
...	...	@@ -823,7 +823,7 @@ pub fn floorPowerOfTwo(comptime T: type, value: T) T {
823	823	var x = value;
824	824
825	825	comptime var i = 1;
826		inline while (T.bit_count > i) : (i *= 2) {
	826	inline while (@typeInfo(T).Int.bits > i) : (i *= 2) {
827	827	x \|= (x >> i);
828	828	}
829	829
...	...	@@ -847,13 +847,13 @@ fn testFloorPowerOfTwo() void {
847	847	/// Returns the next power of two (if the value is not already a power of two).
848	848	/// Only unsigned integers can be used. Zero is not an allowed input.
849	849	/// Result is a type with 1 more bit than the input type.
850		pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(T.is_signed, T.bit_count + 1) {
	850	pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(@typeInfo(T).Int.is_signed, @typeInfo(T).Int.bits + 1) {
851	851	comptime assert(@typeInfo(T) == .Int);
852		comptime assert(!T.is_signed);
	852	comptime assert(!@typeInfo(T).Int.is_signed);
853	853	assert(value != 0);
854		comptime const PromotedType = std.meta.Int(T.is_signed, T.bit_count + 1);
	854	comptime const PromotedType = std.meta.Int(@typeInfo(T).Int.is_signed, @typeInfo(T).Int.bits + 1);
855	855	comptime const shiftType = std.math.Log2Int(PromotedType);
856		return @as(PromotedType, 1) << @intCast(shiftType, T.bit_count - @clz(T, value - 1));
	856	return @as(PromotedType, 1) << @intCast(shiftType, @typeInfo(T).Int.bits - @clz(T, value - 1));
857	857	}
858	858
859	859	/// Returns the next power of two (if the value is not already a power of two).
...	...	@@ -861,9 +861,10 @@ pub fn ceilPowerOfTwoPromote(comptime T: type, value: T) std.meta.Int(T.is_signe
861	861	/// If the value doesn't fit, returns an error.
862	862	pub fn ceilPowerOfTwo(comptime T: type, value: T) (error{Overflow}!T) {
863	863	comptime assert(@typeInfo(T) == .Int);
864		comptime assert(!T.is_signed);
865		comptime const PromotedType = std.meta.Int(T.is_signed, T.bit_count + 1);
866		comptime const overflowBit = @as(PromotedType, 1) << T.bit_count;
	864	const info = @typeInfo(T).Int;
	865	comptime assert(!info.is_signed);
	866	comptime const PromotedType = std.meta.Int(info.is_signed, info.bits + 1);
	867	comptime const overflowBit = @as(PromotedType, 1) << info.bits;
867	868	var x = ceilPowerOfTwoPromote(T, value);
868	869	if (overflowBit & x != 0) {
869	870	return error.Overflow;
...	...	@@ -911,7 +912,7 @@ fn testCeilPowerOfTwo() !void {
911	912
912	913	pub fn log2_int(comptime T: type, x: T) Log2Int(T) {
913	914	assert(x != 0);
914		return @intCast(Log2Int(T), T.bit_count - 1 - @clz(T, x));
	915	return @intCast(Log2Int(T), @typeInfo(T).Int.bits - 1 - @clz(T, x));
915	916	}
916	917
917	918	pub fn log2_int_ceil(comptime T: type, x: T) Log2Int(T) {
...	...	@@ -1008,8 +1009,8 @@ test "max value type" {
1008	1009	testing.expect(x == 2147483647);
1009	1010	}
1010	1011
1011		pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(T.is_signed, T.bit_count * 2) {
1012		const ResultInt = std.meta.Int(T.is_signed, T.bit_count * 2);
	1012	pub fn mulWide(comptime T: type, a: T, b: T) std.meta.Int(@typeInfo(T).Int.is_signed, @typeInfo(T).Int.bits * 2) {
	1013	const ResultInt = std.meta.Int(@typeInfo(T).Int.is_signed, @typeInfo(T).Int.bits * 2);
1013	1014	return @as(ResultInt, a) * @as(ResultInt, b);
1014	1015	}
1015	1016

lib/std/math/big.zig+6-5

...	...	@@ -9,14 +9,15 @@ const assert = std.debug.assert;
9	9	pub const Rational = @import("big/rational.zig").Rational;
10	10	pub const int = @import("big/int.zig");
11	11	pub const Limb = usize;
12		pub const DoubleLimb = std.meta.IntType(false, 2 * Limb.bit_count);
13		pub const SignedDoubleLimb = std.meta.IntType(true, DoubleLimb.bit_count);
	12	const limb_info = @typeInfo(Limb).Int;
	13	pub const DoubleLimb = std.meta.IntType(false, 2 * limb_info.bits);
	14	pub const SignedDoubleLimb = std.meta.IntType(true, 2 * limb_info.bits);
14	15	pub const Log2Limb = std.math.Log2Int(Limb);
15	16
16	17	comptime {
17		assert(std.math.floorPowerOfTwo(usize, Limb.bit_count) == Limb.bit_count);
18		assert(Limb.bit_count <= 64); // u128 set is unsupported
19		assert(Limb.is_signed == false);
	18	assert(std.math.floorPowerOfTwo(usize, limb_info.bits) == limb_info.bits);
	19	assert(limb_info.bits <= 64); // u128 set is unsupported
	20	assert(limb_info.is_signed == false);
20	21	}
21	22
22	23	test "" {

lib/std/math/big/int.zig+44-43

...	...	@@ -6,6 +6,7 @@
6	6	const std = @import("../../std.zig");
7	7	const math = std.math;
8	8	const Limb = std.math.big.Limb;
	9	const limb_bits = @typeInfo(Limb).Int.bits;
9	10	const DoubleLimb = std.math.big.DoubleLimb;
10	11	const SignedDoubleLimb = std.math.big.SignedDoubleLimb;
11	12	const Log2Limb = std.math.big.Log2Limb;
...	...	@@ -28,7 +29,7 @@ pub fn calcLimbLen(scalar: anytype) usize {
28	29	},
29	30	.ComptimeInt => {
30	31	const w_value = if (scalar < 0) -scalar else scalar;
31		return @divFloor(math.log2(w_value), Limb.bit_count) + 1;
	32	return @divFloor(math.log2(w_value), limb_bits) + 1;
32	33	},
33	34	else => @compileError("parameter must be a primitive integer type"),
34	35	}
...	...	@@ -54,7 +55,7 @@ pub fn calcSetStringLimbsBufferLen(base: u8, string_len: usize) usize {
54	55	}
55	56
56	57	pub fn calcSetStringLimbCount(base: u8, string_len: usize) usize {
57		return (string_len + (Limb.bit_count / base - 1)) / (Limb.bit_count / base);
	58	return (string_len + (limb_bits / base - 1)) / (limb_bits / base);
58	59	}
59	60
60	61	/// a + b * c + *carry, sets carry to the overflow bits
...	...	@@ -68,7 +69,7 @@ pub fn addMulLimbWithCarry(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {
68	69	// r2 = b * c
69	70	const bc = @as(DoubleLimb, math.mulWide(Limb, b, c));
70	71	const r2 = @truncate(Limb, bc);
71		const c2 = @truncate(Limb, bc >> Limb.bit_count);
	72	const c2 = @truncate(Limb, bc >> limb_bits);
72	73
73	74	// r1 = r1 + r2
74	75	const c3: Limb = @boolToInt(@addWithOverflow(Limb, r1, r2, &r1));
...	...	@@ -181,7 +182,7 @@ pub const Mutable = struct {
181	182
182	183	switch (@typeInfo(T)) {
183	184	.Int => \|info\| {
184		const UT = if (T.is_signed) std.meta.Int(false, T.bit_count - 1) else T;
	185	const UT = if (info.is_signed) std.meta.Int(false, info.bits - 1) else T;
185	186
186	187	const needed_limbs = @sizeOf(UT) / @sizeOf(Limb);
187	188	assert(needed_limbs <= self.limbs.len); // value too big
...	...	@@ -190,7 +191,7 @@ pub const Mutable = struct {
190	191
191	192	var w_value: UT = if (value < 0) @intCast(UT, -value) else @intCast(UT, value);
192	193
193		if (info.bits <= Limb.bit_count) {
	194	if (info.bits <= limb_bits) {
194	195	self.limbs[0] = @as(Limb, w_value);
195	196	self.len += 1;
196	197	} else {
...	...	@@ -200,15 +201,15 @@ pub const Mutable = struct {
200	201	self.len += 1;
201	202
202	203	// TODO: shift == 64 at compile-time fails. Fails on u128 limbs.
203		w_value >>= Limb.bit_count / 2;
204		w_value >>= Limb.bit_count / 2;
	204	w_value >>= limb_bits / 2;
	205	w_value >>= limb_bits / 2;
205	206	}
206	207	}
207	208	},
208	209	.ComptimeInt => {
209	210	comptime var w_value = if (value < 0) -value else value;
210	211
211		const req_limbs = @divFloor(math.log2(w_value), Limb.bit_count) + 1;
	212	const req_limbs = @divFloor(math.log2(w_value), limb_bits) + 1;
212	213	assert(req_limbs <= self.limbs.len); // value too big
213	214
214	215	self.len = req_limbs;
...	...	@@ -217,14 +218,14 @@ pub const Mutable = struct {
217	218	if (w_value <= maxInt(Limb)) {
218	219	self.limbs[0] = w_value;
219	220	} else {
220		const mask = (1 << Limb.bit_count) - 1;
	221	const mask = (1 << limb_bits) - 1;
221	222
222	223	comptime var i = 0;
223	224	inline while (w_value != 0) : (i += 1) {
224	225	self.limbs[i] = w_value & mask;
225	226
226		w_value >>= Limb.bit_count / 2;
227		w_value >>= Limb.bit_count / 2;
	227	w_value >>= limb_bits / 2;
	228	w_value >>= limb_bits / 2;
228	229	}
229	230	}
230	231	},
...	...	@@ -506,7 +507,7 @@ pub const Mutable = struct {
506	507	/// `a.limbs.len + (shift / (@sizeOf(Limb) * 8))`.
507	508	pub fn shiftLeft(r: *Mutable, a: Const, shift: usize) void {
508	509	llshl(r.limbs[0..], a.limbs[0..a.limbs.len], shift);
509		r.normalize(a.limbs.len + (shift / Limb.bit_count) + 1);
	510	r.normalize(a.limbs.len + (shift / limb_bits) + 1);
510	511	r.positive = a.positive;
511	512	}
512	513
...	...	@@ -516,7 +517,7 @@ pub const Mutable = struct {
516	517	/// Asserts there is enough memory to fit the result. The upper bound Limb count is
517	518	/// `a.limbs.len - (shift / (@sizeOf(Limb) * 8))`.
518	519	pub fn shiftRight(r: *Mutable, a: Const, shift: usize) void {
519		if (a.limbs.len <= shift / Limb.bit_count) {
	520	if (a.limbs.len <= shift / limb_bits) {
520	521	r.len = 1;
521	522	r.positive = true;
522	523	r.limbs[0] = 0;
...	...	@@ -524,7 +525,7 @@ pub const Mutable = struct {
524	525	}
525	526
526	527	const r_len = llshr(r.limbs[0..], a.limbs[0..a.limbs.len], shift);
527		r.len = a.limbs.len - (shift / Limb.bit_count);
	528	r.len = a.limbs.len - (shift / limb_bits);
528	529	r.positive = a.positive;
529	530	}
530	531
...	...	@@ -772,7 +773,7 @@ pub const Mutable = struct {
772	773	}
773	774
774	775	if (ab_zero_limb_count != 0) {
775		rem.shiftLeft(rem.toConst(), ab_zero_limb_count * Limb.bit_count);
	776	rem.shiftLeft(rem.toConst(), ab_zero_limb_count * limb_bits);
776	777	}
777	778	}
778	779
...	...	@@ -803,10 +804,10 @@ pub const Mutable = struct {
803	804	};
804	805	tmp.limbs[0] = 0;
805	806
806		// Normalize so y > Limb.bit_count / 2 (i.e. leading bit is set) and even
	807	// Normalize so y > limb_bits / 2 (i.e. leading bit is set) and even
807	808	var norm_shift = @clz(Limb, y.limbs[y.len - 1]);
808	809	if (norm_shift == 0 and y.toConst().isOdd()) {
809		norm_shift = Limb.bit_count;
	810	norm_shift = limb_bits;
810	811	}
811	812	x.shiftLeft(x.toConst(), norm_shift);
812	813	y.shiftLeft(y.toConst(), norm_shift);
...	...	@@ -820,7 +821,7 @@ pub const Mutable = struct {
820	821	mem.set(Limb, q.limbs[0..q.len], 0);
821	822
822	823	// 2.
823		tmp.shiftLeft(y.toConst(), Limb.bit_count * (n - t));
	824	tmp.shiftLeft(y.toConst(), limb_bits * (n - t));
824	825	while (x.toConst().order(tmp.toConst()) != .lt) {
825	826	q.limbs[n - t] += 1;
826	827	x.sub(x.toConst(), tmp.toConst());
...	...	@@ -833,7 +834,7 @@ pub const Mutable = struct {
833	834	if (x.limbs[i] == y.limbs[t]) {
834	835	q.limbs[i - t - 1] = maxInt(Limb);
835	836	} else {
836		const num = (@as(DoubleLimb, x.limbs[i]) << Limb.bit_count) \| @as(DoubleLimb, x.limbs[i - 1]);
	837	const num = (@as(DoubleLimb, x.limbs[i]) << limb_bits) \| @as(DoubleLimb, x.limbs[i - 1]);
837	838	const z = @intCast(Limb, num / @as(DoubleLimb, y.limbs[t]));
838	839	q.limbs[i - t - 1] = if (z > maxInt(Limb)) maxInt(Limb) else @as(Limb, z);
839	840	}
...	...	@@ -862,11 +863,11 @@ pub const Mutable = struct {
862	863	// 3.3
863	864	tmp.set(q.limbs[i - t - 1]);
864	865	tmp.mul(tmp.toConst(), y.toConst(), mul_limb_buf, allocator);
865		tmp.shiftLeft(tmp.toConst(), Limb.bit_count * (i - t - 1));
	866	tmp.shiftLeft(tmp.toConst(), limb_bits * (i - t - 1));
866	867	x.sub(x.toConst(), tmp.toConst());
867	868
868	869	if (!x.positive) {
869		tmp.shiftLeft(y.toConst(), Limb.bit_count * (i - t - 1));
	870	tmp.shiftLeft(y.toConst(), limb_bits * (i - t - 1));
870	871	x.add(x.toConst(), tmp.toConst());
871	872	q.limbs[i - t - 1] -= 1;
872	873	}
...	...	@@ -949,7 +950,7 @@ pub const Const = struct {
949	950
950	951	/// Returns the number of bits required to represent the absolute value of an integer.
951	952	pub fn bitCountAbs(self: Const) usize {
952		return (self.limbs.len - 1) * Limb.bit_count + (Limb.bit_count - @clz(Limb, self.limbs[self.limbs.len - 1]));
	953	return (self.limbs.len - 1) * limb_bits + (limb_bits - @clz(Limb, self.limbs[self.limbs.len - 1]));
953	954	}
954	955
955	956	/// Returns the number of bits required to represent the integer in twos-complement form.
...	...	@@ -1019,10 +1020,10 @@ pub const Const = struct {
1019	1020	/// Returns an error if self cannot be narrowed into the requested type without truncation.
1020	1021	pub fn to(self: Const, comptime T: type) ConvertError!T {
1021	1022	switch (@typeInfo(T)) {
1022		.Int => {
1023		const UT = std.meta.Int(false, T.bit_count);
	1023	.Int => \|info\| {
	1024	const UT = std.meta.Int(false, info.bits);
1024	1025
1025		if (self.bitCountTwosComp() > T.bit_count) {
	1026	if (self.bitCountTwosComp() > info.bits) {
1026	1027	return error.TargetTooSmall;
1027	1028	}
1028	1029
...	...	@@ -1033,12 +1034,12 @@ pub const Const = struct {
1033	1034	} else {
1034	1035	for (self.limbs[0..self.limbs.len]) \|_, ri\| {
1035	1036	const limb = self.limbs[self.limbs.len - ri - 1];
1036		r <<= Limb.bit_count;
	1037	r <<= limb_bits;
1037	1038	r \|= limb;
1038	1039	}
1039	1040	}
1040	1041
1041		if (!T.is_signed) {
	1042	if (!info.is_signed) {
1042	1043	return if (self.positive) @intCast(T, r) else error.NegativeIntoUnsigned;
1043	1044	} else {
1044	1045	if (self.positive) {
...	...	@@ -1149,7 +1150,7 @@ pub const Const = struct {
1149	1150
1150	1151	outer: for (self.limbs[0..self.limbs.len]) \|limb\| {
1151	1152	var shift: usize = 0;
1152		while (shift < Limb.bit_count) : (shift += base_shift) {
	1153	while (shift < limb_bits) : (shift += base_shift) {
1153	1154	const r = @intCast(u8, (limb >> @intCast(Log2Limb, shift)) & @as(Limb, base - 1));
1154	1155	const ch = std.fmt.digitToChar(r, uppercase);
1155	1156	string[digits_len] = ch;
...	...	@@ -1295,7 +1296,7 @@ pub const Const = struct {
1295	1296	/// Memory is allocated as needed to ensure operations never overflow. The range
1296	1297	/// is bounded only by available memory.
1297	1298	pub const Managed = struct {
1298		pub const sign_bit: usize = 1 << (usize.bit_count - 1);
	1299	pub const sign_bit: usize = 1 << (@typeInfo(usize).Int.bits - 1);
1299	1300
1300	1301	/// Default number of limbs to allocate on creation of a `Managed`.
1301	1302	pub const default_capacity = 4;
...	...	@@ -1448,7 +1449,7 @@ pub const Managed = struct {
1448	1449	for (self.limbs[0..self.len()]) \|limb\| {
1449	1450	std.debug.warn("{x} ", .{limb});
1450	1451	}
1451		std.debug.warn("capacity={} positive={}\n", .{ self.limbs.len, self.positive });
	1452	std.debug.warn("capacity={} positive={}\n", .{ self.limbs.len, self.isPositive() });
1452	1453	}
1453	1454
1454	1455	/// Negate the sign.
...	...	@@ -1716,7 +1717,7 @@ pub const Managed = struct {
1716	1717
1717	1718	/// r = a << shift, in other words, r = a * 2^shift
1718	1719	pub fn shiftLeft(r: *Managed, a: Managed, shift: usize) !void {
1719		try r.ensureCapacity(a.len() + (shift / Limb.bit_count) + 1);
	1720	try r.ensureCapacity(a.len() + (shift / limb_bits) + 1);
1720	1721	var m = r.toMutable();
1721	1722	m.shiftLeft(a.toConst(), shift);
1722	1723	r.setMetadata(m.positive, m.len);
...	...	@@ -1724,13 +1725,13 @@ pub const Managed = struct {
1724	1725
1725	1726	/// r = a >> shift
1726	1727	pub fn shiftRight(r: *Managed, a: Managed, shift: usize) !void {
1727		if (a.len() <= shift / Limb.bit_count) {
	1728	if (a.len() <= shift / limb_bits) {
1728	1729	r.metadata = 1;
1729	1730	r.limbs[0] = 0;
1730	1731	return;
1731	1732	}
1732	1733
1733		try r.ensureCapacity(a.len() - (shift / Limb.bit_count));
	1734	try r.ensureCapacity(a.len() - (shift / limb_bits));
1734	1735	var m = r.toMutable();
1735	1736	m.shiftRight(a.toConst(), shift);
1736	1737	r.setMetadata(m.positive, m.len);
...	...	@@ -2021,7 +2022,7 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
2021	2022	rem.* = 0;
2022	2023	for (a) \|_, ri\| {
2023	2024	const i = a.len - ri - 1;
2024		const pdiv = ((@as(DoubleLimb, rem.*) << Limb.bit_count) \| a[i]);
	2025	const pdiv = ((@as(DoubleLimb, rem.*) << limb_bits) \| a[i]);
2025	2026
2026	2027	if (pdiv == 0) {
2027	2028	quo[i] = 0;
...	...	@@ -2042,10 +2043,10 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
2042	2043	fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
2043	2044	@setRuntimeSafety(debug_safety);
2044	2045	assert(a.len >= 1);
2045		assert(r.len >= a.len + (shift / Limb.bit_count) + 1);
	2046	assert(r.len >= a.len + (shift / limb_bits) + 1);
2046	2047
2047		const limb_shift = shift / Limb.bit_count + 1;
2048		const interior_limb_shift = @intCast(Log2Limb, shift % Limb.bit_count);
	2048	const limb_shift = shift / limb_bits + 1;
	2049	const interior_limb_shift = @intCast(Log2Limb, shift % limb_bits);
2049	2050
2050	2051	var carry: Limb = 0;
2051	2052	var i: usize = 0;
...	...	@@ -2057,7 +2058,7 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
2057	2058	r[dst_i] = carry \| @call(.{ .modifier = .always_inline }, math.shr, .{
2058	2059	Limb,
2059	2060	src_digit,
2060		Limb.bit_count - @intCast(Limb, interior_limb_shift),
	2061	limb_bits - @intCast(Limb, interior_limb_shift),
2061	2062	});
2062	2063	carry = (src_digit << interior_limb_shift);
2063	2064	}
...	...	@@ -2069,10 +2070,10 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
2069	2070	fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
2070	2071	@setRuntimeSafety(debug_safety);
2071	2072	assert(a.len >= 1);
2072		assert(r.len >= a.len - (shift / Limb.bit_count));
	2073	assert(r.len >= a.len - (shift / limb_bits));
2073	2074
2074		const limb_shift = shift / Limb.bit_count;
2075		const interior_limb_shift = @intCast(Log2Limb, shift % Limb.bit_count);
	2075	const limb_shift = shift / limb_bits;
	2076	const interior_limb_shift = @intCast(Log2Limb, shift % limb_bits);
2076	2077
2077	2078	var carry: Limb = 0;
2078	2079	var i: usize = 0;
...	...	@@ -2085,7 +2086,7 @@ fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
2085	2086	carry = @call(.{ .modifier = .always_inline }, math.shl, .{
2086	2087	Limb,
2087	2088	src_digit,
2088		Limb.bit_count - @intCast(Limb, interior_limb_shift),
	2089	limb_bits - @intCast(Limb, interior_limb_shift),
2089	2090	});
2090	2091	}
2091	2092	}
...	...	@@ -2135,7 +2136,7 @@ fn fixedIntFromSignedDoubleLimb(A: SignedDoubleLimb, storage: []Limb) Mutable {
2135	2136	const A_is_positive = A >= 0;
2136	2137	const Au = @intCast(DoubleLimb, if (A < 0) -A else A);
2137	2138	storage[0] = @truncate(Limb, Au);
2138		storage[1] = @truncate(Limb, Au >> Limb.bit_count);
	2139	storage[1] = @truncate(Limb, Au >> limb_bits);
2139	2140	return .{
2140	2141	.limbs = storage[0..2],
2141	2142	.positive = A_is_positive,

lib/std/math/big/int_test.zig+3-3

...	...	@@ -23,13 +23,13 @@ test "big.int comptime_int set" {
23	23	var a = try Managed.initSet(testing.allocator, s);
24	24	defer a.deinit();
25	25
26		const s_limb_count = 128 / Limb.bit_count;
	26	const s_limb_count = 128 / @typeInfo(Limb).Int.bits;
27	27
28	28	comptime var i: usize = 0;
29	29	inline while (i < s_limb_count) : (i += 1) {
30	30	const result = @as(Limb, s & maxInt(Limb));
31		s >>= Limb.bit_count / 2;
32		s >>= Limb.bit_count / 2;
	31	s >>= @typeInfo(Limb).Int.bits / 2;
	32	s >>= @typeInfo(Limb).Int.bits / 2;
33	33	testing.expect(a.limbs[i] == result);
34	34	}
35	35	}

lib/std/math/big/rational.zig+9-7

...	...	@@ -136,7 +136,7 @@ pub const Rational = struct {
136	136	// Translated from golang.go/src/math/big/rat.go.
137	137	debug.assert(@typeInfo(T) == .Float);
138	138
139		const UnsignedInt = std.meta.Int(false, T.bit_count);
	139	const UnsignedInt = std.meta.Int(false, @typeInfo(T).Float.bits);
140	140	const f_bits = @bitCast(UnsignedInt, f);
141	141
142	142	const exponent_bits = math.floatExponentBits(T);
...	...	@@ -194,8 +194,8 @@ pub const Rational = struct {
194	194	// TODO: Indicate whether the result is not exact.
195	195	debug.assert(@typeInfo(T) == .Float);
196	196
197		const fsize = T.bit_count;
198		const BitReprType = std.meta.Int(false, T.bit_count);
	197	const fsize = @typeInfo(T).Float.bits;
	198	const BitReprType = std.meta.Int(false, fsize);
199	199
200	200	const msize = math.floatMantissaBits(T);
201	201	const msize1 = msize + 1;
...	...	@@ -475,16 +475,18 @@ pub const Rational = struct {
475	475	fn extractLowBits(a: Int, comptime T: type) T {
476	476	testing.expect(@typeInfo(T) == .Int);
477	477
478		if (T.bit_count <= Limb.bit_count) {
	478	const t_bits = @typeInfo(T).Int.bits;
	479	const limb_bits = @typeInfo(Limb).Int.bits;
	480	if (t_bits <= limb_bits) {
479	481	return @truncate(T, a.limbs[0]);
480	482	} else {
481	483	var r: T = 0;
482	484	comptime var i: usize = 0;
483	485
484		// Remainder is always 0 since if T.bit_count >= Limb.bit_count -> Limb \| T and both
	486	// Remainder is always 0 since if t_bits >= limb_bits -> Limb \| T and both
485	487	// are powers of two.
486		inline while (i < T.bit_count / Limb.bit_count) : (i += 1) {
487		r \|= math.shl(T, a.limbs[i], i * Limb.bit_count);
	488	inline while (i < t_bits / limb_bits) : (i += 1) {
	489	r \|= math.shl(T, a.limbs[i], i * limb_bits);
488	490	}
489	491
490	492	return r;

lib/std/math/cos.zig+1-1

...	...	@@ -49,7 +49,7 @@ const pi4c = 2.69515142907905952645E-15;
49	49	const m4pi = 1.273239544735162542821171882678754627704620361328125;
50	50
51	51	fn cos_(comptime T: type, x_: T) T {
52		const I = std.meta.Int(true, T.bit_count);
	52	const I = std.meta.Int(true, @typeInfo(T).Float.bits);
53	53
54	54	var x = x_;
55	55	if (math.isNan(x) or math.isInf(x)) {

lib/std/math/pow.zig+2-2

...	...	@@ -128,7 +128,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
128	128	if (yf != 0 and x < 0) {
129	129	return math.nan(T);
130	130	}
131		if (yi >= 1 << (T.bit_count - 1)) {
	131	if (yi >= 1 << (@typeInfo(T).Float.bits - 1)) {
132	132	return math.exp(y * math.ln(x));
133	133	}
134	134
...	...	@@ -150,7 +150,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
150	150	var xe = r2.exponent;
151	151	var x1 = r2.significand;
152	152
153		var i = @floatToInt(std.meta.Int(true, T.bit_count), yi);
	153	var i = @floatToInt(std.meta.Int(true, @typeInfo(T).Float.bits), yi);
154	154	while (i != 0) : (i >>= 1) {
155	155	const overflow_shift = math.floatExponentBits(T) + 1;
156	156	if (xe < -(1 << overflow_shift) or (1 << overflow_shift) < xe) {

lib/std/math/sin.zig+1-1

...	...	@@ -50,7 +50,7 @@ const pi4c = 2.69515142907905952645E-15;
50	50	const m4pi = 1.273239544735162542821171882678754627704620361328125;
51	51
52	52	fn sin_(comptime T: type, x_: T) T {
53		const I = std.meta.Int(true, T.bit_count);
	53	const I = std.meta.Int(true, @typeInfo(T).Float.bits);
54	54
55	55	var x = x_;
56	56	if (x == 0 or math.isNan(x)) {

lib/std/math/sqrt.zig+3-3

...	...	@@ -36,10 +36,10 @@ pub fn sqrt(x: anytype) Sqrt(@TypeOf(x)) {
36	36	}
37	37	}
38	38
39		fn sqrt_int(comptime T: type, value: T) std.meta.Int(false, T.bit_count / 2) {
	39	fn sqrt_int(comptime T: type, value: T) std.meta.Int(false, @typeInfo(T).Int.bits / 2) {
40	40	var op = value;
41	41	var res: T = 0;
42		var one: T = 1 << (T.bit_count - 2);
	42	var one: T = 1 << (@typeInfo(T).Int.bits - 2);
43	43
44	44	// "one" starts at the highest power of four <= than the argument.
45	45	while (one > op) {
...	...	@@ -55,7 +55,7 @@ fn sqrt_int(comptime T: type, value: T) std.meta.Int(false, T.bit_count / 2) {
55	55	one >>= 2;
56	56	}
57	57
58		const ResultType = std.meta.Int(false, T.bit_count / 2);
	58	const ResultType = std.meta.Int(false, @typeInfo(T).Int.bits / 2);
59	59	return @intCast(ResultType, res);
60	60	}
61	61

lib/std/math/tan.zig+1-1

...	...	@@ -43,7 +43,7 @@ const pi4c = 2.69515142907905952645E-15;
43	43	const m4pi = 1.273239544735162542821171882678754627704620361328125;
44	44
45	45	fn tan_(comptime T: type, x_: T) T {
46		const I = std.meta.Int(true, T.bit_count);
	46	const I = std.meta.Int(true, @typeInfo(T).Float.bits);
47	47
48	48	var x = x_;
49	49	if (x == 0 or math.isNan(x)) {

lib/std/mem.zig+21-21

...	...	@@ -949,7 +949,7 @@ pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: builtin.
949	949	/// This function cannot fail and cannot cause undefined behavior.
950	950	/// Assumes the endianness of memory is native. This means the function can
951	951	/// simply pointer cast memory.
952		pub fn readIntNative(comptime T: type, bytes: *const [@divExact(T.bit_count, 8)]u8) T {
	952	pub fn readIntNative(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8) T {
953	953	return @ptrCast(align(1) const T, bytes).;
954	954	}
955	955
...	...	@@ -957,7 +957,7 @@ pub fn readIntNative(comptime T: type, bytes: *const [@divExact(T.bit_count, 8)]
957	957	/// The bit count of T must be evenly divisible by 8.
958	958	/// This function cannot fail and cannot cause undefined behavior.
959	959	/// Assumes the endianness of memory is foreign, so it must byte-swap.
960		pub fn readIntForeign(comptime T: type, bytes: *const [@divExact(T.bit_count, 8)]u8) T {
	960	pub fn readIntForeign(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8) T {
961	961	return @byteSwap(T, readIntNative(T, bytes));
962	962	}
963	963
...	...	@@ -971,18 +971,18 @@ pub const readIntBig = switch (builtin.endian) {
971	971	.Big => readIntNative,
972	972	};
973	973
974		/// Asserts that bytes.len >= T.bit_count / 8. Reads the integer starting from index 0
	974	/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
975	975	/// and ignores extra bytes.
976	976	/// The bit count of T must be evenly divisible by 8.
977	977	/// Assumes the endianness of memory is native. This means the function can
978	978	/// simply pointer cast memory.
979	979	pub fn readIntSliceNative(comptime T: type, bytes: []const u8) T {
980		const n = @divExact(T.bit_count, 8);
	980	const n = @divExact(@typeInfo(T).Int.bits, 8);
981	981	assert(bytes.len >= n);
982	982	return readIntNative(T, bytes[0..n]);
983	983	}
984	984
985		/// Asserts that bytes.len >= T.bit_count / 8. Reads the integer starting from index 0
	985	/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
986	986	/// and ignores extra bytes.
987	987	/// The bit count of T must be evenly divisible by 8.
988	988	/// Assumes the endianness of memory is foreign, so it must byte-swap.
...	...	@@ -1003,7 +1003,7 @@ pub const readIntSliceBig = switch (builtin.endian) {
1003	1003	/// Reads an integer from memory with bit count specified by T.
1004	1004	/// The bit count of T must be evenly divisible by 8.
1005	1005	/// This function cannot fail and cannot cause undefined behavior.
1006		pub fn readInt(comptime T: type, bytes: *const [@divExact(T.bit_count, 8)]u8, endian: builtin.Endian) T {
	1006	pub fn readInt(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8, endian: builtin.Endian) T {
1007	1007	if (endian == builtin.endian) {
1008	1008	return readIntNative(T, bytes);
1009	1009	} else {
...	...	@@ -1011,11 +1011,11 @@ pub fn readInt(comptime T: type, bytes: *const [@divExact(T.bit_count, 8)]u8, en
1011	1011	}
1012	1012	}
1013	1013
1014		/// Asserts that bytes.len >= T.bit_count / 8. Reads the integer starting from index 0
	1014	/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
1015	1015	/// and ignores extra bytes.
1016	1016	/// The bit count of T must be evenly divisible by 8.
1017	1017	pub fn readIntSlice(comptime T: type, bytes: []const u8, endian: builtin.Endian) T {
1018		const n = @divExact(T.bit_count, 8);
	1018	const n = @divExact(@typeInfo(T).Int.bits, 8);
1019	1019	assert(bytes.len >= n);
1020	1020	return readInt(T, bytes[0..n], endian);
1021	1021	}
...	...	@@ -1060,7 +1060,7 @@ test "readIntBig and readIntLittle" {
1060	1060	/// accepts any integer bit width.
1061	1061	/// This function stores in native endian, which means it is implemented as a simple
1062	1062	/// memory store.
1063		pub fn writeIntNative(comptime T: type, buf: *[(T.bit_count + 7) / 8]u8, value: T) void {
	1063	pub fn writeIntNative(comptime T: type, buf: *[(@typeInfo(T).Int.bits + 7) / 8]u8, value: T) void {
1064	1064	@ptrCast(align(1) T, buf). = value;
1065	1065	}
1066	1066
...	...	@@ -1068,7 +1068,7 @@ pub fn writeIntNative(comptime T: type, buf: *[(T.bit_count + 7) / 8]u8, value:
1068	1068	/// This function always succeeds, has defined behavior for all inputs, but
1069	1069	/// the integer bit width must be divisible by 8.
1070	1070	/// This function stores in foreign endian, which means it does a @byteSwap first.
1071		pub fn writeIntForeign(comptime T: type, buf: *[@divExact(T.bit_count, 8)]u8, value: T) void {
	1071	pub fn writeIntForeign(comptime T: type, buf: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T) void {
1072	1072	writeIntNative(T, buf, @byteSwap(T, value));
1073	1073	}
1074	1074
...	...	@@ -1085,7 +1085,7 @@ pub const writeIntBig = switch (builtin.endian) {
1085	1085	/// Writes an integer to memory, storing it in twos-complement.
1086	1086	/// This function always succeeds, has defined behavior for all inputs, but
1087	1087	/// the integer bit width must be divisible by 8.
1088		pub fn writeInt(comptime T: type, buffer: *[@divExact(T.bit_count, 8)]u8, value: T, endian: builtin.Endian) void {
	1088	pub fn writeInt(comptime T: type, buffer: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T, endian: builtin.Endian) void {
1089	1089	if (endian == builtin.endian) {
1090	1090	return writeIntNative(T, buffer, value);
1091	1091	} else {
...	...	@@ -1094,19 +1094,19 @@ pub fn writeInt(comptime T: type, buffer: *[@divExact(T.bit_count, 8)]u8, value:
1094	1094	}
1095	1095
1096	1096	/// Writes a twos-complement little-endian integer to memory.
1097		/// Asserts that buf.len >= T.bit_count / 8.
	1097	/// Asserts that buf.len >= @typeInfo(T).Int.bits / 8.
1098	1098	/// The bit count of T must be divisible by 8.
1099	1099	/// Any extra bytes in buffer after writing the integer are set to zero. To
1100	1100	/// avoid the branch to check for extra buffer bytes, use writeIntLittle
1101	1101	/// instead.
1102	1102	pub fn writeIntSliceLittle(comptime T: type, buffer: []u8, value: T) void {
1103		assert(buffer.len >= @divExact(T.bit_count, 8));
	1103	assert(buffer.len >= @divExact(@typeInfo(T).Int.bits, 8));
1104	1104
1105		if (T.bit_count == 0)
	1105	if (@typeInfo(T).Int.bits == 0)
1106	1106	return set(u8, buffer, 0);
1107	1107
1108	1108	// TODO I want to call writeIntLittle here but comptime eval facilities aren't good enough
1109		const uint = std.meta.Int(false, T.bit_count);
	1109	const uint = std.meta.Int(false, @typeInfo(T).Int.bits);
1110	1110	var bits = @truncate(uint, value);
1111	1111	for (buffer) \|*b\| {
1112	1112	b.* = @truncate(u8, bits);
...	...	@@ -1115,18 +1115,18 @@ pub fn writeIntSliceLittle(comptime T: type, buffer: []u8, value: T) void {
1115	1115	}
1116	1116
1117	1117	/// Writes a twos-complement big-endian integer to memory.
1118		/// Asserts that buffer.len >= T.bit_count / 8.
	1118	/// Asserts that buffer.len >= @typeInfo(T).Int.bits / 8.
1119	1119	/// The bit count of T must be divisible by 8.
1120	1120	/// Any extra bytes in buffer before writing the integer are set to zero. To
1121	1121	/// avoid the branch to check for extra buffer bytes, use writeIntBig instead.
1122	1122	pub fn writeIntSliceBig(comptime T: type, buffer: []u8, value: T) void {
1123		assert(buffer.len >= @divExact(T.bit_count, 8));
	1123	assert(buffer.len >= @divExact(@typeInfo(T).Int.bits, 8));
1124	1124
1125		if (T.bit_count == 0)
	1125	if (@typeInfo(T).Int.bits == 0)
1126	1126	return set(u8, buffer, 0);
1127	1127
1128	1128	// TODO I want to call writeIntBig here but comptime eval facilities aren't good enough
1129		const uint = std.meta.Int(false, T.bit_count);
	1129	const uint = std.meta.Int(false, @typeInfo(T).Int.bits);
1130	1130	var bits = @truncate(uint, value);
1131	1131	var index: usize = buffer.len;
1132	1132	while (index != 0) {
...	...	@@ -1147,13 +1147,13 @@ pub const writeIntSliceForeign = switch (builtin.endian) {
1147	1147	};
1148	1148
1149	1149	/// Writes a twos-complement integer to memory, with the specified endianness.
1150		/// Asserts that buf.len >= T.bit_count / 8.
	1150	/// Asserts that buf.len >= @typeInfo(T).Int.bits / 8.
1151	1151	/// The bit count of T must be evenly divisible by 8.
1152	1152	/// Any extra bytes in buffer not part of the integer are set to zero, with
1153	1153	/// respect to endianness. To avoid the branch to check for extra buffer bytes,
1154	1154	/// use writeInt instead.
1155	1155	pub fn writeIntSlice(comptime T: type, buffer: []u8, value: T, endian: builtin.Endian) void {
1156		comptime assert(T.bit_count % 8 == 0);
	1156	comptime assert(@typeInfo(T).Int.bits % 8 == 0);
1157	1157	return switch (endian) {
1158	1158	.Little => writeIntSliceLittle(T, buffer, value),
1159	1159	.Big => writeIntSliceBig(T, buffer, value),

lib/std/mem/Allocator.zig+4-4

...	...	@@ -159,7 +159,7 @@ fn moveBytes(
159	159	/// Returns a pointer to undefined memory.
160	160	/// Call `destroy` with the result to free the memory.
161	161	pub fn create(self: Allocator, comptime T: type) Error!T {
162		if (@sizeOf(T) == 0) return &(T{});
	162	if (@sizeOf(T) == 0) return @as(*T, undefined);
163	163	const slice = try self.allocAdvancedWithRetAddr(T, null, 1, .exact, @returnAddress());
164	164	return &slice[0];
165	165	}
...	...	@@ -167,11 +167,11 @@ pub fn create(self: Allocator, comptime T: type) Error!T {
167	167	/// `ptr` should be the return value of `create`, or otherwise
168	168	/// have the same address and alignment property.
169	169	pub fn destroy(self: *Allocator, ptr: anytype) void {
170		const T = @TypeOf(ptr).Child;
	170	const info = @typeInfo(@TypeOf(ptr)).Pointer;
	171	const T = info.child;
171	172	if (@sizeOf(T) == 0) return;
172	173	const non_const_ptr = @intToPtr([*]u8, @ptrToInt(ptr));
173		const ptr_align = @typeInfo(@TypeOf(ptr)).Pointer.alignment;
174		_ = self.shrinkBytes(non_const_ptr[0..@sizeOf(T)], ptr_align, 0, 0, @returnAddress());
	174	_ = self.shrinkBytes(non_const_ptr[0..@sizeOf(T)], info.alignment, 0, 0, @returnAddress());
175	175	}
176	176
177	177	/// Allocates an array of `n` items of type `T` and sets all the

lib/std/meta.zig+8-8

...	...	@@ -705,34 +705,34 @@ pub fn Vector(comptime len: u32, comptime child: type) type {
705	705	pub fn cast(comptime DestType: type, target: anytype) DestType {
706	706	const TargetType = @TypeOf(target);
707	707	switch (@typeInfo(DestType)) {
708		.Pointer => {
	708	.Pointer => \|dest_ptr\| {
709	709	switch (@typeInfo(TargetType)) {
710	710	.Int, .ComptimeInt => {
711	711	return @intToPtr(DestType, target);
712	712	},
713	713	.Pointer => \|ptr\| {
714		return @ptrCast(DestType, @alignCast(ptr.alignment, target));
	714	return @ptrCast(DestType, @alignCast(dest_ptr.alignment, target));
715	715	},
716	716	.Optional => \|opt\| {
717	717	if (@typeInfo(opt.child) == .Pointer) {
718		return @ptrCast(DestType, @alignCast(@alignOf(opt.child.Child), target));
	718	return @ptrCast(DestType, @alignCast(dest_ptr, target));
719	719	}
720	720	},
721	721	else => {},
722	722	}
723	723	},
724		.Optional => \|opt\| {
725		if (@typeInfo(opt.child) == .Pointer) {
	724	.Optional => \|dest_opt\| {
	725	if (@typeInfo(dest_opt.child) == .Pointer) {
726	726	switch (@typeInfo(TargetType)) {
727	727	.Int, .ComptimeInt => {
728	728	return @intToPtr(DestType, target);
729	729	},
730		.Pointer => \|ptr\| {
731		return @ptrCast(DestType, @alignCast(ptr.alignment, target));
	730	.Pointer => {
	731	return @ptrCast(DestType, @alignCast(@alignOf(dest_opt.child.Child), target));
732	732	},
733	733	.Optional => \|target_opt\| {
734	734	if (@typeInfo(target_opt.child) == .Pointer) {
735		return @ptrCast(DestType, @alignCast(@alignOf(target_opt.child.Child), target));
	735	return @ptrCast(DestType, @alignCast(@alignOf(dest_opt.child.Child), target));
736	736	}
737	737	},
738	738	else => {},

lib/std/net.zig+4-1

...	...	@@ -1164,7 +1164,7 @@ fn linuxLookupNameFromDnsSearch(
1164	1164	}
1165	1165
1166	1166	const search = if (rc.search.isNull() or dots >= rc.ndots or mem.endsWith(u8, name, "."))
1167		&[_]u8{}
	1167	""
1168	1168	else
1169	1169	rc.search.span();
1170	1170
...	...	@@ -1641,6 +1641,9 @@ pub const StreamServer = struct {
1641	1641	/// by the socket buffer limits, not by the system memory.
1642	1642	SystemResources,
1643	1643
	1644	/// Socket is not listening for new connections.
	1645	SocketNotListening,
	1646
1644	1647	ProtocolFailure,
1645	1648
1646	1649	/// Firewall rules forbid connection.

lib/std/os.zig+113-23

...	...	@@ -2512,13 +2512,14 @@ pub fn readlinkatZ(dirfd: fd_t, file_path: [*:0]const u8, out_buffer: []u8) Read
2512	2512	}
2513	2513	}
2514	2514
2515		pub const SetIdError = error{
2516		ResourceLimitReached,
	2515	pub const SetEidError = error{
2517	2516	InvalidUserId,
2518	2517	PermissionDenied,
2519		} \|\| UnexpectedError;
	2518	};
	2519
	2520	pub const SetIdError = error{ResourceLimitReached} \|\| SetEidError \|\| UnexpectedError;
2520	2521
2521		pub fn setuid(uid: u32) SetIdError!void {
	2522	pub fn setuid(uid: uid_t) SetIdError!void {
2522	2523	switch (errno(system.setuid(uid))) {
2523	2524	0 => return,
2524	2525	EAGAIN => return error.ResourceLimitReached,
...	...	@@ -2528,7 +2529,16 @@ pub fn setuid(uid: u32) SetIdError!void {
2528	2529	}
2529	2530	}
2530	2531
2531		pub fn setreuid(ruid: u32, euid: u32) SetIdError!void {
	2532	pub fn seteuid(uid: uid_t) SetEidError!void {
	2533	switch (errno(system.seteuid(uid))) {
	2534	0 => return,
	2535	EINVAL => return error.InvalidUserId,
	2536	EPERM => return error.PermissionDenied,
	2537	else => \|err\| return unexpectedErrno(err),
	2538	}
	2539	}
	2540
	2541	pub fn setreuid(ruid: uid_t, euid: uid_t) SetIdError!void {
2532	2542	switch (errno(system.setreuid(ruid, euid))) {
2533	2543	0 => return,
2534	2544	EAGAIN => return error.ResourceLimitReached,
...	...	@@ -2538,7 +2548,7 @@ pub fn setreuid(ruid: u32, euid: u32) SetIdError!void {
2538	2548	}
2539	2549	}
2540	2550
2541		pub fn setgid(gid: u32) SetIdError!void {
	2551	pub fn setgid(gid: gid_t) SetIdError!void {
2542	2552	switch (errno(system.setgid(gid))) {
2543	2553	0 => return,
2544	2554	EAGAIN => return error.ResourceLimitReached,
...	...	@@ -2548,7 +2558,16 @@ pub fn setgid(gid: u32) SetIdError!void {
2548	2558	}
2549	2559	}
2550	2560
2551		pub fn setregid(rgid: u32, egid: u32) SetIdError!void {
	2561	pub fn setegid(uid: uid_t) SetEidError!void {
	2562	switch (errno(system.setegid(uid))) {
	2563	0 => return,
	2564	EINVAL => return error.InvalidUserId,
	2565	EPERM => return error.PermissionDenied,
	2566	else => \|err\| return unexpectedErrno(err),
	2567	}
	2568	}
	2569
	2570	pub fn setregid(rgid: gid_t, egid: gid_t) SetIdError!void {
2552	2571	switch (errno(system.setregid(rgid, egid))) {
2553	2572	0 => return,
2554	2573	EAGAIN => return error.ResourceLimitReached,
...	...	@@ -2815,6 +2834,9 @@ pub const AcceptError = error{
2815	2834	/// by the socket buffer limits, not by the system memory.
2816	2835	SystemResources,
2817	2836
	2837	/// Socket is not listening for new connections.
	2838	SocketNotListening,
	2839
2818	2840	ProtocolFailure,
2819	2841
2820	2842	/// Firewall rules forbid connection.
...	...	@@ -2884,21 +2906,21 @@ pub fn accept(
2884	2906	loop.waitUntilFdReadable(sock);
2885	2907	continue;
2886	2908	} else {
2887		return error.WouldBlock;
2888		},
2889		EBADF => unreachable, // always a race condition
2890		ECONNABORTED => return error.ConnectionAborted,
2891		EFAULT => unreachable,
2892		EINVAL => unreachable,
2893		ENOTSOCK => unreachable,
2894		EMFILE => return error.ProcessFdQuotaExceeded,
2895		ENFILE => return error.SystemFdQuotaExceeded,
2896		ENOBUFS => return error.SystemResources,
2897		ENOMEM => return error.SystemResources,
2898		EOPNOTSUPP => unreachable,
2899		EPROTO => return error.ProtocolFailure,
2900		EPERM => return error.BlockedByFirewall,
2901		else => \|err\| return unexpectedErrno(err),
	2909	return error.WouldBlock;
	2910	},
	2911	EBADF => unreachable, // always a race condition
	2912	ECONNABORTED => return error.ConnectionAborted,
	2913	EFAULT => unreachable,
	2914	EINVAL => return error.SocketNotListening,
	2915	ENOTSOCK => unreachable,
	2916	EMFILE => return error.ProcessFdQuotaExceeded,
	2917	ENFILE => return error.SystemFdQuotaExceeded,
	2918	ENOBUFS => return error.SystemResources,
	2919	ENOMEM => return error.SystemResources,
	2920	EOPNOTSUPP => unreachable,
	2921	EPROTO => return error.ProtocolFailure,
	2922	EPERM => return error.BlockedByFirewall,
	2923	else => \|err\| return unexpectedErrno(err),
2902	2924	}
2903	2925	}
2904	2926	} else unreachable;
...	...	@@ -4554,7 +4576,7 @@ pub fn res_mkquery(
4554	4576	// Make a reasonably unpredictable id
4555	4577	var ts: timespec = undefined;
4556	4578	clock_gettime(CLOCK_REALTIME, &ts) catch {};
4557		const UInt = std.meta.Int(false, @TypeOf(ts.tv_nsec).bit_count);
	4579	const UInt = std.meta.Int(false, std.meta.bitCount(@TypeOf(ts.tv_nsec)));
4558	4580	const unsec = @bitCast(UInt, ts.tv_nsec);
4559	4581	const id = @truncate(u32, unsec + unsec / 65536);
4560	4582	q[0] = @truncate(u8, id / 256);
...	...	@@ -5404,3 +5426,71 @@ pub fn signalfd(fd: fd_t, mask: *const sigset_t, flags: u32) !fd_t {
5404	5426	else => \|err\| return std.os.unexpectedErrno(err),
5405	5427	}
5406	5428	}
	5429
	5430	pub const SyncError = error{
	5431	InputOutput,
	5432	NoSpaceLeft,
	5433	DiskQuota,
	5434	AccessDenied,
	5435	} \|\| UnexpectedError;
	5436
	5437	/// Write all pending file contents and metadata modifications to all filesystems.
	5438	pub fn sync() void {
	5439	system.sync();
	5440	}
	5441
	5442	/// Write all pending file contents and metadata modifications to the filesystem which contains the specified file.
	5443	pub fn syncfs(fd: fd_t) SyncError!void {
	5444	const rc = system.syncfs(fd);
	5445	switch (errno(rc)) {
	5446	0 => return,
	5447	EBADF, EINVAL, EROFS => unreachable,
	5448	EIO => return error.InputOutput,
	5449	ENOSPC => return error.NoSpaceLeft,
	5450	EDQUOT => return error.DiskQuota,
	5451	else => \|err\| return std.os.unexpectedErrno(err),
	5452	}
	5453	}
	5454
	5455	/// Write all pending file contents and metadata modifications for the specified file descriptor to the underlying filesystem.
	5456	pub fn fsync(fd: fd_t) SyncError!void {
	5457	if (std.Target.current.os.tag == .windows) {
	5458	if (windows.kernel32.FlushFileBuffers(fd) != 0)
	5459	return;
	5460	switch (windows.kernel32.GetLastError()) {
	5461	.SUCCESS => return,
	5462	.INVALID_HANDLE => unreachable,
	5463	.ACCESS_DENIED => return error.AccessDenied, // a sync was performed but the system couldn't update the access time
	5464	.UNEXP_NET_ERR => return error.InputOutput,
	5465	else => return error.InputOutput,
	5466	}
	5467	}
	5468	const rc = system.fsync(fd);
	5469	switch (errno(rc)) {
	5470	0 => return,
	5471	EBADF, EINVAL, EROFS => unreachable,
	5472	EIO => return error.InputOutput,
	5473	ENOSPC => return error.NoSpaceLeft,
	5474	EDQUOT => return error.DiskQuota,
	5475	else => \|err\| return std.os.unexpectedErrno(err),
	5476	}
	5477	}
	5478
	5479	/// Write all pending file contents for the specified file descriptor to the underlying filesystem, but not necessarily the metadata.
	5480	pub fn fdatasync(fd: fd_t) SyncError!void {
	5481	if (std.Target.current.os.tag == .windows) {
	5482	return fsync(fd) catch \|err\| switch (err) {
	5483	SyncError.AccessDenied => return, // fdatasync doesn't promise that the access time was synced
	5484	else => return err,
	5485	};
	5486	}
	5487	const rc = system.fdatasync(fd);
	5488	switch (errno(rc)) {
	5489	0 => return,
	5490	EBADF, EINVAL, EROFS => unreachable,
	5491	EIO => return error.InputOutput,
	5492	ENOSPC => return error.NoSpaceLeft,
	5493	EDQUOT => return error.DiskQuota,
	5494	else => \|err\| return std.os.unexpectedErrno(err),
	5495	}
	5496	}

lib/std/os/bits/darwin.zig+6-2

...	...	@@ -7,9 +7,13 @@ const std = @import("../../std.zig");
7	7	const assert = std.debug.assert;
8	8	const maxInt = std.math.maxInt;
9	9
	10	// See: https://opensource.apple.com/source/xnu/xnu-6153.141.1/bsd/sys/_types.h.auto.html
	11	// TODO: audit mode_t/pid_t, should likely be u16/i32
10	12	pub const fd_t = c_int;
11	13	pub const pid_t = c_int;
12	14	pub const mode_t = c_uint;
	15	pub const uid_t = u32;
	16	pub const gid_t = u32;
13	17
14	18	pub const in_port_t = u16;
15	19	pub const sa_family_t = u8;
...	...	@@ -79,8 +83,8 @@ pub const Stat = extern struct {
79	83	mode: u16,
80	84	nlink: u16,
81	85	ino: ino_t,
82		uid: u32,
83		gid: u32,
	86	uid: uid_t,
	87	gid: gid_t,
84	88	rdev: i32,
85	89	atimesec: isize,
86	90	atimensec: isize,

lib/std/os/bits/dragonfly.zig+10-3

...	...	@@ -9,10 +9,17 @@ const maxInt = std.math.maxInt;
9	9	pub fn S_ISCHR(m: u32) bool {
10	10	return m & S_IFMT == S_IFCHR;
11	11	}
	12
	13	// See:
	14	// - https://gitweb.dragonflybsd.org/dragonfly.git/blob/HEAD:/include/unistd.h
	15	// - https://gitweb.dragonflybsd.org/dragonfly.git/blob/HEAD:/sys/sys/types.h
	16	// TODO: mode_t should probably be changed to a u16, audit pid_t/off_t as well
12	17	pub const fd_t = c_int;
13	18	pub const pid_t = c_int;
14	19	pub const off_t = c_long;
15	20	pub const mode_t = c_uint;
	21	pub const uid_t = u32;
	22	pub const gid_t = u32;
16	23
17	24	pub const ENOTSUP = EOPNOTSUPP;
18	25	pub const EWOULDBLOCK = EAGAIN;
...	...	@@ -151,8 +158,8 @@ pub const Stat = extern struct {
151	158	dev: c_uint,
152	159	mode: c_ushort,
153	160	padding1: u16,
154		uid: c_uint,
155		gid: c_uint,
	161	uid: uid_t,
	162	gid: gid_t,
156	163	rdev: c_uint,
157	164	atim: timespec,
158	165	mtim: timespec,
...	...	@@ -511,7 +518,7 @@ pub const siginfo_t = extern struct {
511	518	si_errno: c_int,
512	519	si_code: c_int,
513	520	si_pid: c_int,
514		si_uid: c_uint,
	521	si_uid: uid_t,
515	522	si_status: c_int,
516	523	si_addr: ?*c_void,
517	524	si_value: union_sigval,

lib/std/os/bits/freebsd.zig+6-2

...	...	@@ -6,8 +6,12 @@
6	6	const std = @import("../../std.zig");
7	7	const maxInt = std.math.maxInt;
8	8
	9	// See https://svnweb.freebsd.org/base/head/sys/sys/_types.h?view=co
	10	// TODO: audit pid_t/mode_t. They should likely be i32 and u16, respectively
9	11	pub const fd_t = c_int;
10	12	pub const pid_t = c_int;
	13	pub const uid_t = u32;
	14	pub const gid_t = u32;
11	15	pub const mode_t = c_uint;
12	16
13	17	pub const socklen_t = u32;
...	...	@@ -128,8 +132,8 @@ pub const Stat = extern struct {
128	132
129	133	mode: u16,
130	134	__pad0: u16,
131		uid: u32,
132		gid: u32,
	135	uid: uid_t,
	136	gid: gid_t,
133	137	__pad1: u32,
134	138	rdev: u64,
135	139

lib/std/os/bits/linux.zig+5-5

...	...	@@ -29,7 +29,7 @@ const is_mips = builtin.arch.isMIPS();
29	29
30	30	pub const pid_t = i32;
31	31	pub const fd_t = i32;
32		pub const uid_t = i32;
	32	pub const uid_t = u32;
33	33	pub const gid_t = u32;
34	34	pub const clock_t = isize;
35	35
...	...	@@ -846,14 +846,14 @@ pub const SIG_ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
846	846	pub const SIG_DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
847	847	pub const SIG_IGN = @intToPtr(?Sigaction.sigaction_fn, 1);
848	848
849		pub const empty_sigset = [_]u32{0} ** sigset_t.len;
	849	pub const empty_sigset = [_]u32{0} ** @typeInfo(sigset_t).Array.len;
850	850
851	851	pub const signalfd_siginfo = extern struct {
852	852	signo: u32,
853	853	errno: i32,
854	854	code: i32,
855	855	pid: u32,
856		uid: u32,
	856	uid: uid_t,
857	857	fd: i32,
858	858	tid: u32,
859	859	band: u32,
...	...	@@ -1491,10 +1491,10 @@ pub const Statx = extern struct {
1491	1491	nlink: u32,
1492	1492
1493	1493	/// User ID of owner
1494		uid: u32,
	1494	uid: uid_t,
1495	1495
1496	1496	/// Group ID of owner
1497		gid: u32,
	1497	gid: gid_t,
1498	1498
1499	1499	/// File type and mode
1500	1500	mode: u16,

lib/std/os/bits/linux/x86_64.zig+3-2

...	...	@@ -7,6 +7,7 @@
7	7	const std = @import("../../../std.zig");
8	8	const pid_t = linux.pid_t;
9	9	const uid_t = linux.uid_t;
	10	const gid_t = linux.gid_t;
10	11	const clock_t = linux.clock_t;
11	12	const stack_t = linux.stack_t;
12	13	const sigset_t = linux.sigset_t;
...	...	@@ -523,8 +524,8 @@ pub const Stat = extern struct {
523	524	nlink: usize,
524	525
525	526	mode: u32,
526		uid: u32,
527		gid: u32,
	527	uid: uid_t,
	528	gid: gid_t,
528	529	__pad0: u32,
529	530	rdev: u64,
530	531	size: off_t,

lib/std/os/linux.zig+61-29

...	...	@@ -655,7 +655,7 @@ pub fn nanosleep(req: const timespec, rem: ?timespec) usize {
655	655	return syscall2(.nanosleep, @ptrToInt(req), @ptrToInt(rem));
656	656	}
657	657
658		pub fn setuid(uid: u32) usize {
	658	pub fn setuid(uid: uid_t) usize {
659	659	if (@hasField(SYS, "setuid32")) {
660	660	return syscall1(.setuid32, uid);
661	661	} else {
...	...	@@ -663,7 +663,7 @@ pub fn setuid(uid: u32) usize {
663	663	}
664	664	}
665	665
666		pub fn setgid(gid: u32) usize {
	666	pub fn setgid(gid: gid_t) usize {
667	667	if (@hasField(SYS, "setgid32")) {
668	668	return syscall1(.setgid32, gid);
669	669	} else {
...	...	@@ -671,7 +671,7 @@ pub fn setgid(gid: u32) usize {
671	671	}
672	672	}
673	673
674		pub fn setreuid(ruid: u32, euid: u32) usize {
	674	pub fn setreuid(ruid: uid_t, euid: uid_t) usize {
675	675	if (@hasField(SYS, "setreuid32")) {
676	676	return syscall2(.setreuid32, ruid, euid);
677	677	} else {
...	...	@@ -679,7 +679,7 @@ pub fn setreuid(ruid: u32, euid: u32) usize {
679	679	}
680	680	}
681	681
682		pub fn setregid(rgid: u32, egid: u32) usize {
	682	pub fn setregid(rgid: gid_t, egid: gid_t) usize {
683	683	if (@hasField(SYS, "setregid32")) {
684	684	return syscall2(.setregid32, rgid, egid);
685	685	} else {
...	...	@@ -687,47 +687,61 @@ pub fn setregid(rgid: u32, egid: u32) usize {
687	687	}
688	688	}
689	689
690		pub fn getuid() u32 {
	690	pub fn getuid() uid_t {
691	691	if (@hasField(SYS, "getuid32")) {
692		return @as(u32, syscall0(.getuid32));
	692	return @as(uid_t, syscall0(.getuid32));
693	693	} else {
694		return @as(u32, syscall0(.getuid));
	694	return @as(uid_t, syscall0(.getuid));
695	695	}
696	696	}
697	697
698		pub fn getgid() u32 {
	698	pub fn getgid() gid_t {
699	699	if (@hasField(SYS, "getgid32")) {
700		return @as(u32, syscall0(.getgid32));
	700	return @as(gid_t, syscall0(.getgid32));
701	701	} else {
702		return @as(u32, syscall0(.getgid));
	702	return @as(gid_t, syscall0(.getgid));
703	703	}
704	704	}
705	705
706		pub fn geteuid() u32 {
	706	pub fn geteuid() uid_t {
707	707	if (@hasField(SYS, "geteuid32")) {
708		return @as(u32, syscall0(.geteuid32));
	708	return @as(uid_t, syscall0(.geteuid32));
709	709	} else {
710		return @as(u32, syscall0(.geteuid));
	710	return @as(uid_t, syscall0(.geteuid));
711	711	}
712	712	}
713	713
714		pub fn getegid() u32 {
	714	pub fn getegid() gid_t {
715	715	if (@hasField(SYS, "getegid32")) {
716		return @as(u32, syscall0(.getegid32));
	716	return @as(gid_t, syscall0(.getegid32));
717	717	} else {
718		return @as(u32, syscall0(.getegid));
	718	return @as(gid_t, syscall0(.getegid));
719	719	}
720	720	}
721	721
722		pub fn seteuid(euid: u32) usize {
723		return setreuid(std.math.maxInt(u32), euid);
	722	pub fn seteuid(euid: uid_t) usize {
	723	// We use setresuid here instead of setreuid to ensure that the saved uid
	724	// is not changed. This is what musl and recent glibc versions do as well.
	725	//
	726	// The setresuid(2) man page says that if -1 is passed the corresponding
	727	// id will not be changed. Since uid_t is unsigned, this wraps around to the
	728	// max value in C.
	729	comptime assert(@typeInfo(uid_t) == .Int and !@typeInfo(uid_t).Int.is_signed);
	730	return setresuid(std.math.maxInt(uid_t), euid, std.math.maxInt(uid_t));
724	731	}
725	732
726		pub fn setegid(egid: u32) usize {
727		return setregid(std.math.maxInt(u32), egid);
	733	pub fn setegid(egid: gid_t) usize {
	734	// We use setresgid here instead of setregid to ensure that the saved uid
	735	// is not changed. This is what musl and recent glibc versions do as well.
	736	//
	737	// The setresgid(2) man page says that if -1 is passed the corresponding
	738	// id will not be changed. Since gid_t is unsigned, this wraps around to the
	739	// max value in C.
	740	comptime assert(@typeInfo(uid_t) == .Int and !@typeInfo(uid_t).Int.is_signed);
	741	return setresgid(std.math.maxInt(gid_t), egid, std.math.maxInt(gid_t));
728	742	}
729	743
730		pub fn getresuid(ruid: u32, euid: u32, suid: *u32) usize {
	744	pub fn getresuid(ruid: uid_t, euid: uid_t, suid: *uid_t) usize {
731	745	if (@hasField(SYS, "getresuid32")) {
732	746	return syscall3(.getresuid32, @ptrToInt(ruid), @ptrToInt(euid), @ptrToInt(suid));
733	747	} else {
...	...	@@ -735,7 +749,7 @@ pub fn getresuid(ruid: u32, euid: u32, suid: *u32) usize {
735	749	}
736	750	}
737	751
738		pub fn getresgid(rgid: u32, egid: u32, sgid: *u32) usize {
	752	pub fn getresgid(rgid: gid_t, egid: gid_t, sgid: *gid_t) usize {
739	753	if (@hasField(SYS, "getresgid32")) {
740	754	return syscall3(.getresgid32, @ptrToInt(rgid), @ptrToInt(egid), @ptrToInt(sgid));
741	755	} else {
...	...	@@ -743,7 +757,7 @@ pub fn getresgid(rgid: u32, egid: u32, sgid: *u32) usize {
743	757	}
744	758	}
745	759
746		pub fn setresuid(ruid: u32, euid: u32, suid: u32) usize {
	760	pub fn setresuid(ruid: uid_t, euid: uid_t, suid: uid_t) usize {
747	761	if (@hasField(SYS, "setresuid32")) {
748	762	return syscall3(.setresuid32, ruid, euid, suid);
749	763	} else {
...	...	@@ -751,7 +765,7 @@ pub fn setresuid(ruid: u32, euid: u32, suid: u32) usize {
751	765	}
752	766	}
753	767
754		pub fn setresgid(rgid: u32, egid: u32, sgid: u32) usize {
	768	pub fn setresgid(rgid: gid_t, egid: gid_t, sgid: gid_t) usize {
755	769	if (@hasField(SYS, "setresgid32")) {
756	770	return syscall3(.setresgid32, rgid, egid, sgid);
757	771	} else {
...	...	@@ -759,7 +773,7 @@ pub fn setresgid(rgid: u32, egid: u32, sgid: u32) usize {
759	773	}
760	774	}
761	775
762		pub fn getgroups(size: usize, list: *u32) usize {
	776	pub fn getgroups(size: usize, list: *gid_t) usize {
763	777	if (@hasField(SYS, "getgroups32")) {
764	778	return syscall2(.getgroups32, size, @ptrToInt(list));
765	779	} else {
...	...	@@ -767,7 +781,7 @@ pub fn getgroups(size: usize, list: *u32) usize {
767	781	}
768	782	}
769	783
770		pub fn setgroups(size: usize, list: *const u32) usize {
	784	pub fn setgroups(size: usize, list: *const gid_t) usize {
771	785	if (@hasField(SYS, "setgroups32")) {
772	786	return syscall2(.setgroups32, size, @ptrToInt(list));
773	787	} else {
...	...	@@ -815,17 +829,19 @@ pub fn sigaction(sig: u6, noalias act: const Sigaction, noalias oact: ?Sigacti
815	829	return 0;
816	830	}
817	831
	832	const usize_bits = @typeInfo(usize).Int.bits;
	833
818	834	pub fn sigaddset(set: *sigset_t, sig: u6) void {
819	835	const s = sig - 1;
820	836	// shift in musl: s&8sizeof set->__bits-1
821		const shift = @intCast(u5, s & (usize.bit_count - 1));
	837	const shift = @intCast(u5, s & (usize_bits - 1));
822	838	const val = @intCast(u32, 1) << shift;
823		(set.*)[@intCast(usize, s) / usize.bit_count] \|= val;
	839	(set.*)[@intCast(usize, s) / usize_bits] \|= val;
824	840	}
825	841
826	842	pub fn sigismember(set: *const sigset_t, sig: u6) bool {
827	843	const s = sig - 1;
828		return ((set.*)[@intCast(usize, s) / usize.bit_count] & (@intCast(usize, 1) << (s & (usize.bit_count - 1)))) != 0;
	844	return ((set.*)[@intCast(usize, s) / usize_bits] & (@intCast(usize, 1) << (s & (usize_bits - 1)))) != 0;
829	845	}
830	846
831	847	pub fn getsockname(fd: i32, noalias addr: sockaddr, noalias len: socklen_t) usize {
...	...	@@ -1226,6 +1242,22 @@ pub fn bpf(cmd: BPF.Cmd, attr: *BPF.Attr, size: u32) usize {
1226	1242	return syscall3(.bpf, @enumToInt(cmd), @ptrToInt(attr), size);
1227	1243	}
1228	1244
	1245	pub fn sync() void {
	1246	_ = syscall0(.sync);
	1247	}
	1248
	1249	pub fn syncfs(fd: fd_t) usize {
	1250	return syscall1(.syncfs, @bitCast(usize, @as(isize, fd)));
	1251	}
	1252
	1253	pub fn fsync(fd: fd_t) usize {
	1254	return syscall1(.fsync, @bitCast(usize, @as(isize, fd)));
	1255	}
	1256
	1257	pub fn fdatasync(fd: fd_t) usize {
	1258	return syscall1(.fdatasync, @bitCast(usize, @as(isize, fd)));
	1259	}
	1260
1229	1261	test "" {
1230	1262	if (builtin.os.tag == .linux) {
1231	1263	_ = @import("linux/test.zig");

lib/std/os/linux/bpf.zig+758-68

...	...	@@ -3,9 +3,13 @@
3	3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
4	4	// The MIT license requires this copyright notice to be included in all copies
5	5	// and substantial portions of the software.
6		usingnamespace std.os;
	6	usingnamespace std.os.linux;
7	7	const std = @import("../../std.zig");
	8	const errno = getErrno;
	9	const unexpectedErrno = std.os.unexpectedErrno;
8	10	const expectEqual = std.testing.expectEqual;
	11	const expectError = std.testing.expectError;
	12	const expect = std.testing.expect;
9	13
10	14	// instruction classes
11	15	pub const LD = 0x00;
...	...	@@ -62,6 +66,7 @@ pub const MAXINSNS = 4096;
62	66	// instruction classes
63	67	/// jmp mode in word width
64	68	pub const JMP32 = 0x06;
	69
65	70	/// alu mode in double word width
66	71	pub const ALU64 = 0x07;
67	72
...	...	@@ -72,14 +77,17 @@ pub const XADD = 0xc0;
72	77	// alu/jmp fields
73	78	/// mov reg to reg
74	79	pub const MOV = 0xb0;
	80
75	81	/// sign extending arithmetic shift right */
76	82	pub const ARSH = 0xc0;
77	83
78	84	// change endianness of a register
79	85	/// flags for endianness conversion:
80	86	pub const END = 0xd0;
	87
81	88	/// convert to little-endian */
82	89	pub const TO_LE = 0x00;
	90
83	91	/// convert to big-endian
84	92	pub const TO_BE = 0x08;
85	93	pub const FROM_LE = TO_LE;
...	...	@@ -88,29 +96,39 @@ pub const FROM_BE = TO_BE;
88	96	// jmp encodings
89	97	/// jump != *
90	98	pub const JNE = 0x50;
	99
91	100	/// LT is unsigned, '<'
92	101	pub const JLT = 0xa0;
	102
93	103	/// LE is unsigned, '<=' *
94	104	pub const JLE = 0xb0;
	105
95	106	/// SGT is signed '>', GT in x86
96	107	pub const JSGT = 0x60;
	108
97	109	/// SGE is signed '>=', GE in x86
98	110	pub const JSGE = 0x70;
	111
99	112	/// SLT is signed, '<'
100	113	pub const JSLT = 0xc0;
	114
101	115	/// SLE is signed, '<='
102	116	pub const JSLE = 0xd0;
	117
103	118	/// function call
104	119	pub const CALL = 0x80;
	120
105	121	/// function return
106	122	pub const EXIT = 0x90;
107	123
108	124	/// Flag for prog_attach command. If a sub-cgroup installs some bpf program, the
109	125	/// program in this cgroup yields to sub-cgroup program.
110	126	pub const F_ALLOW_OVERRIDE = 0x1;
	127
111	128	/// Flag for prog_attach command. If a sub-cgroup installs some bpf program,
112	129	/// that cgroup program gets run in addition to the program in this cgroup.
113	130	pub const F_ALLOW_MULTI = 0x2;
	131
114	132	/// Flag for prog_attach command.
115	133	pub const F_REPLACE = 0x4;
116	134
...	...	@@ -164,47 +182,61 @@ pub const PSEUDO_CALL = 1;
164	182
165	183	/// flag for BPF_MAP_UPDATE_ELEM command. create new element or update existing
166	184	pub const ANY = 0;
	185
167	186	/// flag for BPF_MAP_UPDATE_ELEM command. create new element if it didn't exist
168	187	pub const NOEXIST = 1;
	188
169	189	/// flag for BPF_MAP_UPDATE_ELEM command. update existing element
170	190	pub const EXIST = 2;
	191
171	192	/// flag for BPF_MAP_UPDATE_ELEM command. spin_lock-ed map_lookup/map_update
172	193	pub const F_LOCK = 4;
173	194
174	195	/// flag for BPF_MAP_CREATE command */
175	196	pub const BPF_F_NO_PREALLOC = 0x1;
	197
176	198	/// flag for BPF_MAP_CREATE command. Instead of having one common LRU list in
177	199	/// the BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list which can
178	200	/// scale and perform better. Note, the LRU nodes (including free nodes) cannot
179	201	/// be moved across different LRU lists.
180	202	pub const BPF_F_NO_COMMON_LRU = 0x2;
	203
181	204	/// flag for BPF_MAP_CREATE command. Specify numa node during map creation
182	205	pub const BPF_F_NUMA_NODE = 0x4;
	206
183	207	/// flag for BPF_MAP_CREATE command. Flags for BPF object read access from
184	208	/// syscall side
185	209	pub const BPF_F_RDONLY = 0x8;
	210
186	211	/// flag for BPF_MAP_CREATE command. Flags for BPF object write access from
187	212	/// syscall side
188	213	pub const BPF_F_WRONLY = 0x10;
	214
189	215	/// flag for BPF_MAP_CREATE command. Flag for stack_map, store build_id+offset
190	216	/// instead of pointer
191	217	pub const BPF_F_STACK_BUILD_ID = 0x20;
	218
192	219	/// flag for BPF_MAP_CREATE command. Zero-initialize hash function seed. This
193	220	/// should only be used for testing.
194	221	pub const BPF_F_ZERO_SEED = 0x40;
	222
195	223	/// flag for BPF_MAP_CREATE command Flags for accessing BPF object from program
196	224	/// side.
197	225	pub const BPF_F_RDONLY_PROG = 0x80;
	226
198	227	/// flag for BPF_MAP_CREATE command. Flags for accessing BPF object from program
199	228	/// side.
200	229	pub const BPF_F_WRONLY_PROG = 0x100;
	230
201	231	/// flag for BPF_MAP_CREATE command. Clone map from listener for newly accepted
202	232	/// socket
203	233	pub const BPF_F_CLONE = 0x200;
	234
204	235	/// flag for BPF_MAP_CREATE command. Enable memory-mapping BPF map
205	236	pub const BPF_F_MMAPABLE = 0x400;
206	237
207		/// These values correspond to "syscalls" within the BPF program's environment
	238	/// These values correspond to "syscalls" within the BPF program's environment,
	239	/// each one is documented in std.os.linux.BPF.kern
208	240	pub const Helper = enum(i32) {
209	241	unspec,
210	242	map_lookup_elem,
...	...	@@ -325,9 +357,34 @@ pub const Helper = enum(i32) {
325	357	tcp_send_ack,
326	358	send_signal_thread,
327	359	jiffies64,
	360	read_branch_records,
	361	get_ns_current_pid_tgid,
	362	xdp_output,
	363	get_netns_cookie,
	364	get_current_ancestor_cgroup_id,
	365	sk_assign,
	366	ktime_get_boot_ns,
	367	seq_printf,
	368	seq_write,
	369	sk_cgroup_id,
	370	sk_ancestor_cgroup_id,
	371	ringbuf_output,
	372	ringbuf_reserve,
	373	ringbuf_submit,
	374	ringbuf_discard,
	375	ringbuf_query,
	376	csum_level,
	377	skc_to_tcp6_sock,
	378	skc_to_tcp_sock,
	379	skc_to_tcp_timewait_sock,
	380	skc_to_tcp_request_sock,
	381	skc_to_udp6_sock,
	382	get_task_stack,
328	383	_,
329	384	};
330	385
	386	// TODO: determine that this is the expected bit layout for both little and big
	387	// endian systems
331	388	/// a single BPF instruction
332	389	pub const Insn = packed struct {
333	390	code: u8,
...	...	@@ -340,19 +397,30 @@ pub const Insn = packed struct {
340	397	/// frame
341	398	pub const Reg = packed enum(u4) { r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10 };
342	399	const Source = packed enum(u1) { reg, imm };
	400
	401	const Mode = packed enum(u8) {
	402	imm = IMM,
	403	abs = ABS,
	404	ind = IND,
	405	mem = MEM,
	406	len = LEN,
	407	msh = MSH,
	408	};
	409
343	410	const AluOp = packed enum(u8) {
344	411	add = ADD,
345	412	sub = SUB,
346	413	mul = MUL,
347	414	div = DIV,
348		op_or = OR,
349		op_and = AND,
	415	alu_or = OR,
	416	alu_and = AND,
350	417	lsh = LSH,
351	418	rsh = RSH,
352	419	neg = NEG,
353	420	mod = MOD,
354	421	xor = XOR,
355	422	mov = MOV,
	423	arsh = ARSH,
356	424	};
357	425
358	426	pub const Size = packed enum(u8) {
...	...	@@ -368,6 +436,13 @@ pub const Insn = packed struct {
368	436	jgt = JGT,
369	437	jge = JGE,
370	438	jset = JSET,
	439	jlt = JLT,
	440	jle = JLE,
	441	jne = JNE,
	442	jsgt = JSGT,
	443	jsge = JSGE,
	444	jslt = JSLT,
	445	jsle = JSLE,
371	446	};
372	447
373	448	const ImmOrReg = union(Source) {
...	...	@@ -419,22 +494,100 @@ pub const Insn = packed struct {
419	494	return alu(64, .add, dst, src);
420	495	}
421	496
	497	pub fn sub(dst: Reg, src: anytype) Insn {
	498	return alu(64, .sub, dst, src);
	499	}
	500
	501	pub fn mul(dst: Reg, src: anytype) Insn {
	502	return alu(64, .mul, dst, src);
	503	}
	504
	505	pub fn div(dst: Reg, src: anytype) Insn {
	506	return alu(64, .div, dst, src);
	507	}
	508
	509	pub fn alu_or(dst: Reg, src: anytype) Insn {
	510	return alu(64, .alu_or, dst, src);
	511	}
	512
	513	pub fn alu_and(dst: Reg, src: anytype) Insn {
	514	return alu(64, .alu_and, dst, src);
	515	}
	516
	517	pub fn lsh(dst: Reg, src: anytype) Insn {
	518	return alu(64, .lsh, dst, src);
	519	}
	520
	521	pub fn rsh(dst: Reg, src: anytype) Insn {
	522	return alu(64, .rsh, dst, src);
	523	}
	524
	525	pub fn neg(dst: Reg) Insn {
	526	return alu(64, .neg, dst, 0);
	527	}
	528
	529	pub fn mod(dst: Reg, src: anytype) Insn {
	530	return alu(64, .mod, dst, src);
	531	}
	532
	533	pub fn xor(dst: Reg, src: anytype) Insn {
	534	return alu(64, .xor, dst, src);
	535	}
	536
	537	pub fn arsh(dst: Reg, src: anytype) Insn {
	538	return alu(64, .arsh, dst, src);
	539	}
	540
422	541	fn jmp(op: JmpOp, dst: Reg, src: anytype, off: i16) Insn {
423	542	return imm_reg(JMP \| @enumToInt(op), dst, src, off);
424	543	}
425	544
	545	pub fn ja(off: i16) Insn {
	546	return jmp(.ja, .r0, 0, off);
	547	}
	548
426	549	pub fn jeq(dst: Reg, src: anytype, off: i16) Insn {
427	550	return jmp(.jeq, dst, src, off);
428	551	}
429	552
430		pub fn stx_mem(size: Size, dst: Reg, src: Reg, off: i16) Insn {
431		return Insn{
432		.code = STX \| @enumToInt(size) \| MEM,
433		.dst = @enumToInt(dst),
434		.src = @enumToInt(src),
435		.off = off,
436		.imm = 0,
437		};
	553	pub fn jgt(dst: Reg, src: anytype, off: i16) Insn {
	554	return jmp(.jgt, dst, src, off);
	555	}
	556
	557	pub fn jge(dst: Reg, src: anytype, off: i16) Insn {
	558	return jmp(.jge, dst, src, off);
	559	}
	560
	561	pub fn jlt(dst: Reg, src: anytype, off: i16) Insn {
	562	return jmp(.jlt, dst, src, off);
	563	}
	564
	565	pub fn jle(dst: Reg, src: anytype, off: i16) Insn {
	566	return jmp(.jle, dst, src, off);
	567	}
	568
	569	pub fn jset(dst: Reg, src: anytype, off: i16) Insn {
	570	return jmp(.jset, dst, src, off);
	571	}
	572
	573	pub fn jne(dst: Reg, src: anytype, off: i16) Insn {
	574	return jmp(.jne, dst, src, off);
	575	}
	576
	577	pub fn jsgt(dst: Reg, src: anytype, off: i16) Insn {
	578	return jmp(.jsgt, dst, src, off);
	579	}
	580
	581	pub fn jsge(dst: Reg, src: anytype, off: i16) Insn {
	582	return jmp(.jsge, dst, src, off);
	583	}
	584
	585	pub fn jslt(dst: Reg, src: anytype, off: i16) Insn {
	586	return jmp(.jslt, dst, src, off);
	587	}
	588
	589	pub fn jsle(dst: Reg, src: anytype, off: i16) Insn {
	590	return jmp(.jsle, dst, src, off);
438	591	}
439	592
440	593	pub fn xadd(dst: Reg, src: Reg) Insn {
...	...	@@ -447,17 +600,34 @@ pub const Insn = packed struct {
447	600	};
448	601	}
449	602
450		/// direct packet access, R0 = (uint )(skb->data + imm32)
451		pub fn ld_abs(size: Size, imm: i32) Insn {
	603	fn ld(mode: Mode, size: Size, dst: Reg, src: Reg, imm: i32) Insn {
452	604	return Insn{
453		.code = LD \| @enumToInt(size) \| ABS,
454		.dst = 0,
455		.src = 0,
	605	.code = @enumToInt(mode) \| @enumToInt(size) \| LD,
	606	.dst = @enumToInt(dst),
	607	.src = @enumToInt(src),
456	608	.off = 0,
457	609	.imm = imm,
458	610	};
459	611	}
460	612
	613	pub fn ld_abs(size: Size, dst: Reg, src: Reg, imm: i32) Insn {
	614	return ld(.abs, size, dst, src, imm);
	615	}
	616
	617	pub fn ld_ind(size: Size, dst: Reg, src: Reg, imm: i32) Insn {
	618	return ld(.ind, size, dst, src, imm);
	619	}
	620
	621	pub fn ldx(size: Size, dst: Reg, src: Reg, off: i16) Insn {
	622	return Insn{
	623	.code = MEM \| @enumToInt(size) \| LDX,
	624	.dst = @enumToInt(dst),
	625	.src = @enumToInt(src),
	626	.off = off,
	627	.imm = 0,
	628	};
	629	}
	630
461	631	fn ld_imm_impl1(dst: Reg, src: Reg, imm: u64) Insn {
462	632	return Insn{
463	633	.code = LD \| DW \| IMM,
...	...	@@ -478,6 +648,14 @@ pub const Insn = packed struct {
478	648	};
479	649	}
480	650
	651	pub fn ld_dw1(dst: Reg, imm: u64) Insn {
	652	return ld_imm_impl1(dst, .r0, imm);
	653	}
	654
	655	pub fn ld_dw2(imm: u64) Insn {
	656	return ld_imm_impl2(imm);
	657	}
	658
481	659	pub fn ld_map_fd1(dst: Reg, map_fd: fd_t) Insn {
482	660	return ld_imm_impl1(dst, @intToEnum(Reg, PSEUDO_MAP_FD), @intCast(u64, map_fd));
483	661	}
...	...	@@ -486,6 +664,53 @@ pub const Insn = packed struct {
486	664	return ld_imm_impl2(@intCast(u64, map_fd));
487	665	}
488	666
	667	pub fn st(comptime size: Size, dst: Reg, off: i16, imm: i32) Insn {
	668	if (size == .double_word) @compileError("TODO: need to determine how to correctly handle double words");
	669	return Insn{
	670	.code = MEM \| @enumToInt(size) \| ST,
	671	.dst = @enumToInt(dst),
	672	.src = 0,
	673	.off = off,
	674	.imm = imm,
	675	};
	676	}
	677
	678	pub fn stx(size: Size, dst: Reg, off: i16, src: Reg) Insn {
	679	return Insn{
	680	.code = MEM \| @enumToInt(size) \| STX,
	681	.dst = @enumToInt(dst),
	682	.src = @enumToInt(src),
	683	.off = off,
	684	.imm = 0,
	685	};
	686	}
	687
	688	fn endian_swap(endian: std.builtin.Endian, comptime size: Size, dst: Reg) Insn {
	689	return Insn{
	690	.code = switch (endian) {
	691	.Big => 0xdc,
	692	.Little => 0xd4,
	693	},
	694	.dst = @enumToInt(dst),
	695	.src = 0,
	696	.off = 0,
	697	.imm = switch (size) {
	698	.byte => @compileError("can't swap a single byte"),
	699	.half_word => 16,
	700	.word => 32,
	701	.double_word => 64,
	702	},
	703	};
	704	}
	705
	706	pub fn le(comptime size: Size, dst: Reg) Insn {
	707	return endian_swap(.Little, size, dst);
	708	}
	709
	710	pub fn be(comptime size: Size, dst: Reg) Insn {
	711	return endian_swap(.Big, size, dst);
	712	}
	713
489	714	pub fn call(helper: Helper) Insn {
490	715	return Insn{
491	716	.code = JMP \| CALL,
...	...	@@ -508,95 +733,242 @@ pub const Insn = packed struct {
508	733	}
509	734	};
510	735
511		fn expect_insn(insn: Insn, val: u64) void {
512		expectEqual(@bitCast(u64, insn), val);
513		}
514
515	736	test "insn bitsize" {
516	737	expectEqual(@bitSizeOf(Insn), 64);
517	738	}
518	739
519		// mov instructions
520		test "mov imm" {
521		expect_insn(Insn.mov(.r1, 1), 0x00000001000001b7);
522		}
523
524		test "mov reg" {
525		expect_insn(Insn.mov(.r6, .r1), 0x00000000000016bf);
526		}
527
528		// alu instructions
529		test "add imm" {
530		expect_insn(Insn.add(.r2, -4), 0xfffffffc00000207);
	740	fn expect_opcode(code: u8, insn: Insn) void {
	741	expectEqual(code, insn.code);
531	742	}
532	743
533		// ld instructions
534		test "ld_abs" {
535		expect_insn(Insn.ld_abs(.byte, 42), 0x0000002a00000030);
536		}
537
538		test "ld_map_fd" {
539		expect_insn(Insn.ld_map_fd1(.r1, 42), 0x0000002a00001118);
540		expect_insn(Insn.ld_map_fd2(42), 0x0000000000000000);
541		}
542
543		// st instructions
544		test "stx_mem" {
545		expect_insn(Insn.stx_mem(.word, .r10, .r0, -4), 0x00000000fffc0a63);
546		}
547
548		test "xadd" {
549		expect_insn(Insn.xadd(.r0, .r1), 0x00000000000010db);
550		}
551
552		// jmp instructions
553		test "jeq imm" {
554		expect_insn(Insn.jeq(.r0, 0, 2), 0x0000000000020015);
555		}
556
557		// other instructions
558		test "call" {
559		expect_insn(Insn.call(.map_lookup_elem), 0x0000000100000085);
560		}
561
562		test "exit" {
563		expect_insn(Insn.exit(), 0x0000000000000095);
	744	// The opcodes were grabbed from https://github.com/iovisor/bpf-docs/blob/master/eBPF.md
	745	test "opcodes" {
	746	// instructions that have a name that end with 1 or 2 are consecutive for
	747	// loading 64-bit immediates (imm is only 32 bits wide)
	748
	749	// alu instructions
	750	expect_opcode(0x07, Insn.add(.r1, 0));
	751	expect_opcode(0x0f, Insn.add(.r1, .r2));
	752	expect_opcode(0x17, Insn.sub(.r1, 0));
	753	expect_opcode(0x1f, Insn.sub(.r1, .r2));
	754	expect_opcode(0x27, Insn.mul(.r1, 0));
	755	expect_opcode(0x2f, Insn.mul(.r1, .r2));
	756	expect_opcode(0x37, Insn.div(.r1, 0));
	757	expect_opcode(0x3f, Insn.div(.r1, .r2));
	758	expect_opcode(0x47, Insn.alu_or(.r1, 0));
	759	expect_opcode(0x4f, Insn.alu_or(.r1, .r2));
	760	expect_opcode(0x57, Insn.alu_and(.r1, 0));
	761	expect_opcode(0x5f, Insn.alu_and(.r1, .r2));
	762	expect_opcode(0x67, Insn.lsh(.r1, 0));
	763	expect_opcode(0x6f, Insn.lsh(.r1, .r2));
	764	expect_opcode(0x77, Insn.rsh(.r1, 0));
	765	expect_opcode(0x7f, Insn.rsh(.r1, .r2));
	766	expect_opcode(0x87, Insn.neg(.r1));
	767	expect_opcode(0x97, Insn.mod(.r1, 0));
	768	expect_opcode(0x9f, Insn.mod(.r1, .r2));
	769	expect_opcode(0xa7, Insn.xor(.r1, 0));
	770	expect_opcode(0xaf, Insn.xor(.r1, .r2));
	771	expect_opcode(0xb7, Insn.mov(.r1, 0));
	772	expect_opcode(0xbf, Insn.mov(.r1, .r2));
	773	expect_opcode(0xc7, Insn.arsh(.r1, 0));
	774	expect_opcode(0xcf, Insn.arsh(.r1, .r2));
	775
	776	// atomic instructions: might be more of these not documented in the wild
	777	expect_opcode(0xdb, Insn.xadd(.r1, .r2));
	778
	779	// TODO: byteswap instructions
	780	expect_opcode(0xd4, Insn.le(.half_word, .r1));
	781	expectEqual(@intCast(i32, 16), Insn.le(.half_word, .r1).imm);
	782	expect_opcode(0xd4, Insn.le(.word, .r1));
	783	expectEqual(@intCast(i32, 32), Insn.le(.word, .r1).imm);
	784	expect_opcode(0xd4, Insn.le(.double_word, .r1));
	785	expectEqual(@intCast(i32, 64), Insn.le(.double_word, .r1).imm);
	786	expect_opcode(0xdc, Insn.be(.half_word, .r1));
	787	expectEqual(@intCast(i32, 16), Insn.be(.half_word, .r1).imm);
	788	expect_opcode(0xdc, Insn.be(.word, .r1));
	789	expectEqual(@intCast(i32, 32), Insn.be(.word, .r1).imm);
	790	expect_opcode(0xdc, Insn.be(.double_word, .r1));
	791	expectEqual(@intCast(i32, 64), Insn.be(.double_word, .r1).imm);
	792
	793	// memory instructions
	794	expect_opcode(0x18, Insn.ld_dw1(.r1, 0));
	795	expect_opcode(0x00, Insn.ld_dw2(0));
	796
	797	// loading a map fd
	798	expect_opcode(0x18, Insn.ld_map_fd1(.r1, 0));
	799	expectEqual(@intCast(u4, PSEUDO_MAP_FD), Insn.ld_map_fd1(.r1, 0).src);
	800	expect_opcode(0x00, Insn.ld_map_fd2(0));
	801
	802	expect_opcode(0x38, Insn.ld_abs(.double_word, .r1, .r2, 0));
	803	expect_opcode(0x20, Insn.ld_abs(.word, .r1, .r2, 0));
	804	expect_opcode(0x28, Insn.ld_abs(.half_word, .r1, .r2, 0));
	805	expect_opcode(0x30, Insn.ld_abs(.byte, .r1, .r2, 0));
	806
	807	expect_opcode(0x58, Insn.ld_ind(.double_word, .r1, .r2, 0));
	808	expect_opcode(0x40, Insn.ld_ind(.word, .r1, .r2, 0));
	809	expect_opcode(0x48, Insn.ld_ind(.half_word, .r1, .r2, 0));
	810	expect_opcode(0x50, Insn.ld_ind(.byte, .r1, .r2, 0));
	811
	812	expect_opcode(0x79, Insn.ldx(.double_word, .r1, .r2, 0));
	813	expect_opcode(0x61, Insn.ldx(.word, .r1, .r2, 0));
	814	expect_opcode(0x69, Insn.ldx(.half_word, .r1, .r2, 0));
	815	expect_opcode(0x71, Insn.ldx(.byte, .r1, .r2, 0));
	816
	817	expect_opcode(0x62, Insn.st(.word, .r1, 0, 0));
	818	expect_opcode(0x6a, Insn.st(.half_word, .r1, 0, 0));
	819	expect_opcode(0x72, Insn.st(.byte, .r1, 0, 0));
	820
	821	expect_opcode(0x63, Insn.stx(.word, .r1, 0, .r2));
	822	expect_opcode(0x6b, Insn.stx(.half_word, .r1, 0, .r2));
	823	expect_opcode(0x73, Insn.stx(.byte, .r1, 0, .r2));
	824	expect_opcode(0x7b, Insn.stx(.double_word, .r1, 0, .r2));
	825
	826	// branch instructions
	827	expect_opcode(0x05, Insn.ja(0));
	828	expect_opcode(0x15, Insn.jeq(.r1, 0, 0));
	829	expect_opcode(0x1d, Insn.jeq(.r1, .r2, 0));
	830	expect_opcode(0x25, Insn.jgt(.r1, 0, 0));
	831	expect_opcode(0x2d, Insn.jgt(.r1, .r2, 0));
	832	expect_opcode(0x35, Insn.jge(.r1, 0, 0));
	833	expect_opcode(0x3d, Insn.jge(.r1, .r2, 0));
	834	expect_opcode(0xa5, Insn.jlt(.r1, 0, 0));
	835	expect_opcode(0xad, Insn.jlt(.r1, .r2, 0));
	836	expect_opcode(0xb5, Insn.jle(.r1, 0, 0));
	837	expect_opcode(0xbd, Insn.jle(.r1, .r2, 0));
	838	expect_opcode(0x45, Insn.jset(.r1, 0, 0));
	839	expect_opcode(0x4d, Insn.jset(.r1, .r2, 0));
	840	expect_opcode(0x55, Insn.jne(.r1, 0, 0));
	841	expect_opcode(0x5d, Insn.jne(.r1, .r2, 0));
	842	expect_opcode(0x65, Insn.jsgt(.r1, 0, 0));
	843	expect_opcode(0x6d, Insn.jsgt(.r1, .r2, 0));
	844	expect_opcode(0x75, Insn.jsge(.r1, 0, 0));
	845	expect_opcode(0x7d, Insn.jsge(.r1, .r2, 0));
	846	expect_opcode(0xc5, Insn.jslt(.r1, 0, 0));
	847	expect_opcode(0xcd, Insn.jslt(.r1, .r2, 0));
	848	expect_opcode(0xd5, Insn.jsle(.r1, 0, 0));
	849	expect_opcode(0xdd, Insn.jsle(.r1, .r2, 0));
	850	expect_opcode(0x85, Insn.call(.unspec));
	851	expect_opcode(0x95, Insn.exit());
564	852	}
565	853
566	854	pub const Cmd = extern enum(usize) {
	855	/// Create a map and return a file descriptor that refers to the map. The
	856	/// close-on-exec file descriptor flag is automatically enabled for the new
	857	/// file descriptor.
	858	///
	859	/// uses MapCreateAttr
567	860	map_create,
	861
	862	/// Look up an element by key in a specified map and return its value.
	863	///
	864	/// uses MapElemAttr
568	865	map_lookup_elem,
	866
	867	/// Create or update an element (key/value pair) in a specified map.
	868	///
	869	/// uses MapElemAttr
569	870	map_update_elem,
	871
	872	/// Look up and delete an element by key in a specified map.
	873	///
	874	/// uses MapElemAttr
570	875	map_delete_elem,
	876
	877	/// Look up an element by key in a specified map and return the key of the
	878	/// next element.
571	879	map_get_next_key,
	880
	881	/// Verify and load an eBPF program, returning a new file descriptor
	882	/// associated with the program. The close-on-exec file descriptor flag
	883	/// is automatically enabled for the new file descriptor.
	884	///
	885	/// uses ProgLoadAttr
572	886	prog_load,
	887
	888	/// Pin a map or eBPF program to a path within the minimal BPF filesystem
	889	///
	890	/// uses ObjAttr
573	891	obj_pin,
	892
	893	/// Get the file descriptor of a BPF object pinned to a certain path
	894	///
	895	/// uses ObjAttr
574	896	obj_get,
	897
	898	/// uses ProgAttachAttr
575	899	prog_attach,
	900
	901	/// uses ProgAttachAttr
576	902	prog_detach,
	903
	904	/// uses TestRunAttr
577	905	prog_test_run,
	906
	907	/// uses GetIdAttr
578	908	prog_get_next_id,
	909
	910	/// uses GetIdAttr
579	911	map_get_next_id,
	912
	913	/// uses GetIdAttr
580	914	prog_get_fd_by_id,
	915
	916	/// uses GetIdAttr
581	917	map_get_fd_by_id,
	918
	919	/// uses InfoAttr
582	920	obj_get_info_by_fd,
	921
	922	/// uses QueryAttr
583	923	prog_query,
	924
	925	/// uses RawTracepointAttr
584	926	raw_tracepoint_open,
	927
	928	/// uses BtfLoadAttr
585	929	btf_load,
	930
	931	/// uses GetIdAttr
586	932	btf_get_fd_by_id,
	933
	934	/// uses TaskFdQueryAttr
587	935	task_fd_query,
	936
	937	/// uses MapElemAttr
588	938	map_lookup_and_delete_elem,
589	939	map_freeze,
	940
	941	/// uses GetIdAttr
590	942	btf_get_next_id,
	943
	944	/// uses MapBatchAttr
591	945	map_lookup_batch,
	946
	947	/// uses MapBatchAttr
592	948	map_lookup_and_delete_batch,
	949
	950	/// uses MapBatchAttr
593	951	map_update_batch,
	952
	953	/// uses MapBatchAttr
594	954	map_delete_batch,
	955
	956	/// uses LinkCreateAttr
595	957	link_create,
	958
	959	/// uses LinkUpdateAttr
596	960	link_update,
	961
	962	/// uses GetIdAttr
597	963	link_get_fd_by_id,
	964
	965	/// uses GetIdAttr
598	966	link_get_next_id,
	967
	968	/// uses EnableStatsAttr
599	969	enable_stats,
	970
	971	/// uses IterCreateAttr
600	972	iter_create,
601	973	link_detach,
602	974	_,
...	...	@@ -630,42 +1002,138 @@ pub const MapType = extern enum(u32) {
630	1002	sk_storage,
631	1003	devmap_hash,
632	1004	struct_ops,
	1005
	1006	/// An ordered and shared CPU version of perf_event_array. They have
	1007	/// similar semantics:
	1008	/// - variable length records
	1009	/// - no blocking: when full, reservation fails
	1010	/// - memory mappable for ease and speed
	1011	/// - epoll notifications for new data, but can busy poll
	1012	///
	1013	/// Ringbufs give BPF programs two sets of APIs:
	1014	/// - ringbuf_output() allows copy data from one place to a ring
	1015	/// buffer, similar to bpf_perf_event_output()
	1016	/// - ringbuf_reserve()/ringbuf_commit()/ringbuf_discard() split the
	1017	/// process into two steps. First a fixed amount of space is reserved,
	1018	/// if that is successful then the program gets a pointer to a chunk of
	1019	/// memory and can be submitted with commit() or discarded with
	1020	/// discard()
	1021	///
	1022	/// ringbuf_output() will incurr an extra memory copy, but allows to submit
	1023	/// records of the length that's not known beforehand, and is an easy
	1024	/// replacement for perf_event_outptu().
	1025	///
	1026	/// ringbuf_reserve() avoids the extra memory copy but requires a known size
	1027	/// of memory beforehand.
	1028	///
	1029	/// ringbuf_query() allows to query properties of the map, 4 are currently
	1030	/// supported:
	1031	/// - BPF_RB_AVAIL_DATA: amount of unconsumed data in ringbuf
	1032	/// - BPF_RB_RING_SIZE: returns size of ringbuf
	1033	/// - BPF_RB_CONS_POS/BPF_RB_PROD_POS returns current logical position
	1034	/// of consumer and producer respectively
	1035	///
	1036	/// key size: 0
	1037	/// value size: 0
	1038	/// max entries: size of ringbuf, must be power of 2
633	1039	ringbuf,
	1040
634	1041	_,
635	1042	};
636	1043
637	1044	pub const ProgType = extern enum(u32) {
638	1045	unspec,
	1046
	1047	/// context type: __sk_buff
639	1048	socket_filter,
	1049
	1050	/// context type: bpf_user_pt_regs_t
640	1051	kprobe,
	1052
	1053	/// context type: __sk_buff
641	1054	sched_cls,
	1055
	1056	/// context type: __sk_buff
642	1057	sched_act,
	1058
	1059	/// context type: u64
643	1060	tracepoint,
	1061
	1062	/// context type: xdp_md
644	1063	xdp,
	1064
	1065	/// context type: bpf_perf_event_data
645	1066	perf_event,
	1067
	1068	/// context type: __sk_buff
646	1069	cgroup_skb,
	1070
	1071	/// context type: bpf_sock
647	1072	cgroup_sock,
	1073
	1074	/// context type: __sk_buff
648	1075	lwt_in,
	1076
	1077	/// context type: __sk_buff
649	1078	lwt_out,
	1079
	1080	/// context type: __sk_buff
650	1081	lwt_xmit,
	1082
	1083	/// context type: bpf_sock_ops
651	1084	sock_ops,
	1085
	1086	/// context type: __sk_buff
652	1087	sk_skb,
	1088
	1089	/// context type: bpf_cgroup_dev_ctx
653	1090	cgroup_device,
	1091
	1092	/// context type: sk_msg_md
654	1093	sk_msg,
	1094
	1095	/// context type: bpf_raw_tracepoint_args
655	1096	raw_tracepoint,
	1097
	1098	/// context type: bpf_sock_addr
656	1099	cgroup_sock_addr,
	1100
	1101	/// context type: __sk_buff
657	1102	lwt_seg6local,
	1103
	1104	/// context type: u32
658	1105	lirc_mode2,
	1106
	1107	/// context type: sk_reuseport_md
659	1108	sk_reuseport,
	1109
	1110	/// context type: __sk_buff
660	1111	flow_dissector,
	1112
	1113	/// context type: bpf_sysctl
661	1114	cgroup_sysctl,
	1115
	1116	/// context type: bpf_raw_tracepoint_args
662	1117	raw_tracepoint_writable,
	1118
	1119	/// context type: bpf_sockopt
663	1120	cgroup_sockopt,
	1121
	1122	/// context type: void *
664	1123	tracing,
	1124
	1125	/// context type: void *
665	1126	struct_ops,
	1127
	1128	/// context type: void *
666	1129	ext,
	1130
	1131	/// context type: void *
667	1132	lsm,
	1133
	1134	/// context type: bpf_sk_lookup
668	1135	sk_lookup,
	1136	_,
669	1137	};
670	1138
671	1139	pub const AttachType = extern enum(u32) {
...	...	@@ -715,27 +1183,38 @@ const obj_name_len = 16;
715	1183	pub const MapCreateAttr = extern struct {
716	1184	/// one of MapType
717	1185	map_type: u32,
	1186
718	1187	/// size of key in bytes
719	1188	key_size: u32,
	1189
720	1190	/// size of value in bytes
721	1191	value_size: u32,
	1192
722	1193	/// max number of entries in a map
723	1194	max_entries: u32,
	1195
724	1196	/// .map_create related flags
725	1197	map_flags: u32,
	1198
726	1199	/// fd pointing to the inner map
727	1200	inner_map_fd: fd_t,
	1201
728	1202	/// numa node (effective only if MapCreateFlags.numa_node is set)
729	1203	numa_node: u32,
730	1204	map_name: [obj_name_len]u8,
	1205
731	1206	/// ifindex of netdev to create on
732	1207	map_ifindex: u32,
	1208
733	1209	/// fd pointing to a BTF type data
734	1210	btf_fd: fd_t,
	1211
735	1212	/// BTF type_id of the key
736	1213	btf_key_type_id: u32,
	1214
737	1215	/// BTF type_id of the value
738	1216	bpf_value_type_id: u32,
	1217
739	1218	/// BTF type_id of a kernel struct stored as the map value
740	1219	btf_vmlinux_value_type_id: u32,
741	1220	};
...	...	@@ -755,10 +1234,12 @@ pub const MapElemAttr = extern struct {
755	1234	pub const MapBatchAttr = extern struct {
756	1235	/// start batch, NULL to start from beginning
757	1236	in_batch: u64,
	1237
758	1238	/// output: next start batch
759	1239	out_batch: u64,
760	1240	keys: u64,
761	1241	values: u64,
	1242
762	1243	/// input/output:
763	1244	/// input: # of key/value elements
764	1245	/// output: # of filled elements
...	...	@@ -775,35 +1256,49 @@ pub const ProgLoadAttr = extern struct {
775	1256	insn_cnt: u32,
776	1257	insns: u64,
777	1258	license: u64,
	1259
778	1260	/// verbosity level of verifier
779	1261	log_level: u32,
	1262
780	1263	/// size of user buffer
781	1264	log_size: u32,
	1265
782	1266	/// user supplied buffer
783	1267	log_buf: u64,
	1268
784	1269	/// not used
785	1270	kern_version: u32,
786	1271	prog_flags: u32,
787	1272	prog_name: [obj_name_len]u8,
788		/// ifindex of netdev to prep for. For some prog types expected attach
789		/// type must be known at load time to verify attach type specific parts
790		/// of prog (context accesses, allowed helpers, etc).
	1273
	1274	/// ifindex of netdev to prep for.
791	1275	prog_ifindex: u32,
	1276
	1277	/// For some prog types expected attach type must be known at load time to
	1278	/// verify attach type specific parts of prog (context accesses, allowed
	1279	/// helpers, etc).
792	1280	expected_attach_type: u32,
	1281
793	1282	/// fd pointing to BTF type data
794	1283	prog_btf_fd: fd_t,
	1284
795	1285	/// userspace bpf_func_info size
796	1286	func_info_rec_size: u32,
797	1287	func_info: u64,
	1288
798	1289	/// number of bpf_func_info records
799	1290	func_info_cnt: u32,
	1291
800	1292	/// userspace bpf_line_info size
801	1293	line_info_rec_size: u32,
802	1294	line_info: u64,
	1295
803	1296	/// number of bpf_line_info records
804	1297	line_info_cnt: u32,
	1298
805	1299	/// in-kernel BTF type id to attach to
806	1300	attact_btf_id: u32,
	1301
807	1302	/// 0 to attach to vmlinux
808	1303	attach_prog_id: u32,
809	1304	};
...	...	@@ -819,29 +1314,36 @@ pub const ObjAttr = extern struct {
819	1314	pub const ProgAttachAttr = extern struct {
820	1315	/// container object to attach to
821	1316	target_fd: fd_t,
	1317
822	1318	/// eBPF program to attach
823	1319	attach_bpf_fd: fd_t,
	1320
824	1321	attach_type: u32,
825	1322	attach_flags: u32,
	1323
826	1324	// TODO: BPF_F_REPLACE flags
827	1325	/// previously attached eBPF program to replace if .replace is used
828	1326	replace_bpf_fd: fd_t,
829	1327	};
830	1328
831	1329	/// struct used by Cmd.prog_test_run command
832		pub const TestAttr = extern struct {
	1330	pub const TestRunAttr = extern struct {
833	1331	prog_fd: fd_t,
834	1332	retval: u32,
	1333
835	1334	/// input: len of data_in
836	1335	data_size_in: u32,
	1336
837	1337	/// input/output: len of data_out. returns ENOSPC if data_out is too small.
838	1338	data_size_out: u32,
839	1339	data_in: u64,
840	1340	data_out: u64,
841	1341	repeat: u32,
842	1342	duration: u32,
	1343
843	1344	/// input: len of ctx_in
844	1345	ctx_size_in: u32,
	1346
845	1347	/// input/output: len of ctx_out. returns ENOSPC if ctx_out is too small.
846	1348	ctx_size_out: u32,
847	1349	ctx_in: u64,
...	...	@@ -894,26 +1396,35 @@ pub const BtfLoadAttr = extern struct {
894	1396	btf_log_level: u32,
895	1397	};
896	1398
	1399	/// struct used by Cmd.task_fd_query
897	1400	pub const TaskFdQueryAttr = extern struct {
898	1401	/// input: pid
899	1402	pid: pid_t,
	1403
900	1404	/// input: fd
901	1405	fd: fd_t,
	1406
902	1407	/// input: flags
903	1408	flags: u32,
	1409
904	1410	/// input/output: buf len
905	1411	buf_len: u32,
	1412
906	1413	/// input/output:
907	1414	/// tp_name for tracepoint
908	1415	/// symbol for kprobe
909	1416	/// filename for uprobe
910	1417	buf: u64,
	1418
911	1419	/// output: prod_id
912	1420	prog_id: u32,
	1421
913	1422	/// output: BPF_FD_TYPE
914	1423	fd_type: u32,
	1424
915	1425	/// output: probe_offset
916	1426	probe_offset: u64,
	1427
917	1428	/// output: probe_addr
918	1429	probe_addr: u64,
919	1430	};
...	...	@@ -922,9 +1433,11 @@ pub const TaskFdQueryAttr = extern struct {
922	1433	pub const LinkCreateAttr = extern struct {
923	1434	/// eBPF program to attach
924	1435	prog_fd: fd_t,
	1436
925	1437	/// object to attach to
926	1438	target_fd: fd_t,
927	1439	attach_type: u32,
	1440
928	1441	/// extra flags
929	1442	flags: u32,
930	1443	};
...	...	@@ -932,10 +1445,13 @@ pub const LinkCreateAttr = extern struct {
932	1445	/// struct used by Cmd.link_update command
933	1446	pub const LinkUpdateAttr = extern struct {
934	1447	link_fd: fd_t,
	1448
935	1449	/// new program to update link with
936	1450	new_prog_fd: fd_t,
	1451
937	1452	/// extra flags
938	1453	flags: u32,
	1454
939	1455	/// expected link's program fd, it is specified only if BPF_F_REPLACE is
940	1456	/// set in flags
941	1457	old_prog_fd: fd_t,
...	...	@@ -952,6 +1468,7 @@ pub const IterCreateAttr = extern struct {
952	1468	flags: u32,
953	1469	};
954	1470
	1471	/// Mega struct that is passed to the bpf() syscall
955	1472	pub const Attr = extern union {
956	1473	map_create: MapCreateAttr,
957	1474	map_elem: MapElemAttr,
...	...	@@ -971,3 +1488,176 @@ pub const Attr = extern union {
971	1488	enable_stats: EnableStatsAttr,
972	1489	iter_create: IterCreateAttr,
973	1490	};
	1491
	1492	pub const Log = struct {
	1493	level: u32,
	1494	buf: []u8,
	1495	};
	1496
	1497	pub fn map_create(map_type: MapType, key_size: u32, value_size: u32, max_entries: u32) !fd_t {
	1498	var attr = Attr{
	1499	.map_create = std.mem.zeroes(MapCreateAttr),
	1500	};
	1501
	1502	attr.map_create.map_type = @enumToInt(map_type);
	1503	attr.map_create.key_size = key_size;
	1504	attr.map_create.value_size = value_size;
	1505	attr.map_create.max_entries = max_entries;
	1506
	1507	const rc = bpf(.map_create, &attr, @sizeOf(MapCreateAttr));
	1508	return switch (errno(rc)) {
	1509	0 => @intCast(fd_t, rc),
	1510	EINVAL => error.MapTypeOrAttrInvalid,
	1511	ENOMEM => error.SystemResources,
	1512	EPERM => error.AccessDenied,
	1513	else => \|err\| unexpectedErrno(rc),
	1514	};
	1515	}
	1516
	1517	test "map_create" {
	1518	const map = try map_create(.hash, 4, 4, 32);
	1519	defer std.os.close(map);
	1520	}
	1521
	1522	pub fn map_lookup_elem(fd: fd_t, key: []const u8, value: []u8) !void {
	1523	var attr = Attr{
	1524	.map_elem = std.mem.zeroes(MapElemAttr),
	1525	};
	1526
	1527	attr.map_elem.map_fd = fd;
	1528	attr.map_elem.key = @ptrToInt(key.ptr);
	1529	attr.map_elem.result.value = @ptrToInt(value.ptr);
	1530
	1531	const rc = bpf(.map_lookup_elem, &attr, @sizeOf(MapElemAttr));
	1532	switch (errno(rc)) {
	1533	0 => return,
	1534	EBADF => return error.BadFd,
	1535	EFAULT => unreachable,
	1536	EINVAL => return error.FieldInAttrNeedsZeroing,
	1537	ENOENT => return error.NotFound,
	1538	EPERM => return error.AccessDenied,
	1539	else => \|err\| return unexpectedErrno(rc),
	1540	}
	1541	}
	1542
	1543	pub fn map_update_elem(fd: fd_t, key: []const u8, value: []const u8, flags: u64) !void {
	1544	var attr = Attr{
	1545	.map_elem = std.mem.zeroes(MapElemAttr),
	1546	};
	1547
	1548	attr.map_elem.map_fd = fd;
	1549	attr.map_elem.key = @ptrToInt(key.ptr);
	1550	attr.map_elem.result = .{ .value = @ptrToInt(value.ptr) };
	1551	attr.map_elem.flags = flags;
	1552
	1553	const rc = bpf(.map_update_elem, &attr, @sizeOf(MapElemAttr));
	1554	switch (errno(rc)) {
	1555	0 => return,
	1556	E2BIG => return error.ReachedMaxEntries,
	1557	EBADF => return error.BadFd,
	1558	EFAULT => unreachable,
	1559	EINVAL => return error.FieldInAttrNeedsZeroing,
	1560	ENOMEM => return error.SystemResources,
	1561	EPERM => return error.AccessDenied,
	1562	else => \|err\| return unexpectedErrno(err),
	1563	}
	1564	}
	1565
	1566	pub fn map_delete_elem(fd: fd_t, key: []const u8) !void {
	1567	var attr = Attr{
	1568	.map_elem = std.mem.zeroes(MapElemAttr),
	1569	};
	1570
	1571	attr.map_elem.map_fd = fd;
	1572	attr.map_elem.key = @ptrToInt(key.ptr);
	1573
	1574	const rc = bpf(.map_delete_elem, &attr, @sizeOf(MapElemAttr));
	1575	switch (errno(rc)) {
	1576	0 => return,
	1577	EBADF => return error.BadFd,
	1578	EFAULT => unreachable,
	1579	EINVAL => return error.FieldInAttrNeedsZeroing,
	1580	ENOENT => return error.NotFound,
	1581	EPERM => return error.AccessDenied,
	1582	else => \|err\| return unexpectedErrno(err),
	1583	}
	1584	}
	1585
	1586	test "map lookup, update, and delete" {
	1587	const key_size = 4;
	1588	const value_size = 4;
	1589	const map = try map_create(.hash, key_size, value_size, 1);
	1590	defer std.os.close(map);
	1591
	1592	const key = std.mem.zeroes([key_size]u8);
	1593	var value = std.mem.zeroes([value_size]u8);
	1594
	1595	// fails looking up value that doesn't exist
	1596	expectError(error.NotFound, map_lookup_elem(map, &key, &value));
	1597
	1598	// succeed at updating and looking up element
	1599	try map_update_elem(map, &key, &value, 0);
	1600	try map_lookup_elem(map, &key, &value);
	1601
	1602	// fails inserting more than max entries
	1603	const second_key = [key_size]u8{ 0, 0, 0, 1 };
	1604	expectError(error.ReachedMaxEntries, map_update_elem(map, &second_key, &value, 0));
	1605
	1606	// succeed at deleting an existing elem
	1607	try map_delete_elem(map, &key);
	1608	expectError(error.NotFound, map_lookup_elem(map, &key, &value));
	1609
	1610	// fail at deleting a non-existing elem
	1611	expectError(error.NotFound, map_delete_elem(map, &key));
	1612	}
	1613
	1614	pub fn prog_load(
	1615	prog_type: ProgType,
	1616	insns: []const Insn,
	1617	log: ?*Log,
	1618	license: []const u8,
	1619	kern_version: u32,
	1620	) !fd_t {
	1621	var attr = Attr{
	1622	.prog_load = std.mem.zeroes(ProgLoadAttr),
	1623	};
	1624
	1625	attr.prog_load.prog_type = @enumToInt(prog_type);
	1626	attr.prog_load.insns = @ptrToInt(insns.ptr);
	1627	attr.prog_load.insn_cnt = @intCast(u32, insns.len);
	1628	attr.prog_load.license = @ptrToInt(license.ptr);
	1629	attr.prog_load.kern_version = kern_version;
	1630
	1631	if (log) \|l\| {
	1632	attr.prog_load.log_buf = @ptrToInt(l.buf.ptr);
	1633	attr.prog_load.log_size = @intCast(u32, l.buf.len);
	1634	attr.prog_load.log_level = l.level;
	1635	}
	1636
	1637	const rc = bpf(.prog_load, &attr, @sizeOf(ProgLoadAttr));
	1638	return switch (errno(rc)) {
	1639	0 => @intCast(fd_t, rc),
	1640	EACCES => error.UnsafeProgram,
	1641	EFAULT => unreachable,
	1642	EINVAL => error.InvalidProgram,
	1643	EPERM => error.AccessDenied,
	1644	else => \|err\| unexpectedErrno(err),
	1645	};
	1646	}
	1647
	1648	test "prog_load" {
	1649	// this should fail because it does not set r0 before exiting
	1650	const bad_prog = [_]Insn{
	1651	Insn.exit(),
	1652	};
	1653
	1654	const good_prog = [_]Insn{
	1655	Insn.mov(.r0, 0),
	1656	Insn.exit(),
	1657	};
	1658
	1659	const prog = try prog_load(.socket_filter, &good_prog, null, "MIT", 0);
	1660	defer std.os.close(prog);
	1661
	1662	expectError(error.UnsafeProgram, prog_load(.socket_filter, &bad_prog, null, "MIT", 0));
	1663	}

lib/std/os/test.zig+36

...	...	@@ -555,3 +555,39 @@ test "signalfd" {
555	555	return error.SkipZigTest;
556	556	_ = std.os.signalfd;
557	557	}
	558
	559	test "sync" {
	560	if (builtin.os.tag != .linux)
	561	return error.SkipZigTest;
	562
	563	var tmp = tmpDir(.{});
	564	defer tmp.cleanup();
	565
	566	const test_out_file = "os_tmp_test";
	567	const file = try tmp.dir.createFile(test_out_file, .{});
	568	defer {
	569	file.close();
	570	tmp.dir.deleteFile(test_out_file) catch {};
	571	}
	572
	573	os.sync();
	574	try os.syncfs(file.handle);
	575	}
	576
	577	test "fsync" {
	578	if (builtin.os.tag != .linux and builtin.os.tag != .windows)
	579	return error.SkipZigTest;
	580
	581	var tmp = tmpDir(.{});
	582	defer tmp.cleanup();
	583
	584	const test_out_file = "os_tmp_test";
	585	const file = try tmp.dir.createFile(test_out_file, .{});
	586	defer {
	587	file.close();
	588	tmp.dir.deleteFile(test_out_file) catch {};
	589	}
	590
	591	try os.fsync(file.handle);
	592	try os.fdatasync(file.handle);
	593	}

lib/std/os/windows/kernel32.zig+2

...	...	@@ -287,3 +287,5 @@ pub extern "kernel32" fn K32GetWsChangesEx(hProcess: HANDLE, lpWatchInfoEx: PPSA
287	287	pub extern "kernel32" fn K32InitializeProcessForWsWatch(hProcess: HANDLE) callconv(.Stdcall) BOOL;
288	288	pub extern "kernel32" fn K32QueryWorkingSet(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;
289	289	pub extern "kernel32" fn K32QueryWorkingSetEx(hProcess: HANDLE, pv: PVOID, cb: DWORD) callconv(.Stdcall) BOOL;
	290
	291	pub extern "kernel32" fn FlushFileBuffers(hFile: HANDLE) callconv(.Stdcall) BOOL;

lib/std/os/windows/ws2_32.zig+1-1

...	...	@@ -12,7 +12,7 @@ pub const SOCKET_ERROR = -1;
12	12	pub const WSADESCRIPTION_LEN = 256;
13	13	pub const WSASYS_STATUS_LEN = 128;
14	14
15		pub const WSADATA = if (usize.bit_count == u64.bit_count)
	15	pub const WSADATA = if (@sizeOf(usize) == @sizeOf(u64))
16	16	extern struct {
17	17	wVersion: WORD,
18	18	wHighVersion: WORD,

lib/std/pdb.zig+1-1

...	...	@@ -636,7 +636,7 @@ const MsfStream = struct {
636	636	blocks: []u32 = undefined,
637	637	block_size: u32 = undefined,
638	638
639		pub const Error = @TypeOf(read).ReturnType.ErrorSet;
	639	pub const Error = @typeInfo(@typeInfo(@TypeOf(read)).Fn.return_type.?).ErrorUnion.error_set;
640	640
641	641	fn init(block_size: u32, file: File, blocks: []u32) MsfStream {
642	642	const stream = MsfStream{

lib/std/process.zig+4-4

...	...	@@ -578,8 +578,8 @@ fn testWindowsCmdLine(input_cmd_line: [*]const u8, expected_args: []const []cons
578	578	}
579	579
580	580	pub const UserInfo = struct {
581		uid: u32,
582		gid: u32,
	581	uid: os.uid_t,
	582	gid: os.gid_t,
583	583	};
584	584
585	585	/// POSIX function which gets a uid from username.
...	...	@@ -607,8 +607,8 @@ pub fn posixGetUserInfo(name: []const u8) !UserInfo {
607	607	var buf: [std.mem.page_size]u8 = undefined;
608	608	var name_index: usize = 0;
609	609	var state = State.Start;
610		var uid: u32 = 0;
611		var gid: u32 = 0;
	610	var uid: os.uid_t = 0;
	611	var gid: os.gid_t = 0;
612	612
613	613	while (true) {
614	614	const amt_read = try reader.read(buf[0..]);

lib/std/progress.zig+3-3

...	...	@@ -197,7 +197,7 @@ pub const Progress = struct {
197	197	var maybe_node: ?*Node = &self.root;
198	198	while (maybe_node) \|node\| {
199	199	if (need_ellipse) {
200		self.bufWrite(&end, "...", .{});
	200	self.bufWrite(&end, "... ", .{});
201	201	}
202	202	need_ellipse = false;
203	203	if (node.name.len != 0 or node.estimated_total_items != null) {
...	...	@@ -218,7 +218,7 @@ pub const Progress = struct {
218	218	maybe_node = node.recently_updated_child;
219	219	}
220	220	if (need_ellipse) {
221		self.bufWrite(&end, "...", .{});
	221	self.bufWrite(&end, "... ", .{});
222	222	}
223	223	}
224	224
...	...	@@ -253,7 +253,7 @@ pub const Progress = struct {
253	253	const bytes_needed_for_esc_codes_at_end = if (std.builtin.os.tag == .windows) 0 else 11;
254	254	const max_end = self.output_buffer.len - bytes_needed_for_esc_codes_at_end;
255	255	if (end.* > max_end) {
256		const suffix = "...";
	256	const suffix = "... ";
257	257	self.columns_written = self.columns_written - (end.* - max_end) + suffix.len;
258	258	std.mem.copy(u8, self.output_buffer[max_end..], suffix);
259	259	end.* = max_end + suffix.len;

lib/std/rand.zig+33-24

...	...	@@ -51,8 +51,9 @@ pub const Random = struct {
51	51	/// Returns a random int `i` such that `0 <= i <= maxInt(T)`.
52	52	/// `i` is evenly distributed.
53	53	pub fn int(r: *Random, comptime T: type) T {
54		const UnsignedT = std.meta.Int(false, T.bit_count);
55		const ByteAlignedT = std.meta.Int(false, @divTrunc(T.bit_count + 7, 8) * 8);
	54	const bits = @typeInfo(T).Int.bits;
	55	const UnsignedT = std.meta.Int(false, bits);
	56	const ByteAlignedT = std.meta.Int(false, @divTrunc(bits + 7, 8) * 8);
56	57
57	58	var rand_bytes: [@sizeOf(ByteAlignedT)]u8 = undefined;
58	59	r.bytes(rand_bytes[0..]);
...	...	@@ -68,10 +69,11 @@ pub const Random = struct {
68	69	/// Constant-time implementation off `uintLessThan`.
69	70	/// The results of this function may be biased.
70	71	pub fn uintLessThanBiased(r: *Random, comptime T: type, less_than: T) T {
71		comptime assert(T.is_signed == false);
72		comptime assert(T.bit_count <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
	72	comptime assert(@typeInfo(T).Int.is_signed == false);
	73	const bits = @typeInfo(T).Int.bits;
	74	comptime assert(bits <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
73	75	assert(0 < less_than);
74		if (T.bit_count <= 32) {
	76	if (bits <= 32) {
75	77	return @intCast(T, limitRangeBiased(u32, r.int(u32), less_than));
76	78	} else {
77	79	return @intCast(T, limitRangeBiased(u64, r.int(u64), less_than));
...	...	@@ -87,13 +89,15 @@ pub const Random = struct {
87	89	/// this function is guaranteed to return.
88	90	/// If you need deterministic runtime bounds, use `uintLessThanBiased`.
89	91	pub fn uintLessThan(r: *Random, comptime T: type, less_than: T) T {
90		comptime assert(T.is_signed == false);
91		comptime assert(T.bit_count <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
	92	comptime assert(@typeInfo(T).Int.is_signed == false);
	93	const bits = @typeInfo(T).Int.bits;
	94	comptime assert(bits <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
92	95	assert(0 < less_than);
93	96	// Small is typically u32
94		const Small = std.meta.Int(false, @divTrunc(T.bit_count + 31, 32) * 32);
	97	const small_bits = @divTrunc(bits + 31, 32) * 32;
	98	const Small = std.meta.Int(false, small_bits);
95	99	// Large is typically u64
96		const Large = std.meta.Int(false, Small.bit_count * 2);
	100	const Large = std.meta.Int(false, small_bits * 2);
97	101
98	102	// adapted from:
99	103	// http://www.pcg-random.org/posts/bounded-rands.html
...	...	@@ -105,7 +109,7 @@ pub const Random = struct {
105	109	// TODO: workaround for https://github.com/ziglang/zig/issues/1770
106	110	// should be:
107	111	// var t: Small = -%less_than;
108		var t: Small = @bitCast(Small, -%@bitCast(std.meta.Int(true, Small.bit_count), @as(Small, less_than)));
	112	var t: Small = @bitCast(Small, -%@bitCast(std.meta.Int(true, small_bits), @as(Small, less_than)));
109	113
110	114	if (t >= less_than) {
111	115	t -= less_than;
...	...	@@ -119,13 +123,13 @@ pub const Random = struct {
119	123	l = @truncate(Small, m);
120	124	}
121	125	}
122		return @intCast(T, m >> Small.bit_count);
	126	return @intCast(T, m >> small_bits);
123	127	}
124	128
125	129	/// Constant-time implementation off `uintAtMost`.
126	130	/// The results of this function may be biased.
127	131	pub fn uintAtMostBiased(r: *Random, comptime T: type, at_most: T) T {
128		assert(T.is_signed == false);
	132	assert(@typeInfo(T).Int.is_signed == false);
129	133	if (at_most == maxInt(T)) {
130	134	// have the full range
131	135	return r.int(T);
...	...	@@ -137,7 +141,7 @@ pub const Random = struct {
137	141	/// See `uintLessThan`, which this function uses in most cases,
138	142	/// for commentary on the runtime of this function.
139	143	pub fn uintAtMost(r: *Random, comptime T: type, at_most: T) T {
140		assert(T.is_signed == false);
	144	assert(@typeInfo(T).Int.is_signed == false);
141	145	if (at_most == maxInt(T)) {
142	146	// have the full range
143	147	return r.int(T);
...	...	@@ -149,9 +153,10 @@ pub const Random = struct {
149	153	/// The results of this function may be biased.
150	154	pub fn intRangeLessThanBiased(r: *Random, comptime T: type, at_least: T, less_than: T) T {
151	155	assert(at_least < less_than);
152		if (T.is_signed) {
	156	const info = @typeInfo(T).Int;
	157	if (info.is_signed) {
153	158	// Two's complement makes this math pretty easy.
154		const UnsignedT = std.meta.Int(false, T.bit_count);
	159	const UnsignedT = std.meta.Int(false, info.bits);
155	160	const lo = @bitCast(UnsignedT, at_least);
156	161	const hi = @bitCast(UnsignedT, less_than);
157	162	const result = lo +% r.uintLessThanBiased(UnsignedT, hi -% lo);
...	...	@@ -167,9 +172,10 @@ pub const Random = struct {
167	172	/// for commentary on the runtime of this function.
168	173	pub fn intRangeLessThan(r: *Random, comptime T: type, at_least: T, less_than: T) T {
169	174	assert(at_least < less_than);
170		if (T.is_signed) {
	175	const info = @typeInfo(T).Int;
	176	if (info.is_signed) {
171	177	// Two's complement makes this math pretty easy.
172		const UnsignedT = std.meta.Int(false, T.bit_count);
	178	const UnsignedT = std.meta.Int(false, info.bits);
173	179	const lo = @bitCast(UnsignedT, at_least);
174	180	const hi = @bitCast(UnsignedT, less_than);
175	181	const result = lo +% r.uintLessThan(UnsignedT, hi -% lo);
...	...	@@ -184,9 +190,10 @@ pub const Random = struct {
184	190	/// The results of this function may be biased.
185	191	pub fn intRangeAtMostBiased(r: *Random, comptime T: type, at_least: T, at_most: T) T {
186	192	assert(at_least <= at_most);
187		if (T.is_signed) {
	193	const info = @typeInfo(T).Int;
	194	if (info.is_signed) {
188	195	// Two's complement makes this math pretty easy.
189		const UnsignedT = std.meta.Int(false, T.bit_count);
	196	const UnsignedT = std.meta.Int(false, info.bits);
190	197	const lo = @bitCast(UnsignedT, at_least);
191	198	const hi = @bitCast(UnsignedT, at_most);
192	199	const result = lo +% r.uintAtMostBiased(UnsignedT, hi -% lo);
...	...	@@ -202,9 +209,10 @@ pub const Random = struct {
202	209	/// for commentary on the runtime of this function.
203	210	pub fn intRangeAtMost(r: *Random, comptime T: type, at_least: T, at_most: T) T {
204	211	assert(at_least <= at_most);
205		if (T.is_signed) {
	212	const info = @typeInfo(T).Int;
	213	if (info.is_signed) {
206	214	// Two's complement makes this math pretty easy.
207		const UnsignedT = std.meta.Int(false, T.bit_count);
	215	const UnsignedT = std.meta.Int(false, info.bits);
208	216	const lo = @bitCast(UnsignedT, at_least);
209	217	const hi = @bitCast(UnsignedT, at_most);
210	218	const result = lo +% r.uintAtMost(UnsignedT, hi -% lo);
...	...	@@ -280,14 +288,15 @@ pub const Random = struct {
280	288	/// into an integer 0 <= result < less_than.
281	289	/// This function introduces a minor bias.
282	290	pub fn limitRangeBiased(comptime T: type, random_int: T, less_than: T) T {
283		comptime assert(T.is_signed == false);
284		const T2 = std.meta.Int(false, T.bit_count * 2);
	291	comptime assert(@typeInfo(T).Int.is_signed == false);
	292	const bits = @typeInfo(T).Int.bits;
	293	const T2 = std.meta.Int(false, bits * 2);
285	294
286	295	// adapted from:
287	296	// http://www.pcg-random.org/posts/bounded-rands.html
288	297	// "Integer Multiplication (Biased)"
289	298	var m: T2 = @as(T2, random_int) * @as(T2, less_than);
290		return @intCast(T, m >> T.bit_count);
	299	return @intCast(T, m >> bits);
291	300	}
292	301
293	302	const SequentialPrng = struct {

lib/std/special/build_runner.zig+1-1

...	...	@@ -133,7 +133,7 @@ pub fn main() !void {
133	133	}
134	134
135	135	fn runBuild(builder: *Builder) anyerror!void {
136		switch (@typeInfo(@TypeOf(root.build).ReturnType)) {
	136	switch (@typeInfo(@typeInfo(@TypeOf(root.build)).Fn.return_type.?)) {
137	137	.Void => root.build(builder),
138	138	.ErrorUnion => try root.build(builder),
139	139	else => @compileError("expected return type of build to be 'void' or '!void'"),

lib/std/special/c.zig+3-2

...	...	@@ -516,11 +516,12 @@ export fn roundf(a: f32) f32 {
516	516	fn generic_fmod(comptime T: type, x: T, y: T) T {
517	517	@setRuntimeSafety(false);
518	518
519		const uint = std.meta.Int(false, T.bit_count);
	519	const bits = @typeInfo(T).Float.bits;
	520	const uint = std.meta.Int(false, bits);
520	521	const log2uint = math.Log2Int(uint);
521	522	const digits = if (T == f32) 23 else 52;
522	523	const exp_bits = if (T == f32) 9 else 12;
523		const bits_minus_1 = T.bit_count - 1;
	524	const bits_minus_1 = bits - 1;
524	525	const mask = if (T == f32) 0xff else 0x7ff;
525	526	var ux = @bitCast(uint, x);
526	527	var uy = @bitCast(uint, y);

lib/std/special/compiler_rt/addXf3.zig+10-8

...	...	@@ -59,23 +59,25 @@ pub fn __aeabi_dsub(a: f64, b: f64) callconv(.AAPCS) f64 {
59	59	}
60	60
61	61	// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
62		fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
63		const Z = std.meta.Int(false, T.bit_count);
64		const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
	62	fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
	63	const bits = @typeInfo(T).Float.bits;
	64	const Z = std.meta.Int(false, bits);
	65	const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
65	66	const significandBits = std.math.floatMantissaBits(T);
66	67	const implicitBit = @as(Z, 1) << significandBits;
67	68
68		const shift = @clz(std.meta.Int(false, T.bit_count), significand.*) - @clz(Z, implicitBit);
	69	const shift = @clz(std.meta.Int(false, bits), significand.*) - @clz(Z, implicitBit);
69	70	significand.* <<= @intCast(S, shift);
70	71	return 1 - shift;
71	72	}
72	73
73	74	// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
74	75	fn addXf3(comptime T: type, a: T, b: T) T {
75		const Z = std.meta.Int(false, T.bit_count);
76		const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
	76	const bits = @typeInfo(T).Float.bits;
	77	const Z = std.meta.Int(false, bits);
	78	const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
77	79
78		const typeWidth = T.bit_count;
	80	const typeWidth = bits;
79	81	const significandBits = std.math.floatMantissaBits(T);
80	82	const exponentBits = std.math.floatExponentBits(T);
81	83
...	...	@@ -187,7 +189,7 @@ fn addXf3(comptime T: type, a: T, b: T) T {
187	189	// If partial cancellation occured, we need to left-shift the result
188	190	// and adjust the exponent:
189	191	if (aSignificand < implicitBit << 3) {
190		const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(false, T.bit_count), implicitBit << 3));
	192	const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(false, bits), implicitBit << 3));
191	193	aSignificand <<= @intCast(S, shift);
192	194	aExponent -= shift;
193	195	}

lib/std/special/compiler_rt/aulldiv.zig+2-2

...	...	@@ -7,8 +7,8 @@ const builtin = @import("builtin");
7	7
8	8	pub fn _alldiv(a: i64, b: i64) callconv(.Stdcall) i64 {
9	9	@setRuntimeSafety(builtin.is_test);
10		const s_a = a >> (i64.bit_count - 1);
11		const s_b = b >> (i64.bit_count - 1);
	10	const s_a = a >> (64 - 1);
	11	const s_b = b >> (64 - 1);
12	12
13	13	const an = (a ^ s_a) -% s_a;
14	14	const bn = (b ^ s_b) -% s_b;

lib/std/special/compiler_rt/aullrem.zig+2-2

...	...	@@ -7,8 +7,8 @@ const builtin = @import("builtin");
7	7
8	8	pub fn _allrem(a: i64, b: i64) callconv(.Stdcall) i64 {
9	9	@setRuntimeSafety(builtin.is_test);
10		const s_a = a >> (i64.bit_count - 1);
11		const s_b = b >> (i64.bit_count - 1);
	10	const s_a = a >> (64 - 1);
	11	const s_b = b >> (64 - 1);
12	12
13	13	const an = (a ^ s_a) -% s_a;
14	14	const bn = (b ^ s_b) -% s_b;

lib/std/special/compiler_rt/compareXf2.zig+4-3

...	...	@@ -27,8 +27,9 @@ const GE = extern enum(i32) {
27	27	pub fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {
28	28	@setRuntimeSafety(builtin.is_test);
29	29
30		const srep_t = std.meta.Int(true, T.bit_count);
31		const rep_t = std.meta.Int(false, T.bit_count);
	30	const bits = @typeInfo(T).Float.bits;
	31	const srep_t = std.meta.Int(true, bits);
	32	const rep_t = std.meta.Int(false, bits);
32	33
33	34	const significandBits = std.math.floatMantissaBits(T);
34	35	const exponentBits = std.math.floatExponentBits(T);
...	...	@@ -73,7 +74,7 @@ pub fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {
73	74	pub fn unordcmp(comptime T: type, a: T, b: T) i32 {
74	75	@setRuntimeSafety(builtin.is_test);
75	76
76		const rep_t = std.meta.Int(false, T.bit_count);
	77	const rep_t = std.meta.Int(false, @typeInfo(T).Float.bits);
77	78
78	79	const significandBits = std.math.floatMantissaBits(T);
79	80	const exponentBits = std.math.floatExponentBits(T);

lib/std/special/compiler_rt/divdf3.zig+4-5

...	...	@@ -12,10 +12,9 @@ const builtin = @import("builtin");
12	12
13	13	pub fn __divdf3(a: f64, b: f64) callconv(.C) f64 {
14	14	@setRuntimeSafety(builtin.is_test);
15		const Z = std.meta.Int(false, f64.bit_count);
16		const SignedZ = std.meta.Int(true, f64.bit_count);
	15	const Z = std.meta.Int(false, 64);
	16	const SignedZ = std.meta.Int(true, 64);
17	17
18		const typeWidth = f64.bit_count;
19	18	const significandBits = std.math.floatMantissaBits(f64);
20	19	const exponentBits = std.math.floatExponentBits(f64);
21	20
...	...	@@ -317,9 +316,9 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: Z, lo: Z) void {
317	316	}
318	317	}
319	318
320		pub fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
	319	pub fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
321	320	@setRuntimeSafety(builtin.is_test);
322		const Z = std.meta.Int(false, T.bit_count);
	321	const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
323	322	const significandBits = std.math.floatMantissaBits(T);
324	323	const implicitBit = @as(Z, 1) << significandBits;
325	324

lib/std/special/compiler_rt/divsf3.zig+3-4

...	...	@@ -12,9 +12,8 @@ const builtin = @import("builtin");
12	12
13	13	pub fn __divsf3(a: f32, b: f32) callconv(.C) f32 {
14	14	@setRuntimeSafety(builtin.is_test);
15		const Z = std.meta.Int(false, f32.bit_count);
	15	const Z = std.meta.Int(false, 32);
16	16
17		const typeWidth = f32.bit_count;
18	17	const significandBits = std.math.floatMantissaBits(f32);
19	18	const exponentBits = std.math.floatExponentBits(f32);
20	19
...	...	@@ -190,9 +189,9 @@ pub fn __divsf3(a: f32, b: f32) callconv(.C) f32 {
190	189	}
191	190	}
192	191
193		fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
	192	fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
194	193	@setRuntimeSafety(builtin.is_test);
195		const Z = std.meta.Int(false, T.bit_count);
	194	const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
196	195	const significandBits = std.math.floatMantissaBits(T);
197	196	const implicitBit = @as(Z, 1) << significandBits;
198	197

lib/std/special/compiler_rt/divtf3.zig+2-3

...	...	@@ -11,10 +11,9 @@ const wideMultiply = @import("divdf3.zig").wideMultiply;
11	11
12	12	pub fn __divtf3(a: f128, b: f128) callconv(.C) f128 {
13	13	@setRuntimeSafety(builtin.is_test);
14		const Z = std.meta.Int(false, f128.bit_count);
15		const SignedZ = std.meta.Int(true, f128.bit_count);
	14	const Z = std.meta.Int(false, 128);
	15	const SignedZ = std.meta.Int(true, 128);
16	16
17		const typeWidth = f128.bit_count;
18	17	const significandBits = std.math.floatMantissaBits(f128);
19	18	const exponentBits = std.math.floatExponentBits(f128);
20	19

lib/std/special/compiler_rt/divti3.zig+2-2

...	...	@@ -9,8 +9,8 @@ const builtin = @import("builtin");
9	9	pub fn __divti3(a: i128, b: i128) callconv(.C) i128 {
10	10	@setRuntimeSafety(builtin.is_test);
11	11
12		const s_a = a >> (i128.bit_count - 1);
13		const s_b = b >> (i128.bit_count - 1);
	12	const s_a = a >> (128 - 1);
	13	const s_b = b >> (128 - 1);
14	14
15	15	const an = (a ^ s_a) -% s_a;
16	16	const bn = (b ^ s_b) -% s_b;

lib/std/special/compiler_rt/fixint.zig+5-4

...	...	@@ -28,7 +28,7 @@ pub fn fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t) fixint_t {
28	28	else => unreachable,
29	29	};
30	30
31		const typeWidth = rep_t.bit_count;
	31	const typeWidth = @typeInfo(rep_t).Int.bits;
32	32	const exponentBits = (typeWidth - significandBits - 1);
33	33	const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
34	34	const maxExponent = ((1 << exponentBits) - 1);
...	...	@@ -50,12 +50,13 @@ pub fn fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t) fixint_t {
50	50	if (exponent < 0) return 0;
51	51
52	52	// The unsigned result needs to be large enough to handle an fixint_t or rep_t
53		const fixuint_t = std.meta.Int(false, fixint_t.bit_count);
54		const UintResultType = if (fixint_t.bit_count > rep_t.bit_count) fixuint_t else rep_t;
	53	const fixint_bits = @typeInfo(fixint_t).Int.bits;
	54	const fixuint_t = std.meta.Int(false, fixint_bits);
	55	const UintResultType = if (fixint_bits > typeWidth) fixuint_t else rep_t;
55	56	var uint_result: UintResultType = undefined;
56	57
57	58	// If the value is too large for the integer type, saturate.
58		if (@intCast(usize, exponent) >= fixint_t.bit_count) {
	59	if (@intCast(usize, exponent) >= fixint_bits) {
59	60	return if (negative) @as(fixint_t, minInt(fixint_t)) else @as(fixint_t, maxInt(fixint_t));
60	61	}
61	62

lib/std/special/compiler_rt/fixuint.zig+3-3

...	...	@@ -15,14 +15,14 @@ pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t
15	15	f128 => u128,
16	16	else => unreachable,
17	17	};
18		const srep_t = @import("std").meta.Int(true, rep_t.bit_count);
	18	const typeWidth = @typeInfo(rep_t).Int.bits;
	19	const srep_t = @import("std").meta.Int(true, typeWidth);
19	20	const significandBits = switch (fp_t) {
20	21	f32 => 23,
21	22	f64 => 52,
22	23	f128 => 112,
23	24	else => unreachable,
24	25	};
25		const typeWidth = rep_t.bit_count;
26	26	const exponentBits = (typeWidth - significandBits - 1);
27	27	const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
28	28	const maxExponent = ((1 << exponentBits) - 1);
...	...	@@ -44,7 +44,7 @@ pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t
44	44	if (sign == -1 or exponent < 0) return 0;
45	45
46	46	// If the value is too large for the integer type, saturate.
47		if (@intCast(c_uint, exponent) >= fixuint_t.bit_count) return ~@as(fixuint_t, 0);
	47	if (@intCast(c_uint, exponent) >= @typeInfo(fixuint_t).Int.bits) return ~@as(fixuint_t, 0);
48	48
49	49	// If 0 <= exponent < significandBits, right shift to get the result.
50	50	// Otherwise, shift left.

lib/std/special/compiler_rt/floatXisf.zig+5-4

...	...	@@ -12,15 +12,16 @@ const FLT_MANT_DIG = 24;
12	12	fn __floatXisf(comptime T: type, arg: T) f32 {
13	13	@setRuntimeSafety(builtin.is_test);
14	14
15		const Z = std.meta.Int(false, T.bit_count);
16		const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
	15	const bits = @typeInfo(T).Int.bits;
	16	const Z = std.meta.Int(false, bits);
	17	const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
17	18
18	19	if (arg == 0) {
19	20	return @as(f32, 0.0);
20	21	}
21	22
22	23	var ai = arg;
23		const N: u32 = T.bit_count;
	24	const N: u32 = bits;
24	25	const si = ai >> @intCast(S, (N - 1));
25	26	ai = ((ai ^ si) -% si);
26	27	var a = @bitCast(Z, ai);
...	...	@@ -66,7 +67,7 @@ fn __floatXisf(comptime T: type, arg: T) f32 {
66	67	// a is now rounded to FLT_MANT_DIG bits
67	68	}
68	69
69		const s = @bitCast(Z, arg) >> (T.bit_count - 32);
	70	const s = @bitCast(Z, arg) >> (@typeInfo(T).Int.bits - 32);
70	71	const r = (@intCast(u32, s) & 0x80000000) \| // sign
71	72	(@intCast(u32, (e + 127)) << 23) \| // exponent
72	73	(@truncate(u32, a) & 0x007fffff); // mantissa-high

lib/std/special/compiler_rt/floatsiXf.zig+4-3

...	...	@@ -10,8 +10,9 @@ const maxInt = std.math.maxInt;
10	10	fn floatsiXf(comptime T: type, a: i32) T {
11	11	@setRuntimeSafety(builtin.is_test);
12	12
13		const Z = std.meta.Int(false, T.bit_count);
14		const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
	13	const bits = @typeInfo(T).Float.bits;
	14	const Z = std.meta.Int(false, bits);
	15	const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
15	16
16	17	if (a == 0) {
17	18	return @as(T, 0.0);
...	...	@@ -22,7 +23,7 @@ fn floatsiXf(comptime T: type, a: i32) T {
22	23	const exponentBias = ((1 << exponentBits - 1) - 1);
23	24
24	25	const implicitBit = @as(Z, 1) << significandBits;
25		const signBit = @as(Z, 1 << Z.bit_count - 1);
	26	const signBit = @as(Z, 1 << bits - 1);
26	27
27	28	const sign = a >> 31;
28	29	// Take absolute value of a via abs(x) = (x^(x >> 31)) - (x >> 31).

lib/std/special/compiler_rt/floatundisf.zig+1-1

...	...	@@ -15,7 +15,7 @@ pub fn __floatundisf(arg: u64) callconv(.C) f32 {
15	15	if (arg == 0) return 0;
16	16
17	17	var a = arg;
18		const N: usize = @TypeOf(a).bit_count;
	18	const N: usize = @typeInfo(@TypeOf(a)).Int.bits;
19	19	// Number of significant digits
20	20	const sd = N - @clz(u64, a);
21	21	// 8 exponent

lib/std/special/compiler_rt/floatunditf.zig+1-1

...	...	@@ -19,7 +19,7 @@ pub fn __floatunditf(a: u64) callconv(.C) f128 {
19	19	const exponent_bias = (1 << (exponent_bits - 1)) - 1;
20	20	const implicit_bit = 1 << mantissa_bits;
21	21
22		const exp: u128 = (u64.bit_count - 1) - @clz(u64, a);
	22	const exp: u128 = (64 - 1) - @clz(u64, a);
23	23	const shift: u7 = mantissa_bits - @intCast(u7, exp);
24	24
25	25	var result: u128 = (@intCast(u128, a) << shift) ^ implicit_bit;

lib/std/special/compiler_rt/floatunsitf.zig+1-1

...	...	@@ -19,7 +19,7 @@ pub fn __floatunsitf(a: u64) callconv(.C) f128 {
19	19	const exponent_bias = (1 << (exponent_bits - 1)) - 1;
20	20	const implicit_bit = 1 << mantissa_bits;
21	21
22		const exp = (u64.bit_count - 1) - @clz(u64, a);
	22	const exp = (64 - 1) - @clz(u64, a);
23	23	const shift = mantissa_bits - @intCast(u7, exp);
24	24
25	25	// TODO(#1148): @bitCast alignment error

lib/std/special/compiler_rt/int.zig+1-1

...	...	@@ -219,7 +219,7 @@ fn test_one_divsi3(a: i32, b: i32, expected_q: i32) void {
219	219	pub fn __udivsi3(n: u32, d: u32) callconv(.C) u32 {
220	220	@setRuntimeSafety(builtin.is_test);
221	221
222		const n_uword_bits: c_uint = u32.bit_count;
	222	const n_uword_bits: c_uint = 32;
223	223	// special cases
224	224	if (d == 0) return 0; // ?!
225	225	if (n == 0) return 0;

lib/std/special/compiler_rt/modti3.zig+2-2

...	...	@@ -14,8 +14,8 @@ const compiler_rt = @import("../compiler_rt.zig");
14	14	pub fn __modti3(a: i128, b: i128) callconv(.C) i128 {
15	15	@setRuntimeSafety(builtin.is_test);
16	16
17		const s_a = a >> (i128.bit_count - 1); // s = a < 0 ? -1 : 0
18		const s_b = b >> (i128.bit_count - 1); // s = b < 0 ? -1 : 0
	17	const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0
	18	const s_b = b >> (128 - 1); // s = b < 0 ? -1 : 0
19	19
20	20	const an = (a ^ s_a) -% s_a; // negate if s == -1
21	21	const bn = (b ^ s_b) -% s_b; // negate if s == -1

lib/std/special/compiler_rt/mulXf3.zig+5-5

...	...	@@ -33,9 +33,9 @@ pub fn __aeabi_dmul(a: f64, b: f64) callconv(.C) f64 {
33	33
34	34	fn mulXf3(comptime T: type, a: T, b: T) T {
35	35	@setRuntimeSafety(builtin.is_test);
36		const Z = std.meta.Int(false, T.bit_count);
	36	const typeWidth = @typeInfo(T).Float.bits;
	37	const Z = std.meta.Int(false, typeWidth);
37	38
38		const typeWidth = T.bit_count;
39	39	const significandBits = std.math.floatMantissaBits(T);
40	40	const exponentBits = std.math.floatExponentBits(T);
41	41
...	...	@@ -269,9 +269,9 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: Z, lo: Z) void {
269	269	}
270	270	}
271	271
272		fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
	272	fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
273	273	@setRuntimeSafety(builtin.is_test);
274		const Z = std.meta.Int(false, T.bit_count);
	274	const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
275	275	const significandBits = std.math.floatMantissaBits(T);
276	276	const implicitBit = @as(Z, 1) << significandBits;
277	277
...	...	@@ -282,7 +282,7 @@ fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i
282	282
283	283	fn wideRightShiftWithSticky(comptime Z: type, hi: Z, lo: Z, count: u32) void {
284	284	@setRuntimeSafety(builtin.is_test);
285		const typeWidth = Z.bit_count;
	285	const typeWidth = @typeInfo(Z).Int.bits;
286	286	const S = std.math.Log2Int(Z);
287	287	if (count < typeWidth) {
288	288	const sticky = @truncate(u8, lo.* << @intCast(S, typeWidth -% count));

lib/std/special/compiler_rt/mulodi4.zig+1-1

...	...	@@ -11,7 +11,7 @@ const minInt = std.math.minInt;
11	11	pub fn __mulodi4(a: i64, b: i64, overflow: *c_int) callconv(.C) i64 {
12	12	@setRuntimeSafety(builtin.is_test);
13	13
14		const min = @bitCast(i64, @as(u64, 1 << (i64.bit_count - 1)));
	14	const min = @bitCast(i64, @as(u64, 1 << (64 - 1)));
15	15	const max = ~min;
16	16
17	17	overflow.* = 0;

lib/std/special/compiler_rt/muloti4.zig+3-3

...	...	@@ -9,7 +9,7 @@ const compiler_rt = @import("../compiler_rt.zig");
9	9	pub fn __muloti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 {
10	10	@setRuntimeSafety(builtin.is_test);
11	11
12		const min = @bitCast(i128, @as(u128, 1 << (i128.bit_count - 1)));
	12	const min = @bitCast(i128, @as(u128, 1 << (128 - 1)));
13	13	const max = ~min;
14	14	overflow.* = 0;
15	15
...	...	@@ -27,9 +27,9 @@ pub fn __muloti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 {
27	27	return r;
28	28	}
29	29
30		const sa = a >> (i128.bit_count - 1);
	30	const sa = a >> (128 - 1);
31	31	const abs_a = (a ^ sa) -% sa;
32		const sb = b >> (i128.bit_count - 1);
	32	const sb = b >> (128 - 1);
33	33	const abs_b = (b ^ sb) -% sb;
34	34
35	35	if (abs_a < 2 or abs_b < 2) {

lib/std/special/compiler_rt/negXf2.zig+1-2

...	...	@@ -24,9 +24,8 @@ pub fn __aeabi_dneg(arg: f64) callconv(.AAPCS) f64 {
24	24	}
25	25
26	26	fn negXf2(comptime T: type, a: T) T {
27		const Z = std.meta.Int(false, T.bit_count);
	27	const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
28	28
29		const typeWidth = T.bit_count;
30	29	const significandBits = std.math.floatMantissaBits(T);
31	30	const exponentBits = std.math.floatExponentBits(T);
32	31

lib/std/special/compiler_rt/shift.zig+13-12

...	...	@@ -9,8 +9,9 @@ const Log2Int = std.math.Log2Int;
9	9
10	10	fn Dwords(comptime T: type, comptime signed_half: bool) type {
11	11	return extern union {
12		pub const HalfTU = std.meta.Int(false, @divExact(T.bit_count, 2));
13		pub const HalfTS = std.meta.Int(true, @divExact(T.bit_count, 2));
	12	pub const bits = @divExact(@typeInfo(T).Int.bits, 2);
	13	pub const HalfTU = std.meta.Int(false, bits);
	14	pub const HalfTS = std.meta.Int(true, bits);
14	15	pub const HalfT = if (signed_half) HalfTS else HalfTU;
15	16
16	17	all: T,
...	...	@@ -30,15 +31,15 @@ pub fn ashlXi3(comptime T: type, a: T, b: i32) T {
30	31	const input = dwords{ .all = a };
31	32	var output: dwords = undefined;
32	33
33		if (b >= dwords.HalfT.bit_count) {
	34	if (b >= dwords.bits) {
34	35	output.s.low = 0;
35		output.s.high = input.s.low << @intCast(S, b - dwords.HalfT.bit_count);
	36	output.s.high = input.s.low << @intCast(S, b - dwords.bits);
36	37	} else if (b == 0) {
37	38	return a;
38	39	} else {
39	40	output.s.low = input.s.low << @intCast(S, b);
40	41	output.s.high = input.s.high << @intCast(S, b);
41		output.s.high \|= input.s.low >> @intCast(S, dwords.HalfT.bit_count - b);
	42	output.s.high \|= input.s.low >> @intCast(S, dwords.bits - b);
42	43	}
43	44
44	45	return output.all;
...	...	@@ -53,14 +54,14 @@ pub fn ashrXi3(comptime T: type, a: T, b: i32) T {
53	54	const input = dwords{ .all = a };
54	55	var output: dwords = undefined;
55	56
56		if (b >= dwords.HalfT.bit_count) {
57		output.s.high = input.s.high >> (dwords.HalfT.bit_count - 1);
58		output.s.low = input.s.high >> @intCast(S, b - dwords.HalfT.bit_count);
	57	if (b >= dwords.bits) {
	58	output.s.high = input.s.high >> (dwords.bits - 1);
	59	output.s.low = input.s.high >> @intCast(S, b - dwords.bits);
59	60	} else if (b == 0) {
60	61	return a;
61	62	} else {
62	63	output.s.high = input.s.high >> @intCast(S, b);
63		output.s.low = input.s.high << @intCast(S, dwords.HalfT.bit_count - b);
	64	output.s.low = input.s.high << @intCast(S, dwords.bits - b);
64	65	// Avoid sign-extension here
65	66	output.s.low \|= @bitCast(
66	67	dwords.HalfT,
...	...	@@ -80,14 +81,14 @@ pub fn lshrXi3(comptime T: type, a: T, b: i32) T {
80	81	const input = dwords{ .all = a };
81	82	var output: dwords = undefined;
82	83
83		if (b >= dwords.HalfT.bit_count) {
	84	if (b >= dwords.bits) {
84	85	output.s.high = 0;
85		output.s.low = input.s.high >> @intCast(S, b - dwords.HalfT.bit_count);
	86	output.s.low = input.s.high >> @intCast(S, b - dwords.bits);
86	87	} else if (b == 0) {
87	88	return a;
88	89	} else {
89	90	output.s.high = input.s.high >> @intCast(S, b);
90		output.s.low = input.s.high << @intCast(S, dwords.HalfT.bit_count - b);
	91	output.s.low = input.s.high << @intCast(S, dwords.bits - b);
91	92	output.s.low \|= input.s.low >> @intCast(S, b);
92	93	}
93	94

lib/std/special/compiler_rt/truncXfYf2.zig+2-2

...	...	@@ -50,7 +50,7 @@ fn truncXfYf2(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
50	50
51	51	// Various constants whose values follow from the type parameters.
52	52	// Any reasonable optimizer will fold and propagate all of these.
53		const srcBits = src_t.bit_count;
	53	const srcBits = @typeInfo(src_t).Float.bits;
54	54	const srcExpBits = srcBits - srcSigBits - 1;
55	55	const srcInfExp = (1 << srcExpBits) - 1;
56	56	const srcExpBias = srcInfExp >> 1;
...	...	@@ -65,7 +65,7 @@ fn truncXfYf2(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
65	65	const srcQNaN = 1 << (srcSigBits - 1);
66	66	const srcNaNCode = srcQNaN - 1;
67	67
68		const dstBits = dst_t.bit_count;
	68	const dstBits = @typeInfo(dst_t).Float.bits;
69	69	const dstExpBits = dstBits - dstSigBits - 1;
70	70	const dstInfExp = (1 << dstExpBits) - 1;
71	71	const dstExpBias = dstInfExp >> 1;

lib/std/special/compiler_rt/udivmod.zig+36-34

...	...	@@ -15,8 +15,10 @@ const high = 1 - low;
15	15	pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem: ?*DoubleInt) DoubleInt {
16	16	@setRuntimeSafety(is_test);
17	17
18		const SingleInt = @import("std").meta.Int(false, @divExact(DoubleInt.bit_count, 2));
19		const SignedDoubleInt = @import("std").meta.Int(true, DoubleInt.bit_count);
	18	const double_int_bits = @typeInfo(DoubleInt).Int.bits;
	19	const single_int_bits = @divExact(double_int_bits, 2);
	20	const SingleInt = @import("std").meta.Int(false, single_int_bits);
	21	const SignedDoubleInt = @import("std").meta.Int(true, double_int_bits);
20	22	const Log2SingleInt = @import("std").math.Log2Int(SingleInt);
21	23
22	24	const n = @ptrCast(const [2]SingleInt, &a).; // TODO issue #421
...	...	@@ -82,21 +84,21 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
82	84	// ---
83	85	// K 0
84	86	sr = @bitCast(c_uint, @as(c_int, @clz(SingleInt, d[high])) - @as(c_int, @clz(SingleInt, n[high])));
85		// 0 <= sr <= SingleInt.bit_count - 2 or sr large
86		if (sr > SingleInt.bit_count - 2) {
	87	// 0 <= sr <= single_int_bits - 2 or sr large
	88	if (sr > single_int_bits - 2) {
87	89	if (maybe_rem) \|rem\| {
88	90	rem.* = a;
89	91	}
90	92	return 0;
91	93	}
92	94	sr += 1;
93		// 1 <= sr <= SingleInt.bit_count - 1
94		// q.all = a << (DoubleInt.bit_count - sr);
	95	// 1 <= sr <= single_int_bits - 1
	96	// q.all = a << (double_int_bits - sr);
95	97	q[low] = 0;
96		q[high] = n[low] << @intCast(Log2SingleInt, SingleInt.bit_count - sr);
	98	q[high] = n[low] << @intCast(Log2SingleInt, single_int_bits - sr);
97	99	// r.all = a >> sr;
98	100	r[high] = n[high] >> @intCast(Log2SingleInt, sr);
99		r[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
	101	r[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
100	102	} else {
101	103	// d[low] != 0
102	104	if (d[high] == 0) {
...	...	@@ -113,74 +115,74 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
113	115	}
114	116	sr = @ctz(SingleInt, d[low]);
115	117	q[high] = n[high] >> @intCast(Log2SingleInt, sr);
116		q[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
	118	q[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
117	119	return @ptrCast(align(@alignOf(SingleInt)) DoubleInt, &q[0]).; // TODO issue #421
118	120	}
119	121	// K X
120	122	// ---
121	123	// 0 K
122		sr = 1 + SingleInt.bit_count + @as(c_uint, @clz(SingleInt, d[low])) - @as(c_uint, @clz(SingleInt, n[high]));
123		// 2 <= sr <= DoubleInt.bit_count - 1
124		// q.all = a << (DoubleInt.bit_count - sr);
	124	sr = 1 + single_int_bits + @as(c_uint, @clz(SingleInt, d[low])) - @as(c_uint, @clz(SingleInt, n[high]));
	125	// 2 <= sr <= double_int_bits - 1
	126	// q.all = a << (double_int_bits - sr);
125	127	// r.all = a >> sr;
126		if (sr == SingleInt.bit_count) {
	128	if (sr == single_int_bits) {
127	129	q[low] = 0;
128	130	q[high] = n[low];
129	131	r[high] = 0;
130	132	r[low] = n[high];
131		} else if (sr < SingleInt.bit_count) {
132		// 2 <= sr <= SingleInt.bit_count - 1
	133	} else if (sr < single_int_bits) {
	134	// 2 <= sr <= single_int_bits - 1
133	135	q[low] = 0;
134		q[high] = n[low] << @intCast(Log2SingleInt, SingleInt.bit_count - sr);
	136	q[high] = n[low] << @intCast(Log2SingleInt, single_int_bits - sr);
135	137	r[high] = n[high] >> @intCast(Log2SingleInt, sr);
136		r[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
	138	r[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
137	139	} else {
138		// SingleInt.bit_count + 1 <= sr <= DoubleInt.bit_count - 1
139		q[low] = n[low] << @intCast(Log2SingleInt, DoubleInt.bit_count - sr);
140		q[high] = (n[high] << @intCast(Log2SingleInt, DoubleInt.bit_count - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr - SingleInt.bit_count));
	140	// single_int_bits + 1 <= sr <= double_int_bits - 1
	141	q[low] = n[low] << @intCast(Log2SingleInt, double_int_bits - sr);
	142	q[high] = (n[high] << @intCast(Log2SingleInt, double_int_bits - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr - single_int_bits));
141	143	r[high] = 0;
142		r[low] = n[high] >> @intCast(Log2SingleInt, sr - SingleInt.bit_count);
	144	r[low] = n[high] >> @intCast(Log2SingleInt, sr - single_int_bits);
143	145	}
144	146	} else {
145	147	// K X
146	148	// ---
147	149	// K K
148	150	sr = @bitCast(c_uint, @as(c_int, @clz(SingleInt, d[high])) - @as(c_int, @clz(SingleInt, n[high])));
149		// 0 <= sr <= SingleInt.bit_count - 1 or sr large
150		if (sr > SingleInt.bit_count - 1) {
	151	// 0 <= sr <= single_int_bits - 1 or sr large
	152	if (sr > single_int_bits - 1) {
151	153	if (maybe_rem) \|rem\| {
152	154	rem.* = a;
153	155	}
154	156	return 0;
155	157	}
156	158	sr += 1;
157		// 1 <= sr <= SingleInt.bit_count
158		// q.all = a << (DoubleInt.bit_count - sr);
	159	// 1 <= sr <= single_int_bits
	160	// q.all = a << (double_int_bits - sr);
159	161	// r.all = a >> sr;
160	162	q[low] = 0;
161		if (sr == SingleInt.bit_count) {
	163	if (sr == single_int_bits) {
162	164	q[high] = n[low];
163	165	r[high] = 0;
164	166	r[low] = n[high];
165	167	} else {
166	168	r[high] = n[high] >> @intCast(Log2SingleInt, sr);
167		r[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
168		q[high] = n[low] << @intCast(Log2SingleInt, SingleInt.bit_count - sr);
	169	r[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) \| (n[low] >> @intCast(Log2SingleInt, sr));
	170	q[high] = n[low] << @intCast(Log2SingleInt, single_int_bits - sr);
169	171	}
170	172	}
171	173	}
172	174	// Not a special case
173	175	// q and r are initialized with:
174		// q.all = a << (DoubleInt.bit_count - sr);
	176	// q.all = a << (double_int_bits - sr);
175	177	// r.all = a >> sr;
176		// 1 <= sr <= DoubleInt.bit_count - 1
	178	// 1 <= sr <= double_int_bits - 1
177	179	var carry: u32 = 0;
178	180	var r_all: DoubleInt = undefined;
179	181	while (sr > 0) : (sr -= 1) {
180	182	// r:q = ((r:q) << 1) \| carry
181		r[high] = (r[high] << 1) \| (r[low] >> (SingleInt.bit_count - 1));
182		r[low] = (r[low] << 1) \| (q[high] >> (SingleInt.bit_count - 1));
183		q[high] = (q[high] << 1) \| (q[low] >> (SingleInt.bit_count - 1));
	183	r[high] = (r[high] << 1) \| (r[low] >> (single_int_bits - 1));
	184	r[low] = (r[low] << 1) \| (q[high] >> (single_int_bits - 1));
	185	q[high] = (q[high] << 1) \| (q[low] >> (single_int_bits - 1));
184	186	q[low] = (q[low] << 1) \| carry;
185	187	// carry = 0;
186	188	// if (r.all >= b)
...	...	@@ -189,7 +191,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
189	191	// carry = 1;
190	192	// }
191	193	r_all = @ptrCast(align(@alignOf(SingleInt)) DoubleInt, &r[0]).; // TODO issue #421
192		const s: SignedDoubleInt = @bitCast(SignedDoubleInt, b -% r_all -% 1) >> (DoubleInt.bit_count - 1);
	194	const s: SignedDoubleInt = @bitCast(SignedDoubleInt, b -% r_all -% 1) >> (double_int_bits - 1);
193	195	carry = @intCast(u32, s & 1);
194	196	r_all -= b & @bitCast(DoubleInt, s);
195	197	r = @ptrCast([2]SingleInt, &r_all).; // TODO issue #421

lib/std/special/test_runner.zig+1-1

...	...	@@ -40,7 +40,7 @@ pub fn main() anyerror!void {
40	40	test_node.activate();
41	41	progress.refresh();
42	42	if (progress.terminal == null) {
43		std.debug.print("{}/{} {}...", .{ i + 1, test_fn_list.len, test_fn.name });
	43	std.debug.print("{}/{} {}... ", .{ i + 1, test_fn_list.len, test_fn.name });
44	44	}
45	45	const result = if (test_fn.async_frame_size) \|size\| switch (io_mode) {
46	46	.evented => blk: {

lib/std/start.zig+2-2

...	...	@@ -67,7 +67,7 @@ fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv
67	67	uefi.handle = handle;
68	68	uefi.system_table = system_table;
69	69
70		switch (@TypeOf(root.main).ReturnType) {
	70	switch (@typeInfo(@TypeOf(root.main)).Fn.return_type.?) {
71	71	noreturn => {
72	72	root.main();
73	73	},
...	...	@@ -239,7 +239,7 @@ fn callMainAsync(loop: *std.event.Loop) callconv(.Async) u8 {
239	239	// This is not marked inline because it is called with @asyncCall when
240	240	// there is an event loop.
241	241	pub fn callMain() u8 {
242		switch (@typeInfo(@TypeOf(root.main).ReturnType)) {
	242	switch (@typeInfo(@typeInfo(@TypeOf(root.main)).Fn.return_type.?)) {
243	243	.NoReturn => {
244	244	root.main();
245	245	},

lib/std/std.zig+1

...	...	@@ -50,6 +50,7 @@ pub const builtin = @import("builtin.zig");
50	50	pub const c = @import("c.zig");
51	51	pub const cache_hash = @import("cache_hash.zig");
52	52	pub const coff = @import("coff.zig");
	53	pub const compress = @import("compress.zig");
53	54	pub const crypto = @import("crypto.zig");
54	55	pub const cstr = @import("cstr.zig");
55	56	pub const debug = @import("debug.zig");

lib/std/target.zig+59-1

...	...	@@ -101,7 +101,7 @@ pub const Target = struct {
101	101
102	102	/// Latest Windows version that the Zig Standard Library is aware of
103	103	pub const latest = WindowsVersion.win10_20h1;
104
	104
105	105	pub const Range = struct {
106	106	min: WindowsVersion,
107	107	max: WindowsVersion,
...	...	@@ -468,6 +468,7 @@ pub const Target = struct {
468	468	/// TODO Get rid of this one.
469	469	unknown,
470	470	coff,
	471	pe,
471	472	elf,
472	473	macho,
473	474	wasm,
...	...	@@ -771,6 +772,63 @@ pub const Target = struct {
771	772	};
772	773	}
773	774
	775	pub fn toCoffMachine(arch: Arch) std.coff.MachineType {
	776	return switch (arch) {
	777	.avr => .Unknown,
	778	.msp430 => .Unknown,
	779	.arc => .Unknown,
	780	.arm => .ARM,
	781	.armeb => .Unknown,
	782	.hexagon => .Unknown,
	783	.le32 => .Unknown,
	784	.mips => .Unknown,
	785	.mipsel => .Unknown,
	786	.powerpc => .POWERPC,
	787	.r600 => .Unknown,
	788	.riscv32 => .RISCV32,
	789	.sparc => .Unknown,
	790	.sparcel => .Unknown,
	791	.tce => .Unknown,
	792	.tcele => .Unknown,
	793	.thumb => .Thumb,
	794	.thumbeb => .Thumb,
	795	.i386 => .I386,
	796	.xcore => .Unknown,
	797	.nvptx => .Unknown,
	798	.amdil => .Unknown,
	799	.hsail => .Unknown,
	800	.spir => .Unknown,
	801	.kalimba => .Unknown,
	802	.shave => .Unknown,
	803	.lanai => .Unknown,
	804	.wasm32 => .Unknown,
	805	.renderscript32 => .Unknown,
	806	.aarch64_32 => .ARM64,
	807	.aarch64 => .ARM64,
	808	.aarch64_be => .Unknown,
	809	.mips64 => .Unknown,
	810	.mips64el => .Unknown,
	811	.powerpc64 => .Unknown,
	812	.powerpc64le => .Unknown,
	813	.riscv64 => .RISCV64,
	814	.x86_64 => .X64,
	815	.nvptx64 => .Unknown,
	816	.le64 => .Unknown,
	817	.amdil64 => .Unknown,
	818	.hsail64 => .Unknown,
	819	.spir64 => .Unknown,
	820	.wasm64 => .Unknown,
	821	.renderscript64 => .Unknown,
	822	.amdgcn => .Unknown,
	823	.bpfel => .Unknown,
	824	.bpfeb => .Unknown,
	825	.sparcv9 => .Unknown,
	826	.s390x => .Unknown,
	827	.ve => .Unknown,
	828	.spu_2 => .Unknown,
	829	};
	830	}
	831
774	832	pub fn endian(arch: Arch) builtin.Endian {
775	833	return switch (arch) {
776	834	.avr,

lib/std/thread.zig+3-3

...	...	@@ -166,7 +166,7 @@ pub const Thread = struct {
166	166	fn threadMain(raw_arg: windows.LPVOID) callconv(.C) windows.DWORD {
167	167	const arg = if (@sizeOf(Context) == 0) {} else @ptrCast(Context, @alignCast(@alignOf(Context), raw_arg)).;
168	168
169		switch (@typeInfo(@TypeOf(startFn).ReturnType)) {
	169	switch (@typeInfo(@typeInfo(@TypeOf(startFn)).Fn.return_type.?)) {
170	170	.NoReturn => {
171	171	startFn(arg);
172	172	},
...	...	@@ -227,7 +227,7 @@ pub const Thread = struct {
227	227	fn linuxThreadMain(ctx_addr: usize) callconv(.C) u8 {
228	228	const arg = if (@sizeOf(Context) == 0) {} else @intToPtr(const Context, ctx_addr).;
229	229
230		switch (@typeInfo(@TypeOf(startFn).ReturnType)) {
	230	switch (@typeInfo(@typeInfo(@TypeOf(startFn)).Fn.return_type.?)) {
231	231	.NoReturn => {
232	232	startFn(arg);
233	233	},
...	...	@@ -259,7 +259,7 @@ pub const Thread = struct {
259	259	fn posixThreadMain(ctx: ?c_void) callconv(.C) ?c_void {
260	260	const arg = if (@sizeOf(Context) == 0) {} else @ptrCast(Context, @alignCast(@alignOf(Context), ctx)).;
261	261
262		switch (@typeInfo(@TypeOf(startFn).ReturnType)) {
	262	switch (@typeInfo(@typeInfo(@TypeOf(startFn)).Fn.return_type.?)) {
263	263	.NoReturn => {
264	264	startFn(arg);
265	265	},

lib/std/zig.zig+1-1

...	...	@@ -22,7 +22,7 @@ pub const SrcHash = [16]u8;
22	22	/// If it is long, blake3 hash is computed.
23	23	pub fn hashSrc(src: []const u8) SrcHash {
24	24	var out: SrcHash = undefined;
25		if (src.len <= SrcHash.len) {
	25	if (src.len <= @typeInfo(SrcHash).Array.len) {
26	26	std.mem.copy(u8, &out, src);
27	27	std.mem.set(u8, out[src.len..], 0);
28	28	} else {

lib/std/zig/parser_test.zig+114-6

...	...	@@ -615,6 +615,17 @@ test "zig fmt: infix operator and then multiline string literal" {
615	615	);
616	616	}
617	617
	618	test "zig fmt: infix operator and then multiline string literal" {
	619	try testCanonical(
	620	\\const x = "" ++
	621	\\ \\ hi0
	622	\\ \\ hi1
	623	\\ \\ hi2
	624	\\;
	625	\\
	626	);
	627	}
	628
618	629	test "zig fmt: C pointers" {
619	630	try testCanonical(
620	631	\\const Ptr = [*c]i32;
...	...	@@ -885,6 +896,28 @@ test "zig fmt: 2nd arg multiline string" {
885	896	);
886	897	}
887	898
	899	test "zig fmt: 2nd arg multiline string many args" {
	900	try testCanonical(
	901	\\comptime {
	902	\\ cases.addAsm("hello world linux x86_64",
	903	\\ \\.text
	904	\\ , "Hello, world!\n", "Hello, world!\n");
	905	\\}
	906	\\
	907	);
	908	}
	909
	910	test "zig fmt: final arg multiline string" {
	911	try testCanonical(
	912	\\comptime {
	913	\\ cases.addAsm("hello world linux x86_64", "Hello, world!\n",
	914	\\ \\.text
	915	\\ );
	916	\\}
	917	\\
	918	);
	919	}
	920
888	921	test "zig fmt: if condition wraps" {
889	922	try testTransform(
890	923	\\comptime {
...	...	@@ -915,6 +948,11 @@ test "zig fmt: if condition wraps" {
915	948	\\ var a = if (a) \|*f\| x: {
916	949	\\ break :x &a.b;
917	950	\\ } else \|err\| err;
	951	\\ var a = if (cond and
	952	\\ cond) \|*f\|
	953	\\ x: {
	954	\\ break :x &a.b;
	955	\\ } else \|err\| err;
918	956	\\}
919	957	,
920	958	\\comptime {
...	...	@@ -951,6 +989,35 @@ test "zig fmt: if condition wraps" {
951	989	\\ var a = if (a) \|*f\| x: {
952	990	\\ break :x &a.b;
953	991	\\ } else \|err\| err;
	992	\\ var a = if (cond and
	993	\\ cond) \|*f\|
	994	\\ x: {
	995	\\ break :x &a.b;
	996	\\ } else \|err\| err;
	997	\\}
	998	\\
	999	);
	1000	}
	1001
	1002	test "zig fmt: if condition has line break but must not wrap" {
	1003	try testCanonical(
	1004	\\comptime {
	1005	\\ if (self.user_input_options.put(
	1006	\\ name,
	1007	\\ UserInputOption{
	1008	\\ .name = name,
	1009	\\ .used = false,
	1010	\\ },
	1011	\\ ) catch unreachable) \|*prev_value\| {
	1012	\\ foo();
	1013	\\ bar();
	1014	\\ }
	1015	\\ if (put(
	1016	\\ a,
	1017	\\ b,
	1018	\\ )) {
	1019	\\ foo();
	1020	\\ }
954	1021	\\}
955	1022	\\
956	1023	);
...	...	@@ -977,6 +1044,18 @@ test "zig fmt: if condition has line break but must not wrap" {
977	1044	);
978	1045	}
979	1046
	1047	test "zig fmt: function call with multiline argument" {
	1048	try testCanonical(
	1049	\\comptime {
	1050	\\ self.user_input_options.put(name, UserInputOption{
	1051	\\ .name = name,
	1052	\\ .used = false,
	1053	\\ });
	1054	\\}
	1055	\\
	1056	);
	1057	}
	1058
980	1059	test "zig fmt: same-line doc comment on variable declaration" {
981	1060	try testTransform(
982	1061	\\pub const MAP_ANONYMOUS = 0x1000; /// allocated from memory, swap space
...	...	@@ -1228,7 +1307,7 @@ test "zig fmt: array literal with hint" {
1228	1307	\\const a = []u8{
1229	1308	\\ 1, 2,
1230	1309	\\ 3, //
1231		\\ 4,
	1310	\\ 4,
1232	1311	\\ 5, 6,
1233	1312	\\ 7,
1234	1313	\\};
...	...	@@ -1293,7 +1372,7 @@ test "zig fmt: multiline string parameter in fn call with trailing comma" {
1293	1372	\\ \\ZIG_C_HEADER_FILES {}
1294	1373	\\ \\ZIG_DIA_GUIDS_LIB {}
1295	1374	\\ \\
1296		\\ ,
	1375	\\ ,
1297	1376	\\ std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR),
1298	1377	\\ std.cstr.toSliceConst(c.ZIG_CXX_COMPILER),
1299	1378	\\ std.cstr.toSliceConst(c.ZIG_DIA_GUIDS_LIB),
...	...	@@ -2885,20 +2964,20 @@ test "zig fmt: multiline string in array" {
2885	2964	try testCanonical(
2886	2965	\\const Foo = [][]const u8{
2887	2966	\\ \\aaa
2888		\\,
	2967	\\ ,
2889	2968	\\ \\bbb
2890	2969	\\};
2891	2970	\\
2892	2971	\\fn bar() void {
2893	2972	\\ const Foo = [][]const u8{
2894	2973	\\ \\aaa
2895		\\ ,
	2974	\\ ,
2896	2975	\\ \\bbb
2897	2976	\\ };
2898	2977	\\ const Bar = [][]const u8{ // comment here
2899	2978	\\ \\aaa
2900	2979	\\ \\
2901		\\ , // and another comment can go here
	2980	\\ , // and another comment can go here
2902	2981	\\ \\bbb
2903	2982	\\ };
2904	2983	\\}
...	...	@@ -3214,6 +3293,34 @@ test "zig fmt: C var args" {
3214	3293	);
3215	3294	}
3216	3295
	3296	test "zig fmt: Only indent multiline string literals in function calls" {
	3297	try testCanonical(
	3298	\\test "zig fmt:" {
	3299	\\ try testTransform(
	3300	\\ \\const X = struct {
	3301	\\ \\ foo: i32, bar: i8 };
	3302	\\ ,
	3303	\\ \\const X = struct {
	3304	\\ \\ foo: i32, bar: i8
	3305	\\ \\};
	3306	\\ \\
	3307	\\ );
	3308	\\}
	3309	\\
	3310	);
	3311	}
	3312
	3313	test "zig fmt: Don't add extra newline after if" {
	3314	try testCanonical(
	3315	\\pub fn atomicSymLink(allocator: *Allocator, existing_path: []const u8, new_path: []const u8) !void {
	3316	\\ if (cwd().symLink(existing_path, new_path, .{})) {
	3317	\\ return;
	3318	\\ }
	3319	\\}
	3320	\\
	3321	);
	3322	}
	3323
3217	3324	const std = @import("std");
3218	3325	const mem = std.mem;
3219	3326	const warn = std.debug.warn;
...	...	@@ -3256,7 +3363,8 @@ fn testParse(source: []const u8, allocator: mem.Allocator, anything_changed: b
3256	3363	var buffer = std.ArrayList(u8).init(allocator);
3257	3364	errdefer buffer.deinit();
3258	3365
3259		anything_changed.* = try std.zig.render(allocator, buffer.outStream(), tree);
	3366	const outStream = buffer.outStream();
	3367	anything_changed.* = try std.zig.render(allocator, outStream, tree);
3260	3368	return buffer.toOwnedSlice();
3261	3369	}
3262	3370	fn testTransform(source: []const u8, expected_source: []const u8) !void {

lib/std/zig/render.zig+763-912

...	...	@@ -6,10 +6,12 @@
6	6	const std = @import("../std.zig");
7	7	const assert = std.debug.assert;
8	8	const mem = std.mem;
	9	const meta = std.meta;
9	10	const ast = std.zig.ast;
10	11	const Token = std.zig.Token;
11	12
12	13	const indent_delta = 4;
	14	const asm_indent_delta = 2;
13	15
14	16	pub const Error = error{
15	17	/// Ran out of memory allocating call stack frames to complete rendering.
...	...	@@ -21,70 +23,32 @@ pub fn render(allocator: mem.Allocator, stream: anytype, tree: ast.Tree) (@Typ
21	23	// cannot render an invalid tree
22	24	std.debug.assert(tree.errors.len == 0);
23	25
24		// make a passthrough stream that checks whether something changed
25		const MyStream = struct {
26		const MyStream = @This();
27		const StreamError = @TypeOf(stream).Error;
28
29		child_stream: @TypeOf(stream),
30		anything_changed: bool,
31		source_index: usize,
32		source: []const u8,
33
34		fn write(self: *MyStream, bytes: []const u8) StreamError!usize {
35		if (!self.anything_changed) {
36		const end = self.source_index + bytes.len;
37		if (end > self.source.len) {
38		self.anything_changed = true;
39		} else {
40		const src_slice = self.source[self.source_index..end];
41		self.source_index += bytes.len;
42		if (!mem.eql(u8, bytes, src_slice)) {
43		self.anything_changed = true;
44		}
45		}
46		}
47
48		return self.child_stream.write(bytes);
49		}
50		};
51		var my_stream = MyStream{
52		.child_stream = stream,
53		.anything_changed = false,
54		.source_index = 0,
55		.source = tree.source,
56		};
57		const my_stream_stream: std.io.Writer(*MyStream, MyStream.StreamError, MyStream.write) = .{
58		.context = &my_stream,
59		};
	26	var change_detection_stream = std.io.changeDetectionStream(tree.source, stream);
	27	var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, change_detection_stream.writer());
60	28
61		try renderRoot(allocator, my_stream_stream, tree);
	29	try renderRoot(allocator, &auto_indenting_stream, tree);
62	30
63		if (my_stream.source_index != my_stream.source.len) {
64		my_stream.anything_changed = true;
65		}
66
67		return my_stream.anything_changed;
	31	return change_detection_stream.changeDetected();
68	32	}
69	33
70	34	fn renderRoot(
71	35	allocator: *mem.Allocator,
72		stream: anytype,
	36	ais: anytype,
73	37	tree: *ast.Tree,
74		) (@TypeOf(stream).Error \|\| Error)!void {
	38	) (@TypeOf(ais.*).Error \|\| Error)!void {
	39
75	40	// render all the line comments at the beginning of the file
76	41	for (tree.token_ids) \|token_id, i\| {
77	42	if (token_id != .LineComment) break;
78	43	const token_loc = tree.token_locs[i];
79		try stream.print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
	44	try ais.writer().print("{}\n", .{mem.trimRight(u8, tree.tokenSliceLoc(token_loc), " ")});
80	45	const next_token = tree.token_locs[i + 1];
81	46	const loc = tree.tokenLocationLoc(token_loc.end, next_token);
82	47	if (loc.line >= 2) {
83		try stream.writeByte('\n');
	48	try ais.insertNewline();
84	49	}
85	50	}
86	51
87		var start_col: usize = 0;
88	52	var decl_i: ast.NodeIndex = 0;
89	53	const root_decls = tree.root_node.decls();
90	54
...	...	@@ -145,7 +109,7 @@ fn renderRoot(
145	109	// If there's no next reformatted `decl`, just copy the
146	110	// remaining input tokens and bail out.
147	111	const start = tree.token_locs[copy_start_token_index].start;
148		try copyFixingWhitespace(stream, tree.source[start..]);
	112	try copyFixingWhitespace(ais, tree.source[start..]);
149	113	return;
150	114	}
151	115	decl = root_decls[decl_i];
...	...	@@ -186,26 +150,25 @@ fn renderRoot(
186	150
187	151	const start = tree.token_locs[copy_start_token_index].start;
188	152	const end = tree.token_locs[copy_end_token_index].start;
189		try copyFixingWhitespace(stream, tree.source[start..end]);
	153	try copyFixingWhitespace(ais, tree.source[start..end]);
190	154	}
191	155
192		try renderTopLevelDecl(allocator, stream, tree, 0, &start_col, decl);
	156	try renderTopLevelDecl(allocator, ais, tree, decl);
193	157	decl_i += 1;
194	158	if (decl_i >= root_decls.len) return;
195		try renderExtraNewline(tree, stream, &start_col, root_decls[decl_i]);
	159	try renderExtraNewline(tree, ais, root_decls[decl_i]);
196	160	}
197	161	}
198	162
199		fn renderExtraNewline(tree: ast.Tree, stream: anytype, start_col: usize, node: *ast.Node) @TypeOf(stream).Error!void {
200		return renderExtraNewlineToken(tree, stream, start_col, node.firstToken());
	163	fn renderExtraNewline(tree: ast.Tree, ais: anytype, node: ast.Node) @TypeOf(ais.*).Error!void {
	164	return renderExtraNewlineToken(tree, ais, node.firstToken());
201	165	}
202	166
203	167	fn renderExtraNewlineToken(
204	168	tree: *ast.Tree,
205		stream: anytype,
206		start_col: *usize,
	169	ais: anytype,
207	170	first_token: ast.TokenIndex,
208		) @TypeOf(stream).Error!void {
	171	) @TypeOf(ais.*).Error!void {
209	172	var prev_token = first_token;
210	173	if (prev_token == 0) return;
211	174	var newline_threshold: usize = 2;
...	...	@@ -218,28 +181,27 @@ fn renderExtraNewlineToken(
218	181	const prev_token_end = tree.token_locs[prev_token - 1].end;
219	182	const loc = tree.tokenLocation(prev_token_end, first_token);
220	183	if (loc.line >= newline_threshold) {
221		try stream.writeByte('\n');
222		start_col.* = 0;
	184	try ais.insertNewline();
223	185	}
224	186	}
225	187
226		fn renderTopLevelDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tree, indent: usize, start_col: usize, decl: ast.Node) (@TypeOf(stream).Error \|\| Error)!void {
227		try renderContainerDecl(allocator, stream, tree, indent, start_col, decl, .Newline);
	188	fn renderTopLevelDecl(allocator: mem.Allocator, ais: anytype, tree: ast.Tree, decl: ast.Node) (@TypeOf(ais.).Error \|\| Error)!void {
	189	try renderContainerDecl(allocator, ais, tree, decl, .Newline);
228	190	}
229	191
230		fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tree, indent: usize, start_col: usize, decl: ast.Node, space: Space) (@TypeOf(stream).Error \|\| Error)!void {
	192	fn renderContainerDecl(allocator: mem.Allocator, ais: anytype, tree: ast.Tree, decl: ast.Node, space: Space) (@TypeOf(ais.).Error \|\| Error)!void {
231	193	switch (decl.tag) {
232	194	.FnProto => {
233	195	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
234	196
235		try renderDocComments(tree, stream, fn_proto, fn_proto.getDocComments(), indent, start_col);
	197	try renderDocComments(tree, ais, fn_proto, fn_proto.getDocComments());
236	198
237	199	if (fn_proto.getBodyNode()) \|body_node\| {
238		try renderExpression(allocator, stream, tree, indent, start_col, decl, .Space);
239		try renderExpression(allocator, stream, tree, indent, start_col, body_node, space);
	200	try renderExpression(allocator, ais, tree, decl, .Space);
	201	try renderExpression(allocator, ais, tree, body_node, space);
240	202	} else {
241		try renderExpression(allocator, stream, tree, indent, start_col, decl, .None);
242		try renderToken(tree, stream, tree.nextToken(decl.lastToken()), indent, start_col, space);
	203	try renderExpression(allocator, ais, tree, decl, .None);
	204	try renderToken(tree, ais, tree.nextToken(decl.lastToken()), space);
243	205	}
244	206	},
245	207
...	...	@@ -247,35 +209,35 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tr
247	209	const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
248	210
249	211	if (use_decl.visib_token) \|visib_token\| {
250		try renderToken(tree, stream, visib_token, indent, start_col, .Space); // pub
	212	try renderToken(tree, ais, visib_token, .Space); // pub
251	213	}
252		try renderToken(tree, stream, use_decl.use_token, indent, start_col, .Space); // usingnamespace
253		try renderExpression(allocator, stream, tree, indent, start_col, use_decl.expr, .None);
254		try renderToken(tree, stream, use_decl.semicolon_token, indent, start_col, space); // ;
	214	try renderToken(tree, ais, use_decl.use_token, .Space); // usingnamespace
	215	try renderExpression(allocator, ais, tree, use_decl.expr, .None);
	216	try renderToken(tree, ais, use_decl.semicolon_token, space); // ;
255	217	},
256	218
257	219	.VarDecl => {
258	220	const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
259	221
260		try renderDocComments(tree, stream, var_decl, var_decl.getDocComments(), indent, start_col);
261		try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
	222	try renderDocComments(tree, ais, var_decl, var_decl.getDocComments());
	223	try renderVarDecl(allocator, ais, tree, var_decl);
262	224	},
263	225
264	226	.TestDecl => {
265	227	const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
266	228
267		try renderDocComments(tree, stream, test_decl, test_decl.doc_comments, indent, start_col);
268		try renderToken(tree, stream, test_decl.test_token, indent, start_col, .Space);
269		try renderExpression(allocator, stream, tree, indent, start_col, test_decl.name, .Space);
270		try renderExpression(allocator, stream, tree, indent, start_col, test_decl.body_node, space);
	229	try renderDocComments(tree, ais, test_decl, test_decl.doc_comments);
	230	try renderToken(tree, ais, test_decl.test_token, .Space);
	231	try renderExpression(allocator, ais, tree, test_decl.name, .Space);
	232	try renderExpression(allocator, ais, tree, test_decl.body_node, space);
271	233	},
272	234
273	235	.ContainerField => {
274	236	const field = @fieldParentPtr(ast.Node.ContainerField, "base", decl);
275	237
276		try renderDocComments(tree, stream, field, field.doc_comments, indent, start_col);
	238	try renderDocComments(tree, ais, field, field.doc_comments);
277	239	if (field.comptime_token) \|t\| {
278		try renderToken(tree, stream, t, indent, start_col, .Space); // comptime
	240	try renderToken(tree, ais, t, .Space); // comptime
279	241	}
280	242
281	243	const src_has_trailing_comma = blk: {
...	...	@@ -288,68 +250,67 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tr
288	250	const last_token_space: Space = if (src_has_trailing_comma) .None else space;
289	251
290	252	if (field.type_expr == null and field.value_expr == null) {
291		try renderToken(tree, stream, field.name_token, indent, start_col, last_token_space); // name
	253	try renderToken(tree, ais, field.name_token, last_token_space); // name
292	254	} else if (field.type_expr != null and field.value_expr == null) {
293		try renderToken(tree, stream, field.name_token, indent, start_col, .None); // name
294		try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // :
	255	try renderToken(tree, ais, field.name_token, .None); // name
	256	try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // :
295	257
296	258	if (field.align_expr) \|align_value_expr\| {
297		try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
	259	try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
298	260	const lparen_token = tree.prevToken(align_value_expr.firstToken());
299	261	const align_kw = tree.prevToken(lparen_token);
300	262	const rparen_token = tree.nextToken(align_value_expr.lastToken());
301		try renderToken(tree, stream, align_kw, indent, start_col, .None); // align
302		try renderToken(tree, stream, lparen_token, indent, start_col, .None); // (
303		try renderExpression(allocator, stream, tree, indent, start_col, align_value_expr, .None); // alignment
304		try renderToken(tree, stream, rparen_token, indent, start_col, last_token_space); // )
	263	try renderToken(tree, ais, align_kw, .None); // align
	264	try renderToken(tree, ais, lparen_token, .None); // (
	265	try renderExpression(allocator, ais, tree, align_value_expr, .None); // alignment
	266	try renderToken(tree, ais, rparen_token, last_token_space); // )
305	267	} else {
306		try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, last_token_space); // type
	268	try renderExpression(allocator, ais, tree, field.type_expr.?, last_token_space); // type
307	269	}
308	270	} else if (field.type_expr == null and field.value_expr != null) {
309		try renderToken(tree, stream, field.name_token, indent, start_col, .Space); // name
310		try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // =
311		try renderExpression(allocator, stream, tree, indent, start_col, field.value_expr.?, last_token_space); // value
	271	try renderToken(tree, ais, field.name_token, .Space); // name
	272	try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // =
	273	try renderExpression(allocator, ais, tree, field.value_expr.?, last_token_space); // value
312	274	} else {
313		try renderToken(tree, stream, field.name_token, indent, start_col, .None); // name
314		try renderToken(tree, stream, tree.nextToken(field.name_token), indent, start_col, .Space); // :
	275	try renderToken(tree, ais, field.name_token, .None); // name
	276	try renderToken(tree, ais, tree.nextToken(field.name_token), .Space); // :
315	277
316	278	if (field.align_expr) \|align_value_expr\| {
317		try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
	279	try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
318	280	const lparen_token = tree.prevToken(align_value_expr.firstToken());
319	281	const align_kw = tree.prevToken(lparen_token);
320	282	const rparen_token = tree.nextToken(align_value_expr.lastToken());
321		try renderToken(tree, stream, align_kw, indent, start_col, .None); // align
322		try renderToken(tree, stream, lparen_token, indent, start_col, .None); // (
323		try renderExpression(allocator, stream, tree, indent, start_col, align_value_expr, .None); // alignment
324		try renderToken(tree, stream, rparen_token, indent, start_col, .Space); // )
	283	try renderToken(tree, ais, align_kw, .None); // align
	284	try renderToken(tree, ais, lparen_token, .None); // (
	285	try renderExpression(allocator, ais, tree, align_value_expr, .None); // alignment
	286	try renderToken(tree, ais, rparen_token, .Space); // )
325	287	} else {
326		try renderExpression(allocator, stream, tree, indent, start_col, field.type_expr.?, .Space); // type
	288	try renderExpression(allocator, ais, tree, field.type_expr.?, .Space); // type
327	289	}
328		try renderToken(tree, stream, tree.prevToken(field.value_expr.?.firstToken()), indent, start_col, .Space); // =
329		try renderExpression(allocator, stream, tree, indent, start_col, field.value_expr.?, last_token_space); // value
	290	try renderToken(tree, ais, tree.prevToken(field.value_expr.?.firstToken()), .Space); // =
	291	try renderExpression(allocator, ais, tree, field.value_expr.?, last_token_space); // value
330	292	}
331	293
332	294	if (src_has_trailing_comma) {
333	295	const comma = tree.nextToken(field.lastToken());
334		try renderToken(tree, stream, comma, indent, start_col, space);
	296	try renderToken(tree, ais, comma, space);
335	297	}
336	298	},
337	299
338	300	.Comptime => {
339	301	assert(!decl.requireSemiColon());
340		try renderExpression(allocator, stream, tree, indent, start_col, decl, space);
	302	try renderExpression(allocator, ais, tree, decl, space);
341	303	},
342	304
343	305	.DocComment => {
344	306	const comment = @fieldParentPtr(ast.Node.DocComment, "base", decl);
345	307	const kind = tree.token_ids[comment.first_line];
346		try renderToken(tree, stream, comment.first_line, indent, start_col, .Newline);
	308	try renderToken(tree, ais, comment.first_line, .Newline);
347	309	var tok_i = comment.first_line + 1;
348	310	while (true) : (tok_i += 1) {
349	311	const tok_id = tree.token_ids[tok_i];
350	312	if (tok_id == kind) {
351		try stream.writeByteNTimes(' ', indent);
352		try renderToken(tree, stream, tok_i, indent, start_col, .Newline);
	313	try renderToken(tree, ais, tok_i, .Newline);
353	314	} else if (tok_id == .LineComment) {
354	315	continue;
355	316	} else {
...	...	@@ -363,13 +324,11 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tr
363	324
364	325	fn renderExpression(
365	326	allocator: *mem.Allocator,
366		stream: anytype,
	327	ais: anytype,
367	328	tree: *ast.Tree,
368		indent: usize,
369		start_col: *usize,
370	329	base: *ast.Node,
371	330	space: Space,
372		) (@TypeOf(stream).Error \|\| Error)!void {
	331	) (@TypeOf(ais.*).Error \|\| Error)!void {
373	332	switch (base.tag) {
374	333	.Identifier,
375	334	.IntegerLiteral,
...	...	@@ -383,18 +342,18 @@ fn renderExpression(
383	342	.UndefinedLiteral,
384	343	=> {
385	344	const casted_node = base.cast(ast.Node.OneToken).?;
386		return renderToken(tree, stream, casted_node.token, indent, start_col, space);
	345	return renderToken(tree, ais, casted_node.token, space);
387	346	},
388	347
389	348	.AnyType => {
390	349	const any_type = base.castTag(.AnyType).?;
391	350	if (mem.eql(u8, tree.tokenSlice(any_type.token), "var")) {
392	351	// TODO remove in next release cycle
393		try stream.writeAll("anytype");
394		if (space == .Comma) try stream.writeAll(",\n");
	352	try ais.writer().writeAll("anytype");
	353	if (space == .Comma) try ais.writer().writeAll(",\n");
395	354	return;
396	355	}
397		return renderToken(tree, stream, any_type.token, indent, start_col, space);
	356	return renderToken(tree, ais, any_type.token, space);
398	357	},
399	358
400	359	.Block, .LabeledBlock => {
...	...	@@ -424,65 +383,65 @@ fn renderExpression(
424	383	};
425	384
426	385	if (block.label) \|label\| {
427		try renderToken(tree, stream, label, indent, start_col, Space.None);
428		try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space);
	386	try renderToken(tree, ais, label, Space.None);
	387	try renderToken(tree, ais, tree.nextToken(label), Space.Space);
429	388	}
430	389
431	390	if (block.statements.len == 0) {
432		try renderToken(tree, stream, block.lbrace, indent + indent_delta, start_col, Space.None);
433		return renderToken(tree, stream, block.rbrace, indent, start_col, space);
	391	ais.pushIndentNextLine();
	392	defer ais.popIndent();
	393	try renderToken(tree, ais, block.lbrace, Space.None);
434	394	} else {
435		const block_indent = indent + indent_delta;
436		try renderToken(tree, stream, block.lbrace, block_indent, start_col, Space.Newline);
	395	ais.pushIndentNextLine();
	396	defer ais.popIndent();
	397
	398	try renderToken(tree, ais, block.lbrace, Space.Newline);
437	399
438	400	for (block.statements) \|statement, i\| {
439		try stream.writeByteNTimes(' ', block_indent);
440		try renderStatement(allocator, stream, tree, block_indent, start_col, statement);
	401	try renderStatement(allocator, ais, tree, statement);
441	402
442	403	if (i + 1 < block.statements.len) {
443		try renderExtraNewline(tree, stream, start_col, block.statements[i + 1]);
	404	try renderExtraNewline(tree, ais, block.statements[i + 1]);
444	405	}
445	406	}
446
447		try stream.writeByteNTimes(' ', indent);
448		return renderToken(tree, stream, block.rbrace, indent, start_col, space);
449	407	}
	408	return renderToken(tree, ais, block.rbrace, space);
450	409	},
451	410
452	411	.Defer => {
453	412	const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
454	413
455		try renderToken(tree, stream, defer_node.defer_token, indent, start_col, Space.Space);
	414	try renderToken(tree, ais, defer_node.defer_token, Space.Space);
456	415	if (defer_node.payload) \|payload\| {
457		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
	416	try renderExpression(allocator, ais, tree, payload, Space.Space);
458	417	}
459		return renderExpression(allocator, stream, tree, indent, start_col, defer_node.expr, space);
	418	return renderExpression(allocator, ais, tree, defer_node.expr, space);
460	419	},
461	420	.Comptime => {
462	421	const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
463	422
464		try renderToken(tree, stream, comptime_node.comptime_token, indent, start_col, Space.Space);
465		return renderExpression(allocator, stream, tree, indent, start_col, comptime_node.expr, space);
	423	try renderToken(tree, ais, comptime_node.comptime_token, Space.Space);
	424	return renderExpression(allocator, ais, tree, comptime_node.expr, space);
466	425	},
467	426	.Nosuspend => {
468	427	const nosuspend_node = @fieldParentPtr(ast.Node.Nosuspend, "base", base);
469	428	if (mem.eql(u8, tree.tokenSlice(nosuspend_node.nosuspend_token), "noasync")) {
470	429	// TODO: remove this
471		try stream.writeAll("nosuspend ");
	430	try ais.writer().writeAll("nosuspend ");
472	431	} else {
473		try renderToken(tree, stream, nosuspend_node.nosuspend_token, indent, start_col, Space.Space);
	432	try renderToken(tree, ais, nosuspend_node.nosuspend_token, Space.Space);
474	433	}
475		return renderExpression(allocator, stream, tree, indent, start_col, nosuspend_node.expr, space);
	434	return renderExpression(allocator, ais, tree, nosuspend_node.expr, space);
476	435	},
477	436
478	437	.Suspend => {
479	438	const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
480	439
481	440	if (suspend_node.body) \|body\| {
482		try renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, Space.Space);
483		return renderExpression(allocator, stream, tree, indent, start_col, body, space);
	441	try renderToken(tree, ais, suspend_node.suspend_token, Space.Space);
	442	return renderExpression(allocator, ais, tree, body, space);
484	443	} else {
485		return renderToken(tree, stream, suspend_node.suspend_token, indent, start_col, space);
	444	return renderToken(tree, ais, suspend_node.suspend_token, space);
486	445	}
487	446	},
488	447
...	...	@@ -490,26 +449,21 @@ fn renderExpression(
490	449	const infix_op_node = @fieldParentPtr(ast.Node.Catch, "base", base);
491	450
492	451	const op_space = Space.Space;
493		try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
	452	try renderExpression(allocator, ais, tree, infix_op_node.lhs, op_space);
494	453
495	454	const after_op_space = blk: {
496		const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
497		break :blk if (loc.line == 0) op_space else Space.Newline;
	455	const same_line = tree.tokensOnSameLine(infix_op_node.op_token, tree.nextToken(infix_op_node.op_token));
	456	break :blk if (same_line) op_space else Space.Newline;
498	457	};
499	458
500		try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
501		if (after_op_space == Space.Newline and
502		tree.token_ids[tree.nextToken(infix_op_node.op_token)] != .MultilineStringLiteralLine)
503		{
504		try stream.writeByteNTimes(' ', indent + indent_delta);
505		start_col.* = indent + indent_delta;
506		}
	459	try renderToken(tree, ais, infix_op_node.op_token, after_op_space);
507	460
508	461	if (infix_op_node.payload) \|payload\| {
509		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
	462	try renderExpression(allocator, ais, tree, payload, Space.Space);
510	463	}
511	464
512		return renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.rhs, space);
	465	ais.pushIndentOneShot();
	466	return renderExpression(allocator, ais, tree, infix_op_node.rhs, space);
513	467	},
514	468
515	469	.Add,
...	...	@@ -561,22 +515,16 @@ fn renderExpression(
561	515	.Period, .ErrorUnion, .Range => Space.None,
562	516	else => Space.Space,
563	517	};
564		try renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.lhs, op_space);
	518	try renderExpression(allocator, ais, tree, infix_op_node.lhs, op_space);
565	519
566	520	const after_op_space = blk: {
567	521	const loc = tree.tokenLocation(tree.token_locs[infix_op_node.op_token].end, tree.nextToken(infix_op_node.op_token));
568	522	break :blk if (loc.line == 0) op_space else Space.Newline;
569	523	};
570	524
571		try renderToken(tree, stream, infix_op_node.op_token, indent, start_col, after_op_space);
572		if (after_op_space == Space.Newline and
573		tree.token_ids[tree.nextToken(infix_op_node.op_token)] != .MultilineStringLiteralLine)
574		{
575		try stream.writeByteNTimes(' ', indent + indent_delta);
576		start_col.* = indent + indent_delta;
577		}
578
579		return renderExpression(allocator, stream, tree, indent, start_col, infix_op_node.rhs, space);
	525	try renderToken(tree, ais, infix_op_node.op_token, after_op_space);
	526	ais.pushIndentOneShot();
	527	return renderExpression(allocator, ais, tree, infix_op_node.rhs, space);
580	528	},
581	529
582	530	.BitNot,
...	...	@@ -587,8 +535,8 @@ fn renderExpression(
587	535	.AddressOf,
588	536	=> {
589	537	const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
590		try renderToken(tree, stream, casted_node.op_token, indent, start_col, Space.None);
591		return renderExpression(allocator, stream, tree, indent, start_col, casted_node.rhs, space);
	538	try renderToken(tree, ais, casted_node.op_token, Space.None);
	539	return renderExpression(allocator, ais, tree, casted_node.rhs, space);
592	540	},
593	541
594	542	.Try,
...	...	@@ -596,18 +544,16 @@ fn renderExpression(
596	544	.Await,
597	545	=> {
598	546	const casted_node = @fieldParentPtr(ast.Node.SimplePrefixOp, "base", base);
599		try renderToken(tree, stream, casted_node.op_token, indent, start_col, Space.Space);
600		return renderExpression(allocator, stream, tree, indent, start_col, casted_node.rhs, space);
	547	try renderToken(tree, ais, casted_node.op_token, Space.Space);
	548	return renderExpression(allocator, ais, tree, casted_node.rhs, space);
601	549	},
602	550
603	551	.ArrayType => {
604	552	const array_type = @fieldParentPtr(ast.Node.ArrayType, "base", base);
605	553	return renderArrayType(
606	554	allocator,
607		stream,
	555	ais,
608	556	tree,
609		indent,
610		start_col,
611	557	array_type.op_token,
612	558	array_type.rhs,
613	559	array_type.len_expr,
...	...	@@ -619,10 +565,8 @@ fn renderExpression(
619	565	const array_type = @fieldParentPtr(ast.Node.ArrayTypeSentinel, "base", base);
620	566	return renderArrayType(
621	567	allocator,
622		stream,
	568	ais,
623	569	tree,
624		indent,
625		start_col,
626	570	array_type.op_token,
627	571	array_type.rhs,
628	572	array_type.len_expr,
...	...	@@ -635,111 +579,111 @@ fn renderExpression(
635	579	const ptr_type = @fieldParentPtr(ast.Node.PtrType, "base", base);
636	580	const op_tok_id = tree.token_ids[ptr_type.op_token];
637	581	switch (op_tok_id) {
638		.Asterisk, .AsteriskAsterisk => try stream.writeByte('*'),
	582	.Asterisk, .AsteriskAsterisk => try ais.writer().writeByte('*'),
639	583	.LBracket => if (tree.token_ids[ptr_type.op_token + 2] == .Identifier)
640		try stream.writeAll("[*c")
	584	try ais.writer().writeAll("[*c")
641	585	else
642		try stream.writeAll("[*"),
	586	try ais.writer().writeAll("[*"),
643	587	else => unreachable,
644	588	}
645	589	if (ptr_type.ptr_info.sentinel) \|sentinel\| {
646	590	const colon_token = tree.prevToken(sentinel.firstToken());
647		try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
	591	try renderToken(tree, ais, colon_token, Space.None); // :
648	592	const sentinel_space = switch (op_tok_id) {
649	593	.LBracket => Space.None,
650	594	else => Space.Space,
651	595	};
652		try renderExpression(allocator, stream, tree, indent, start_col, sentinel, sentinel_space);
	596	try renderExpression(allocator, ais, tree, sentinel, sentinel_space);
653	597	}
654	598	switch (op_tok_id) {
655	599	.Asterisk, .AsteriskAsterisk => {},
656		.LBracket => try stream.writeByte(']'),
	600	.LBracket => try ais.writer().writeByte(']'),
657	601	else => unreachable,
658	602	}
659	603	if (ptr_type.ptr_info.allowzero_token) \|allowzero_token\| {
660		try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
	604	try renderToken(tree, ais, allowzero_token, Space.Space); // allowzero
661	605	}
662	606	if (ptr_type.ptr_info.align_info) \|align_info\| {
663	607	const lparen_token = tree.prevToken(align_info.node.firstToken());
664	608	const align_token = tree.prevToken(lparen_token);
665	609
666		try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
667		try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
	610	try renderToken(tree, ais, align_token, Space.None); // align
	611	try renderToken(tree, ais, lparen_token, Space.None); // (
668	612
669		try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
	613	try renderExpression(allocator, ais, tree, align_info.node, Space.None);
670	614
671	615	if (align_info.bit_range) \|bit_range\| {
672	616	const colon1 = tree.prevToken(bit_range.start.firstToken());
673	617	const colon2 = tree.prevToken(bit_range.end.firstToken());
674	618
675		try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
676		try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
677		try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
678		try renderExpression(allocator, stream, tree, indent, start_col, bit_range.end, Space.None);
	619	try renderToken(tree, ais, colon1, Space.None); // :
	620	try renderExpression(allocator, ais, tree, bit_range.start, Space.None);
	621	try renderToken(tree, ais, colon2, Space.None); // :
	622	try renderExpression(allocator, ais, tree, bit_range.end, Space.None);
679	623
680	624	const rparen_token = tree.nextToken(bit_range.end.lastToken());
681		try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
	625	try renderToken(tree, ais, rparen_token, Space.Space); // )
682	626	} else {
683	627	const rparen_token = tree.nextToken(align_info.node.lastToken());
684		try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
	628	try renderToken(tree, ais, rparen_token, Space.Space); // )
685	629	}
686	630	}
687	631	if (ptr_type.ptr_info.const_token) \|const_token\| {
688		try renderToken(tree, stream, const_token, indent, start_col, Space.Space); // const
	632	try renderToken(tree, ais, const_token, Space.Space); // const
689	633	}
690	634	if (ptr_type.ptr_info.volatile_token) \|volatile_token\| {
691		try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
	635	try renderToken(tree, ais, volatile_token, Space.Space); // volatile
692	636	}
693		return renderExpression(allocator, stream, tree, indent, start_col, ptr_type.rhs, space);
	637	return renderExpression(allocator, ais, tree, ptr_type.rhs, space);
694	638	},
695	639
696	640	.SliceType => {
697	641	const slice_type = @fieldParentPtr(ast.Node.SliceType, "base", base);
698		try renderToken(tree, stream, slice_type.op_token, indent, start_col, Space.None); // [
	642	try renderToken(tree, ais, slice_type.op_token, Space.None); // [
699	643	if (slice_type.ptr_info.sentinel) \|sentinel\| {
700	644	const colon_token = tree.prevToken(sentinel.firstToken());
701		try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
702		try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
703		try renderToken(tree, stream, tree.nextToken(sentinel.lastToken()), indent, start_col, Space.None); // ]
	645	try renderToken(tree, ais, colon_token, Space.None); // :
	646	try renderExpression(allocator, ais, tree, sentinel, Space.None);
	647	try renderToken(tree, ais, tree.nextToken(sentinel.lastToken()), Space.None); // ]
704	648	} else {
705		try renderToken(tree, stream, tree.nextToken(slice_type.op_token), indent, start_col, Space.None); // ]
	649	try renderToken(tree, ais, tree.nextToken(slice_type.op_token), Space.None); // ]
706	650	}
707	651
708	652	if (slice_type.ptr_info.allowzero_token) \|allowzero_token\| {
709		try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
	653	try renderToken(tree, ais, allowzero_token, Space.Space); // allowzero
710	654	}
711	655	if (slice_type.ptr_info.align_info) \|align_info\| {
712	656	const lparen_token = tree.prevToken(align_info.node.firstToken());
713	657	const align_token = tree.prevToken(lparen_token);
714	658
715		try renderToken(tree, stream, align_token, indent, start_col, Space.None); // align
716		try renderToken(tree, stream, lparen_token, indent, start_col, Space.None); // (
	659	try renderToken(tree, ais, align_token, Space.None); // align
	660	try renderToken(tree, ais, lparen_token, Space.None); // (
717	661
718		try renderExpression(allocator, stream, tree, indent, start_col, align_info.node, Space.None);
	662	try renderExpression(allocator, ais, tree, align_info.node, Space.None);
719	663
720	664	if (align_info.bit_range) \|bit_range\| {
721	665	const colon1 = tree.prevToken(bit_range.start.firstToken());
722	666	const colon2 = tree.prevToken(bit_range.end.firstToken());
723	667
724		try renderToken(tree, stream, colon1, indent, start_col, Space.None); // :
725		try renderExpression(allocator, stream, tree, indent, start_col, bit_range.start, Space.None);
726		try renderToken(tree, stream, colon2, indent, start_col, Space.None); // :
727		try renderExpression(allocator, stream, tree, indent, start_col, bit_range.end, Space.None);
	668	try renderToken(tree, ais, colon1, Space.None); // :
	669	try renderExpression(allocator, ais, tree, bit_range.start, Space.None);
	670	try renderToken(tree, ais, colon2, Space.None); // :
	671	try renderExpression(allocator, ais, tree, bit_range.end, Space.None);
728	672
729	673	const rparen_token = tree.nextToken(bit_range.end.lastToken());
730		try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
	674	try renderToken(tree, ais, rparen_token, Space.Space); // )
731	675	} else {
732	676	const rparen_token = tree.nextToken(align_info.node.lastToken());
733		try renderToken(tree, stream, rparen_token, indent, start_col, Space.Space); // )
	677	try renderToken(tree, ais, rparen_token, Space.Space); // )
734	678	}
735	679	}
736	680	if (slice_type.ptr_info.const_token) \|const_token\| {
737		try renderToken(tree, stream, const_token, indent, start_col, Space.Space);
	681	try renderToken(tree, ais, const_token, Space.Space);
738	682	}
739	683	if (slice_type.ptr_info.volatile_token) \|volatile_token\| {
740		try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space);
	684	try renderToken(tree, ais, volatile_token, Space.Space);
741	685	}
742		return renderExpression(allocator, stream, tree, indent, start_col, slice_type.rhs, space);
	686	return renderExpression(allocator, ais, tree, slice_type.rhs, space);
743	687	},
744	688
745	689	.ArrayInitializer, .ArrayInitializerDot => {
...	...	@@ -768,27 +712,33 @@ fn renderExpression(
768	712
769	713	if (exprs.len == 0) {
770	714	switch (lhs) {
771		.dot => \|dot\| try renderToken(tree, stream, dot, indent, start_col, Space.None),
772		.node => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
	715	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	716	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
	717	}
	718
	719	{
	720	ais.pushIndent();
	721	defer ais.popIndent();
	722	try renderToken(tree, ais, lbrace, Space.None);
773	723	}
774		try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
775		return renderToken(tree, stream, rtoken, indent, start_col, space);
776		}
777	724
778		if (exprs.len == 1 and tree.token_ids[exprs[0].lastToken() + 1] == .RBrace) {
	725	return renderToken(tree, ais, rtoken, space);
	726	}
	727	if (exprs.len == 1 and tree.token_ids[exprs[0].*.lastToken() + 1] == .RBrace) {
779	728	const expr = exprs[0];
	729
780	730	switch (lhs) {
781		.dot => \|dot\| try renderToken(tree, stream, dot, indent, start_col, Space.None),
782		.node => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
	731	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	732	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
783	733	}
784		try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
785		try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
786		return renderToken(tree, stream, rtoken, indent, start_col, space);
	734	try renderToken(tree, ais, lbrace, Space.None);
	735	try renderExpression(allocator, ais, tree, expr, Space.None);
	736	return renderToken(tree, ais, rtoken, space);
787	737	}
788	738
789	739	switch (lhs) {
790		.dot => \|dot\| try renderToken(tree, stream, dot, indent, start_col, Space.None),
791		.node => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
	740	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	741	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
792	742	}
793	743
794	744	// scan to find row size
...	...	@@ -830,79 +780,70 @@ fn renderExpression(
830	780	var expr_widths = widths[0 .. widths.len - row_size];
831	781	var column_widths = widths[widths.len - row_size ..];
832	782
833		// Null stream for counting the printed length of each expression
	783	// Null ais for counting the printed length of each expression
834	784	var counting_stream = std.io.countingOutStream(std.io.null_out_stream);
	785	var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, counting_stream.writer());
835	786
836	787	for (exprs) \|expr, i\| {
837	788	counting_stream.bytes_written = 0;
838		var dummy_col: usize = 0;
839		try renderExpression(allocator, counting_stream.outStream(), tree, indent, &dummy_col, expr, Space.None);
	789	try renderExpression(allocator, &auto_indenting_stream, tree, expr, Space.None);
840	790	const width = @intCast(usize, counting_stream.bytes_written);
841	791	const col = i % row_size;
842	792	column_widths[col] = std.math.max(column_widths[col], width);
843	793	expr_widths[i] = width;
844	794	}
845	795
846		var new_indent = indent + indent_delta;
	796	{
	797	ais.pushIndentNextLine();
	798	defer ais.popIndent();
	799	try renderToken(tree, ais, lbrace, Space.Newline);
847	800
848		if (tree.token_ids[tree.nextToken(lbrace)] != .MultilineStringLiteralLine) {
849		try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
850		try stream.writeByteNTimes(' ', new_indent);
851		} else {
852		new_indent -= indent_delta;
853		try renderToken(tree, stream, lbrace, new_indent, start_col, Space.None);
854		}
	801	var col: usize = 1;
	802	for (exprs) \|expr, i\| {
	803	if (i + 1 < exprs.len) {
	804	const next_expr = exprs[i + 1];
	805	try renderExpression(allocator, ais, tree, expr, Space.None);
855	806
856		var col: usize = 1;
857		for (exprs) \|expr, i\| {
858		if (i + 1 < exprs.len) {
859		const next_expr = exprs[i + 1];
860		try renderExpression(allocator, stream, tree, new_indent, start_col, expr, Space.None);
	807	const comma = tree.nextToken(expr.*.lastToken());
861	808
862		const comma = tree.nextToken(expr.lastToken());
	809	if (col != row_size) {
	810	try renderToken(tree, ais, comma, Space.Space); // ,
863	811
864		if (col != row_size) {
865		try renderToken(tree, stream, comma, new_indent, start_col, Space.Space); // ,
	812	const padding = column_widths[i % row_size] - expr_widths[i];
	813	try ais.writer().writeByteNTimes(' ', padding);
866	814
867		const padding = column_widths[i % row_size] - expr_widths[i];
868		try stream.writeByteNTimes(' ', padding);
	815	col += 1;
	816	continue;
	817	}
	818	col = 1;
869	819
870		col += 1;
871		continue;
872		}
873		col = 1;
	820	if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
	821	try renderToken(tree, ais, comma, Space.Newline); // ,
	822	} else {
	823	try renderToken(tree, ais, comma, Space.None); // ,
	824	}
874	825
875		if (tree.token_ids[tree.nextToken(comma)] != .MultilineStringLiteralLine) {
876		try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
	826	try renderExtraNewline(tree, ais, next_expr);
877	827	} else {
878		try renderToken(tree, stream, comma, new_indent, start_col, Space.None); // ,
879		}
880
881		try renderExtraNewline(tree, stream, start_col, next_expr);
882		if (next_expr.tag != .MultilineStringLiteral) {
883		try stream.writeByteNTimes(' ', new_indent);
	828	try renderExpression(allocator, ais, tree, expr, Space.Comma); // ,
884	829	}
885		} else {
886		try renderExpression(allocator, stream, tree, new_indent, start_col, expr, Space.Comma); // ,
887	830	}
888	831	}
889		if (exprs[exprs.len - 1].tag != .MultilineStringLiteral) {
890		try stream.writeByteNTimes(' ', indent);
891		}
892		return renderToken(tree, stream, rtoken, indent, start_col, space);
	832	return renderToken(tree, ais, rtoken, space);
893	833	} else {
894		try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
	834	try renderToken(tree, ais, lbrace, Space.Space);
895	835	for (exprs) \|expr, i\| {
896	836	if (i + 1 < exprs.len) {
897		try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
898		const comma = tree.nextToken(expr.lastToken());
899		try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
	837	const next_expr = exprs[i + 1];
	838	try renderExpression(allocator, ais, tree, expr, Space.None);
	839	const comma = tree.nextToken(expr.*.lastToken());
	840	try renderToken(tree, ais, comma, Space.Space); // ,
900	841	} else {
901		try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.Space);
	842	try renderExpression(allocator, ais, tree, expr, Space.Space);
902	843	}
903	844	}
904	845
905		return renderToken(tree, stream, rtoken, indent, start_col, space);
	846	return renderToken(tree, ais, rtoken, space);
906	847	}
907	848	},
908	849
...	...	@@ -932,11 +873,17 @@ fn renderExpression(
932	873
933	874	if (field_inits.len == 0) {
934	875	switch (lhs) {
935		.dot => \|dot\| try renderToken(tree, stream, dot, indent, start_col, Space.None),
936		.node => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
	876	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	877	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
937	878	}
938		try renderToken(tree, stream, lbrace, indent + indent_delta, start_col, Space.None);
939		return renderToken(tree, stream, rtoken, indent, start_col, space);
	879
	880	{
	881	ais.pushIndentNextLine();
	882	defer ais.popIndent();
	883	try renderToken(tree, ais, lbrace, Space.None);
	884	}
	885
	886	return renderToken(tree, ais, rtoken, space);
940	887	}
941	888
942	889	const src_has_trailing_comma = blk: {
...	...	@@ -952,9 +899,10 @@ fn renderExpression(
952	899	const expr_outputs_one_line = blk: {
953	900	// render field expressions until a LF is found
954	901	for (field_inits) \|field_init\| {
955		var find_stream = FindByteOutStream.init('\n');
956		var dummy_col: usize = 0;
957		try renderExpression(allocator, find_stream.outStream(), tree, 0, &dummy_col, field_init, Space.None);
	902	var find_stream = std.io.findByteOutStream('\n', std.io.null_out_stream);
	903	var auto_indenting_stream = std.io.autoIndentingStream(indent_delta, find_stream.writer());
	904
	905	try renderExpression(allocator, &auto_indenting_stream, tree, field_init, Space.None);
958	906	if (find_stream.byte_found) break :blk false;
959	907	}
960	908	break :blk true;
...	...	@@ -967,7 +915,6 @@ fn renderExpression(
967	915	.StructInitializer,
968	916	.StructInitializerDot,
969	917	=> break :blk,
970
971	918	else => {},
972	919	}
973	920
...	...	@@ -977,76 +924,78 @@ fn renderExpression(
977	924	}
978	925
979	926	switch (lhs) {
980		.dot => \|dot\| try renderToken(tree, stream, dot, indent, start_col, Space.None),
981		.node => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
	927	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	928	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
982	929	}
983		try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
984		try renderExpression(allocator, stream, tree, indent, start_col, &field_init.base, Space.Space);
985		return renderToken(tree, stream, rtoken, indent, start_col, space);
	930	try renderToken(tree, ais, lbrace, Space.Space);
	931	try renderExpression(allocator, ais, tree, &field_init.base, Space.Space);
	932	return renderToken(tree, ais, rtoken, space);
986	933	}
987	934
988	935	if (!src_has_trailing_comma and src_same_line and expr_outputs_one_line) {
989	936	// render all on one line, no trailing comma
990	937	switch (lhs) {
991		.dot => \|dot\| try renderToken(tree, stream, dot, indent, start_col, Space.None),
992		.node => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None),
	938	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	939	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
993	940	}
994		try renderToken(tree, stream, lbrace, indent, start_col, Space.Space);
	941	try renderToken(tree, ais, lbrace, Space.Space);
995	942
996	943	for (field_inits) \|field_init, i\| {
997	944	if (i + 1 < field_inits.len) {
998		try renderExpression(allocator, stream, tree, indent, start_col, field_init, Space.None);
	945	try renderExpression(allocator, ais, tree, field_init, Space.None);
999	946
1000	947	const comma = tree.nextToken(field_init.lastToken());
1001		try renderToken(tree, stream, comma, indent, start_col, Space.Space);
	948	try renderToken(tree, ais, comma, Space.Space);
1002	949	} else {
1003		try renderExpression(allocator, stream, tree, indent, start_col, field_init, Space.Space);
	950	try renderExpression(allocator, ais, tree, field_init, Space.Space);
1004	951	}
1005	952	}
1006	953
1007		return renderToken(tree, stream, rtoken, indent, start_col, space);
	954	return renderToken(tree, ais, rtoken, space);
1008	955	}
1009	956
1010		const new_indent = indent + indent_delta;
	957	{
	958	switch (lhs) {
	959	.dot => \|dot\| try renderToken(tree, ais, dot, Space.None),
	960	.node => \|node\| try renderExpression(allocator, ais, tree, node, Space.None),
	961	}
1011	962
1012		switch (lhs) {
1013		.dot => \|dot\| try renderToken(tree, stream, dot, new_indent, start_col, Space.None),
1014		.node => \|node\| try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.None),
1015		}
1016		try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline);
	963	ais.pushIndentNextLine();
	964	defer ais.popIndent();
1017	965
1018		for (field_inits) \|field_init, i\| {
1019		try stream.writeByteNTimes(' ', new_indent);
	966	try renderToken(tree, ais, lbrace, Space.Newline);
1020	967
1021		if (i + 1 < field_inits.len) {
1022		try renderExpression(allocator, stream, tree, new_indent, start_col, field_init, Space.None);
	968	for (field_inits) \|field_init, i\| {
	969	if (i + 1 < field_inits.len) {
	970	const next_field_init = field_inits[i + 1];
	971	try renderExpression(allocator, ais, tree, field_init, Space.None);
1023	972
1024		const comma = tree.nextToken(field_init.lastToken());
1025		try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline);
	973	const comma = tree.nextToken(field_init.lastToken());
	974	try renderToken(tree, ais, comma, Space.Newline);
1026	975
1027		try renderExtraNewline(tree, stream, start_col, field_inits[i + 1]);
1028		} else {
1029		try renderExpression(allocator, stream, tree, new_indent, start_col, field_init, Space.Comma);
	976	try renderExtraNewline(tree, ais, next_field_init);
	977	} else {
	978	try renderExpression(allocator, ais, tree, field_init, Space.Comma);
	979	}
1030	980	}
1031	981	}
1032	982
1033		try stream.writeByteNTimes(' ', indent);
1034		return renderToken(tree, stream, rtoken, indent, start_col, space);
	983	return renderToken(tree, ais, rtoken, space);
1035	984	},
1036	985
1037	986	.Call => {
1038	987	const call = @fieldParentPtr(ast.Node.Call, "base", base);
1039	988	if (call.async_token) \|async_token\| {
1040		try renderToken(tree, stream, async_token, indent, start_col, Space.Space);
	989	try renderToken(tree, ais, async_token, Space.Space);
1041	990	}
1042	991
1043		try renderExpression(allocator, stream, tree, indent, start_col, call.lhs, Space.None);
	992	try renderExpression(allocator, ais, tree, call.lhs, Space.None);
1044	993
1045	994	const lparen = tree.nextToken(call.lhs.lastToken());
1046	995
1047	996	if (call.params_len == 0) {
1048		try renderToken(tree, stream, lparen, indent, start_col, Space.None);
1049		return renderToken(tree, stream, call.rtoken, indent, start_col, space);
	997	try renderToken(tree, ais, lparen, Space.None);
	998	return renderToken(tree, ais, call.rtoken, space);
1050	999	}
1051	1000
1052	1001	const src_has_trailing_comma = blk: {
...	...	@@ -1055,43 +1004,41 @@ fn renderExpression(
1055	1004	};
1056	1005
1057	1006	if (src_has_trailing_comma) {
1058		const new_indent = indent + indent_delta;
1059		try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline);
	1007	try renderToken(tree, ais, lparen, Space.Newline);
1060	1008
1061	1009	const params = call.params();
1062	1010	for (params) \|param_node, i\| {
1063		const param_node_new_indent = if (param_node.tag == .MultilineStringLiteral) blk: {
1064		break :blk indent;
1065		} else blk: {
1066		try stream.writeByteNTimes(' ', new_indent);
1067		break :blk new_indent;
1068		};
	1011	ais.pushIndent();
	1012	defer ais.popIndent();
1069	1013
1070	1014	if (i + 1 < params.len) {
1071		try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node, Space.None);
	1015	const next_node = params[i + 1];
	1016	try renderExpression(allocator, ais, tree, param_node, Space.None);
1072	1017	const comma = tree.nextToken(param_node.lastToken());
1073		try renderToken(tree, stream, comma, new_indent, start_col, Space.Newline); // ,
1074		try renderExtraNewline(tree, stream, start_col, params[i + 1]);
	1018	try renderToken(tree, ais, comma, Space.Newline); // ,
	1019	try renderExtraNewline(tree, ais, next_node);
1075	1020	} else {
1076		try renderExpression(allocator, stream, tree, param_node_new_indent, start_col, param_node, Space.Comma);
1077		try stream.writeByteNTimes(' ', indent);
1078		return renderToken(tree, stream, call.rtoken, indent, start_col, space);
	1021	try renderExpression(allocator, ais, tree, param_node, Space.Comma);
1079	1022	}
1080	1023	}
	1024	return renderToken(tree, ais, call.rtoken, space);
1081	1025	}
1082	1026
1083		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
	1027	try renderToken(tree, ais, lparen, Space.None); // (
1084	1028
1085	1029	const params = call.params();
1086	1030	for (params) \|param_node, i\| {
1087		try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.None);
	1031	if (param_node.*.tag == .MultilineStringLiteral) ais.pushIndentOneShot();
	1032
	1033	try renderExpression(allocator, ais, tree, param_node, Space.None);
1088	1034
1089	1035	if (i + 1 < params.len) {
	1036	const next_param = params[i + 1];
1090	1037	const comma = tree.nextToken(param_node.lastToken());
1091		try renderToken(tree, stream, comma, indent, start_col, Space.Space);
	1038	try renderToken(tree, ais, comma, Space.Space);
1092	1039	}
1093	1040	}
1094		return renderToken(tree, stream, call.rtoken, indent, start_col, space);
	1041	return renderToken(tree, ais, call.rtoken, space);
1095	1042	},
1096	1043
1097	1044	.ArrayAccess => {
...	...	@@ -1100,26 +1047,25 @@ fn renderExpression(
1100	1047	const lbracket = tree.nextToken(suffix_op.lhs.lastToken());
1101	1048	const rbracket = tree.nextToken(suffix_op.index_expr.lastToken());
1102	1049
1103		try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1104		try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
	1050	try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
	1051	try renderToken(tree, ais, lbracket, Space.None); // [
1105	1052
1106	1053	const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
1107	1054	const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
1108		const new_indent = if (ends_with_comment) indent + indent_delta else indent;
1109		const new_space = if (ends_with_comment) Space.Newline else Space.None;
1110		try renderExpression(allocator, stream, tree, new_indent, start_col, suffix_op.index_expr, new_space);
1111		if (starts_with_comment) {
1112		try stream.writeByte('\n');
1113		}
1114		if (ends_with_comment or starts_with_comment) {
1115		try stream.writeByteNTimes(' ', indent);
	1055	{
	1056	const new_space = if (ends_with_comment) Space.Newline else Space.None;
	1057
	1058	ais.pushIndent();
	1059	defer ais.popIndent();
	1060	try renderExpression(allocator, ais, tree, suffix_op.index_expr, new_space);
1116	1061	}
1117		return renderToken(tree, stream, rbracket, indent, start_col, space); // ]
	1062	if (starts_with_comment) try ais.maybeInsertNewline();
	1063	return renderToken(tree, ais, rbracket, space); // ]
1118	1064	},
	1065
1119	1066	.Slice => {
1120	1067	const suffix_op = base.castTag(.Slice).?;
1121
1122		try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
	1068	try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
1123	1069
1124	1070	const lbracket = tree.prevToken(suffix_op.start.firstToken());
1125	1071	const dotdot = tree.nextToken(suffix_op.start.lastToken());
...	...	@@ -1129,32 +1075,33 @@ fn renderExpression(
1129	1075	const after_start_space = if (after_start_space_bool) Space.Space else Space.None;
1130	1076	const after_op_space = if (suffix_op.end != null) after_start_space else Space.None;
1131	1077
1132		try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
1133		try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.start, after_start_space);
1134		try renderToken(tree, stream, dotdot, indent, start_col, after_op_space); // ..
	1078	try renderToken(tree, ais, lbracket, Space.None); // [
	1079	try renderExpression(allocator, ais, tree, suffix_op.start, after_start_space);
	1080	try renderToken(tree, ais, dotdot, after_op_space); // ..
1135	1081	if (suffix_op.end) \|end\| {
1136	1082	const after_end_space = if (suffix_op.sentinel != null) Space.Space else Space.None;
1137		try renderExpression(allocator, stream, tree, indent, start_col, end, after_end_space);
	1083	try renderExpression(allocator, ais, tree, end, after_end_space);
1138	1084	}
1139	1085	if (suffix_op.sentinel) \|sentinel\| {
1140	1086	const colon = tree.prevToken(sentinel.firstToken());
1141		try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
1142		try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
	1087	try renderToken(tree, ais, colon, Space.None); // :
	1088	try renderExpression(allocator, ais, tree, sentinel, Space.None);
1143	1089	}
1144		return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ]
	1090	return renderToken(tree, ais, suffix_op.rtoken, space); // ]
1145	1091	},
	1092
1146	1093	.Deref => {
1147	1094	const suffix_op = base.castTag(.Deref).?;
1148	1095
1149		try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1150		return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // .*
	1096	try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
	1097	return renderToken(tree, ais, suffix_op.rtoken, space); // .*
1151	1098	},
1152	1099	.UnwrapOptional => {
1153	1100	const suffix_op = base.castTag(.UnwrapOptional).?;
1154	1101
1155		try renderExpression(allocator, stream, tree, indent, start_col, suffix_op.lhs, Space.None);
1156		try renderToken(tree, stream, tree.prevToken(suffix_op.rtoken), indent, start_col, Space.None); // .
1157		return renderToken(tree, stream, suffix_op.rtoken, indent, start_col, space); // ?
	1102	try renderExpression(allocator, ais, tree, suffix_op.lhs, Space.None);
	1103	try renderToken(tree, ais, tree.prevToken(suffix_op.rtoken), Space.None); // .
	1104	return renderToken(tree, ais, suffix_op.rtoken, space); // ?
1158	1105	},
1159	1106
1160	1107	.Break => {
...	...	@@ -1163,145 +1110,152 @@ fn renderExpression(
1163	1110	const maybe_label = flow_expr.getLabel();
1164	1111
1165	1112	if (maybe_label == null and maybe_rhs == null) {
1166		return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // break
	1113	return renderToken(tree, ais, flow_expr.ltoken, space); // break
1167	1114	}
1168	1115
1169		try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // break
	1116	try renderToken(tree, ais, flow_expr.ltoken, Space.Space); // break
1170	1117	if (maybe_label) \|label\| {
1171	1118	const colon = tree.nextToken(flow_expr.ltoken);
1172		try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
	1119	try renderToken(tree, ais, colon, Space.None); // :
1173	1120
1174	1121	if (maybe_rhs == null) {
1175		return renderToken(tree, stream, label, indent, start_col, space); // label
	1122	return renderToken(tree, ais, label, space); // label
1176	1123	}
1177		try renderToken(tree, stream, label, indent, start_col, Space.Space); // label
	1124	try renderToken(tree, ais, label, Space.Space); // label
1178	1125	}
1179		return renderExpression(allocator, stream, tree, indent, start_col, maybe_rhs.?, space);
	1126	return renderExpression(allocator, ais, tree, maybe_rhs.?, space);
1180	1127	},
1181	1128
1182	1129	.Continue => {
1183	1130	const flow_expr = base.castTag(.Continue).?;
1184	1131	if (flow_expr.getLabel()) \|label\| {
1185		try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space); // continue
	1132	try renderToken(tree, ais, flow_expr.ltoken, Space.Space); // continue
1186	1133	const colon = tree.nextToken(flow_expr.ltoken);
1187		try renderToken(tree, stream, colon, indent, start_col, Space.None); // :
1188		return renderToken(tree, stream, label, indent, start_col, space); // label
	1134	try renderToken(tree, ais, colon, Space.None); // :
	1135	return renderToken(tree, ais, label, space); // label
1189	1136	} else {
1190		return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space); // continue
	1137	return renderToken(tree, ais, flow_expr.ltoken, space); // continue
1191	1138	}
1192	1139	},
1193	1140
1194	1141	.Return => {
1195	1142	const flow_expr = base.castTag(.Return).?;
1196	1143	if (flow_expr.getRHS()) \|rhs\| {
1197		try renderToken(tree, stream, flow_expr.ltoken, indent, start_col, Space.Space);
1198		return renderExpression(allocator, stream, tree, indent, start_col, rhs, space);
	1144	try renderToken(tree, ais, flow_expr.ltoken, Space.Space);
	1145	return renderExpression(allocator, ais, tree, rhs, space);
1199	1146	} else {
1200		return renderToken(tree, stream, flow_expr.ltoken, indent, start_col, space);
	1147	return renderToken(tree, ais, flow_expr.ltoken, space);
1201	1148	}
1202	1149	},
1203	1150
1204	1151	.Payload => {
1205	1152	const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
1206	1153
1207		try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
1208		try renderExpression(allocator, stream, tree, indent, start_col, payload.error_symbol, Space.None);
1209		return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
	1154	try renderToken(tree, ais, payload.lpipe, Space.None);
	1155	try renderExpression(allocator, ais, tree, payload.error_symbol, Space.None);
	1156	return renderToken(tree, ais, payload.rpipe, space);
1210	1157	},
1211	1158
1212	1159	.PointerPayload => {
1213	1160	const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
1214	1161
1215		try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
	1162	try renderToken(tree, ais, payload.lpipe, Space.None);
1216	1163	if (payload.ptr_token) \|ptr_token\| {
1217		try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
	1164	try renderToken(tree, ais, ptr_token, Space.None);
1218	1165	}
1219		try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
1220		return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
	1166	try renderExpression(allocator, ais, tree, payload.value_symbol, Space.None);
	1167	return renderToken(tree, ais, payload.rpipe, space);
1221	1168	},
1222	1169
1223	1170	.PointerIndexPayload => {
1224	1171	const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
1225	1172
1226		try renderToken(tree, stream, payload.lpipe, indent, start_col, Space.None);
	1173	try renderToken(tree, ais, payload.lpipe, Space.None);
1227	1174	if (payload.ptr_token) \|ptr_token\| {
1228		try renderToken(tree, stream, ptr_token, indent, start_col, Space.None);
	1175	try renderToken(tree, ais, ptr_token, Space.None);
1229	1176	}
1230		try renderExpression(allocator, stream, tree, indent, start_col, payload.value_symbol, Space.None);
	1177	try renderExpression(allocator, ais, tree, payload.value_symbol, Space.None);
1231	1178
1232	1179	if (payload.index_symbol) \|index_symbol\| {
1233	1180	const comma = tree.nextToken(payload.value_symbol.lastToken());
1234	1181
1235		try renderToken(tree, stream, comma, indent, start_col, Space.Space);
1236		try renderExpression(allocator, stream, tree, indent, start_col, index_symbol, Space.None);
	1182	try renderToken(tree, ais, comma, Space.Space);
	1183	try renderExpression(allocator, ais, tree, index_symbol, Space.None);
1237	1184	}
1238	1185
1239		return renderToken(tree, stream, payload.rpipe, indent, start_col, space);
	1186	return renderToken(tree, ais, payload.rpipe, space);
1240	1187	},
1241	1188
1242	1189	.GroupedExpression => {
1243	1190	const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
1244	1191
1245		try renderToken(tree, stream, grouped_expr.lparen, indent, start_col, Space.None);
1246		try renderExpression(allocator, stream, tree, indent, start_col, grouped_expr.expr, Space.None);
1247		return renderToken(tree, stream, grouped_expr.rparen, indent, start_col, space);
	1192	try renderToken(tree, ais, grouped_expr.lparen, Space.None);
	1193	{
	1194	ais.pushIndentOneShot();
	1195	try renderExpression(allocator, ais, tree, grouped_expr.expr, Space.None);
	1196	}
	1197	return renderToken(tree, ais, grouped_expr.rparen, space);
1248	1198	},
1249	1199
1250	1200	.FieldInitializer => {
1251	1201	const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
1252	1202
1253		try renderToken(tree, stream, field_init.period_token, indent, start_col, Space.None); // .
1254		try renderToken(tree, stream, field_init.name_token, indent, start_col, Space.Space); // name
1255		try renderToken(tree, stream, tree.nextToken(field_init.name_token), indent, start_col, Space.Space); // =
1256		return renderExpression(allocator, stream, tree, indent, start_col, field_init.expr, space);
	1203	try renderToken(tree, ais, field_init.period_token, Space.None); // .
	1204	try renderToken(tree, ais, field_init.name_token, Space.Space); // name
	1205	try renderToken(tree, ais, tree.nextToken(field_init.name_token), Space.Space); // =
	1206	return renderExpression(allocator, ais, tree, field_init.expr, space);
1257	1207	},
1258	1208
1259	1209	.ContainerDecl => {
1260	1210	const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
1261	1211
1262	1212	if (container_decl.layout_token) \|layout_token\| {
1263		try renderToken(tree, stream, layout_token, indent, start_col, Space.Space);
	1213	try renderToken(tree, ais, layout_token, Space.Space);
1264	1214	}
1265	1215
1266	1216	switch (container_decl.init_arg_expr) {
1267	1217	.None => {
1268		try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.Space); // union
	1218	try renderToken(tree, ais, container_decl.kind_token, Space.Space); // union
1269	1219	},
1270	1220	.Enum => \|enum_tag_type\| {
1271		try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
	1221	try renderToken(tree, ais, container_decl.kind_token, Space.None); // union
1272	1222
1273	1223	const lparen = tree.nextToken(container_decl.kind_token);
1274	1224	const enum_token = tree.nextToken(lparen);
1275	1225
1276		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1277		try renderToken(tree, stream, enum_token, indent, start_col, Space.None); // enum
	1226	try renderToken(tree, ais, lparen, Space.None); // (
	1227	try renderToken(tree, ais, enum_token, Space.None); // enum
1278	1228
1279	1229	if (enum_tag_type) \|expr\| {
1280		try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.None); // (
1281		try renderExpression(allocator, stream, tree, indent, start_col, expr, Space.None);
	1230	try renderToken(tree, ais, tree.nextToken(enum_token), Space.None); // (
	1231	try renderExpression(allocator, ais, tree, expr, Space.None);
1282	1232
1283	1233	const rparen = tree.nextToken(expr.lastToken());
1284		try renderToken(tree, stream, rparen, indent, start_col, Space.None); // )
1285		try renderToken(tree, stream, tree.nextToken(rparen), indent, start_col, Space.Space); // )
	1234	try renderToken(tree, ais, rparen, Space.None); // )
	1235	try renderToken(tree, ais, tree.nextToken(rparen), Space.Space); // )
1286	1236	} else {
1287		try renderToken(tree, stream, tree.nextToken(enum_token), indent, start_col, Space.Space); // )
	1237	try renderToken(tree, ais, tree.nextToken(enum_token), Space.Space); // )
1288	1238	}
1289	1239	},
1290	1240	.Type => \|type_expr\| {
1291		try renderToken(tree, stream, container_decl.kind_token, indent, start_col, Space.None); // union
	1241	try renderToken(tree, ais, container_decl.kind_token, Space.None); // union
1292	1242
1293	1243	const lparen = tree.nextToken(container_decl.kind_token);
1294	1244	const rparen = tree.nextToken(type_expr.lastToken());
1295	1245
1296		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1297		try renderExpression(allocator, stream, tree, indent, start_col, type_expr, Space.None);
1298		try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
	1246	try renderToken(tree, ais, lparen, Space.None); // (
	1247	try renderExpression(allocator, ais, tree, type_expr, Space.None);
	1248	try renderToken(tree, ais, rparen, Space.Space); // )
1299	1249	},
1300	1250	}
1301	1251
1302	1252	if (container_decl.fields_and_decls_len == 0) {
1303		try renderToken(tree, stream, container_decl.lbrace_token, indent + indent_delta, start_col, Space.None); // {
1304		return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
	1253	{
	1254	ais.pushIndentNextLine();
	1255	defer ais.popIndent();
	1256	try renderToken(tree, ais, container_decl.lbrace_token, Space.None); // {
	1257	}
	1258	return renderToken(tree, ais, container_decl.rbrace_token, space); // }
1305	1259	}
1306	1260
1307	1261	const src_has_trailing_comma = blk: {
...	...	@@ -1332,43 +1286,39 @@ fn renderExpression(
1332	1286
1333	1287	if (src_has_trailing_comma or !src_has_only_fields) {
1334	1288	// One declaration per line
1335		const new_indent = indent + indent_delta;
1336		try renderToken(tree, stream, container_decl.lbrace_token, new_indent, start_col, .Newline); // {
	1289	ais.pushIndentNextLine();
	1290	defer ais.popIndent();
	1291	try renderToken(tree, ais, container_decl.lbrace_token, .Newline); // {
1337	1292
1338	1293	for (fields_and_decls) \|decl, i\| {
1339		try stream.writeByteNTimes(' ', new_indent);
1340		try renderContainerDecl(allocator, stream, tree, new_indent, start_col, decl, .Newline);
	1294	try renderContainerDecl(allocator, ais, tree, decl, .Newline);
1341	1295
1342	1296	if (i + 1 < fields_and_decls.len) {
1343		try renderExtraNewline(tree, stream, start_col, fields_and_decls[i + 1]);
	1297	try renderExtraNewline(tree, ais, fields_and_decls[i + 1]);
1344	1298	}
1345	1299	}
1346
1347		try stream.writeByteNTimes(' ', indent);
1348	1300	} else if (src_has_newline) {
1349	1301	// All the declarations on the same line, but place the items on
1350	1302	// their own line
1351		try renderToken(tree, stream, container_decl.lbrace_token, indent, start_col, .Newline); // {
	1303	try renderToken(tree, ais, container_decl.lbrace_token, .Newline); // {
1352	1304
1353		const new_indent = indent + indent_delta;
1354		try stream.writeByteNTimes(' ', new_indent);
	1305	ais.pushIndent();
	1306	defer ais.popIndent();
1355	1307
1356	1308	for (fields_and_decls) \|decl, i\| {
1357	1309	const space_after_decl: Space = if (i + 1 >= fields_and_decls.len) .Newline else .Space;
1358		try renderContainerDecl(allocator, stream, tree, new_indent, start_col, decl, space_after_decl);
	1310	try renderContainerDecl(allocator, ais, tree, decl, space_after_decl);
1359	1311	}
1360
1361		try stream.writeByteNTimes(' ', indent);
1362	1312	} else {
1363	1313	// All the declarations on the same line
1364		try renderToken(tree, stream, container_decl.lbrace_token, indent, start_col, .Space); // {
	1314	try renderToken(tree, ais, container_decl.lbrace_token, .Space); // {
1365	1315
1366	1316	for (fields_and_decls) \|decl\| {
1367		try renderContainerDecl(allocator, stream, tree, indent, start_col, decl, .Space);
	1317	try renderContainerDecl(allocator, ais, tree, decl, .Space);
1368	1318	}
1369	1319	}
1370	1320
1371		return renderToken(tree, stream, container_decl.rbrace_token, indent, start_col, space); // }
	1321	return renderToken(tree, ais, container_decl.rbrace_token, space); // }
1372	1322	},
1373	1323
1374	1324	.ErrorSetDecl => {
...	...	@@ -1377,9 +1327,9 @@ fn renderExpression(
1377	1327	const lbrace = tree.nextToken(err_set_decl.error_token);
1378	1328
1379	1329	if (err_set_decl.decls_len == 0) {
1380		try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None);
1381		try renderToken(tree, stream, lbrace, indent, start_col, Space.None);
1382		return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space);
	1330	try renderToken(tree, ais, err_set_decl.error_token, Space.None);
	1331	try renderToken(tree, ais, lbrace, Space.None);
	1332	return renderToken(tree, ais, err_set_decl.rbrace_token, space);
1383	1333	}
1384	1334
1385	1335	if (err_set_decl.decls_len == 1) blk: {
...	...	@@ -1393,13 +1343,13 @@ fn renderExpression(
1393	1343	break :blk;
1394	1344	}
1395	1345
1396		try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
1397		try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
1398		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
1399		return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
	1346	try renderToken(tree, ais, err_set_decl.error_token, Space.None); // error
	1347	try renderToken(tree, ais, lbrace, Space.None); // {
	1348	try renderExpression(allocator, ais, tree, node, Space.None);
	1349	return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
1400	1350	}
1401	1351
1402		try renderToken(tree, stream, err_set_decl.error_token, indent, start_col, Space.None); // error
	1352	try renderToken(tree, ais, err_set_decl.error_token, Space.None); // error
1403	1353
1404	1354	const src_has_trailing_comma = blk: {
1405	1355	const maybe_comma = tree.prevToken(err_set_decl.rbrace_token);
...	...	@@ -1407,72 +1357,66 @@ fn renderExpression(
1407	1357	};
1408	1358
1409	1359	if (src_has_trailing_comma) {
1410		try renderToken(tree, stream, lbrace, indent, start_col, Space.Newline); // {
1411		const new_indent = indent + indent_delta;
1412
1413		const decls = err_set_decl.decls();
1414		for (decls) \|node, i\| {
1415		try stream.writeByteNTimes(' ', new_indent);
1416
1417		if (i + 1 < decls.len) {
1418		try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.None);
1419		try renderToken(tree, stream, tree.nextToken(node.lastToken()), new_indent, start_col, Space.Newline); // ,
1420
1421		try renderExtraNewline(tree, stream, start_col, decls[i + 1]);
1422		} else {
1423		try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.Comma);
	1360	{
	1361	ais.pushIndent();
	1362	defer ais.popIndent();
	1363
	1364	try renderToken(tree, ais, lbrace, Space.Newline); // {
	1365	const decls = err_set_decl.decls();
	1366	for (decls) \|node, i\| {
	1367	if (i + 1 < decls.len) {
	1368	try renderExpression(allocator, ais, tree, node, Space.None);
	1369	try renderToken(tree, ais, tree.nextToken(node.lastToken()), Space.Newline); // ,
	1370
	1371	try renderExtraNewline(tree, ais, decls[i + 1]);
	1372	} else {
	1373	try renderExpression(allocator, ais, tree, node, Space.Comma);
	1374	}
1424	1375	}
1425	1376	}
1426	1377
1427		try stream.writeByteNTimes(' ', indent);
1428		return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
	1378	return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
1429	1379	} else {
1430		try renderToken(tree, stream, lbrace, indent, start_col, Space.Space); // {
	1380	try renderToken(tree, ais, lbrace, Space.Space); // {
1431	1381
1432	1382	const decls = err_set_decl.decls();
1433	1383	for (decls) \|node, i\| {
1434	1384	if (i + 1 < decls.len) {
1435		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
	1385	try renderExpression(allocator, ais, tree, node, Space.None);
1436	1386
1437	1387	const comma_token = tree.nextToken(node.lastToken());
1438	1388	assert(tree.token_ids[comma_token] == .Comma);
1439		try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1440		try renderExtraNewline(tree, stream, start_col, decls[i + 1]);
	1389	try renderToken(tree, ais, comma_token, Space.Space); // ,
	1390	try renderExtraNewline(tree, ais, decls[i + 1]);
1441	1391	} else {
1442		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
	1392	try renderExpression(allocator, ais, tree, node, Space.Space);
1443	1393	}
1444	1394	}
1445	1395
1446		return renderToken(tree, stream, err_set_decl.rbrace_token, indent, start_col, space); // }
	1396	return renderToken(tree, ais, err_set_decl.rbrace_token, space); // }
1447	1397	}
1448	1398	},
1449	1399
1450	1400	.ErrorTag => {
1451	1401	const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", base);
1452	1402
1453		try renderDocComments(tree, stream, tag, tag.doc_comments, indent, start_col);
1454		return renderToken(tree, stream, tag.name_token, indent, start_col, space); // name
	1403	try renderDocComments(tree, ais, tag, tag.doc_comments);
	1404	return renderToken(tree, ais, tag.name_token, space); // name
1455	1405	},
1456	1406
1457	1407	.MultilineStringLiteral => {
1458		// TODO: Don't indent in this function, but let the caller indent.
1459		// If this has been implemented, a lot of hacky solutions in i.e. ArrayInit and FunctionCall can be removed
1460	1408	const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
1461	1409
1462		var skip_first_indent = true;
1463		if (tree.token_ids[multiline_str_literal.firstToken() - 1] != .LineComment) {
1464		try stream.print("\n", .{});
1465		skip_first_indent = false;
1466		}
1467
1468		for (multiline_str_literal.lines()) \|t\| {
1469		if (!skip_first_indent) {
1470		try stream.writeByteNTimes(' ', indent + indent_delta);
	1410	{
	1411	const locked_indents = ais.lockOneShotIndent();
	1412	defer {
	1413	var i: u8 = 0;
	1414	while (i < locked_indents) : (i += 1) ais.popIndent();
1471	1415	}
1472		try renderToken(tree, stream, t, indent, start_col, Space.None);
1473		skip_first_indent = false;
	1416	try ais.maybeInsertNewline();
	1417
	1418	for (multiline_str_literal.lines()) \|t\| try renderToken(tree, ais, t, Space.None);
1474	1419	}
1475		try stream.writeByteNTimes(' ', indent);
1476	1420	},
1477	1421
1478	1422	.BuiltinCall => {
...	...	@@ -1480,9 +1424,9 @@ fn renderExpression(
1480	1424
1481	1425	// TODO remove after 0.7.0 release
1482	1426	if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType"))
1483		return stream.writeAll("@Type(.Opaque)");
	1427	return ais.writer().writeAll("@Type(.Opaque)");
1484	1428
1485		try renderToken(tree, stream, builtin_call.builtin_token, indent, start_col, Space.None); // @name
	1429	try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name
1486	1430
1487	1431	const src_params_trailing_comma = blk: {
1488	1432	if (builtin_call.params_len < 2) break :blk false;
...	...	@@ -1494,31 +1438,30 @@ fn renderExpression(
1494	1438	const lparen = tree.nextToken(builtin_call.builtin_token);
1495	1439
1496	1440	if (!src_params_trailing_comma) {
1497		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
	1441	try renderToken(tree, ais, lparen, Space.None); // (
1498	1442
1499	1443	// render all on one line, no trailing comma
1500	1444	const params = builtin_call.params();
1501	1445	for (params) \|param_node, i\| {
1502		try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.None);
	1446	try renderExpression(allocator, ais, tree, param_node, Space.None);
1503	1447
1504	1448	if (i + 1 < params.len) {
1505	1449	const comma_token = tree.nextToken(param_node.lastToken());
1506		try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
	1450	try renderToken(tree, ais, comma_token, Space.Space); // ,
1507	1451	}
1508	1452	}
1509	1453	} else {
1510	1454	// one param per line
1511		const new_indent = indent + indent_delta;
1512		try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
	1455	ais.pushIndent();
	1456	defer ais.popIndent();
	1457	try renderToken(tree, ais, lparen, Space.Newline); // (
1513	1458
1514	1459	for (builtin_call.params()) \|param_node\| {
1515		try stream.writeByteNTimes(' ', new_indent);
1516		try renderExpression(allocator, stream, tree, indent, start_col, param_node, Space.Comma);
	1460	try renderExpression(allocator, ais, tree, param_node, Space.Comma);
1517	1461	}
1518		try stream.writeByteNTimes(' ', indent);
1519	1462	}
1520	1463
1521		return renderToken(tree, stream, builtin_call.rparen_token, indent, start_col, space); // )
	1464	return renderToken(tree, ais, builtin_call.rparen_token, space); // )
1522	1465	},
1523	1466
1524	1467	.FnProto => {
...	...	@@ -1528,24 +1471,24 @@ fn renderExpression(
1528	1471	const visib_token = tree.token_ids[visib_token_index];
1529	1472	assert(visib_token == .Keyword_pub or visib_token == .Keyword_export);
1530	1473
1531		try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
	1474	try renderToken(tree, ais, visib_token_index, Space.Space); // pub
1532	1475	}
1533	1476
1534	1477	if (fn_proto.getExternExportInlineToken()) \|extern_export_inline_token\| {
1535	1478	if (fn_proto.getIsExternPrototype() == null)
1536		try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export/inline
	1479	try renderToken(tree, ais, extern_export_inline_token, Space.Space); // extern/export/inline
1537	1480	}
1538	1481
1539	1482	if (fn_proto.getLibName()) \|lib_name\| {
1540		try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
	1483	try renderExpression(allocator, ais, tree, lib_name, Space.Space);
1541	1484	}
1542	1485
1543	1486	const lparen = if (fn_proto.getNameToken()) \|name_token\| blk: {
1544		try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
1545		try renderToken(tree, stream, name_token, indent, start_col, Space.None); // name
	1487	try renderToken(tree, ais, fn_proto.fn_token, Space.Space); // fn
	1488	try renderToken(tree, ais, name_token, Space.None); // name
1546	1489	break :blk tree.nextToken(name_token);
1547	1490	} else blk: {
1548		try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
	1491	try renderToken(tree, ais, fn_proto.fn_token, Space.Space); // fn
1549	1492	break :blk tree.nextToken(fn_proto.fn_token);
1550	1493	};
1551	1494	assert(tree.token_ids[lparen] == .LParen);
...	...	@@ -1572,47 +1515,45 @@ fn renderExpression(
1572	1515	};
1573	1516
1574	1517	if (!src_params_trailing_comma) {
1575		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
	1518	try renderToken(tree, ais, lparen, Space.None); // (
1576	1519
1577	1520	// render all on one line, no trailing comma
1578	1521	for (fn_proto.params()) \|param_decl, i\| {
1579		try renderParamDecl(allocator, stream, tree, indent, start_col, param_decl, Space.None);
	1522	try renderParamDecl(allocator, ais, tree, param_decl, Space.None);
1580	1523
1581	1524	if (i + 1 < fn_proto.params_len or fn_proto.getVarArgsToken() != null) {
1582	1525	const comma = tree.nextToken(param_decl.lastToken());
1583		try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
	1526	try renderToken(tree, ais, comma, Space.Space); // ,
1584	1527	}
1585	1528	}
1586	1529	if (fn_proto.getVarArgsToken()) \|var_args_token\| {
1587		try renderToken(tree, stream, var_args_token, indent, start_col, Space.None);
	1530	try renderToken(tree, ais, var_args_token, Space.None);
1588	1531	}
1589	1532	} else {
1590	1533	// one param per line
1591		const new_indent = indent + indent_delta;
1592		try renderToken(tree, stream, lparen, new_indent, start_col, Space.Newline); // (
	1534	ais.pushIndent();
	1535	defer ais.popIndent();
	1536	try renderToken(tree, ais, lparen, Space.Newline); // (
1593	1537
1594	1538	for (fn_proto.params()) \|param_decl\| {
1595		try stream.writeByteNTimes(' ', new_indent);
1596		try renderParamDecl(allocator, stream, tree, new_indent, start_col, param_decl, Space.Comma);
	1539	try renderParamDecl(allocator, ais, tree, param_decl, Space.Comma);
1597	1540	}
1598	1541	if (fn_proto.getVarArgsToken()) \|var_args_token\| {
1599		try stream.writeByteNTimes(' ', new_indent);
1600		try renderToken(tree, stream, var_args_token, new_indent, start_col, Space.Comma);
	1542	try renderToken(tree, ais, var_args_token, Space.Comma);
1601	1543	}
1602		try stream.writeByteNTimes(' ', indent);
1603	1544	}
1604	1545
1605		try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
	1546	try renderToken(tree, ais, rparen, Space.Space); // )
1606	1547
1607	1548	if (fn_proto.getAlignExpr()) \|align_expr\| {
1608	1549	const align_rparen = tree.nextToken(align_expr.lastToken());
1609	1550	const align_lparen = tree.prevToken(align_expr.firstToken());
1610	1551	const align_kw = tree.prevToken(align_lparen);
1611	1552
1612		try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
1613		try renderToken(tree, stream, align_lparen, indent, start_col, Space.None); // (
1614		try renderExpression(allocator, stream, tree, indent, start_col, align_expr, Space.None);
1615		try renderToken(tree, stream, align_rparen, indent, start_col, Space.Space); // )
	1553	try renderToken(tree, ais, align_kw, Space.None); // align
	1554	try renderToken(tree, ais, align_lparen, Space.None); // (
	1555	try renderExpression(allocator, ais, tree, align_expr, Space.None);
	1556	try renderToken(tree, ais, align_rparen, Space.Space); // )
1616	1557	}
1617	1558
1618	1559	if (fn_proto.getSectionExpr()) \|section_expr\| {
...	...	@@ -1620,10 +1561,10 @@ fn renderExpression(
1620	1561	const section_lparen = tree.prevToken(section_expr.firstToken());
1621	1562	const section_kw = tree.prevToken(section_lparen);
1622	1563
1623		try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // section
1624		try renderToken(tree, stream, section_lparen, indent, start_col, Space.None); // (
1625		try renderExpression(allocator, stream, tree, indent, start_col, section_expr, Space.None);
1626		try renderToken(tree, stream, section_rparen, indent, start_col, Space.Space); // )
	1564	try renderToken(tree, ais, section_kw, Space.None); // section
	1565	try renderToken(tree, ais, section_lparen, Space.None); // (
	1566	try renderExpression(allocator, ais, tree, section_expr, Space.None);
	1567	try renderToken(tree, ais, section_rparen, Space.Space); // )
1627	1568	}
1628	1569
1629	1570	if (fn_proto.getCallconvExpr()) \|callconv_expr\| {
...	...	@@ -1631,23 +1572,23 @@ fn renderExpression(
1631	1572	const callconv_lparen = tree.prevToken(callconv_expr.firstToken());
1632	1573	const callconv_kw = tree.prevToken(callconv_lparen);
1633	1574
1634		try renderToken(tree, stream, callconv_kw, indent, start_col, Space.None); // callconv
1635		try renderToken(tree, stream, callconv_lparen, indent, start_col, Space.None); // (
1636		try renderExpression(allocator, stream, tree, indent, start_col, callconv_expr, Space.None);
1637		try renderToken(tree, stream, callconv_rparen, indent, start_col, Space.Space); // )
	1575	try renderToken(tree, ais, callconv_kw, Space.None); // callconv
	1576	try renderToken(tree, ais, callconv_lparen, Space.None); // (
	1577	try renderExpression(allocator, ais, tree, callconv_expr, Space.None);
	1578	try renderToken(tree, ais, callconv_rparen, Space.Space); // )
1638	1579	} else if (fn_proto.getIsExternPrototype() != null) {
1639		try stream.writeAll("callconv(.C) ");
	1580	try ais.writer().writeAll("callconv(.C) ");
1640	1581	} else if (fn_proto.getIsAsync() != null) {
1641		try stream.writeAll("callconv(.Async) ");
	1582	try ais.writer().writeAll("callconv(.Async) ");
1642	1583	}
1643	1584
1644	1585	switch (fn_proto.return_type) {
1645	1586	.Explicit => \|node\| {
1646		return renderExpression(allocator, stream, tree, indent, start_col, node, space);
	1587	return renderExpression(allocator, ais, tree, node, space);
1647	1588	},
1648	1589	.InferErrorSet => \|node\| {
1649		try renderToken(tree, stream, tree.prevToken(node.firstToken()), indent, start_col, Space.None); // !
1650		return renderExpression(allocator, stream, tree, indent, start_col, node, space);
	1590	try renderToken(tree, ais, tree.prevToken(node.firstToken()), Space.None); // !
	1591	return renderExpression(allocator, ais, tree, node, space);
1651	1592	},
1652	1593	.Invalid => unreachable,
1653	1594	}
...	...	@@ -1657,11 +1598,11 @@ fn renderExpression(
1657	1598	const anyframe_type = @fieldParentPtr(ast.Node.AnyFrameType, "base", base);
1658	1599
1659	1600	if (anyframe_type.result) \|result\| {
1660		try renderToken(tree, stream, anyframe_type.anyframe_token, indent, start_col, Space.None); // anyframe
1661		try renderToken(tree, stream, result.arrow_token, indent, start_col, Space.None); // ->
1662		return renderExpression(allocator, stream, tree, indent, start_col, result.return_type, space);
	1601	try renderToken(tree, ais, anyframe_type.anyframe_token, Space.None); // anyframe
	1602	try renderToken(tree, ais, result.arrow_token, Space.None); // ->
	1603	return renderExpression(allocator, ais, tree, result.return_type, space);
1663	1604	} else {
1664		return renderToken(tree, stream, anyframe_type.anyframe_token, indent, start_col, space); // anyframe
	1605	return renderToken(tree, ais, anyframe_type.anyframe_token, space); // anyframe
1665	1606	}
1666	1607	},
1667	1608
...	...	@@ -1670,38 +1611,38 @@ fn renderExpression(
1670	1611	.Switch => {
1671	1612	const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
1672	1613
1673		try renderToken(tree, stream, switch_node.switch_token, indent, start_col, Space.Space); // switch
1674		try renderToken(tree, stream, tree.nextToken(switch_node.switch_token), indent, start_col, Space.None); // (
	1614	try renderToken(tree, ais, switch_node.switch_token, Space.Space); // switch
	1615	try renderToken(tree, ais, tree.nextToken(switch_node.switch_token), Space.None); // (
1675	1616
1676	1617	const rparen = tree.nextToken(switch_node.expr.lastToken());
1677	1618	const lbrace = tree.nextToken(rparen);
1678	1619
1679	1620	if (switch_node.cases_len == 0) {
1680		try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
1681		try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1682		try renderToken(tree, stream, lbrace, indent, start_col, Space.None); // {
1683		return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
	1621	try renderExpression(allocator, ais, tree, switch_node.expr, Space.None);
	1622	try renderToken(tree, ais, rparen, Space.Space); // )
	1623	try renderToken(tree, ais, lbrace, Space.None); // {
	1624	return renderToken(tree, ais, switch_node.rbrace, space); // }
1684	1625	}
1685	1626
1686		try renderExpression(allocator, stream, tree, indent, start_col, switch_node.expr, Space.None);
1687
1688		const new_indent = indent + indent_delta;
	1627	try renderExpression(allocator, ais, tree, switch_node.expr, Space.None);
	1628	try renderToken(tree, ais, rparen, Space.Space); // )
1689	1629
1690		try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1691		try renderToken(tree, stream, lbrace, new_indent, start_col, Space.Newline); // {
	1630	{
	1631	ais.pushIndentNextLine();
	1632	defer ais.popIndent();
	1633	try renderToken(tree, ais, lbrace, Space.Newline); // {
1692	1634
1693		const cases = switch_node.cases();
1694		for (cases) \|node, i\| {
1695		try stream.writeByteNTimes(' ', new_indent);
1696		try renderExpression(allocator, stream, tree, new_indent, start_col, node, Space.Comma);
	1635	const cases = switch_node.cases();
	1636	for (cases) \|node, i\| {
	1637	try renderExpression(allocator, ais, tree, node, Space.Comma);
1697	1638
1698		if (i + 1 < cases.len) {
1699		try renderExtraNewline(tree, stream, start_col, cases[i + 1]);
	1639	if (i + 1 < cases.len) {
	1640	try renderExtraNewline(tree, ais, cases[i + 1]);
	1641	}
1700	1642	}
1701	1643	}
1702	1644
1703		try stream.writeByteNTimes(' ', indent);
1704		return renderToken(tree, stream, switch_node.rbrace, indent, start_col, space); // }
	1645	return renderToken(tree, ais, switch_node.rbrace, space); // }
1705	1646	},
1706	1647
1707	1648	.SwitchCase => {
...	...	@@ -1718,43 +1659,41 @@ fn renderExpression(
1718	1659	const items = switch_case.items();
1719	1660	for (items) \|node, i\| {
1720	1661	if (i + 1 < items.len) {
1721		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
	1662	try renderExpression(allocator, ais, tree, node, Space.None);
1722	1663
1723	1664	const comma_token = tree.nextToken(node.lastToken());
1724		try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1725		try renderExtraNewline(tree, stream, start_col, items[i + 1]);
	1665	try renderToken(tree, ais, comma_token, Space.Space); // ,
	1666	try renderExtraNewline(tree, ais, items[i + 1]);
1726	1667	} else {
1727		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
	1668	try renderExpression(allocator, ais, tree, node, Space.Space);
1728	1669	}
1729	1670	}
1730	1671	} else {
1731	1672	const items = switch_case.items();
1732	1673	for (items) \|node, i\| {
1733	1674	if (i + 1 < items.len) {
1734		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
	1675	try renderExpression(allocator, ais, tree, node, Space.None);
1735	1676
1736	1677	const comma_token = tree.nextToken(node.lastToken());
1737		try renderToken(tree, stream, comma_token, indent, start_col, Space.Newline); // ,
1738		try renderExtraNewline(tree, stream, start_col, items[i + 1]);
1739		try stream.writeByteNTimes(' ', indent);
	1678	try renderToken(tree, ais, comma_token, Space.Newline); // ,
	1679	try renderExtraNewline(tree, ais, items[i + 1]);
1740	1680	} else {
1741		try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Comma);
1742		try stream.writeByteNTimes(' ', indent);
	1681	try renderExpression(allocator, ais, tree, node, Space.Comma);
1743	1682	}
1744	1683	}
1745	1684	}
1746	1685
1747		try renderToken(tree, stream, switch_case.arrow_token, indent, start_col, Space.Space); // =>
	1686	try renderToken(tree, ais, switch_case.arrow_token, Space.Space); // =>
1748	1687
1749	1688	if (switch_case.payload) \|payload\| {
1750		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
	1689	try renderExpression(allocator, ais, tree, payload, Space.Space);
1751	1690	}
1752	1691
1753		return renderExpression(allocator, stream, tree, indent, start_col, switch_case.expr, space);
	1692	return renderExpression(allocator, ais, tree, switch_case.expr, space);
1754	1693	},
1755	1694	.SwitchElse => {
1756	1695	const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
1757		return renderToken(tree, stream, switch_else.token, indent, start_col, space);
	1696	return renderToken(tree, ais, switch_else.token, space);
1758	1697	},
1759	1698	.Else => {
1760	1699	const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
...	...	@@ -1763,37 +1702,37 @@ fn renderExpression(
1763	1702	const same_line = body_is_block or tree.tokensOnSameLine(else_node.else_token, else_node.body.lastToken());
1764	1703
1765	1704	const after_else_space = if (same_line or else_node.payload != null) Space.Space else Space.Newline;
1766		try renderToken(tree, stream, else_node.else_token, indent, start_col, after_else_space);
	1705	try renderToken(tree, ais, else_node.else_token, after_else_space);
1767	1706
1768	1707	if (else_node.payload) \|payload\| {
1769	1708	const payload_space = if (same_line) Space.Space else Space.Newline;
1770		try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
	1709	try renderExpression(allocator, ais, tree, payload, payload_space);
1771	1710	}
1772	1711
1773	1712	if (same_line) {
1774		return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
	1713	return renderExpression(allocator, ais, tree, else_node.body, space);
	1714	} else {
	1715	ais.pushIndent();
	1716	defer ais.popIndent();
	1717	return renderExpression(allocator, ais, tree, else_node.body, space);
1775	1718	}
1776
1777		try stream.writeByteNTimes(' ', indent + indent_delta);
1778		start_col.* = indent + indent_delta;
1779		return renderExpression(allocator, stream, tree, indent, start_col, else_node.body, space);
1780	1719	},
1781	1720
1782	1721	.While => {
1783	1722	const while_node = @fieldParentPtr(ast.Node.While, "base", base);
1784	1723
1785	1724	if (while_node.label) \|label\| {
1786		try renderToken(tree, stream, label, indent, start_col, Space.None); // label
1787		try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
	1725	try renderToken(tree, ais, label, Space.None); // label
	1726	try renderToken(tree, ais, tree.nextToken(label), Space.Space); // :
1788	1727	}
1789	1728
1790	1729	if (while_node.inline_token) \|inline_token\| {
1791		try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
	1730	try renderToken(tree, ais, inline_token, Space.Space); // inline
1792	1731	}
1793	1732
1794		try renderToken(tree, stream, while_node.while_token, indent, start_col, Space.Space); // while
1795		try renderToken(tree, stream, tree.nextToken(while_node.while_token), indent, start_col, Space.None); // (
1796		try renderExpression(allocator, stream, tree, indent, start_col, while_node.condition, Space.None);
	1733	try renderToken(tree, ais, while_node.while_token, Space.Space); // while
	1734	try renderToken(tree, ais, tree.nextToken(while_node.while_token), Space.None); // (
	1735	try renderExpression(allocator, ais, tree, while_node.condition, Space.None);
1797	1736
1798	1737	const cond_rparen = tree.nextToken(while_node.condition.lastToken());
1799	1738
...	...	@@ -1815,12 +1754,12 @@ fn renderExpression(
1815	1754
1816	1755	{
1817	1756	const rparen_space = if (while_node.payload != null or while_node.continue_expr != null) Space.Space else block_start_space;
1818		try renderToken(tree, stream, cond_rparen, indent, start_col, rparen_space); // )
	1757	try renderToken(tree, ais, cond_rparen, rparen_space); // )
1819	1758	}
1820	1759
1821	1760	if (while_node.payload) \|payload\| {
1822		const payload_space = if (while_node.continue_expr != null) Space.Space else block_start_space;
1823		try renderExpression(allocator, stream, tree, indent, start_col, payload, payload_space);
	1761	const payload_space = Space.Space; //if (while_node.continue_expr != null) Space.Space else block_start_space;
	1762	try renderExpression(allocator, ais, tree, payload, payload_space);
1824	1763	}
1825	1764
1826	1765	if (while_node.continue_expr) \|continue_expr\| {
...	...	@@ -1828,29 +1767,22 @@ fn renderExpression(
1828	1767	const lparen = tree.prevToken(continue_expr.firstToken());
1829	1768	const colon = tree.prevToken(lparen);
1830	1769
1831		try renderToken(tree, stream, colon, indent, start_col, Space.Space); // :
1832		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
	1770	try renderToken(tree, ais, colon, Space.Space); // :
	1771	try renderToken(tree, ais, lparen, Space.None); // (
1833	1772
1834		try renderExpression(allocator, stream, tree, indent, start_col, continue_expr, Space.None);
	1773	try renderExpression(allocator, ais, tree, continue_expr, Space.None);
1835	1774
1836		try renderToken(tree, stream, rparen, indent, start_col, block_start_space); // )
	1775	try renderToken(tree, ais, rparen, block_start_space); // )
1837	1776	}
1838	1777
1839		var new_indent = indent;
1840		if (block_start_space == Space.Newline) {
1841		new_indent += indent_delta;
1842		try stream.writeByteNTimes(' ', new_indent);
1843		start_col.* = new_indent;
	1778	{
	1779	if (!body_is_block) ais.pushIndent();
	1780	defer if (!body_is_block) ais.popIndent();
	1781	try renderExpression(allocator, ais, tree, while_node.body, after_body_space);
1844	1782	}
1845	1783
1846		try renderExpression(allocator, stream, tree, indent, start_col, while_node.body, after_body_space);
1847
1848	1784	if (while_node.@"else") \|@"else"\| {
1849		if (after_body_space == Space.Newline) {
1850		try stream.writeByteNTimes(' ', indent);
1851		start_col.* = indent;
1852		}
1853		return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
	1785	return renderExpression(allocator, ais, tree, &@"else".base, space);
1854	1786	}
1855	1787	},
1856	1788
...	...	@@ -1858,17 +1790,17 @@ fn renderExpression(
1858	1790	const for_node = @fieldParentPtr(ast.Node.For, "base", base);
1859	1791
1860	1792	if (for_node.label) \|label\| {
1861		try renderToken(tree, stream, label, indent, start_col, Space.None); // label
1862		try renderToken(tree, stream, tree.nextToken(label), indent, start_col, Space.Space); // :
	1793	try renderToken(tree, ais, label, Space.None); // label
	1794	try renderToken(tree, ais, tree.nextToken(label), Space.Space); // :
1863	1795	}
1864	1796
1865	1797	if (for_node.inline_token) \|inline_token\| {
1866		try renderToken(tree, stream, inline_token, indent, start_col, Space.Space); // inline
	1798	try renderToken(tree, ais, inline_token, Space.Space); // inline
1867	1799	}
1868	1800
1869		try renderToken(tree, stream, for_node.for_token, indent, start_col, Space.Space); // for
1870		try renderToken(tree, stream, tree.nextToken(for_node.for_token), indent, start_col, Space.None); // (
1871		try renderExpression(allocator, stream, tree, indent, start_col, for_node.array_expr, Space.None);
	1801	try renderToken(tree, ais, for_node.for_token, Space.Space); // for
	1802	try renderToken(tree, ais, tree.nextToken(for_node.for_token), Space.None); // (
	1803	try renderExpression(allocator, ais, tree, for_node.array_expr, Space.None);
1872	1804
1873	1805	const rparen = tree.nextToken(for_node.array_expr.lastToken());
1874	1806
...	...	@@ -1876,10 +1808,10 @@ fn renderExpression(
1876	1808	const src_one_line_to_body = !body_is_block and tree.tokensOnSameLine(rparen, for_node.body.firstToken());
1877	1809	const body_on_same_line = body_is_block or src_one_line_to_body;
1878	1810
1879		try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
	1811	try renderToken(tree, ais, rparen, Space.Space); // )
1880	1812
1881	1813	const space_after_payload = if (body_on_same_line) Space.Space else Space.Newline;
1882		try renderExpression(allocator, stream, tree, indent, start_col, for_node.payload, space_after_payload); // \|x\|
	1814	try renderExpression(allocator, ais, tree, for_node.payload, space_after_payload); // \|x\|
1883	1815
1884	1816	const space_after_body = blk: {
1885	1817	if (for_node.@"else") \|@"else"\| {
...	...	@@ -1894,13 +1826,14 @@ fn renderExpression(
1894	1826	}
1895	1827	};
1896	1828
1897		const body_indent = if (body_on_same_line) indent else indent + indent_delta;
1898		if (!body_on_same_line) try stream.writeByteNTimes(' ', body_indent);
1899		try renderExpression(allocator, stream, tree, body_indent, start_col, for_node.body, space_after_body); // { body }
	1829	{
	1830	if (!body_on_same_line) ais.pushIndent();
	1831	defer if (!body_on_same_line) ais.popIndent();
	1832	try renderExpression(allocator, ais, tree, for_node.body, space_after_body); // { body }
	1833	}
1900	1834
1901	1835	if (for_node.@"else") \|@"else"\| {
1902		if (space_after_body == Space.Newline) try stream.writeByteNTimes(' ', indent);
1903		return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space); // else
	1836	return renderExpression(allocator, ais, tree, &@"else".base, space); // else
1904	1837	}
1905	1838	},
1906	1839
...	...	@@ -1910,29 +1843,29 @@ fn renderExpression(
1910	1843	const lparen = tree.nextToken(if_node.if_token);
1911	1844	const rparen = tree.nextToken(if_node.condition.lastToken());
1912	1845
1913		try renderToken(tree, stream, if_node.if_token, indent, start_col, Space.Space); // if
1914		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
	1846	try renderToken(tree, ais, if_node.if_token, Space.Space); // if
	1847	try renderToken(tree, ais, lparen, Space.None); // (
1915	1848
1916		try renderExpression(allocator, stream, tree, indent, start_col, if_node.condition, Space.None); // condition
	1849	try renderExpression(allocator, ais, tree, if_node.condition, Space.None); // condition
1917	1850
1918	1851	const body_is_if_block = if_node.body.tag == .If;
1919	1852	const body_is_block = nodeIsBlock(if_node.body);
1920	1853
1921	1854	if (body_is_if_block) {
1922		try renderExtraNewline(tree, stream, start_col, if_node.body);
	1855	try renderExtraNewline(tree, ais, if_node.body);
1923	1856	} else if (body_is_block) {
1924	1857	const after_rparen_space = if (if_node.payload == null) Space.BlockStart else Space.Space;
1925		try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
	1858	try renderToken(tree, ais, rparen, after_rparen_space); // )
1926	1859
1927	1860	if (if_node.payload) \|payload\| {
1928		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.BlockStart); // \|x\|
	1861	try renderExpression(allocator, ais, tree, payload, Space.BlockStart); // \|x\|
1929	1862	}
1930	1863
1931	1864	if (if_node.@"else") \|@"else"\| {
1932		try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.SpaceOrOutdent);
1933		return renderExpression(allocator, stream, tree, indent, start_col, &@"else".base, space);
	1865	try renderExpression(allocator, ais, tree, if_node.body, Space.SpaceOrOutdent);
	1866	return renderExpression(allocator, ais, tree, &@"else".base, space);
1934	1867	} else {
1935		return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
	1868	return renderExpression(allocator, ais, tree, if_node.body, space);
1936	1869	}
1937	1870	}
1938	1871
...	...	@@ -1940,186 +1873,184 @@ fn renderExpression(
1940	1873
1941	1874	if (src_has_newline) {
1942	1875	const after_rparen_space = if (if_node.payload == null) Space.Newline else Space.Space;
1943		try renderToken(tree, stream, rparen, indent, start_col, after_rparen_space); // )
	1876	try renderToken(tree, ais, rparen, after_rparen_space); // )
1944	1877
1945	1878	if (if_node.payload) \|payload\| {
1946		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
	1879	try renderExpression(allocator, ais, tree, payload, Space.Newline);
1947	1880	}
1948	1881
1949		const new_indent = indent + indent_delta;
1950		try stream.writeByteNTimes(' ', new_indent);
1951
1952	1882	if (if_node.@"else") \|@"else"\| {
1953	1883	const else_is_block = nodeIsBlock(@"else".body);
1954		try renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, Space.Newline);
1955		try stream.writeByteNTimes(' ', indent);
	1884
	1885	{
	1886	ais.pushIndent();
	1887	defer ais.popIndent();
	1888	try renderExpression(allocator, ais, tree, if_node.body, Space.Newline);
	1889	}
1956	1890
1957	1891	if (else_is_block) {
1958		try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space); // else
	1892	try renderToken(tree, ais, @"else".else_token, Space.Space); // else
1959	1893
1960	1894	if (@"else".payload) \|payload\| {
1961		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
	1895	try renderExpression(allocator, ais, tree, payload, Space.Space);
1962	1896	}
1963	1897
1964		return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
	1898	return renderExpression(allocator, ais, tree, @"else".body, space);
1965	1899	} else {
1966	1900	const after_else_space = if (@"else".payload == null) Space.Newline else Space.Space;
1967		try renderToken(tree, stream, @"else".else_token, indent, start_col, after_else_space); // else
	1901	try renderToken(tree, ais, @"else".else_token, after_else_space); // else
1968	1902
1969	1903	if (@"else".payload) \|payload\| {
1970		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Newline);
	1904	try renderExpression(allocator, ais, tree, payload, Space.Newline);
1971	1905	}
1972		try stream.writeByteNTimes(' ', new_indent);
1973	1906
1974		return renderExpression(allocator, stream, tree, new_indent, start_col, @"else".body, space);
	1907	ais.pushIndent();
	1908	defer ais.popIndent();
	1909	return renderExpression(allocator, ais, tree, @"else".body, space);
1975	1910	}
1976	1911	} else {
1977		return renderExpression(allocator, stream, tree, new_indent, start_col, if_node.body, space);
	1912	ais.pushIndent();
	1913	defer ais.popIndent();
	1914	return renderExpression(allocator, ais, tree, if_node.body, space);
1978	1915	}
1979	1916	}
1980	1917
1981		try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
	1918	// Single line if statement
	1919
	1920	try renderToken(tree, ais, rparen, Space.Space); // )
1982	1921
1983	1922	if (if_node.payload) \|payload\| {
1984		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
	1923	try renderExpression(allocator, ais, tree, payload, Space.Space);
1985	1924	}
1986	1925
1987	1926	if (if_node.@"else") \|@"else"\| {
1988		try renderExpression(allocator, stream, tree, indent, start_col, if_node.body, Space.Space);
1989		try renderToken(tree, stream, @"else".else_token, indent, start_col, Space.Space);
	1927	try renderExpression(allocator, ais, tree, if_node.body, Space.Space);
	1928	try renderToken(tree, ais, @"else".else_token, Space.Space);
1990	1929
1991	1930	if (@"else".payload) \|payload\| {
1992		try renderExpression(allocator, stream, tree, indent, start_col, payload, Space.Space);
	1931	try renderExpression(allocator, ais, tree, payload, Space.Space);
1993	1932	}
1994	1933
1995		return renderExpression(allocator, stream, tree, indent, start_col, @"else".body, space);
	1934	return renderExpression(allocator, ais, tree, @"else".body, space);
1996	1935	} else {
1997		return renderExpression(allocator, stream, tree, indent, start_col, if_node.body, space);
	1936	return renderExpression(allocator, ais, tree, if_node.body, space);
1998	1937	}
1999	1938	},
2000	1939
2001	1940	.Asm => {
2002	1941	const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
2003	1942
2004		try renderToken(tree, stream, asm_node.asm_token, indent, start_col, Space.Space); // asm
	1943	try renderToken(tree, ais, asm_node.asm_token, Space.Space); // asm
2005	1944
2006	1945	if (asm_node.volatile_token) \|volatile_token\| {
2007		try renderToken(tree, stream, volatile_token, indent, start_col, Space.Space); // volatile
2008		try renderToken(tree, stream, tree.nextToken(volatile_token), indent, start_col, Space.None); // (
	1946	try renderToken(tree, ais, volatile_token, Space.Space); // volatile
	1947	try renderToken(tree, ais, tree.nextToken(volatile_token), Space.None); // (
2009	1948	} else {
2010		try renderToken(tree, stream, tree.nextToken(asm_node.asm_token), indent, start_col, Space.None); // (
	1949	try renderToken(tree, ais, tree.nextToken(asm_node.asm_token), Space.None); // (
2011	1950	}
2012	1951
2013		if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
2014		try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.None);
2015		return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
2016		}
	1952	asmblk: {
	1953	ais.pushIndent();
	1954	defer ais.popIndent();
2017	1955
2018		try renderExpression(allocator, stream, tree, indent, start_col, asm_node.template, Space.Newline);
	1956	if (asm_node.outputs.len == 0 and asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
	1957	try renderExpression(allocator, ais, tree, asm_node.template, Space.None);
	1958	break :asmblk;
	1959	}
2019	1960
2020		const indent_once = indent + indent_delta;
	1961	try renderExpression(allocator, ais, tree, asm_node.template, Space.Newline);
2021	1962
2022		if (asm_node.template.tag == .MultilineStringLiteral) {
2023		// After rendering a multiline string literal the cursor is
2024		// already offset by indent
2025		try stream.writeByteNTimes(' ', indent_delta);
2026		} else {
2027		try stream.writeByteNTimes(' ', indent_once);
2028		}
	1963	ais.setIndentDelta(asm_indent_delta);
	1964	defer ais.setIndentDelta(indent_delta);
2029	1965
2030		const colon1 = tree.nextToken(asm_node.template.lastToken());
2031		const indent_extra = indent_once + 2;
	1966	const colon1 = tree.nextToken(asm_node.template.lastToken());
2032	1967
2033		const colon2 = if (asm_node.outputs.len == 0) blk: {
2034		try renderToken(tree, stream, colon1, indent, start_col, Space.Newline); // :
2035		try stream.writeByteNTimes(' ', indent_once);
	1968	const colon2 = if (asm_node.outputs.len == 0) blk: {
	1969	try renderToken(tree, ais, colon1, Space.Newline); // :
2036	1970
2037		break :blk tree.nextToken(colon1);
2038		} else blk: {
2039		try renderToken(tree, stream, colon1, indent, start_col, Space.Space); // :
2040
2041		for (asm_node.outputs) \|*asm_output, i\| {
2042		if (i + 1 < asm_node.outputs.len) {
2043		const next_asm_output = asm_node.outputs[i + 1];
2044		try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.None);
2045
2046		const comma = tree.prevToken(next_asm_output.firstToken());
2047		try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
2048		try renderExtraNewlineToken(tree, stream, start_col, next_asm_output.firstToken());
2049
2050		try stream.writeByteNTimes(' ', indent_extra);
2051		} else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
2052		try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.Newline);
2053		try stream.writeByteNTimes(' ', indent);
2054		return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
2055		} else {
2056		try renderAsmOutput(allocator, stream, tree, indent_extra, start_col, asm_output, Space.Newline);
2057		try stream.writeByteNTimes(' ', indent_once);
2058		const comma_or_colon = tree.nextToken(asm_output.lastToken());
2059		break :blk switch (tree.token_ids[comma_or_colon]) {
2060		.Comma => tree.nextToken(comma_or_colon),
2061		else => comma_or_colon,
2062		};
2063		}
2064		}
2065		unreachable;
2066		};
	1971	break :blk tree.nextToken(colon1);
	1972	} else blk: {
	1973	try renderToken(tree, ais, colon1, Space.Space); // :
2067	1974
2068		const colon3 = if (asm_node.inputs.len == 0) blk: {
2069		try renderToken(tree, stream, colon2, indent, start_col, Space.Newline); // :
2070		try stream.writeByteNTimes(' ', indent_once);
	1975	ais.pushIndent();
	1976	defer ais.popIndent();
2071	1977
2072		break :blk tree.nextToken(colon2);
2073		} else blk: {
2074		try renderToken(tree, stream, colon2, indent, start_col, Space.Space); // :
2075
2076		for (asm_node.inputs) \|*asm_input, i\| {
2077		if (i + 1 < asm_node.inputs.len) {
2078		const next_asm_input = &asm_node.inputs[i + 1];
2079		try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.None);
2080
2081		const comma = tree.prevToken(next_asm_input.firstToken());
2082		try renderToken(tree, stream, comma, indent_extra, start_col, Space.Newline); // ,
2083		try renderExtraNewlineToken(tree, stream, start_col, next_asm_input.firstToken());
2084
2085		try stream.writeByteNTimes(' ', indent_extra);
2086		} else if (asm_node.clobbers.len == 0) {
2087		try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.Newline);
2088		try stream.writeByteNTimes(' ', indent);
2089		return renderToken(tree, stream, asm_node.rparen, indent, start_col, space); // )
2090		} else {
2091		try renderAsmInput(allocator, stream, tree, indent_extra, start_col, asm_input, Space.Newline);
2092		try stream.writeByteNTimes(' ', indent_once);
2093		const comma_or_colon = tree.nextToken(asm_input.lastToken());
2094		break :blk switch (tree.token_ids[comma_or_colon]) {
2095		.Comma => tree.nextToken(comma_or_colon),
2096		else => comma_or_colon,
2097		};
	1978	for (asm_node.outputs) \|*asm_output, i\| {
	1979	if (i + 1 < asm_node.outputs.len) {
	1980	const next_asm_output = asm_node.outputs[i + 1];
	1981	try renderAsmOutput(allocator, ais, tree, asm_output, Space.None);
	1982
	1983	const comma = tree.prevToken(next_asm_output.firstToken());
	1984	try renderToken(tree, ais, comma, Space.Newline); // ,
	1985	try renderExtraNewlineToken(tree, ais, next_asm_output.firstToken());
	1986	} else if (asm_node.inputs.len == 0 and asm_node.clobbers.len == 0) {
	1987	try renderAsmOutput(allocator, ais, tree, asm_output, Space.Newline);
	1988	break :asmblk;
	1989	} else {
	1990	try renderAsmOutput(allocator, ais, tree, asm_output, Space.Newline);
	1991	const comma_or_colon = tree.nextToken(asm_output.lastToken());
	1992	break :blk switch (tree.token_ids[comma_or_colon]) {
	1993	.Comma => tree.nextToken(comma_or_colon),
	1994	else => comma_or_colon,
	1995	};
	1996	}
2098	1997	}
2099		}
2100		unreachable;
2101		};
	1998	unreachable;
	1999	};
2102	2000
2103		try renderToken(tree, stream, colon3, indent, start_col, Space.Space); // :
	2001	const colon3 = if (asm_node.inputs.len == 0) blk: {
	2002	try renderToken(tree, ais, colon2, Space.Newline); // :
	2003	break :blk tree.nextToken(colon2);
	2004	} else blk: {
	2005	try renderToken(tree, ais, colon2, Space.Space); // :
	2006	ais.pushIndent();
	2007	defer ais.popIndent();
	2008	for (asm_node.inputs) \|*asm_input, i\| {
	2009	if (i + 1 < asm_node.inputs.len) {
	2010	const next_asm_input = &asm_node.inputs[i + 1];
	2011	try renderAsmInput(allocator, ais, tree, asm_input, Space.None);
	2012
	2013	const comma = tree.prevToken(next_asm_input.firstToken());
	2014	try renderToken(tree, ais, comma, Space.Newline); // ,
	2015	try renderExtraNewlineToken(tree, ais, next_asm_input.firstToken());
	2016	} else if (asm_node.clobbers.len == 0) {
	2017	try renderAsmInput(allocator, ais, tree, asm_input, Space.Newline);
	2018	break :asmblk;
	2019	} else {
	2020	try renderAsmInput(allocator, ais, tree, asm_input, Space.Newline);
	2021	const comma_or_colon = tree.nextToken(asm_input.lastToken());
	2022	break :blk switch (tree.token_ids[comma_or_colon]) {
	2023	.Comma => tree.nextToken(comma_or_colon),
	2024	else => comma_or_colon,
	2025	};
	2026	}
	2027	}
	2028	unreachable;
	2029	};
2104	2030
2105		for (asm_node.clobbers) \|clobber_node, i\| {
2106		if (i + 1 >= asm_node.clobbers.len) {
2107		try renderExpression(allocator, stream, tree, indent_extra, start_col, clobber_node, Space.Newline);
2108		try stream.writeByteNTimes(' ', indent);
2109		return renderToken(tree, stream, asm_node.rparen, indent, start_col, space);
2110		} else {
2111		try renderExpression(allocator, stream, tree, indent_extra, start_col, clobber_node, Space.None);
2112		const comma = tree.nextToken(clobber_node.lastToken());
2113		try renderToken(tree, stream, comma, indent_once, start_col, Space.Space); // ,
	2031	try renderToken(tree, ais, colon3, Space.Space); // :
	2032	ais.pushIndent();
	2033	defer ais.popIndent();
	2034	for (asm_node.clobbers) \|clobber_node, i\| {
	2035	if (i + 1 >= asm_node.clobbers.len) {
	2036	try renderExpression(allocator, ais, tree, clobber_node, Space.Newline);
	2037	break :asmblk;
	2038	} else {
	2039	try renderExpression(allocator, ais, tree, clobber_node, Space.None);
	2040	const comma = tree.nextToken(clobber_node.lastToken());
	2041	try renderToken(tree, ais, comma, Space.Space); // ,
	2042	}
2114	2043	}
2115	2044	}
	2045
	2046	return renderToken(tree, ais, asm_node.rparen, space);
2116	2047	},
2117	2048
2118	2049	.EnumLiteral => {
2119	2050	const enum_literal = @fieldParentPtr(ast.Node.EnumLiteral, "base", base);
2120	2051
2121		try renderToken(tree, stream, enum_literal.dot, indent, start_col, Space.None); // .
2122		return renderToken(tree, stream, enum_literal.name, indent, start_col, space); // name
	2052	try renderToken(tree, ais, enum_literal.dot, Space.None); // .
	2053	return renderToken(tree, ais, enum_literal.name, space); // name
2123	2054	},
2124	2055
2125	2056	.ContainerField,
...	...	@@ -2133,118 +2064,115 @@ fn renderExpression(
2133	2064
2134	2065	fn renderArrayType(
2135	2066	allocator: *mem.Allocator,
2136		stream: anytype,
	2067	ais: anytype,
2137	2068	tree: *ast.Tree,
2138		indent: usize,
2139		start_col: *usize,
2140	2069	lbracket: ast.TokenIndex,
2141	2070	rhs: *ast.Node,
2142	2071	len_expr: *ast.Node,
2143	2072	opt_sentinel: ?*ast.Node,
2144	2073	space: Space,
2145		) (@TypeOf(stream).Error \|\| Error)!void {
	2074	) (@TypeOf(ais.*).Error \|\| Error)!void {
2146	2075	const rbracket = tree.nextToken(if (opt_sentinel) \|sentinel\|
2147	2076	sentinel.lastToken()
2148	2077	else
2149	2078	len_expr.lastToken());
2150	2079
2151		try renderToken(tree, stream, lbracket, indent, start_col, Space.None); // [
2152
2153	2080	const starts_with_comment = tree.token_ids[lbracket + 1] == .LineComment;
2154	2081	const ends_with_comment = tree.token_ids[rbracket - 1] == .LineComment;
2155		const new_indent = if (ends_with_comment) indent + indent_delta else indent;
2156	2082	const new_space = if (ends_with_comment) Space.Newline else Space.None;
2157		try renderExpression(allocator, stream, tree, new_indent, start_col, len_expr, new_space);
2158		if (starts_with_comment) {
2159		try stream.writeByte('\n');
2160		}
2161		if (ends_with_comment or starts_with_comment) {
2162		try stream.writeByteNTimes(' ', indent);
2163		}
2164		if (opt_sentinel) \|sentinel\| {
2165		const colon_token = tree.prevToken(sentinel.firstToken());
2166		try renderToken(tree, stream, colon_token, indent, start_col, Space.None); // :
2167		try renderExpression(allocator, stream, tree, indent, start_col, sentinel, Space.None);
	2083	{
	2084	const do_indent = (starts_with_comment or ends_with_comment);
	2085	if (do_indent) ais.pushIndent();
	2086	defer if (do_indent) ais.popIndent();
	2087
	2088	try renderToken(tree, ais, lbracket, Space.None); // [
	2089	try renderExpression(allocator, ais, tree, len_expr, new_space);
	2090
	2091	if (starts_with_comment) {
	2092	try ais.maybeInsertNewline();
	2093	}
	2094	if (opt_sentinel) \|sentinel\| {
	2095	const colon_token = tree.prevToken(sentinel.firstToken());
	2096	try renderToken(tree, ais, colon_token, Space.None); // :
	2097	try renderExpression(allocator, ais, tree, sentinel, Space.None);
	2098	}
	2099	if (starts_with_comment) {
	2100	try ais.maybeInsertNewline();
	2101	}
2168	2102	}
2169		try renderToken(tree, stream, rbracket, indent, start_col, Space.None); // ]
	2103	try renderToken(tree, ais, rbracket, Space.None); // ]
2170	2104
2171		return renderExpression(allocator, stream, tree, indent, start_col, rhs, space);
	2105	return renderExpression(allocator, ais, tree, rhs, space);
2172	2106	}
2173	2107
2174	2108	fn renderAsmOutput(
2175	2109	allocator: *mem.Allocator,
2176		stream: anytype,
	2110	ais: anytype,
2177	2111	tree: *ast.Tree,
2178		indent: usize,
2179		start_col: *usize,
2180	2112	asm_output: *const ast.Node.Asm.Output,
2181	2113	space: Space,
2182		) (@TypeOf(stream).Error \|\| Error)!void {
2183		try stream.writeAll("[");
2184		try renderExpression(allocator, stream, tree, indent, start_col, asm_output.symbolic_name, Space.None);
2185		try stream.writeAll("] ");
2186		try renderExpression(allocator, stream, tree, indent, start_col, asm_output.constraint, Space.None);
2187		try stream.writeAll(" (");
	2114	) (@TypeOf(ais.*).Error \|\| Error)!void {
	2115	try ais.writer().writeAll("[");
	2116	try renderExpression(allocator, ais, tree, asm_output.symbolic_name, Space.None);
	2117	try ais.writer().writeAll("] ");
	2118	try renderExpression(allocator, ais, tree, asm_output.constraint, Space.None);
	2119	try ais.writer().writeAll(" (");
2188	2120
2189	2121	switch (asm_output.kind) {
2190	2122	ast.Node.Asm.Output.Kind.Variable => \|variable_name\| {
2191		try renderExpression(allocator, stream, tree, indent, start_col, &variable_name.base, Space.None);
	2123	try renderExpression(allocator, ais, tree, &variable_name.base, Space.None);
2192	2124	},
2193	2125	ast.Node.Asm.Output.Kind.Return => \|return_type\| {
2194		try stream.writeAll("-> ");
2195		try renderExpression(allocator, stream, tree, indent, start_col, return_type, Space.None);
	2126	try ais.writer().writeAll("-> ");
	2127	try renderExpression(allocator, ais, tree, return_type, Space.None);
2196	2128	},
2197	2129	}
2198	2130
2199		return renderToken(tree, stream, asm_output.lastToken(), indent, start_col, space); // )
	2131	return renderToken(tree, ais, asm_output.lastToken(), space); // )
2200	2132	}
2201	2133
2202	2134	fn renderAsmInput(
2203	2135	allocator: *mem.Allocator,
2204		stream: anytype,
	2136	ais: anytype,
2205	2137	tree: *ast.Tree,
2206		indent: usize,
2207		start_col: *usize,
2208	2138	asm_input: *const ast.Node.Asm.Input,
2209	2139	space: Space,
2210		) (@TypeOf(stream).Error \|\| Error)!void {
2211		try stream.writeAll("[");
2212		try renderExpression(allocator, stream, tree, indent, start_col, asm_input.symbolic_name, Space.None);
2213		try stream.writeAll("] ");
2214		try renderExpression(allocator, stream, tree, indent, start_col, asm_input.constraint, Space.None);
2215		try stream.writeAll(" (");
2216		try renderExpression(allocator, stream, tree, indent, start_col, asm_input.expr, Space.None);
2217		return renderToken(tree, stream, asm_input.lastToken(), indent, start_col, space); // )
	2140	) (@TypeOf(ais.*).Error \|\| Error)!void {
	2141	try ais.writer().writeAll("[");
	2142	try renderExpression(allocator, ais, tree, asm_input.symbolic_name, Space.None);
	2143	try ais.writer().writeAll("] ");
	2144	try renderExpression(allocator, ais, tree, asm_input.constraint, Space.None);
	2145	try ais.writer().writeAll(" (");
	2146	try renderExpression(allocator, ais, tree, asm_input.expr, Space.None);
	2147	return renderToken(tree, ais, asm_input.lastToken(), space); // )
2218	2148	}
2219	2149
2220	2150	fn renderVarDecl(
2221	2151	allocator: *mem.Allocator,
2222		stream: anytype,
	2152	ais: anytype,
2223	2153	tree: *ast.Tree,
2224		indent: usize,
2225		start_col: *usize,
2226	2154	var_decl: *ast.Node.VarDecl,
2227		) (@TypeOf(stream).Error \|\| Error)!void {
	2155	) (@TypeOf(ais.*).Error \|\| Error)!void {
2228	2156	if (var_decl.getVisibToken()) \|visib_token\| {
2229		try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
	2157	try renderToken(tree, ais, visib_token, Space.Space); // pub
2230	2158	}
2231	2159
2232	2160	if (var_decl.getExternExportToken()) \|extern_export_token\| {
2233		try renderToken(tree, stream, extern_export_token, indent, start_col, Space.Space); // extern
	2161	try renderToken(tree, ais, extern_export_token, Space.Space); // extern
2234	2162
2235	2163	if (var_decl.getLibName()) \|lib_name\| {
2236		try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space); // "lib"
	2164	try renderExpression(allocator, ais, tree, lib_name, Space.Space); // "lib"
2237	2165	}
2238	2166	}
2239	2167
2240	2168	if (var_decl.getComptimeToken()) \|comptime_token\| {
2241		try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space); // comptime
	2169	try renderToken(tree, ais, comptime_token, Space.Space); // comptime
2242	2170	}
2243	2171
2244	2172	if (var_decl.getThreadLocalToken()) \|thread_local_token\| {
2245		try renderToken(tree, stream, thread_local_token, indent, start_col, Space.Space); // threadlocal
	2173	try renderToken(tree, ais, thread_local_token, Space.Space); // threadlocal
2246	2174	}
2247		try renderToken(tree, stream, var_decl.mut_token, indent, start_col, Space.Space); // var
	2175	try renderToken(tree, ais, var_decl.mut_token, Space.Space); // var
2248	2176
2249	2177	const name_space = if (var_decl.getTypeNode() == null and
2250	2178	(var_decl.getAlignNode() != null or
...	...	@@ -2253,95 +2181,92 @@ fn renderVarDecl(
2253	2181	Space.Space
2254	2182	else
2255	2183	Space.None;
2256		try renderToken(tree, stream, var_decl.name_token, indent, start_col, name_space);
	2184	try renderToken(tree, ais, var_decl.name_token, name_space);
2257	2185
2258	2186	if (var_decl.getTypeNode()) \|type_node\| {
2259		try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, start_col, Space.Space);
	2187	try renderToken(tree, ais, tree.nextToken(var_decl.name_token), Space.Space);
2260	2188	const s = if (var_decl.getAlignNode() != null or
2261	2189	var_decl.getSectionNode() != null or
2262	2190	var_decl.getInitNode() != null) Space.Space else Space.None;
2263		try renderExpression(allocator, stream, tree, indent, start_col, type_node, s);
	2191	try renderExpression(allocator, ais, tree, type_node, s);
2264	2192	}
2265	2193
2266	2194	if (var_decl.getAlignNode()) \|align_node\| {
2267	2195	const lparen = tree.prevToken(align_node.firstToken());
2268	2196	const align_kw = tree.prevToken(lparen);
2269	2197	const rparen = tree.nextToken(align_node.lastToken());
2270		try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
2271		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
2272		try renderExpression(allocator, stream, tree, indent, start_col, align_node, Space.None);
	2198	try renderToken(tree, ais, align_kw, Space.None); // align
	2199	try renderToken(tree, ais, lparen, Space.None); // (
	2200	try renderExpression(allocator, ais, tree, align_node, Space.None);
2273	2201	const s = if (var_decl.getSectionNode() != null or var_decl.getInitNode() != null) Space.Space else Space.None;
2274		try renderToken(tree, stream, rparen, indent, start_col, s); // )
	2202	try renderToken(tree, ais, rparen, s); // )
2275	2203	}
2276	2204
2277	2205	if (var_decl.getSectionNode()) \|section_node\| {
2278	2206	const lparen = tree.prevToken(section_node.firstToken());
2279	2207	const section_kw = tree.prevToken(lparen);
2280	2208	const rparen = tree.nextToken(section_node.lastToken());
2281		try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // linksection
2282		try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
2283		try renderExpression(allocator, stream, tree, indent, start_col, section_node, Space.None);
	2209	try renderToken(tree, ais, section_kw, Space.None); // linksection
	2210	try renderToken(tree, ais, lparen, Space.None); // (
	2211	try renderExpression(allocator, ais, tree, section_node, Space.None);
2284	2212	const s = if (var_decl.getInitNode() != null) Space.Space else Space.None;
2285		try renderToken(tree, stream, rparen, indent, start_col, s); // )
	2213	try renderToken(tree, ais, rparen, s); // )
2286	2214	}
2287	2215
2288	2216	if (var_decl.getInitNode()) \|init_node\| {
2289	2217	const s = if (init_node.tag == .MultilineStringLiteral) Space.None else Space.Space;
2290		try renderToken(tree, stream, var_decl.getEqToken().?, indent, start_col, s); // =
2291		try renderExpression(allocator, stream, tree, indent, start_col, init_node, Space.None);
	2218	try renderToken(tree, ais, var_decl.getEqToken().?, s); // =
	2219	ais.pushIndentOneShot();
	2220	try renderExpression(allocator, ais, tree, init_node, Space.None);
2292	2221	}
2293	2222
2294		try renderToken(tree, stream, var_decl.semicolon_token, indent, start_col, Space.Newline);
	2223	try renderToken(tree, ais, var_decl.semicolon_token, Space.Newline);
2295	2224	}
2296	2225
2297	2226	fn renderParamDecl(
2298	2227	allocator: *mem.Allocator,
2299		stream: anytype,
	2228	ais: anytype,
2300	2229	tree: *ast.Tree,
2301		indent: usize,
2302		start_col: *usize,
2303	2230	param_decl: ast.Node.FnProto.ParamDecl,
2304	2231	space: Space,
2305		) (@TypeOf(stream).Error \|\| Error)!void {
2306		try renderDocComments(tree, stream, param_decl, param_decl.doc_comments, indent, start_col);
	2232	) (@TypeOf(ais.*).Error \|\| Error)!void {
	2233	try renderDocComments(tree, ais, param_decl, param_decl.doc_comments);
2307	2234
2308	2235	if (param_decl.comptime_token) \|comptime_token\| {
2309		try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space);
	2236	try renderToken(tree, ais, comptime_token, Space.Space);
2310	2237	}
2311	2238	if (param_decl.noalias_token) \|noalias_token\| {
2312		try renderToken(tree, stream, noalias_token, indent, start_col, Space.Space);
	2239	try renderToken(tree, ais, noalias_token, Space.Space);
2313	2240	}
2314	2241	if (param_decl.name_token) \|name_token\| {
2315		try renderToken(tree, stream, name_token, indent, start_col, Space.None);
2316		try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
	2242	try renderToken(tree, ais, name_token, Space.None);
	2243	try renderToken(tree, ais, tree.nextToken(name_token), Space.Space); // :
2317	2244	}
2318	2245	switch (param_decl.param_type) {
2319		.any_type, .type_expr => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, space),
	2246	.any_type, .type_expr => \|node\| try renderExpression(allocator, ais, tree, node, space),
2320	2247	}
2321	2248	}
2322	2249
2323	2250	fn renderStatement(
2324	2251	allocator: *mem.Allocator,
2325		stream: anytype,
	2252	ais: anytype,
2326	2253	tree: *ast.Tree,
2327		indent: usize,
2328		start_col: *usize,
2329	2254	base: *ast.Node,
2330		) (@TypeOf(stream).Error \|\| Error)!void {
	2255	) (@TypeOf(ais.*).Error \|\| Error)!void {
2331	2256	switch (base.tag) {
2332	2257	.VarDecl => {
2333	2258	const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
2334		try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
	2259	try renderVarDecl(allocator, ais, tree, var_decl);
2335	2260	},
2336	2261	else => {
2337	2262	if (base.requireSemiColon()) {
2338		try renderExpression(allocator, stream, tree, indent, start_col, base, Space.None);
	2263	try renderExpression(allocator, ais, tree, base, Space.None);
2339	2264
2340	2265	const semicolon_index = tree.nextToken(base.lastToken());
2341	2266	assert(tree.token_ids[semicolon_index] == .Semicolon);
2342		try renderToken(tree, stream, semicolon_index, indent, start_col, Space.Newline);
	2267	try renderToken(tree, ais, semicolon_index, Space.Newline);
2343	2268	} else {
2344		try renderExpression(allocator, stream, tree, indent, start_col, base, Space.Newline);
	2269	try renderExpression(allocator, ais, tree, base, Space.Newline);
2345	2270	}
2346	2271	},
2347	2272	}
...	...	@@ -2360,24 +2285,19 @@ const Space = enum {
2360	2285
2361	2286	fn renderTokenOffset(
2362	2287	tree: *ast.Tree,
2363		stream: anytype,
	2288	ais: anytype,
2364	2289	token_index: ast.TokenIndex,
2365		indent: usize,
2366		start_col: *usize,
2367	2290	space: Space,
2368	2291	token_skip_bytes: usize,
2369		) (@TypeOf(stream).Error \|\| Error)!void {
	2292	) (@TypeOf(ais.*).Error \|\| Error)!void {
2370	2293	if (space == Space.BlockStart) {
2371		if (start_col.* < indent + indent_delta)
2372		return renderToken(tree, stream, token_index, indent, start_col, Space.Space);
2373		try renderToken(tree, stream, token_index, indent, start_col, Space.Newline);
2374		try stream.writeByteNTimes(' ', indent);
2375		start_col.* = indent;
2376		return;
	2294	// If placing the lbrace on the current line would cause an uggly gap then put the lbrace on the next line
	2295	const new_space = if (ais.isLineOverIndented()) Space.Newline else Space.Space;
	2296	return renderToken(tree, ais, token_index, new_space);
2377	2297	}
2378	2298
2379	2299	var token_loc = tree.token_locs[token_index];
2380		try stream.writeAll(mem.trimRight(u8, tree.tokenSliceLoc(token_loc)[token_skip_bytes..], " "));
	2300	try ais.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(token_loc)[token_skip_bytes..], " "));
2381	2301
2382	2302	if (space == Space.NoComment)
2383	2303	return;
...	...	@@ -2386,20 +2306,20 @@ fn renderTokenOffset(
2386	2306	var next_token_loc = tree.token_locs[token_index + 1];
2387	2307
2388	2308	if (space == Space.Comma) switch (next_token_id) {
2389		.Comma => return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline),
	2309	.Comma => return renderToken(tree, ais, token_index + 1, Space.Newline),
2390	2310	.LineComment => {
2391		try stream.writeAll(", ");
2392		return renderToken(tree, stream, token_index + 1, indent, start_col, Space.Newline);
	2311	try ais.writer().writeAll(", ");
	2312	return renderToken(tree, ais, token_index + 1, Space.Newline);
2393	2313	},
2394	2314	else => {
2395	2315	if (token_index + 2 < tree.token_ids.len and
2396	2316	tree.token_ids[token_index + 2] == .MultilineStringLiteralLine)
2397	2317	{
2398		try stream.writeAll(",");
	2318	try ais.writer().writeAll(",");
2399	2319	return;
2400	2320	} else {
2401		try stream.writeAll(",\n");
2402		start_col.* = 0;
	2321	try ais.writer().writeAll(",");
	2322	try ais.insertNewline();
2403	2323	return;
2404	2324	}
2405	2325	},
...	...	@@ -2423,15 +2343,14 @@ fn renderTokenOffset(
2423	2343	if (next_token_id == .MultilineStringLiteralLine) {
2424	2344	return;
2425	2345	} else {
2426		try stream.writeAll("\n");
2427		start_col.* = 0;
	2346	try ais.insertNewline();
2428	2347	return;
2429	2348	}
2430	2349	},
2431	2350	Space.Space, Space.SpaceOrOutdent => {
2432	2351	if (next_token_id == .MultilineStringLiteralLine)
2433	2352	return;
2434		try stream.writeByte(' ');
	2353	try ais.writer().writeByte(' ');
2435	2354	return;
2436	2355	},
2437	2356	Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
...	...	@@ -2448,8 +2367,7 @@ fn renderTokenOffset(
2448	2367	next_token_id = tree.token_ids[token_index + offset];
2449	2368	next_token_loc = tree.token_locs[token_index + offset];
2450	2369	if (next_token_id != .LineComment) {
2451		try stream.writeByte('\n');
2452		start_col.* = 0;
	2370	try ais.insertNewline();
2453	2371	return;
2454	2372	}
2455	2373	},
...	...	@@ -2462,7 +2380,7 @@ fn renderTokenOffset(
2462	2380
2463	2381	var loc = tree.tokenLocationLoc(token_loc.end, next_token_loc);
2464	2382	if (loc.line == 0) {
2465		try stream.print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
	2383	try ais.writer().print(" {}", .{mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " ")});
2466	2384	offset = 2;
2467	2385	token_loc = next_token_loc;
2468	2386	next_token_loc = tree.token_locs[token_index + offset];
...	...	@@ -2470,26 +2388,16 @@ fn renderTokenOffset(
2470	2388	if (next_token_id != .LineComment) {
2471	2389	switch (space) {
2472	2390	Space.None, Space.Space => {
2473		try stream.writeByte('\n');
2474		const after_comment_token = tree.token_ids[token_index + offset];
2475		const next_line_indent = switch (after_comment_token) {
2476		.RParen, .RBrace, .RBracket => indent,
2477		else => indent + indent_delta,
2478		};
2479		try stream.writeByteNTimes(' ', next_line_indent);
2480		start_col.* = next_line_indent;
	2391	try ais.insertNewline();
2481	2392	},
2482	2393	Space.SpaceOrOutdent => {
2483		try stream.writeByte('\n');
2484		try stream.writeByteNTimes(' ', indent);
2485		start_col.* = indent;
	2394	try ais.insertNewline();
2486	2395	},
2487	2396	Space.Newline => {
2488	2397	if (next_token_id == .MultilineStringLiteralLine) {
2489	2398	return;
2490	2399	} else {
2491		try stream.writeAll("\n");
2492		start_col.* = 0;
	2400	try ais.insertNewline();
2493	2401	return;
2494	2402	}
2495	2403	},
...	...	@@ -2505,10 +2413,9 @@ fn renderTokenOffset(
2505	2413	// translate-c doesn't generate correct newlines
2506	2414	// in generated code (loc.line == 0) so treat that case
2507	2415	// as though there was meant to be a newline between the tokens
2508		const newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
2509		try stream.writeByteNTimes('\n', newline_count);
2510		try stream.writeByteNTimes(' ', indent);
2511		try stream.writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
	2416	var newline_count = if (loc.line <= 1) @as(u8, 1) else @as(u8, 2);
	2417	while (newline_count > 0) : (newline_count -= 1) try ais.insertNewline();
	2418	try ais.writer().writeAll(mem.trimRight(u8, tree.tokenSliceLoc(next_token_loc), " "));
2512	2419
2513	2420	offset += 1;
2514	2421	token_loc = next_token_loc;
...	...	@@ -2520,32 +2427,15 @@ fn renderTokenOffset(
2520	2427	if (next_token_id == .MultilineStringLiteralLine) {
2521	2428	return;
2522	2429	} else {
2523		try stream.writeAll("\n");
2524		start_col.* = 0;
	2430	try ais.insertNewline();
2525	2431	return;
2526	2432	}
2527	2433	},
2528	2434	Space.None, Space.Space => {
2529		try stream.writeByte('\n');
2530
2531		const after_comment_token = tree.token_ids[token_index + offset];
2532		const next_line_indent = switch (after_comment_token) {
2533		.RParen, .RBrace, .RBracket => blk: {
2534		if (indent > indent_delta) {
2535		break :blk indent - indent_delta;
2536		} else {
2537		break :blk 0;
2538		}
2539		},
2540		else => indent,
2541		};
2542		try stream.writeByteNTimes(' ', next_line_indent);
2543		start_col.* = next_line_indent;
	2435	try ais.insertNewline();
2544	2436	},
2545	2437	Space.SpaceOrOutdent => {
2546		try stream.writeByte('\n');
2547		try stream.writeByteNTimes(' ', indent);
2548		start_col.* = indent;
	2438	try ais.insertNewline();
2549	2439	},
2550	2440	Space.NoNewline => {},
2551	2441	Space.NoComment, Space.Comma, Space.BlockStart => unreachable,
...	...	@@ -2558,46 +2448,38 @@ fn renderTokenOffset(
2558	2448
2559	2449	fn renderToken(
2560	2450	tree: *ast.Tree,
2561		stream: anytype,
	2451	ais: anytype,
2562	2452	token_index: ast.TokenIndex,
2563		indent: usize,
2564		start_col: *usize,
2565	2453	space: Space,
2566		) (@TypeOf(stream).Error \|\| Error)!void {
2567		return renderTokenOffset(tree, stream, token_index, indent, start_col, space, 0);
	2454	) (@TypeOf(ais.*).Error \|\| Error)!void {
	2455	return renderTokenOffset(tree, ais, token_index, space, 0);
2568	2456	}
2569	2457
2570	2458	fn renderDocComments(
2571	2459	tree: *ast.Tree,
2572		stream: anytype,
	2460	ais: anytype,
2573	2461	node: anytype,
2574	2462	doc_comments: ?*ast.Node.DocComment,
2575		indent: usize,
2576		start_col: *usize,
2577		) (@TypeOf(stream).Error \|\| Error)!void {
	2463	) (@TypeOf(ais.*).Error \|\| Error)!void {
2578	2464	const comment = doc_comments orelse return;
2579		return renderDocCommentsToken(tree, stream, comment, node.firstToken(), indent, start_col);
	2465	return renderDocCommentsToken(tree, ais, comment, node.firstToken());
2580	2466	}
2581	2467
2582	2468	fn renderDocCommentsToken(
2583	2469	tree: *ast.Tree,
2584		stream: anytype,
	2470	ais: anytype,
2585	2471	comment: *ast.Node.DocComment,
2586	2472	first_token: ast.TokenIndex,
2587		indent: usize,
2588		start_col: *usize,
2589		) (@TypeOf(stream).Error \|\| Error)!void {
	2473	) (@TypeOf(ais.*).Error \|\| Error)!void {
2590	2474	var tok_i = comment.first_line;
2591	2475	while (true) : (tok_i += 1) {
2592	2476	switch (tree.token_ids[tok_i]) {
2593	2477	.DocComment, .ContainerDocComment => {
2594	2478	if (comment.first_line < first_token) {
2595		try renderToken(tree, stream, tok_i, indent, start_col, Space.Newline);
2596		try stream.writeByteNTimes(' ', indent);
	2479	try renderToken(tree, ais, tok_i, Space.Newline);
2597	2480	} else {
2598		try renderToken(tree, stream, tok_i, indent, start_col, Space.NoComment);
2599		try stream.writeAll("\n");
2600		try stream.writeByteNTimes(' ', indent);
	2481	try renderToken(tree, ais, tok_i, Space.NoComment);
	2482	try ais.insertNewline();
2601	2483	}
2602	2484	},
2603	2485	.LineComment => continue,
...	...	@@ -2669,41 +2551,10 @@ fn nodeCausesSliceOpSpace(base: *ast.Node) bool {
2669	2551	};
2670	2552	}
2671	2553
2672		/// A `std.io.OutStream` that returns whether the given character has been written to it.
2673		/// The contents are not written to anything.
2674		const FindByteOutStream = struct {
2675		byte_found: bool,
2676		byte: u8,
2677
2678		pub const Error = error{};
2679		pub const OutStream = std.io.OutStream(*FindByteOutStream, Error, write);
2680
2681		pub fn init(byte: u8) FindByteOutStream {
2682		return FindByteOutStream{
2683		.byte = byte,
2684		.byte_found = false,
2685		};
2686		}
2687
2688		pub fn write(self: *FindByteOutStream, bytes: []const u8) Error!usize {
2689		if (self.byte_found) return bytes.len;
2690		self.byte_found = blk: {
2691		for (bytes) \|b\|
2692		if (b == self.byte) break :blk true;
2693		break :blk false;
2694		};
2695		return bytes.len;
2696		}
2697
2698		pub fn outStream(self: *FindByteOutStream) OutStream {
2699		return .{ .context = self };
2700		}
2701		};
2702
2703		fn copyFixingWhitespace(stream: anytype, slice: []const u8) @TypeOf(stream).Error!void {
	2554	fn copyFixingWhitespace(ais: anytype, slice: []const u8) @TypeOf(ais.*).Error!void {
2704	2555	for (slice) \|byte\| switch (byte) {
2705		'\t' => try stream.writeAll(" "),
	2556	'\t' => try ais.writer().writeAll(" "),
2706	2557	'\r' => {},
2707		else => try stream.writeByte(byte),
	2558	else => try ais.writer().writeByte(byte),
2708	2559	};
2709	2560	}

lib/std/zig/tokenizer.zig+2-1

...	...	@@ -1175,6 +1175,7 @@ pub const Tokenizer = struct {
1175	1175	},
1176	1176	.num_dot_dec => switch (c) {
1177	1177	'.' => {
	1178	result.id = .IntegerLiteral;
1178	1179	self.index -= 1;
1179	1180	state = .start;
1180	1181	break;
...	...	@@ -1183,7 +1184,6 @@ pub const Tokenizer = struct {
1183	1184	state = .float_exponent_unsigned;
1184	1185	},
1185	1186	'0'...'9' => {
1186		result.id = .FloatLiteral;
1187	1187	state = .float_fraction_dec;
1188	1188	},
1189	1189	else => {
...	...	@@ -1769,6 +1769,7 @@ test "tokenizer - number literals decimal" {
1769	1769	testTokenize("7", &[_]Token.Id{.IntegerLiteral});
1770	1770	testTokenize("8", &[_]Token.Id{.IntegerLiteral});
1771	1771	testTokenize("9", &[_]Token.Id{.IntegerLiteral});
	1772	testTokenize("1..", &[_]Token.Id{ .IntegerLiteral, .Ellipsis2 });
1772	1773	testTokenize("0a", &[_]Token.Id{ .Invalid, .Identifier });
1773	1774	testTokenize("9b", &[_]Token.Id{ .Invalid, .Identifier });
1774	1775	testTokenize("1z", &[_]Token.Id{ .Invalid, .Identifier });

src-self-hosted/Module.zig+165-54

...	...	@@ -125,7 +125,7 @@ pub const Decl = struct {
125	125	/// mapping them to an address in the output file.
126	126	/// Memory owned by this decl, using Module's allocator.
127	127	name: [*:0]const u8,
128		/// The direct parent container of the Decl. This is either a `Scope.File` or `Scope.ZIRModule`.
	128	/// The direct parent container of the Decl. This is either a `Scope.Container` or `Scope.ZIRModule`.
129	129	/// Reference to externally owned memory.
130	130	scope: *Scope,
131	131	/// The AST Node decl index or ZIR Inst index that contains this declaration.
...	...	@@ -217,9 +217,10 @@ pub const Decl = struct {
217	217
218	218	pub fn src(self: Decl) usize {
219	219	switch (self.scope.tag) {
220		.file => {
221		const file = @fieldParentPtr(Scope.File, "base", self.scope);
222		const tree = file.contents.tree;
	220	.container => {
	221	const container = @fieldParentPtr(Scope.Container, "base", self.scope);
	222	const tree = container.file_scope.contents.tree;
	223	// TODO Container should have it's own decls()
223	224	const decl_node = tree.root_node.decls()[self.src_index];
224	225	return tree.token_locs[decl_node.firstToken()].start;
225	226	},
...	...	@@ -229,7 +230,7 @@ pub const Decl = struct {
229	230	const src_decl = module.decls[self.src_index];
230	231	return src_decl.inst.src;
231	232	},
232		.block => unreachable,
	233	.file, .block => unreachable,
233	234	.gen_zir => unreachable,
234	235	.local_val => unreachable,
235	236	.local_ptr => unreachable,
...	...	@@ -359,6 +360,7 @@ pub const Scope = struct {
359	360	.local_ptr => return self.cast(LocalPtr).?.gen_zir.arena,
360	361	.zir_module => return &self.cast(ZIRModule).?.contents.module.arena.allocator,
361	362	.file => unreachable,
	363	.container => unreachable,
362	364	}
363	365	}
364	366
...	...	@@ -368,15 +370,16 @@ pub const Scope = struct {
368	370	return switch (self.tag) {
369	371	.block => self.cast(Block).?.decl,
370	372	.gen_zir => self.cast(GenZIR).?.decl,
371		.local_val => return self.cast(LocalVal).?.gen_zir.decl,
372		.local_ptr => return self.cast(LocalPtr).?.gen_zir.decl,
	373	.local_val => self.cast(LocalVal).?.gen_zir.decl,
	374	.local_ptr => self.cast(LocalPtr).?.gen_zir.decl,
373	375	.decl => self.cast(DeclAnalysis).?.decl,
374	376	.zir_module => null,
375	377	.file => null,
	378	.container => null,
376	379	};
377	380	}
378	381
379		/// Asserts the scope has a parent which is a ZIRModule or File and
	382	/// Asserts the scope has a parent which is a ZIRModule or Container and
380	383	/// returns it.
381	384	pub fn namespace(self: Scope) Scope {
382	385	switch (self.tag) {
...	...	@@ -385,7 +388,8 @@ pub const Scope = struct {
385	388	.local_val => return self.cast(LocalVal).?.gen_zir.decl.scope,
386	389	.local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.scope,
387	390	.decl => return self.cast(DeclAnalysis).?.decl.scope,
388		.zir_module, .file => return self,
	391	.file => return &self.cast(File).?.root_container.base,
	392	.zir_module, .container => return self,
389	393	}
390	394	}
391	395
...	...	@@ -399,8 +403,9 @@ pub const Scope = struct {
399	403	.local_val => unreachable,
400	404	.local_ptr => unreachable,
401	405	.decl => unreachable,
	406	.file => unreachable,
402	407	.zir_module => return self.cast(ZIRModule).?.fullyQualifiedNameHash(name),
403		.file => return self.cast(File).?.fullyQualifiedNameHash(name),
	408	.container => return self.cast(Container).?.fullyQualifiedNameHash(name),
404	409	}
405	410	}
406	411
...	...	@@ -409,11 +414,12 @@ pub const Scope = struct {
409	414	switch (self.tag) {
410	415	.file => return self.cast(File).?.contents.tree,
411	416	.zir_module => unreachable,
412		.decl => return self.cast(DeclAnalysis).?.decl.scope.cast(File).?.contents.tree,
413		.block => return self.cast(Block).?.decl.scope.cast(File).?.contents.tree,
414		.gen_zir => return self.cast(GenZIR).?.decl.scope.cast(File).?.contents.tree,
415		.local_val => return self.cast(LocalVal).?.gen_zir.decl.scope.cast(File).?.contents.tree,
416		.local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.scope.cast(File).?.contents.tree,
	417	.decl => return self.cast(DeclAnalysis).?.decl.scope.cast(Container).?.file_scope.contents.tree,
	418	.block => return self.cast(Block).?.decl.scope.cast(Container).?.file_scope.contents.tree,
	419	.gen_zir => return self.cast(GenZIR).?.decl.scope.cast(Container).?.file_scope.contents.tree,
	420	.local_val => return self.cast(LocalVal).?.gen_zir.decl.scope.cast(Container).?.file_scope.contents.tree,
	421	.local_ptr => return self.cast(LocalPtr).?.gen_zir.decl.scope.cast(Container).?.file_scope.contents.tree,
	422	.container => return self.cast(Container).?.file_scope.contents.tree,
417	423	}
418	424	}
419	425
...	...	@@ -427,13 +433,15 @@ pub const Scope = struct {
427	433	.decl => unreachable,
428	434	.zir_module => unreachable,
429	435	.file => unreachable,
	436	.container => unreachable,
430	437	};
431	438	}
432	439
433		/// Asserts the scope has a parent which is a ZIRModule or File and
	440	/// Asserts the scope has a parent which is a ZIRModule, Contaienr or File and
434	441	/// returns the sub_file_path field.
435	442	pub fn subFilePath(base: *Scope) []const u8 {
436	443	switch (base.tag) {
	444	.container => return @fieldParentPtr(Container, "base", base).file_scope.sub_file_path,
437	445	.file => return @fieldParentPtr(File, "base", base).sub_file_path,
438	446	.zir_module => return @fieldParentPtr(ZIRModule, "base", base).sub_file_path,
439	447	.block => unreachable,
...	...	@@ -453,11 +461,13 @@ pub const Scope = struct {
453	461	.local_val => unreachable,
454	462	.local_ptr => unreachable,
455	463	.decl => unreachable,
	464	.container => unreachable,
456	465	}
457	466	}
458	467
459	468	pub fn getSource(base: Scope, module: Module) ![:0]const u8 {
460	469	switch (base.tag) {
	470	.container => return @fieldParentPtr(Container, "base", base).file_scope.getSource(module),
461	471	.file => return @fieldParentPtr(File, "base", base).getSource(module),
462	472	.zir_module => return @fieldParentPtr(ZIRModule, "base", base).getSource(module),
463	473	.gen_zir => unreachable,
...	...	@@ -471,8 +481,9 @@ pub const Scope = struct {
471	481	/// Asserts the scope is a namespace Scope and removes the Decl from the namespace.
472	482	pub fn removeDecl(base: Scope, child: Decl) void {
473	483	switch (base.tag) {
474		.file => return @fieldParentPtr(File, "base", base).removeDecl(child),
	484	.container => return @fieldParentPtr(Container, "base", base).removeDecl(child),
475	485	.zir_module => return @fieldParentPtr(ZIRModule, "base", base).removeDecl(child),
	486	.file => unreachable,
476	487	.block => unreachable,
477	488	.gen_zir => unreachable,
478	489	.local_val => unreachable,
...	...	@@ -499,6 +510,7 @@ pub const Scope = struct {
499	510	.local_val => unreachable,
500	511	.local_ptr => unreachable,
501	512	.decl => unreachable,
	513	.container => unreachable,
502	514	}
503	515	}
504	516
...	...	@@ -515,6 +527,8 @@ pub const Scope = struct {
515	527	zir_module,
516	528	/// .zig source code.
517	529	file,
	530	/// struct, enum or union, every .file contains one of these.
	531	container,
518	532	block,
519	533	decl,
520	534	gen_zir,
...	...	@@ -522,6 +536,33 @@ pub const Scope = struct {
522	536	local_ptr,
523	537	};
524	538
	539	pub const Container = struct {
	540	pub const base_tag: Tag = .container;
	541	base: Scope = Scope{ .tag = base_tag },
	542
	543	file_scope: *Scope.File,
	544
	545	/// Direct children of the file.
	546	decls: std.AutoArrayHashMapUnmanaged(*Decl, void),
	547
	548	// TODO implement container types and put this in a status union
	549	// ty: Type
	550
	551	pub fn deinit(self: Container, gpa: Allocator) void {
	552	self.decls.deinit(gpa);
	553	self.* = undefined;
	554	}
	555
	556	pub fn removeDecl(self: Container, child: Decl) void {
	557	_ = self.decls.remove(child);
	558	}
	559
	560	pub fn fullyQualifiedNameHash(self: *Container, name: []const u8) NameHash {
	561	// TODO container scope qualified names.
	562	return std.zig.hashSrc(name);
	563	}
	564	};
	565
525	566	pub const File = struct {
526	567	pub const base_tag: Tag = .file;
527	568	base: Scope = Scope{ .tag = base_tag },
...	...	@@ -544,8 +585,7 @@ pub const Scope = struct {
544	585	loaded_success,
545	586	},
546	587
547		/// Direct children of the file.
548		decls: ArrayListUnmanaged(*Decl),
	588	root_container: Container,
549	589
550	590	pub fn unload(self: File, gpa: Allocator) void {
551	591	switch (self.status) {
...	...	@@ -569,20 +609,11 @@ pub const Scope = struct {
569	609	}
570	610
571	611	pub fn deinit(self: File, gpa: Allocator) void {
572		self.decls.deinit(gpa);
	612	self.root_container.deinit(gpa);
573	613	self.unload(gpa);
574	614	self.* = undefined;
575	615	}
576	616
577		pub fn removeDecl(self: File, child: Decl) void {
578		for (self.decls.items) \|item, i\| {
579		if (item == child) {
580		_ = self.decls.swapRemove(i);
581		return;
582		}
583		}
584		}
585
586	617	pub fn dumpSrc(self: *File, src: usize) void {
587	618	const loc = std.zig.findLineColumn(self.source.bytes, src);
588	619	std.debug.print("{}:{}:{}\n", .{ self.sub_file_path, loc.line + 1, loc.column + 1 });
...	...	@@ -595,6 +626,7 @@ pub const Scope = struct {
595	626	module.gpa,
596	627	self.sub_file_path,
597	628	std.math.maxInt(u32),
	629	null,
598	630	1,
599	631	0,
600	632	);
...	...	@@ -604,11 +636,6 @@ pub const Scope = struct {
604	636	.bytes => \|bytes\| return bytes,
605	637	}
606	638	}
607
608		pub fn fullyQualifiedNameHash(self: *File, name: []const u8) NameHash {
609		// We don't have struct scopes yet so this is currently just a simple name hash.
610		return std.zig.hashSrc(name);
611		}
612	639	};
613	640
614	641	pub const ZIRModule = struct {
...	...	@@ -697,6 +724,7 @@ pub const Scope = struct {
697	724	module.gpa,
698	725	self.sub_file_path,
699	726	std.math.maxInt(u32),
	727	null,
700	728	1,
701	729	0,
702	730	);
...	...	@@ -861,7 +889,10 @@ pub fn init(gpa: *Allocator, options: InitOptions) !Module {
861	889	.source = .{ .unloaded = {} },
862	890	.contents = .{ .not_available = {} },
863	891	.status = .never_loaded,
864		.decls = .{},
	892	.root_container = .{
	893	.file_scope = root_scope,
	894	.decls = .{},
	895	},
865	896	};
866	897	break :blk &root_scope.base;
867	898	} else if (mem.endsWith(u8, options.root_pkg.root_src_path, ".zir")) {
...	...	@@ -969,7 +1000,7 @@ pub fn update(self: *Module) !void {
969	1000	// to force a refresh we unload now.
970	1001	if (self.root_scope.cast(Scope.File)) \|zig_file\| {
971	1002	zig_file.unload(self.gpa);
972		self.analyzeRootSrcFile(zig_file) catch \|err\| switch (err) {
	1003	self.analyzeContainer(&zig_file.root_container) catch \|err\| switch (err) {
973	1004	error.AnalysisFail => {
974	1005	assert(self.totalErrorCount() != 0);
975	1006	},
...	...	@@ -1237,8 +1268,8 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1237	1268	const tracy = trace(@src());
1238	1269	defer tracy.end();
1239	1270
1240		const file_scope = decl.scope.cast(Scope.File).?;
1241		const tree = try self.getAstTree(file_scope);
	1271	const container_scope = decl.scope.cast(Scope.Container).?;
	1272	const tree = try self.getAstTree(container_scope);
1242	1273	const ast_node = tree.root_node.decls()[decl.src_index];
1243	1274	switch (ast_node.tag) {
1244	1275	.FnProto => {
...	...	@@ -1698,10 +1729,12 @@ fn getSrcModule(self: Module, root_scope: Scope.ZIRModule) !*zir.Module {
1698	1729	}
1699	1730	}
1700	1731
1701		fn getAstTree(self: Module, root_scope: Scope.File) !*ast.Tree {
	1732	fn getAstTree(self: Module, container_scope: Scope.Container) !*ast.Tree {
1702	1733	const tracy = trace(@src());
1703	1734	defer tracy.end();
1704	1735
	1736	const root_scope = container_scope.file_scope;
	1737
1705	1738	switch (root_scope.status) {
1706	1739	.never_loaded, .unloaded_success => {
1707	1740	try self.failed_files.ensureCapacity(self.gpa, self.failed_files.items().len + 1);
...	...	@@ -1743,25 +1776,25 @@ fn getAstTree(self: Module, root_scope: Scope.File) !*ast.Tree {
1743	1776	}
1744	1777	}
1745	1778
1746		fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
	1779	fn analyzeContainer(self: Module, container_scope: Scope.Container) !void {
1747	1780	const tracy = trace(@src());
1748	1781	defer tracy.end();
1749	1782
1750	1783	// We may be analyzing it for the first time, or this may be
1751	1784	// an incremental update. This code handles both cases.
1752		const tree = try self.getAstTree(root_scope);
	1785	const tree = try self.getAstTree(container_scope);
1753	1786	const decls = tree.root_node.decls();
1754	1787
1755	1788	try self.work_queue.ensureUnusedCapacity(decls.len);
1756		try root_scope.decls.ensureCapacity(self.gpa, decls.len);
	1789	try container_scope.decls.ensureCapacity(self.gpa, decls.len);
1757	1790
1758	1791	// Keep track of the decls that we expect to see in this file so that
1759	1792	// we know which ones have been deleted.
1760	1793	var deleted_decls = std.AutoArrayHashMap(*Decl, void).init(self.gpa);
1761	1794	defer deleted_decls.deinit();
1762		try deleted_decls.ensureCapacity(root_scope.decls.items.len);
1763		for (root_scope.decls.items) \|file_decl\| {
1764		deleted_decls.putAssumeCapacityNoClobber(file_decl, {});
	1795	try deleted_decls.ensureCapacity(container_scope.decls.items().len);
	1796	for (container_scope.decls.items()) \|entry\| {
	1797	deleted_decls.putAssumeCapacityNoClobber(entry.key, {});
1765	1798	}
1766	1799
1767	1800	for (decls) \|src_decl, decl_i\| {
...	...	@@ -1773,7 +1806,7 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1773	1806
1774	1807	const name_loc = tree.token_locs[name_tok];
1775	1808	const name = tree.tokenSliceLoc(name_loc);
1776		const name_hash = root_scope.fullyQualifiedNameHash(name);
	1809	const name_hash = container_scope.fullyQualifiedNameHash(name);
1777	1810	const contents_hash = std.zig.hashSrc(tree.getNodeSource(src_decl));
1778	1811	if (self.decl_table.get(name_hash)) \|decl\| {
1779	1812	// Update the AST Node index of the decl, even if its contents are unchanged, it may
...	...	@@ -1789,6 +1822,9 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1789	1822	try self.markOutdatedDecl(decl);
1790	1823	decl.contents_hash = contents_hash;
1791	1824	} else switch (self.bin_file.tag) {
	1825	.coff => {
	1826	// TODO Implement for COFF
	1827	},
1792	1828	.elf => if (decl.fn_link.elf.len != 0) {
1793	1829	// TODO Look into detecting when this would be unnecessary by storing enough state
1794	1830	// in `Decl` to notice that the line number did not change.
...	...	@@ -1801,8 +1837,8 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1801	1837	}
1802	1838	}
1803	1839	} else {
1804		const new_decl = try self.createNewDecl(&root_scope.base, name, decl_i, name_hash, contents_hash);
1805		root_scope.decls.appendAssumeCapacity(new_decl);
	1840	const new_decl = try self.createNewDecl(&container_scope.base, name, decl_i, name_hash, contents_hash);
	1841	container_scope.decls.putAssumeCapacity(new_decl, {});
1806	1842	if (fn_proto.getExternExportInlineToken()) \|maybe_export_token\| {
1807	1843	if (tree.token_ids[maybe_export_token] == .Keyword_export) {
1808	1844	self.work_queue.writeItemAssumeCapacity(.{ .analyze_decl = new_decl });
...	...	@@ -1812,7 +1848,7 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1812	1848	} else if (src_decl.castTag(.VarDecl)) \|var_decl\| {
1813	1849	const name_loc = tree.token_locs[var_decl.name_token];
1814	1850	const name = tree.tokenSliceLoc(name_loc);
1815		const name_hash = root_scope.fullyQualifiedNameHash(name);
	1851	const name_hash = container_scope.fullyQualifiedNameHash(name);
1816	1852	const contents_hash = std.zig.hashSrc(tree.getNodeSource(src_decl));
1817	1853	if (self.decl_table.get(name_hash)) \|decl\| {
1818	1854	// Update the AST Node index of the decl, even if its contents are unchanged, it may
...	...	@@ -1828,8 +1864,8 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1828	1864	decl.contents_hash = contents_hash;
1829	1865	}
1830	1866	} else {
1831		const new_decl = try self.createNewDecl(&root_scope.base, name, decl_i, name_hash, contents_hash);
1832		root_scope.decls.appendAssumeCapacity(new_decl);
	1867	const new_decl = try self.createNewDecl(&container_scope.base, name, decl_i, name_hash, contents_hash);
	1868	container_scope.decls.putAssumeCapacity(new_decl, {});
1833	1869	if (var_decl.getExternExportToken()) \|maybe_export_token\| {
1834	1870	if (tree.token_ids[maybe_export_token] == .Keyword_export) {
1835	1871	self.work_queue.writeItemAssumeCapacity(.{ .analyze_decl = new_decl });
...	...	@@ -1841,11 +1877,11 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1841	1877	const name = try std.fmt.allocPrint(self.gpa, "__comptime_{}", .{name_index});
1842	1878	defer self.gpa.free(name);
1843	1879
1844		const name_hash = root_scope.fullyQualifiedNameHash(name);
	1880	const name_hash = container_scope.fullyQualifiedNameHash(name);
1845	1881	const contents_hash = std.zig.hashSrc(tree.getNodeSource(src_decl));
1846	1882
1847		const new_decl = try self.createNewDecl(&root_scope.base, name, decl_i, name_hash, contents_hash);
1848		root_scope.decls.appendAssumeCapacity(new_decl);
	1883	const new_decl = try self.createNewDecl(&container_scope.base, name, decl_i, name_hash, contents_hash);
	1884	container_scope.decls.putAssumeCapacity(new_decl, {});
1849	1885	self.work_queue.writeItemAssumeCapacity(.{ .analyze_decl = new_decl });
1850	1886	} else if (src_decl.castTag(.ContainerField)) \|container_field\| {
1851	1887	log.err("TODO: analyze container field", .{});
...	...	@@ -2047,12 +2083,14 @@ fn allocateNewDecl(
2047	2083	.deletion_flag = false,
2048	2084	.contents_hash = contents_hash,
2049	2085	.link = switch (self.bin_file.tag) {
	2086	.coff => .{ .coff = link.File.Coff.TextBlock.empty },
2050	2087	.elf => .{ .elf = link.File.Elf.TextBlock.empty },
2051	2088	.macho => .{ .macho = link.File.MachO.TextBlock.empty },
2052	2089	.c => .{ .c = {} },
2053	2090	.wasm => .{ .wasm = {} },
2054	2091	},
2055	2092	.fn_link = switch (self.bin_file.tag) {
	2093	.coff => .{ .coff = {} },
2056	2094	.elf => .{ .elf = link.File.Elf.SrcFn.empty },
2057	2095	.macho => .{ .macho = link.File.MachO.SrcFn.empty },
2058	2096	.c => .{ .c = {} },
...	...	@@ -2591,6 +2629,72 @@ pub fn analyzeIsErr(self: Module, scope: Scope, src: usize, operand: *Inst) In
2591	2629	return self.fail(scope, src, "TODO implement analysis of iserr", .{});
2592	2630	}
2593	2631
	2632	pub fn analyzeSlice(self: Module, scope: Scope, src: usize, array_ptr: Inst, start: Inst, end_opt: ?Inst, sentinel_opt: ?Inst) InnerError!*Inst {
	2633	const ptr_child = switch (array_ptr.ty.zigTypeTag()) {
	2634	.Pointer => array_ptr.ty.elemType(),
	2635	else => return self.fail(scope, src, "expected pointer, found '{}'", .{array_ptr.ty}),
	2636	};
	2637
	2638	var array_type = ptr_child;
	2639	const elem_type = switch (ptr_child.zigTypeTag()) {
	2640	.Array => ptr_child.elemType(),
	2641	.Pointer => blk: {
	2642	if (ptr_child.isSinglePointer()) {
	2643	if (ptr_child.elemType().zigTypeTag() == .Array) {
	2644	array_type = ptr_child.elemType();
	2645	break :blk ptr_child.elemType().elemType();
	2646	}
	2647
	2648	return self.fail(scope, src, "slice of single-item pointer", .{});
	2649	}
	2650	break :blk ptr_child.elemType();
	2651	},
	2652	else => return self.fail(scope, src, "slice of non-array type '{}'", .{ptr_child}),
	2653	};
	2654
	2655	const slice_sentinel = if (sentinel_opt) \|sentinel\| blk: {
	2656	const casted = try self.coerce(scope, elem_type, sentinel);
	2657	break :blk try self.resolveConstValue(scope, casted);
	2658	} else null;
	2659
	2660	var return_ptr_size: std.builtin.TypeInfo.Pointer.Size = .Slice;
	2661	var return_elem_type = elem_type;
	2662	if (end_opt) \|end\| {
	2663	if (end.value()) \|end_val\| {
	2664	if (start.value()) \|start_val\| {
	2665	const start_u64 = start_val.toUnsignedInt();
	2666	const end_u64 = end_val.toUnsignedInt();
	2667	if (start_u64 > end_u64) {
	2668	return self.fail(scope, src, "out of bounds slice", .{});
	2669	}
	2670
	2671	const len = end_u64 - start_u64;
	2672	const array_sentinel = if (array_type.zigTypeTag() == .Array and end_u64 == array_type.arrayLen())
	2673	array_type.sentinel()
	2674	else
	2675	slice_sentinel;
	2676	return_elem_type = try self.arrayType(scope, len, array_sentinel, elem_type);
	2677	return_ptr_size = .One;
	2678	}
	2679	}
	2680	}
	2681	const return_type = try self.ptrType(
	2682	scope,
	2683	src,
	2684	return_elem_type,
	2685	if (end_opt == null) slice_sentinel else null,
	2686	0, // TODO alignment
	2687	0,
	2688	0,
	2689	!ptr_child.isConstPtr(),
	2690	ptr_child.isAllowzeroPtr(),
	2691	ptr_child.isVolatilePtr(),
	2692	return_ptr_size,
	2693	);
	2694
	2695	return self.fail(scope, src, "TODO implement analysis of slice", .{});
	2696	}
	2697
2594	2698	/// Asserts that lhs and rhs types are both numeric.
2595	2699	pub fn cmpNumeric(
2596	2700	self: *Module,
...	...	@@ -2801,6 +2905,12 @@ pub fn resolvePeerTypes(self: Module, scope: Scope, instructions: []*Inst) !Ty
2801	2905	prev_inst = next_inst;
2802	2906	continue;
2803	2907	}
	2908	if (next_inst.ty.zigTypeTag() == .Undefined)
	2909	continue;
	2910	if (prev_inst.ty.zigTypeTag() == .Undefined) {
	2911	prev_inst = next_inst;
	2912	continue;
	2913	}
2804	2914	if (prev_inst.ty.isInt() and
2805	2915	next_inst.ty.isInt() and
2806	2916	prev_inst.ty.isSignedInt() == next_inst.ty.isSignedInt())
...	...	@@ -3052,6 +3162,7 @@ fn failWithOwnedErrorMsg(self: Module, scope: Scope, src: usize, err_msg: *Err
3052	3162	self.failed_files.putAssumeCapacityNoClobber(scope, err_msg);
3053	3163	},
3054	3164	.file => unreachable,
	3165	.container => unreachable,
3055	3166	}
3056	3167	return error.AnalysisFail;
3057	3168	}

src-self-hosted/astgen.zig+74-26

...	...	@@ -275,16 +275,16 @@ pub fn expr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node) InnerEr
275	275	.ErrorType => return rlWrap(mod, scope, rl, try errorType(mod, scope, node.castTag(.ErrorType).?)),
276	276	.For => return forExpr(mod, scope, rl, node.castTag(.For).?),
277	277	.ArrayAccess => return arrayAccess(mod, scope, rl, node.castTag(.ArrayAccess).?),
	278	.Slice => return rlWrap(mod, scope, rl, try sliceExpr(mod, scope, node.castTag(.Slice).?)),
278	279	.Catch => return catchExpr(mod, scope, rl, node.castTag(.Catch).?),
279	280	.Comptime => return comptimeKeyword(mod, scope, rl, node.castTag(.Comptime).?),
	281	.OrElse => return orelseExpr(mod, scope, rl, node.castTag(.OrElse).?),
280	282
281	283	.Defer => return mod.failNode(scope, node, "TODO implement astgen.expr for .Defer", .{}),
282	284	.Range => return mod.failNode(scope, node, "TODO implement astgen.expr for .Range", .{}),
283		.OrElse => return mod.failNode(scope, node, "TODO implement astgen.expr for .OrElse", .{}),
284	285	.Await => return mod.failNode(scope, node, "TODO implement astgen.expr for .Await", .{}),
285	286	.Resume => return mod.failNode(scope, node, "TODO implement astgen.expr for .Resume", .{}),
286	287	.Try => return mod.failNode(scope, node, "TODO implement astgen.expr for .Try", .{}),
287		.Slice => return mod.failNode(scope, node, "TODO implement astgen.expr for .Slice", .{}),
288	288	.ArrayInitializer => return mod.failNode(scope, node, "TODO implement astgen.expr for .ArrayInitializer", .{}),
289	289	.ArrayInitializerDot => return mod.failNode(scope, node, "TODO implement astgen.expr for .ArrayInitializerDot", .{}),
290	290	.StructInitializer => return mod.failNode(scope, node, "TODO implement astgen.expr for .StructInitializer", .{}),
...	...	@@ -790,13 +790,31 @@ fn errorType(mod: Module, scope: Scope, node: ast.Node.OneToken) InnerError!
790	790	}
791	791
792	792	fn catchExpr(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node.Catch) InnerError!zir.Inst {
	793	return orelseCatchExpr(mod, scope, rl, node.lhs, node.op_token, .iserr, .unwrap_err_unsafe, node.rhs, node.payload);
	794	}
	795
	796	fn orelseExpr(mod: Module, scope: Scope, rl: ResultLoc, node: ast.Node.SimpleInfixOp) InnerError!zir.Inst {
	797	return orelseCatchExpr(mod, scope, rl, node.lhs, node.op_token, .isnull, .unwrap_optional_unsafe, node.rhs, null);
	798	}
	799
	800	fn orelseCatchExpr(
	801	mod: *Module,
	802	scope: *Scope,
	803	rl: ResultLoc,
	804	lhs: *ast.Node,
	805	op_token: ast.TokenIndex,
	806	cond_op: zir.Inst.Tag,
	807	unwrap_op: zir.Inst.Tag,
	808	rhs: *ast.Node,
	809	payload_node: ?*ast.Node,
	810	) InnerError!*zir.Inst {
793	811	const tree = scope.tree();
794		const src = tree.token_locs[node.op_token].start;
	812	const src = tree.token_locs[op_token].start;
795	813
796		const err_union_ptr = try expr(mod, scope, .ref, node.lhs);
797		// TODO we could avoid an unnecessary copy if .iserr took a pointer
798		const err_union = try addZIRUnOp(mod, scope, src, .deref, err_union_ptr);
799		const cond = try addZIRUnOp(mod, scope, src, .iserr, err_union);
	814	const operand_ptr = try expr(mod, scope, .ref, lhs);
	815	// TODO we could avoid an unnecessary copy if .iserr, .isnull took a pointer
	816	const err_union = try addZIRUnOp(mod, scope, src, .deref, operand_ptr);
	817	const cond = try addZIRUnOp(mod, scope, src, cond_op, err_union);
800	818
801	819	var block_scope: Scope.GenZIR = .{
802	820	.parent = scope,
...	...	@@ -825,55 +843,55 @@ fn catchExpr(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Catch)
825	843	.inferred_ptr, .bitcasted_ptr, .block_ptr => .{ .block_ptr = block },
826	844	};
827	845
828		var err_scope: Scope.GenZIR = .{
	846	var then_scope: Scope.GenZIR = .{
829	847	.parent = scope,
830	848	.decl = block_scope.decl,
831	849	.arena = block_scope.arena,
832	850	.instructions = .{},
833	851	};
834		defer err_scope.instructions.deinit(mod.gpa);
	852	defer then_scope.instructions.deinit(mod.gpa);
835	853
836	854	var err_val_scope: Scope.LocalVal = undefined;
837		const err_sub_scope = blk: {
838		const payload = node.payload orelse
839		break :blk &err_scope.base;
	855	const then_sub_scope = blk: {
	856	const payload = payload_node orelse
	857	break :blk &then_scope.base;
840	858
841	859	const err_name = tree.tokenSlice(payload.castTag(.Payload).?.error_symbol.firstToken());
842	860	if (mem.eql(u8, err_name, "_"))
843		break :blk &err_scope.base;
	861	break :blk &then_scope.base;
844	862
845		const unwrapped_err_ptr = try addZIRUnOp(mod, &err_scope.base, src, .unwrap_err_code, err_union_ptr);
	863	const unwrapped_err_ptr = try addZIRUnOp(mod, &then_scope.base, src, .unwrap_err_code, operand_ptr);
846	864	err_val_scope = .{
847		.parent = &err_scope.base,
848		.gen_zir = &err_scope,
	865	.parent = &then_scope.base,
	866	.gen_zir = &then_scope,
849	867	.name = err_name,
850		.inst = try addZIRUnOp(mod, &err_scope.base, src, .deref, unwrapped_err_ptr),
	868	.inst = try addZIRUnOp(mod, &then_scope.base, src, .deref, unwrapped_err_ptr),
851	869	};
852	870	break :blk &err_val_scope.base;
853	871	};
854	872
855		_ = try addZIRInst(mod, &err_scope.base, src, zir.Inst.Break, .{
	873	_ = try addZIRInst(mod, &then_scope.base, src, zir.Inst.Break, .{
856	874	.block = block,
857		.operand = try expr(mod, err_sub_scope, branch_rl, node.rhs),
	875	.operand = try expr(mod, then_sub_scope, branch_rl, rhs),
858	876	}, .{});
859	877
860		var not_err_scope: Scope.GenZIR = .{
	878	var else_scope: Scope.GenZIR = .{
861	879	.parent = scope,
862	880	.decl = block_scope.decl,
863	881	.arena = block_scope.arena,
864	882	.instructions = .{},
865	883	};
866		defer not_err_scope.instructions.deinit(mod.gpa);
	884	defer else_scope.instructions.deinit(mod.gpa);
867	885
868		const unwrapped_payload = try addZIRUnOp(mod, &not_err_scope.base, src, .unwrap_err_unsafe, err_union_ptr);
869		_ = try addZIRInst(mod, &not_err_scope.base, src, zir.Inst.Break, .{
	886	const unwrapped_payload = try addZIRUnOp(mod, &else_scope.base, src, unwrap_op, operand_ptr);
	887	_ = try addZIRInst(mod, &else_scope.base, src, zir.Inst.Break, .{
870	888	.block = block,
871	889	.operand = unwrapped_payload,
872	890	}, .{});
873	891
874		condbr.positionals.then_body = .{ .instructions = try err_scope.arena.dupe(*zir.Inst, err_scope.instructions.items) };
875		condbr.positionals.else_body = .{ .instructions = try not_err_scope.arena.dupe(*zir.Inst, not_err_scope.instructions.items) };
876		return rlWrap(mod, scope, rl, &block.base);
	892	condbr.positionals.then_body = .{ .instructions = try then_scope.arena.dupe(*zir.Inst, then_scope.instructions.items) };
	893	condbr.positionals.else_body = .{ .instructions = try else_scope.arena.dupe(*zir.Inst, else_scope.instructions.items) };
	894	return rlWrapPtr(mod, scope, rl, &block.base);
877	895	}
878	896
879	897	/// Return whether the identifier names of two tokens are equal. Resolves @"" tokens without allocating.
...	...	@@ -933,6 +951,36 @@ fn arrayAccess(mod: Module, scope: Scope, rl: ResultLoc, node: *ast.Node.Array
933	951	return rlWrapPtr(mod, scope, rl, try addZIRInst(mod, scope, src, zir.Inst.ElemPtr, .{ .array_ptr = array_ptr, .index = index }, .{}));
934	952	}
935	953
	954	fn sliceExpr(mod: Module, scope: Scope, node: ast.Node.Slice) InnerError!zir.Inst {
	955	const tree = scope.tree();
	956	const src = tree.token_locs[node.rtoken].start;
	957
	958	const usize_type = try addZIRInstConst(mod, scope, src, .{
	959	.ty = Type.initTag(.type),
	960	.val = Value.initTag(.usize_type),
	961	});
	962
	963	const array_ptr = try expr(mod, scope, .ref, node.lhs);
	964	const start = try expr(mod, scope, .{ .ty = usize_type }, node.start);
	965
	966	if (node.end == null and node.sentinel == null) {
	967	return try addZIRBinOp(mod, scope, src, .slice_start, array_ptr, start);
	968	}
	969
	970	const end = if (node.end) \|end\| try expr(mod, scope, .{ .ty = usize_type }, end) else null;
	971	// we could get the child type here, but it is easier to just do it in semantic analysis.
	972	const sentinel = if (node.sentinel) \|sentinel\| try expr(mod, scope, .none, sentinel) else null;
	973
	974	return try addZIRInst(
	975	mod,
	976	scope,
	977	src,
	978	zir.Inst.Slice,
	979	.{ .array_ptr = array_ptr, .start = start },
	980	.{ .end = end, .sentinel = sentinel },
	981	);
	982	}
	983
936	984	fn deref(mod: Module, scope: Scope, node: ast.Node.SimpleSuffixOp) InnerError!zir.Inst {
937	985	const tree = scope.tree();
938	986	const src = tree.token_locs[node.rtoken].start;

src-self-hosted/codegen.zig+225-116

...	...	@@ -59,14 +59,21 @@ pub const GenerateSymbolError = error{
59	59	AnalysisFail,
60	60	};
61	61
	62	pub const DebugInfoOutput = union(enum) {
	63	dwarf: struct {
	64	dbg_line: *std.ArrayList(u8),
	65	dbg_info: *std.ArrayList(u8),
	66	dbg_info_type_relocs: *link.File.DbgInfoTypeRelocsTable,
	67	},
	68	none,
	69	};
	70
62	71	pub fn generateSymbol(
63	72	bin_file: *link.File,
64	73	src: usize,
65	74	typed_value: TypedValue,
66	75	code: *std.ArrayList(u8),
67		dbg_line: *std.ArrayList(u8),
68		dbg_info: *std.ArrayList(u8),
69		dbg_info_type_relocs: *link.File.DbgInfoTypeRelocsTable,
	76	debug_output: DebugInfoOutput,
70	77	) GenerateSymbolError!Result {
71	78	const tracy = trace(@src());
72	79	defer tracy.end();
...	...	@@ -76,70 +83,70 @@ pub fn generateSymbol(
76	83	switch (bin_file.options.target.cpu.arch) {
77	84	.wasm32 => unreachable, // has its own code path
78	85	.wasm64 => unreachable, // has its own code path
79		.arm => return Function(.arm).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
80		.armeb => return Function(.armeb).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
81		//.aarch64 => return Function(.aarch64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
82		//.aarch64_be => return Function(.aarch64_be).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
83		//.aarch64_32 => return Function(.aarch64_32).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
84		//.arc => return Function(.arc).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
85		//.avr => return Function(.avr).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
86		//.bpfel => return Function(.bpfel).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
87		//.bpfeb => return Function(.bpfeb).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
88		//.hexagon => return Function(.hexagon).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
89		//.mips => return Function(.mips).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
90		//.mipsel => return Function(.mipsel).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
91		//.mips64 => return Function(.mips64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
92		//.mips64el => return Function(.mips64el).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
93		//.msp430 => return Function(.msp430).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
94		//.powerpc => return Function(.powerpc).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
95		//.powerpc64 => return Function(.powerpc64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
96		//.powerpc64le => return Function(.powerpc64le).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
97		//.r600 => return Function(.r600).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
98		//.amdgcn => return Function(.amdgcn).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
99		//.riscv32 => return Function(.riscv32).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
100		.riscv64 => return Function(.riscv64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
101		//.sparc => return Function(.sparc).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
102		//.sparcv9 => return Function(.sparcv9).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
103		//.sparcel => return Function(.sparcel).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
104		//.s390x => return Function(.s390x).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
105		.spu_2 => return Function(.spu_2).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
106		//.tce => return Function(.tce).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
107		//.tcele => return Function(.tcele).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
108		//.thumb => return Function(.thumb).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
109		//.thumbeb => return Function(.thumbeb).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
110		//.i386 => return Function(.i386).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
111		.x86_64 => return Function(.x86_64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
112		//.xcore => return Function(.xcore).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
113		//.nvptx => return Function(.nvptx).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
114		//.nvptx64 => return Function(.nvptx64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
115		//.le32 => return Function(.le32).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
116		//.le64 => return Function(.le64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
117		//.amdil => return Function(.amdil).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
118		//.amdil64 => return Function(.amdil64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
119		//.hsail => return Function(.hsail).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
120		//.hsail64 => return Function(.hsail64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
121		//.spir => return Function(.spir).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
122		//.spir64 => return Function(.spir64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
123		//.kalimba => return Function(.kalimba).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
124		//.shave => return Function(.shave).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
125		//.lanai => return Function(.lanai).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
126		//.renderscript32 => return Function(.renderscript32).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
127		//.renderscript64 => return Function(.renderscript64).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
128		//.ve => return Function(.ve).generateSymbol(bin_file, src, typed_value, code, dbg_line, dbg_info, dbg_info_type_relocs),
	86	.arm => return Function(.arm).generateSymbol(bin_file, src, typed_value, code, debug_output),
	87	.armeb => return Function(.armeb).generateSymbol(bin_file, src, typed_value, code, debug_output),
	88	//.aarch64 => return Function(.aarch64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	89	//.aarch64_be => return Function(.aarch64_be).generateSymbol(bin_file, src, typed_value, code, debug_output),
	90	//.aarch64_32 => return Function(.aarch64_32).generateSymbol(bin_file, src, typed_value, code, debug_output),
	91	//.arc => return Function(.arc).generateSymbol(bin_file, src, typed_value, code, debug_output),
	92	//.avr => return Function(.avr).generateSymbol(bin_file, src, typed_value, code, debug_output),
	93	//.bpfel => return Function(.bpfel).generateSymbol(bin_file, src, typed_value, code, debug_output),
	94	//.bpfeb => return Function(.bpfeb).generateSymbol(bin_file, src, typed_value, code, debug_output),
	95	//.hexagon => return Function(.hexagon).generateSymbol(bin_file, src, typed_value, code, debug_output),
	96	//.mips => return Function(.mips).generateSymbol(bin_file, src, typed_value, code, debug_output),
	97	//.mipsel => return Function(.mipsel).generateSymbol(bin_file, src, typed_value, code, debug_output),
	98	//.mips64 => return Function(.mips64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	99	//.mips64el => return Function(.mips64el).generateSymbol(bin_file, src, typed_value, code, debug_output),
	100	//.msp430 => return Function(.msp430).generateSymbol(bin_file, src, typed_value, code, debug_output),
	101	//.powerpc => return Function(.powerpc).generateSymbol(bin_file, src, typed_value, code, debug_output),
	102	//.powerpc64 => return Function(.powerpc64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	103	//.powerpc64le => return Function(.powerpc64le).generateSymbol(bin_file, src, typed_value, code, debug_output),
	104	//.r600 => return Function(.r600).generateSymbol(bin_file, src, typed_value, code, debug_output),
	105	//.amdgcn => return Function(.amdgcn).generateSymbol(bin_file, src, typed_value, code, debug_output),
	106	//.riscv32 => return Function(.riscv32).generateSymbol(bin_file, src, typed_value, code, debug_output),
	107	.riscv64 => return Function(.riscv64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	108	//.sparc => return Function(.sparc).generateSymbol(bin_file, src, typed_value, code, debug_output),
	109	//.sparcv9 => return Function(.sparcv9).generateSymbol(bin_file, src, typed_value, code, debug_output),
	110	//.sparcel => return Function(.sparcel).generateSymbol(bin_file, src, typed_value, code, debug_output),
	111	//.s390x => return Function(.s390x).generateSymbol(bin_file, src, typed_value, code, debug_output),
	112	.spu_2 => return Function(.spu_2).generateSymbol(bin_file, src, typed_value, code, debug_output),
	113	//.tce => return Function(.tce).generateSymbol(bin_file, src, typed_value, code, debug_output),
	114	//.tcele => return Function(.tcele).generateSymbol(bin_file, src, typed_value, code, debug_output),
	115	//.thumb => return Function(.thumb).generateSymbol(bin_file, src, typed_value, code, debug_output),
	116	//.thumbeb => return Function(.thumbeb).generateSymbol(bin_file, src, typed_value, code, debug_output),
	117	//.i386 => return Function(.i386).generateSymbol(bin_file, src, typed_value, code, debug_output),
	118	.x86_64 => return Function(.x86_64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	119	//.xcore => return Function(.xcore).generateSymbol(bin_file, src, typed_value, code, debug_output),
	120	//.nvptx => return Function(.nvptx).generateSymbol(bin_file, src, typed_value, code, debug_output),
	121	//.nvptx64 => return Function(.nvptx64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	122	//.le32 => return Function(.le32).generateSymbol(bin_file, src, typed_value, code, debug_output),
	123	//.le64 => return Function(.le64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	124	//.amdil => return Function(.amdil).generateSymbol(bin_file, src, typed_value, code, debug_output),
	125	//.amdil64 => return Function(.amdil64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	126	//.hsail => return Function(.hsail).generateSymbol(bin_file, src, typed_value, code, debug_output),
	127	//.hsail64 => return Function(.hsail64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	128	//.spir => return Function(.spir).generateSymbol(bin_file, src, typed_value, code, debug_output),
	129	//.spir64 => return Function(.spir64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	130	//.kalimba => return Function(.kalimba).generateSymbol(bin_file, src, typed_value, code, debug_output),
	131	//.shave => return Function(.shave).generateSymbol(bin_file, src, typed_value, code, debug_output),
	132	//.lanai => return Function(.lanai).generateSymbol(bin_file, src, typed_value, code, debug_output),
	133	//.renderscript32 => return Function(.renderscript32).generateSymbol(bin_file, src, typed_value, code, debug_output),
	134	//.renderscript64 => return Function(.renderscript64).generateSymbol(bin_file, src, typed_value, code, debug_output),
	135	//.ve => return Function(.ve).generateSymbol(bin_file, src, typed_value, code, debug_output),
129	136	else => @panic("Backend architectures that don't have good support yet are commented out, to improve compilation performance. If you are interested in one of these other backends feel free to uncomment them. Eventually these will be completed, but stage1 is slow and a memory hog."),
130	137	}
131	138	},
132	139	.Array => {
133	140	// TODO populate .debug_info for the array
134	141	if (typed_value.val.cast(Value.Payload.Bytes)) \|payload\| {
135		if (typed_value.ty.arraySentinel()) \|sentinel\| {
	142	if (typed_value.ty.sentinel()) \|sentinel\| {
136	143	try code.ensureCapacity(code.items.len + payload.data.len + 1);
137	144	code.appendSliceAssumeCapacity(payload.data);
138	145	const prev_len = code.items.len;
139	146	switch (try generateSymbol(bin_file, src, .{
140	147	.ty = typed_value.ty.elemType(),
141	148	.val = sentinel,
142		}, code, dbg_line, dbg_info, dbg_info_type_relocs)) {
	149	}, code, debug_output)) {
143	150	.appended => return Result{ .appended = {} },
144	151	.externally_managed => \|slice\| {
145	152	code.appendSliceAssumeCapacity(slice);
...	...	@@ -239,9 +246,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
239	246	target: *const std.Target,
240	247	mod_fn: *const Module.Fn,
241	248	code: *std.ArrayList(u8),
242		dbg_line: *std.ArrayList(u8),
243		dbg_info: *std.ArrayList(u8),
244		dbg_info_type_relocs: *link.File.DbgInfoTypeRelocsTable,
	249	debug_output: DebugInfoOutput,
245	250	err_msg: ?*ErrorMsg,
246	251	args: []MCValue,
247	252	ret_mcv: MCValue,
...	...	@@ -419,9 +424,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
419	424	src: usize,
420	425	typed_value: TypedValue,
421	426	code: *std.ArrayList(u8),
422		dbg_line: *std.ArrayList(u8),
423		dbg_info: *std.ArrayList(u8),
424		dbg_info_type_relocs: *link.File.DbgInfoTypeRelocsTable,
	427	debug_output: DebugInfoOutput,
425	428	) GenerateSymbolError!Result {
426	429	const module_fn = typed_value.val.cast(Value.Payload.Function).?.func;
427	430
...	...	@@ -436,8 +439,8 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
436	439	try branch_stack.append(.{});
437	440
438	441	const src_data: struct {lbrace_src: usize, rbrace_src: usize, source: []const u8} = blk: {
439		if (module_fn.owner_decl.scope.cast(Module.Scope.File)) \|scope_file\| {
440		const tree = scope_file.contents.tree;
	442	if (module_fn.owner_decl.scope.cast(Module.Scope.Container)) \|container_scope\| {
	443	const tree = container_scope.file_scope.contents.tree;
441	444	const fn_proto = tree.root_node.decls()[module_fn.owner_decl.src_index].castTag(.FnProto).?;
442	445	const block = fn_proto.getBodyNode().?.castTag(.Block).?;
443	446	const lbrace_src = tree.token_locs[block.lbrace].start;
...	...	@@ -457,9 +460,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
457	460	.bin_file = bin_file,
458	461	.mod_fn = module_fn,
459	462	.code = code,
460		.dbg_line = dbg_line,
461		.dbg_info = dbg_info,
462		.dbg_info_type_relocs = dbg_info_type_relocs,
	463	.debug_output = debug_output,
463	464	.err_msg = null,
464	465	.args = undefined, // populated after `resolveCallingConventionValues`
465	466	.ret_mcv = undefined, // populated after `resolveCallingConventionValues`
...	...	@@ -598,35 +599,50 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
598	599	}
599	600
600	601	fn dbgSetPrologueEnd(self: *Self) InnerError!void {
601		try self.dbg_line.append(DW.LNS_set_prologue_end);
602		try self.dbgAdvancePCAndLine(self.prev_di_src);
	602	switch (self.debug_output) {
	603	.dwarf => \|dbg_out\| {
	604	try dbg_out.dbg_line.append(DW.LNS_set_prologue_end);
	605	try self.dbgAdvancePCAndLine(self.prev_di_src);
	606	},
	607	.none => {},
	608	}
603	609	}
604	610
605	611	fn dbgSetEpilogueBegin(self: *Self) InnerError!void {
606		try self.dbg_line.append(DW.LNS_set_epilogue_begin);
607		try self.dbgAdvancePCAndLine(self.prev_di_src);
	612	switch (self.debug_output) {
	613	.dwarf => \|dbg_out\| {
	614	try dbg_out.dbg_line.append(DW.LNS_set_epilogue_begin);
	615	try self.dbgAdvancePCAndLine(self.prev_di_src);
	616	},
	617	.none => {},
	618	}
608	619	}
609	620
610	621	fn dbgAdvancePCAndLine(self: *Self, src: usize) InnerError!void {
611		// TODO Look into improving the performance here by adding a token-index-to-line
612		// lookup table, and changing ir.Inst from storing byte offset to token. Currently
613		// this involves scanning over the source code for newlines
614		// (but only from the previous byte offset to the new one).
615		const delta_line = std.zig.lineDelta(self.source, self.prev_di_src, src);
616		const delta_pc = self.code.items.len - self.prev_di_pc;
617	622	self.prev_di_src = src;
618	623	self.prev_di_pc = self.code.items.len;
619		// TODO Look into using the DWARF special opcodes to compress this data. It lets you emit
620		// single-byte opcodes that add different numbers to both the PC and the line number
621		// at the same time.
622		try self.dbg_line.ensureCapacity(self.dbg_line.items.len + 11);
623		self.dbg_line.appendAssumeCapacity(DW.LNS_advance_pc);
624		leb128.writeULEB128(self.dbg_line.writer(), delta_pc) catch unreachable;
625		if (delta_line != 0) {
626		self.dbg_line.appendAssumeCapacity(DW.LNS_advance_line);
627		leb128.writeILEB128(self.dbg_line.writer(), delta_line) catch unreachable;
	624	switch (self.debug_output) {
	625	.dwarf => \|dbg_out\| {
	626	// TODO Look into improving the performance here by adding a token-index-to-line
	627	// lookup table, and changing ir.Inst from storing byte offset to token. Currently
	628	// this involves scanning over the source code for newlines
	629	// (but only from the previous byte offset to the new one).
	630	const delta_line = std.zig.lineDelta(self.source, self.prev_di_src, src);
	631	const delta_pc = self.code.items.len - self.prev_di_pc;
	632	// TODO Look into using the DWARF special opcodes to compress this data. It lets you emit
	633	// single-byte opcodes that add different numbers to both the PC and the line number
	634	// at the same time.
	635	try dbg_out.dbg_line.ensureCapacity(dbg_out.dbg_line.items.len + 11);
	636	dbg_out.dbg_line.appendAssumeCapacity(DW.LNS_advance_pc);
	637	leb128.writeULEB128(dbg_out.dbg_line.writer(), delta_pc) catch unreachable;
	638	if (delta_line != 0) {
	639	dbg_out.dbg_line.appendAssumeCapacity(DW.LNS_advance_line);
	640	leb128.writeILEB128(dbg_out.dbg_line.writer(), delta_line) catch unreachable;
	641	}
	642	dbg_out.dbg_line.appendAssumeCapacity(DW.LNS_copy);
	643	},
	644	.none => {},
628	645	}
629		self.dbg_line.appendAssumeCapacity(DW.LNS_copy);
630	646	}
631	647
632	648	/// Asserts there is already capacity to insert into top branch inst_table.
...	...	@@ -654,18 +670,23 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
654	670	/// Adds a Type to the .debug_info at the current position. The bytes will be populated later,
655	671	/// after codegen for this symbol is done.
656	672	fn addDbgInfoTypeReloc(self: *Self, ty: Type) !void {
657		assert(ty.hasCodeGenBits());
658		const index = self.dbg_info.items.len;
659		try self.dbg_info.resize(index + 4); // DW.AT_type, DW.FORM_ref4
660
661		const gop = try self.dbg_info_type_relocs.getOrPut(self.gpa, ty);
662		if (!gop.found_existing) {
663		gop.entry.value = .{
664		.off = undefined,
665		.relocs = .{},
666		};
	673	switch (self.debug_output) {
	674	.dwarf => \|dbg_out\| {
	675	assert(ty.hasCodeGenBits());
	676	const index = dbg_out.dbg_info.items.len;
	677	try dbg_out.dbg_info.resize(index + 4); // DW.AT_type, DW.FORM_ref4
	678
	679	const gop = try dbg_out.dbg_info_type_relocs.getOrPut(self.gpa, ty);
	680	if (!gop.found_existing) {
	681	gop.entry.value = .{
	682	.off = undefined,
	683	.relocs = .{},
	684	};
	685	}
	686	try gop.entry.value.relocs.append(self.gpa, @intCast(u32, index));
	687	},
	688	.none => {},
667	689	}
668		try gop.entry.value.relocs.append(self.gpa, @intCast(u32, index));
669	690	}
670	691
671	692	fn genFuncInst(self: Self, inst: ir.Inst) !MCValue {
...	...	@@ -1258,14 +1279,19 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1258	1279	self.registers.putAssumeCapacityNoClobber(toCanonicalReg(reg), &inst.base);
1259	1280	self.markRegUsed(reg);
1260	1281
1261		try self.dbg_info.ensureCapacity(self.dbg_info.items.len + 8 + name_with_null.len);
1262		self.dbg_info.appendAssumeCapacity(link.File.Elf.abbrev_parameter);
1263		self.dbg_info.appendSliceAssumeCapacity(&[2]u8{ // DW.AT_location, DW.FORM_exprloc
1264		1, // ULEB128 dwarf expression length
1265		reg.dwarfLocOp(),
1266		});
1267		try self.addDbgInfoTypeReloc(inst.base.ty); // DW.AT_type, DW.FORM_ref4
1268		self.dbg_info.appendSliceAssumeCapacity(name_with_null); // DW.AT_name, DW.FORM_string
	1282	switch (self.debug_output) {
	1283	.dwarf => \|dbg_out\| {
	1284	try dbg_out.dbg_info.ensureCapacity(dbg_out.dbg_info.items.len + 8 + name_with_null.len);
	1285	dbg_out.dbg_info.appendAssumeCapacity(link.File.Elf.abbrev_parameter);
	1286	dbg_out.dbg_info.appendSliceAssumeCapacity(&[2]u8{ // DW.AT_location, DW.FORM_exprloc
	1287	1, // ULEB128 dwarf expression length
	1288	reg.dwarfLocOp(),
	1289	});
	1290	try self.addDbgInfoTypeReloc(inst.base.ty); // DW.AT_type, DW.FORM_ref4
	1291	dbg_out.dbg_info.appendSliceAssumeCapacity(name_with_null); // DW.AT_name, DW.FORM_string
	1292	},
	1293	.none => {},
	1294	}
1269	1295	},
1270	1296	else => {},
1271	1297	}
...	...	@@ -1302,7 +1328,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1302	1328
1303	1329	// Due to incremental compilation, how function calls are generated depends
1304	1330	// on linking.
1305		if (self.bin_file.cast(link.File.Elf)) \|elf_file\| {
	1331	if (self.bin_file.tag == link.File.Elf.base_tag or self.bin_file.tag == link.File.Coff.base_tag) {
1306	1332	switch (arch) {
1307	1333	.x86_64 => {
1308	1334	for (info.args) \|mc_arg, arg_i\| {
...	...	@@ -1341,10 +1367,17 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1341	1367	if (inst.func.cast(ir.Inst.Constant)) \|func_inst\| {
1342	1368	if (func_inst.val.cast(Value.Payload.Function)) \|func_val\| {
1343	1369	const func = func_val.func;
1344		const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
	1370
1345	1371	const ptr_bits = self.target.cpu.arch.ptrBitWidth();
1346	1372	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
1347		const got_addr = @intCast(u32, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * ptr_bytes);
	1373	const got_addr = if (self.bin_file.cast(link.File.Elf)) \|elf_file\| blk: {
	1374	const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
	1375	break :blk @intCast(u32, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * ptr_bytes);
	1376	} else if (self.bin_file.cast(link.File.Coff)) \|coff_file\|
	1377	@intCast(u32, coff_file.offset_table_virtual_address + func.owner_decl.link.coff.offset_table_index * ptr_bytes)
	1378	else
	1379	unreachable;
	1380
1348	1381	// ff 14 25 xx xx xx xx call [addr]
1349	1382	try self.code.ensureCapacity(self.code.items.len + 7);
1350	1383	self.code.appendSliceAssumeCapacity(&[3]u8{ 0xff, 0x14, 0x25 });
...	...	@@ -1362,10 +1395,16 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1362	1395	if (inst.func.cast(ir.Inst.Constant)) \|func_inst\| {
1363	1396	if (func_inst.val.cast(Value.Payload.Function)) \|func_val\| {
1364	1397	const func = func_val.func;
1365		const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
	1398
1366	1399	const ptr_bits = self.target.cpu.arch.ptrBitWidth();
1367	1400	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
1368		const got_addr = @intCast(u32, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * ptr_bytes);
	1401	const got_addr = if (self.bin_file.cast(link.File.Elf)) \|elf_file\| blk: {
	1402	const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
	1403	break :blk @intCast(u32, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * ptr_bytes);
	1404	} else if (self.bin_file.cast(link.File.Coff)) \|coff_file\|
	1405	coff_file.offset_table_virtual_address + func.owner_decl.link.coff.offset_table_index * ptr_bytes
	1406	else
	1407	unreachable;
1369	1408
1370	1409	try self.genSetReg(inst.base.src, .ra, .{ .memory = got_addr });
1371	1410	mem.writeIntLittle(u32, try self.code.addManyAsArray(4), Instruction.jalr(.ra, 0, .ra).toU32());
...	...	@@ -1383,8 +1422,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1383	1422	}
1384	1423	if (func_inst.val.cast(Value.Payload.Function)) \|func_val\| {
1385	1424	const func = func_val.func;
1386		const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
1387		const got_addr = @intCast(u16, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * 2);
	1425	const got_addr = if (self.bin_file.cast(link.File.Elf)) \|elf_file\| blk: {
	1426	const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
	1427	break :blk @intCast(u16, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * 2);
	1428	} else if (self.bin_file.cast(link.File.Coff)) \|coff_file\|
	1429	@intCast(u16, coff_file.offset_table_virtual_address + func.owner_decl.link.coff.offset_table_index * 2)
	1430	else
	1431	unreachable;
	1432
1388	1433	const return_type = func.owner_decl.typed_value.most_recent.typed_value.ty.fnReturnType();
1389	1434	// First, push the return address, then jump; if noreturn, don't bother with the first step
1390	1435	// TODO: implement packed struct -> u16 at comptime and move the bitcast here
...	...	@@ -1420,10 +1465,15 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1420	1465	if (inst.func.cast(ir.Inst.Constant)) \|func_inst\| {
1421	1466	if (func_inst.val.cast(Value.Payload.Function)) \|func_val\| {
1422	1467	const func = func_val.func;
1423		const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
1424	1468	const ptr_bits = self.target.cpu.arch.ptrBitWidth();
1425	1469	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
1426		const got_addr = @intCast(u32, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * ptr_bytes);
	1470	const got_addr = if (self.bin_file.cast(link.File.Elf)) \|elf_file\| blk: {
	1471	const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
	1472	break :blk @intCast(u32, got.p_vaddr + func.owner_decl.link.elf.offset_table_index * ptr_bytes);
	1473	} else if (self.bin_file.cast(link.File.Coff)) \|coff_file\|
	1474	coff_file.offset_table_virtual_address + func.owner_decl.link.coff.offset_table_index * ptr_bytes
	1475	else
	1476	unreachable;
1427	1477
1428	1478	// TODO only works with leaf functions
1429	1479	// at the moment, which works fine for
...	...	@@ -1443,7 +1493,57 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1443	1493	}
1444	1494	} else if (self.bin_file.cast(link.File.MachO)) \|macho_file\| {
1445	1495	switch (arch) {
1446		.x86_64 => return self.fail(inst.base.src, "TODO implement codegen for call when linking with MachO for x86_64 arch", .{}),
	1496	.x86_64 => {
	1497	for (info.args) \|mc_arg, arg_i\| {
	1498	const arg = inst.args[arg_i];
	1499	const arg_mcv = try self.resolveInst(inst.args[arg_i]);
	1500	// Here we do not use setRegOrMem even though the logic is similar, because
	1501	// the function call will move the stack pointer, so the offsets are different.
	1502	switch (mc_arg) {
	1503	.none => continue,
	1504	.register => \|reg\| {
	1505	try self.genSetReg(arg.src, reg, arg_mcv);
	1506	// TODO interact with the register allocator to mark the instruction as moved.
	1507	},
	1508	.stack_offset => {
	1509	// Here we need to emit instructions like this:
	1510	// mov qword ptr [rsp + stack_offset], x
	1511	return self.fail(inst.base.src, "TODO implement calling with parameters in memory", .{});
	1512	},
	1513	.ptr_stack_offset => {
	1514	return self.fail(inst.base.src, "TODO implement calling with MCValue.ptr_stack_offset arg", .{});
	1515	},
	1516	.ptr_embedded_in_code => {
	1517	return self.fail(inst.base.src, "TODO implement calling with MCValue.ptr_embedded_in_code arg", .{});
	1518	},
	1519	.undef => unreachable,
	1520	.immediate => unreachable,
	1521	.unreach => unreachable,
	1522	.dead => unreachable,
	1523	.embedded_in_code => unreachable,
	1524	.memory => unreachable,
	1525	.compare_flags_signed => unreachable,
	1526	.compare_flags_unsigned => unreachable,
	1527	}
	1528	}
	1529
	1530	if (inst.func.cast(ir.Inst.Constant)) \|func_inst\| {
	1531	if (func_inst.val.cast(Value.Payload.Function)) \|func_val\| {
	1532	const func = func_val.func;
	1533	const got = &macho_file.sections.items[macho_file.got_section_index.?];
	1534	const ptr_bytes = 8;
	1535	const got_addr = @intCast(u32, got.addr + func.owner_decl.link.macho.offset_table_index.? * ptr_bytes);
	1536	// ff 14 25 xx xx xx xx call [addr]
	1537	try self.code.ensureCapacity(self.code.items.len + 7);
	1538	self.code.appendSliceAssumeCapacity(&[3]u8{ 0xff, 0x14, 0x25 });
	1539	mem.writeIntLittle(u32, self.code.addManyAsArrayAssumeCapacity(4), got_addr);
	1540	} else {
	1541	return self.fail(inst.base.src, "TODO implement calling bitcasted functions", .{});
	1542	}
	1543	} else {
	1544	return self.fail(inst.base.src, "TODO implement calling runtime known function pointer", .{});
	1545	}
	1546	},
1447	1547	.aarch64 => return self.fail(inst.base.src, "TODO implement codegen for call when linking with MachO for aarch64 arch", .{}),
1448	1548	else => unreachable,
1449	1549	}
...	...	@@ -1933,7 +2033,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
1933	2033
1934	2034	if (mem.eql(u8, inst.asm_source, "syscall")) {
1935	2035	try self.code.appendSlice(&[_]u8{ 0x0f, 0x05 });
1936		} else {
	2036	} else if (inst.asm_source.len != 0) {
1937	2037	return self.fail(inst.base.src, "TODO implement support for more x86 assembly instructions", .{});
1938	2038	}
1939	2039
...	...	@@ -2486,6 +2586,15 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
2486	2586	const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
2487	2587	const got_addr = got.p_vaddr + decl.link.elf.offset_table_index * ptr_bytes;
2488	2588	return MCValue{ .memory = got_addr };
	2589	} else if (self.bin_file.cast(link.File.MachO)) \|macho_file\| {
	2590	const decl = payload.decl;
	2591	const got = &macho_file.sections.items[macho_file.got_section_index.?];
	2592	const got_addr = got.addr + decl.link.macho.offset_table_index.? * ptr_bytes;
	2593	return MCValue{ .memory = got_addr };
	2594	} else if (self.bin_file.cast(link.File.Coff)) \|coff_file\| {
	2595	const decl = payload.decl;
	2596	const got_addr = coff_file.offset_table_virtual_address + decl.link.coff.offset_table_index * ptr_bytes;
	2597	return MCValue{ .memory = got_addr };
2489	2598	} else {
2490	2599	return self.fail(src, "TODO codegen non-ELF const Decl pointer", .{});
2491	2600	}

src-self-hosted/codegen/c.zig+1-1

...	...	@@ -85,7 +85,7 @@ fn genArray(file: C, decl: Decl) !void {
85	85	const name = try map(file.base.allocator, mem.span(decl.name));
86	86	defer file.base.allocator.free(name);
87	87	if (tv.val.cast(Value.Payload.Bytes)) \|payload\|
88		if (tv.ty.arraySentinel()) \|sentinel\|
	88	if (tv.ty.sentinel()) \|sentinel\|
89	89	if (sentinel.toUnsignedInt() == 0)
90	90	try file.constants.writer().print("const char *const {} = \"{}\";\n", .{ name, payload.data })
91	91	else

src-self-hosted/link.zig+20-2

...	...	@@ -34,6 +34,7 @@ pub const File = struct {
34	34
35	35	pub const LinkBlock = union {
36	36	elf: Elf.TextBlock,
	37	coff: Coff.TextBlock,
37	38	macho: MachO.TextBlock,
38	39	c: void,
39	40	wasm: void,
...	...	@@ -41,6 +42,7 @@ pub const File = struct {
41	42
42	43	pub const LinkFn = union {
43	44	elf: Elf.SrcFn,
	45	coff: Coff.SrcFn,
44	46	macho: MachO.SrcFn,
45	47	c: void,
46	48	wasm: ?Wasm.FnData,
...	...	@@ -66,7 +68,7 @@ pub const File = struct {
66	68	pub fn openPath(allocator: Allocator, dir: fs.Dir, sub_path: []const u8, options: Options) !File {
67	69	switch (options.object_format) {
68	70	.unknown => unreachable,
69		.coff => return error.TODOImplementCoff,
	71	.coff, .pe => return Coff.openPath(allocator, dir, sub_path, options),
70	72	.elf => return Elf.openPath(allocator, dir, sub_path, options),
71	73	.macho => return MachO.openPath(allocator, dir, sub_path, options),
72	74	.wasm => return Wasm.openPath(allocator, dir, sub_path, options),
...	...	@@ -85,7 +87,7 @@ pub const File = struct {
85	87
86	88	pub fn makeWritable(base: *File, dir: fs.Dir, sub_path: []const u8) !void {
87	89	switch (base.tag) {
88		.elf, .macho => {
	90	.coff, .elf, .macho => {
89	91	if (base.file != null) return;
90	92	base.file = try dir.createFile(sub_path, .{
91	93	.truncate = false,
...	...	@@ -112,6 +114,7 @@ pub const File = struct {
112	114	/// after allocateDeclIndexes for any given Decl.
113	115	pub fn updateDecl(base: File, module: Module, decl: *Module.Decl) !void {
114	116	switch (base.tag) {
	117	.coff => return @fieldParentPtr(Coff, "base", base).updateDecl(module, decl),
115	118	.elf => return @fieldParentPtr(Elf, "base", base).updateDecl(module, decl),
116	119	.macho => return @fieldParentPtr(MachO, "base", base).updateDecl(module, decl),
117	120	.c => return @fieldParentPtr(C, "base", base).updateDecl(module, decl),
...	...	@@ -121,6 +124,7 @@ pub const File = struct {
121	124
122	125	pub fn updateDeclLineNumber(base: File, module: Module, decl: *Module.Decl) !void {
123	126	switch (base.tag) {
	127	.coff => return @fieldParentPtr(Coff, "base", base).updateDeclLineNumber(module, decl),
124	128	.elf => return @fieldParentPtr(Elf, "base", base).updateDeclLineNumber(module, decl),
125	129	.macho => return @fieldParentPtr(MachO, "base", base).updateDeclLineNumber(module, decl),
126	130	.c, .wasm => {},
...	...	@@ -131,6 +135,7 @@ pub const File = struct {
131	135	/// any given Decl.
132	136	pub fn allocateDeclIndexes(base: File, decl: Module.Decl) !void {
133	137	switch (base.tag) {
	138	.coff => return @fieldParentPtr(Coff, "base", base).allocateDeclIndexes(decl),
134	139	.elf => return @fieldParentPtr(Elf, "base", base).allocateDeclIndexes(decl),
135	140	.macho => return @fieldParentPtr(MachO, "base", base).allocateDeclIndexes(decl),
136	141	.c, .wasm => {},
...	...	@@ -140,6 +145,7 @@ pub const File = struct {
140	145	pub fn deinit(base: *File) void {
141	146	if (base.file) \|f\| f.close();
142	147	switch (base.tag) {
	148	.coff => @fieldParentPtr(Coff, "base", base).deinit(),
143	149	.elf => @fieldParentPtr(Elf, "base", base).deinit(),
144	150	.macho => @fieldParentPtr(MachO, "base", base).deinit(),
145	151	.c => @fieldParentPtr(C, "base", base).deinit(),
...	...	@@ -149,6 +155,11 @@ pub const File = struct {
149	155
150	156	pub fn destroy(base: *File) void {
151	157	switch (base.tag) {
	158	.coff => {
	159	const parent = @fieldParentPtr(Coff, "base", base);
	160	parent.deinit();
	161	base.allocator.destroy(parent);
	162	},
152	163	.elf => {
153	164	const parent = @fieldParentPtr(Elf, "base", base);
154	165	parent.deinit();
...	...	@@ -177,6 +188,7 @@ pub const File = struct {
177	188	defer tracy.end();
178	189
179	190	try switch (base.tag) {
	191	.coff => @fieldParentPtr(Coff, "base", base).flush(module),
180	192	.elf => @fieldParentPtr(Elf, "base", base).flush(module),
181	193	.macho => @fieldParentPtr(MachO, "base", base).flush(module),
182	194	.c => @fieldParentPtr(C, "base", base).flush(module),
...	...	@@ -186,6 +198,7 @@ pub const File = struct {
186	198
187	199	pub fn freeDecl(base: File, decl: Module.Decl) void {
188	200	switch (base.tag) {
	201	.coff => @fieldParentPtr(Coff, "base", base).freeDecl(decl),
189	202	.elf => @fieldParentPtr(Elf, "base", base).freeDecl(decl),
190	203	.macho => @fieldParentPtr(MachO, "base", base).freeDecl(decl),
191	204	.c => unreachable,
...	...	@@ -195,6 +208,7 @@ pub const File = struct {
195	208
196	209	pub fn errorFlags(base: *File) ErrorFlags {
197	210	return switch (base.tag) {
	211	.coff => @fieldParentPtr(Coff, "base", base).error_flags,
198	212	.elf => @fieldParentPtr(Elf, "base", base).error_flags,
199	213	.macho => @fieldParentPtr(MachO, "base", base).error_flags,
200	214	.c => return .{ .no_entry_point_found = false },
...	...	@@ -211,6 +225,7 @@ pub const File = struct {
211	225	exports: []const *Module.Export,
212	226	) !void {
213	227	switch (base.tag) {
	228	.coff => return @fieldParentPtr(Coff, "base", base).updateDeclExports(module, decl, exports),
214	229	.elf => return @fieldParentPtr(Elf, "base", base).updateDeclExports(module, decl, exports),
215	230	.macho => return @fieldParentPtr(MachO, "base", base).updateDeclExports(module, decl, exports),
216	231	.c => return {},
...	...	@@ -220,6 +235,7 @@ pub const File = struct {
220	235
221	236	pub fn getDeclVAddr(base: File, decl: const Module.Decl) u64 {
222	237	switch (base.tag) {
	238	.coff => return @fieldParentPtr(Coff, "base", base).getDeclVAddr(decl),
223	239	.elf => return @fieldParentPtr(Elf, "base", base).getDeclVAddr(decl),
224	240	.macho => return @fieldParentPtr(MachO, "base", base).getDeclVAddr(decl),
225	241	.c => unreachable,
...	...	@@ -228,6 +244,7 @@ pub const File = struct {
228	244	}
229	245
230	246	pub const Tag = enum {
	247	coff,
231	248	elf,
232	249	macho,
233	250	c,
...	...	@@ -239,6 +256,7 @@ pub const File = struct {
239	256	};
240	257
241	258	pub const C = @import("link/C.zig");
	259	pub const Coff = @import("link/Coff.zig");
242	260	pub const Elf = @import("link/Elf.zig");
243	261	pub const MachO = @import("link/MachO.zig");
244	262	pub const Wasm = @import("link/Wasm.zig");

src-self-hosted/link/Coff.zig created+792

...	...	@@ -0,0 +1,792 @@
	1	const Coff = @This();
	2
	3	const std = @import("std");
	4	const log = std.log.scoped(.link);
	5	const Allocator = std.mem.Allocator;
	6	const assert = std.debug.assert;
	7	const fs = std.fs;
	8
	9	const trace = @import("../tracy.zig").trace;
	10	const Module = @import("../Module.zig");
	11	const codegen = @import("../codegen.zig");
	12	const link = @import("../link.zig");
	13
	14	const allocation_padding = 4 / 3;
	15	const minimum_text_block_size = 64 * allocation_padding;
	16
	17	const section_alignment = 4096;
	18	const file_alignment = 512;
	19	const image_base = 0x400_000;
	20	const section_table_size = 2 * 40;
	21	comptime {
	22	std.debug.assert(std.mem.isAligned(image_base, section_alignment));
	23	}
	24
	25	pub const base_tag: link.File.Tag = .coff;
	26
	27	const msdos_stub = @embedFile("msdos-stub.bin");
	28
	29	base: link.File,
	30	ptr_width: enum { p32, p64 },
	31	error_flags: link.File.ErrorFlags = .{},
	32
	33	text_block_free_list: std.ArrayListUnmanaged(*TextBlock) = .{},
	34	last_text_block: ?*TextBlock = null,
	35
	36	/// Section table file pointer.
	37	section_table_offset: u32 = 0,
	38	/// Section data file pointer.
	39	section_data_offset: u32 = 0,
	40	/// Optiona header file pointer.
	41	optional_header_offset: u32 = 0,
	42
	43	/// Absolute virtual address of the offset table when the executable is loaded in memory.
	44	offset_table_virtual_address: u32 = 0,
	45	/// Current size of the offset table on disk, must be a multiple of `file_alignment`
	46	offset_table_size: u32 = 0,
	47	/// Contains absolute virtual addresses
	48	offset_table: std.ArrayListUnmanaged(u64) = .{},
	49	/// Free list of offset table indices
	50	offset_table_free_list: std.ArrayListUnmanaged(u32) = .{},
	51
	52	/// Virtual address of the entry point procedure relative to `image_base`
	53	entry_addr: ?u32 = null,
	54
	55	/// Absolute virtual address of the text section when the executable is loaded in memory.
	56	text_section_virtual_address: u32 = 0,
	57	/// Current size of the `.text` section on disk, must be a multiple of `file_alignment`
	58	text_section_size: u32 = 0,
	59
	60	offset_table_size_dirty: bool = false,
	61	text_section_size_dirty: bool = false,
	62	/// This flag is set when the virtual size of the whole image file when loaded in memory has changed
	63	/// and needs to be updated in the optional header.
	64	size_of_image_dirty: bool = false,
	65
	66	pub const TextBlock = struct {
	67	/// Offset of the code relative to the start of the text section
	68	text_offset: u32,
	69	/// Used size of the text block
	70	size: u32,
	71	/// This field is undefined for symbols with size = 0.
	72	offset_table_index: u32,
	73	/// Points to the previous and next neighbors, based on the `text_offset`.
	74	/// This can be used to find, for example, the capacity of this `TextBlock`.
	75	prev: ?*TextBlock,
	76	next: ?*TextBlock,
	77
	78	pub const empty = TextBlock{
	79	.text_offset = 0,
	80	.size = 0,
	81	.offset_table_index = undefined,
	82	.prev = null,
	83	.next = null,
	84	};
	85
	86	/// Returns how much room there is to grow in virtual address space.
	87	fn capacity(self: TextBlock) u64 {
	88	if (self.next) \|next\| {
	89	return next.text_offset - self.text_offset;
	90	}
	91	// This is the last block, the capacity is only limited by the address space.
	92	return std.math.maxInt(u32) - self.text_offset;
	93	}
	94
	95	fn freeListEligible(self: TextBlock) bool {
	96	// No need to keep a free list node for the last block.
	97	const next = self.next orelse return false;
	98	const cap = next.text_offset - self.text_offset;
	99	const ideal_cap = self.size * allocation_padding;
	100	if (cap <= ideal_cap) return false;
	101	const surplus = cap - ideal_cap;
	102	return surplus >= minimum_text_block_size;
	103	}
	104
	105	/// Absolute virtual address of the text block when the file is loaded in memory.
	106	fn getVAddr(self: TextBlock, coff: Coff) u32 {
	107	return coff.text_section_virtual_address + self.text_offset;
	108	}
	109	};
	110
	111	pub const SrcFn = void;
	112
	113	pub fn openPath(allocator: Allocator, dir: fs.Dir, sub_path: []const u8, options: link.Options) !link.File {
	114	assert(options.object_format == .coff);
	115
	116	const file = try dir.createFile(sub_path, .{ .truncate = false, .read = true, .mode = link.determineMode(options) });
	117	errdefer file.close();
	118
	119	var coff_file = try allocator.create(Coff);
	120	errdefer allocator.destroy(coff_file);
	121
	122	coff_file.* = openFile(allocator, file, options) catch \|err\| switch (err) {
	123	error.IncrFailed => try createFile(allocator, file, options),
	124	else => \|e\| return e,
	125	};
	126
	127	return &coff_file.base;
	128	}
	129
	130	/// Returns error.IncrFailed if incremental update could not be performed.
	131	fn openFile(allocator: *Allocator, file: fs.File, options: link.Options) !Coff {
	132	switch (options.output_mode) {
	133	.Exe => {},
	134	.Obj => return error.IncrFailed,
	135	.Lib => return error.IncrFailed,
	136	}
	137	var self: Coff = .{
	138	.base = .{
	139	.file = file,
	140	.tag = .coff,
	141	.options = options,
	142	.allocator = allocator,
	143	},
	144	.ptr_width = switch (options.target.cpu.arch.ptrBitWidth()) {
	145	32 => .p32,
	146	64 => .p64,
	147	else => return error.UnsupportedELFArchitecture,
	148	},
	149	};
	150	errdefer self.deinit();
	151
	152	// TODO implement reading the PE/COFF file
	153	return error.IncrFailed;
	154	}
	155
	156	/// Truncates the existing file contents and overwrites the contents.
	157	/// Returns an error if `file` is not already open with +read +write +seek abilities.
	158	fn createFile(allocator: *Allocator, file: fs.File, options: link.Options) !Coff {
	159	// TODO Write object specific relocations, COFF symbol table, then enable object file output.
	160	switch (options.output_mode) {
	161	.Exe => {},
	162	.Obj => return error.TODOImplementWritingObjFiles,
	163	.Lib => return error.TODOImplementWritingLibFiles,
	164	}
	165	var self: Coff = .{
	166	.base = .{
	167	.tag = .coff,
	168	.options = options,
	169	.allocator = allocator,
	170	.file = file,
	171	},
	172	.ptr_width = switch (options.target.cpu.arch.ptrBitWidth()) {
	173	32 => .p32,
	174	64 => .p64,
	175	else => return error.UnsupportedCOFFArchitecture,
	176	},
	177	};
	178	errdefer self.deinit();
	179
	180	var coff_file_header_offset: u32 = 0;
	181	if (options.output_mode == .Exe) {
	182	// Write the MS-DOS stub and the PE signature
	183	try self.base.file.?.pwriteAll(msdos_stub ++ "PE\x00\x00", 0);
	184	coff_file_header_offset = msdos_stub.len + 4;
	185	}
	186
	187	// COFF file header
	188	const data_directory_count = 0;
	189	var hdr_data: [112 + data_directory_count * 8 + section_table_size]u8 = undefined;
	190	var index: usize = 0;
	191
	192	const machine = self.base.options.target.cpu.arch.toCoffMachine();
	193	if (machine == .Unknown) {
	194	return error.UnsupportedCOFFArchitecture;
	195	}
	196	std.mem.writeIntLittle(u16, hdr_data[0..2], @enumToInt(machine));
	197	index += 2;
	198
	199	// Number of sections (we only use .got, .text)
	200	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 2);
	201	index += 2;
	202	// TimeDateStamp (u32), PointerToSymbolTable (u32), NumberOfSymbols (u32)
	203	std.mem.set(u8, hdr_data[index..][0..12], 0);
	204	index += 12;
	205
	206	const optional_header_size = switch (options.output_mode) {
	207	.Exe => data_directory_count * 8 + switch (self.ptr_width) {
	208	.p32 => @as(u16, 96),
	209	.p64 => 112,
	210	},
	211	else => 0,
	212	};
	213
	214	const section_table_offset = coff_file_header_offset + 20 + optional_header_size;
	215	const default_offset_table_size = file_alignment;
	216	const default_size_of_code = 0;
	217
	218	self.section_data_offset = std.mem.alignForwardGeneric(u32, self.section_table_offset + section_table_size, file_alignment);
	219	const section_data_relative_virtual_address = std.mem.alignForwardGeneric(u32, self.section_table_offset + section_table_size, section_alignment);
	220	self.offset_table_virtual_address = image_base + section_data_relative_virtual_address;
	221	self.offset_table_size = default_offset_table_size;
	222	self.section_table_offset = section_table_offset;
	223	self.text_section_virtual_address = image_base + section_data_relative_virtual_address + section_alignment;
	224	self.text_section_size = default_size_of_code;
	225
	226	// Size of file when loaded in memory
	227	const size_of_image = std.mem.alignForwardGeneric(u32, self.text_section_virtual_address - image_base + default_size_of_code, section_alignment);
	228
	229	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], optional_header_size);
	230	index += 2;
	231
	232	// Characteristics
	233	var characteristics: u16 = std.coff.IMAGE_FILE_DEBUG_STRIPPED \| std.coff.IMAGE_FILE_RELOCS_STRIPPED; // TODO Remove debug info stripped flag when necessary
	234	if (options.output_mode == .Exe) {
	235	characteristics \|= std.coff.IMAGE_FILE_EXECUTABLE_IMAGE;
	236	}
	237	switch (self.ptr_width) {
	238	.p32 => characteristics \|= std.coff.IMAGE_FILE_32BIT_MACHINE,
	239	.p64 => characteristics \|= std.coff.IMAGE_FILE_LARGE_ADDRESS_AWARE,
	240	}
	241	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], characteristics);
	242	index += 2;
	243
	244	assert(index == 20);
	245	try self.base.file.?.pwriteAll(hdr_data[0..index], coff_file_header_offset);
	246
	247	if (options.output_mode == .Exe) {
	248	self.optional_header_offset = coff_file_header_offset + 20;
	249	// Optional header
	250	index = 0;
	251	std.mem.writeIntLittle(u16, hdr_data[0..2], switch (self.ptr_width) {
	252	.p32 => @as(u16, 0x10b),
	253	.p64 => 0x20b,
	254	});
	255	index += 2;
	256
	257	// Linker version (u8 + u8)
	258	std.mem.set(u8, hdr_data[index..][0..2], 0);
	259	index += 2;
	260
	261	// SizeOfCode (UNUSED, u32), SizeOfInitializedData (u32), SizeOfUninitializedData (u32), AddressOfEntryPoint (u32), BaseOfCode (UNUSED, u32)
	262	std.mem.set(u8, hdr_data[index..][0..20], 0);
	263	index += 20;
	264
	265	if (self.ptr_width == .p32) {
	266	// Base of data relative to the image base (UNUSED)
	267	std.mem.set(u8, hdr_data[index..][0..4], 0);
	268	index += 4;
	269
	270	// Image base address
	271	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], image_base);
	272	index += 4;
	273	} else {
	274	// Image base address
	275	std.mem.writeIntLittle(u64, hdr_data[index..][0..8], image_base);
	276	index += 8;
	277	}
	278
	279	// Section alignment
	280	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], section_alignment);
	281	index += 4;
	282	// File alignment
	283	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], file_alignment);
	284	index += 4;
	285	// Required OS version, 6.0 is vista
	286	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 6);
	287	index += 2;
	288	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 0);
	289	index += 2;
	290	// Image version
	291	std.mem.set(u8, hdr_data[index..][0..4], 0);
	292	index += 4;
	293	// Required subsystem version, same as OS version
	294	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 6);
	295	index += 2;
	296	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 0);
	297	index += 2;
	298	// Reserved zeroes (u32)
	299	std.mem.set(u8, hdr_data[index..][0..4], 0);
	300	index += 4;
	301	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], size_of_image);
	302	index += 4;
	303	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], self.section_data_offset);
	304	index += 4;
	305	// CheckSum (u32)
	306	std.mem.set(u8, hdr_data[index..][0..4], 0);
	307	index += 4;
	308	// Subsystem, TODO: Let users specify the subsystem, always CUI for now
	309	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 3);
	310	index += 2;
	311	// DLL characteristics
	312	std.mem.writeIntLittle(u16, hdr_data[index..][0..2], 0x0);
	313	index += 2;
	314
	315	switch (self.ptr_width) {
	316	.p32 => {
	317	// Size of stack reserve + commit
	318	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x1_000_000);
	319	index += 4;
	320	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x1_000);
	321	index += 4;
	322	// Size of heap reserve + commit
	323	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x100_000);
	324	index += 4;
	325	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], 0x1_000);
	326	index += 4;
	327	},
	328	.p64 => {
	329	// Size of stack reserve + commit
	330	std.mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x1_000_000);
	331	index += 8;
	332	std.mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x1_000);
	333	index += 8;
	334	// Size of heap reserve + commit
	335	std.mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x100_000);
	336	index += 8;
	337	std.mem.writeIntLittle(u64, hdr_data[index..][0..8], 0x1_000);
	338	index += 8;
	339	},
	340	}
	341
	342	// Reserved zeroes
	343	std.mem.set(u8, hdr_data[index..][0..4], 0);
	344	index += 4;
	345
	346	// Number of data directories
	347	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], data_directory_count);
	348	index += 4;
	349	// Initialize data directories to zero
	350	std.mem.set(u8, hdr_data[index..][0 .. data_directory_count * 8], 0);
	351	index += data_directory_count * 8;
	352
	353	assert(index == optional_header_size);
	354	}
	355
	356	// Write section table.
	357	// First, the .got section
	358	hdr_data[index..][0..8].* = ".got\x00\x00\x00\x00".*;
	359	index += 8;
	360	if (options.output_mode == .Exe) {
	361	// Virtual size (u32)
	362	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], default_offset_table_size);
	363	index += 4;
	364	// Virtual address (u32)
	365	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], self.offset_table_virtual_address - image_base);
	366	index += 4;
	367	} else {
	368	std.mem.set(u8, hdr_data[index..][0..8], 0);
	369	index += 8;
	370	}
	371	// Size of raw data (u32)
	372	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], default_offset_table_size);
	373	index += 4;
	374	// File pointer to the start of the section
	375	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], self.section_data_offset);
	376	index += 4;
	377	// Pointer to relocations (u32), PointerToLinenumbers (u32), NumberOfRelocations (u16), NumberOfLinenumbers (u16)
	378	std.mem.set(u8, hdr_data[index..][0..12], 0);
	379	index += 12;
	380	// Section flags
	381	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], std.coff.IMAGE_SCN_CNT_INITIALIZED_DATA \| std.coff.IMAGE_SCN_MEM_READ);
	382	index += 4;
	383	// Then, the .text section
	384	hdr_data[index..][0..8].* = ".text\x00\x00\x00".*;
	385	index += 8;
	386	if (options.output_mode == .Exe) {
	387	// Virtual size (u32)
	388	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], default_size_of_code);
	389	index += 4;
	390	// Virtual address (u32)
	391	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], self.text_section_virtual_address - image_base);
	392	index += 4;
	393	} else {
	394	std.mem.set(u8, hdr_data[index..][0..8], 0);
	395	index += 8;
	396	}
	397	// Size of raw data (u32)
	398	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], default_size_of_code);
	399	index += 4;
	400	// File pointer to the start of the section
	401	std.mem.writeIntLittle(u32, hdr_data[index..][0..4], self.section_data_offset + default_offset_table_size);
	402	index += 4;
	403	// Pointer to relocations (u32), PointerToLinenumbers (u32), NumberOfRelocations (u16), NumberOfLinenumbers (u16)
	404	std.mem.set(u8, hdr_data[index..][0..12], 0);
	405	index += 12;
	406	// Section flags
	407	std.mem.writeIntLittle(
	408	u32,
	409	hdr_data[index..][0..4],
	410	std.coff.IMAGE_SCN_CNT_CODE \| std.coff.IMAGE_SCN_MEM_EXECUTE \| std.coff.IMAGE_SCN_MEM_READ \| std.coff.IMAGE_SCN_MEM_WRITE,
	411	);
	412	index += 4;
	413
	414	assert(index == optional_header_size + section_table_size);
	415	try self.base.file.?.pwriteAll(hdr_data[0..index], self.optional_header_offset);
	416	try self.base.file.?.setEndPos(self.section_data_offset + default_offset_table_size + default_size_of_code);
	417
	418	return self;
	419	}
	420
	421	pub fn allocateDeclIndexes(self: Coff, decl: Module.Decl) !void {
	422	try self.offset_table.ensureCapacity(self.base.allocator, self.offset_table.items.len + 1);
	423
	424	if (self.offset_table_free_list.popOrNull()) \|i\| {
	425	decl.link.coff.offset_table_index = i;
	426	} else {
	427	decl.link.coff.offset_table_index = @intCast(u32, self.offset_table.items.len);
	428	_ = self.offset_table.addOneAssumeCapacity();
	429
	430	const entry_size = self.base.options.target.cpu.arch.ptrBitWidth() / 8;
	431	if (self.offset_table.items.len > self.offset_table_size / entry_size) {
	432	self.offset_table_size_dirty = true;
	433	}
	434	}
	435
	436	self.offset_table.items[decl.link.coff.offset_table_index] = 0;
	437	}
	438
	439	fn allocateTextBlock(self: Coff, text_block: TextBlock, new_block_size: u64, alignment: u64) !u64 {
	440	const new_block_min_capacity = new_block_size * allocation_padding;
	441
	442	// We use these to indicate our intention to update metadata, placing the new block,
	443	// and possibly removing a free list node.
	444	// It would be simpler to do it inside the for loop below, but that would cause a
	445	// problem if an error was returned later in the function. So this action
	446	// is actually carried out at the end of the function, when errors are no longer possible.
	447	var block_placement: ?*TextBlock = null;
	448	var free_list_removal: ?usize = null;
	449
	450	const vaddr = blk: {
	451	var i: usize = 0;
	452	while (i < self.text_block_free_list.items.len) {
	453	const free_block = self.text_block_free_list.items[i];
	454
	455	const next_block_text_offset = free_block.text_offset + free_block.capacity();
	456	const new_block_text_offset = std.mem.alignForwardGeneric(u64, free_block.getVAddr(self.*) + free_block.size, alignment) - self.text_section_virtual_address;
	457	if (new_block_text_offset < next_block_text_offset and next_block_text_offset - new_block_text_offset >= new_block_min_capacity) {
	458	block_placement = free_block;
	459
	460	const remaining_capacity = next_block_text_offset - new_block_text_offset - new_block_min_capacity;
	461	if (remaining_capacity < minimum_text_block_size) {
	462	free_list_removal = i;
	463	}
	464
	465	break :blk new_block_text_offset + self.text_section_virtual_address;
	466	} else {
	467	if (!free_block.freeListEligible()) {
	468	_ = self.text_block_free_list.swapRemove(i);
	469	} else {
	470	i += 1;
	471	}
	472	continue;
	473	}
	474	} else if (self.last_text_block) \|last\| {
	475	const new_block_vaddr = std.mem.alignForwardGeneric(u64, last.getVAddr(self.*) + last.size, alignment);
	476	block_placement = last;
	477	break :blk new_block_vaddr;
	478	} else {
	479	break :blk self.text_section_virtual_address;
	480	}
	481	};
	482
	483	const expand_text_section = block_placement == null or block_placement.?.next == null;
	484	if (expand_text_section) {
	485	const needed_size = @intCast(u32, std.mem.alignForwardGeneric(u64, vaddr + new_block_size - self.text_section_virtual_address, file_alignment));
	486	if (needed_size > self.text_section_size) {
	487	const current_text_section_virtual_size = std.mem.alignForwardGeneric(u32, self.text_section_size, section_alignment);
	488	const new_text_section_virtual_size = std.mem.alignForwardGeneric(u32, needed_size, section_alignment);
	489	if (current_text_section_virtual_size != new_text_section_virtual_size) {
	490	self.size_of_image_dirty = true;
	491	// Write new virtual size
	492	var buf: [4]u8 = undefined;
	493	std.mem.writeIntLittle(u32, &buf, new_text_section_virtual_size);
	494	try self.base.file.?.pwriteAll(&buf, self.section_table_offset + 40 + 8);
	495	}
	496
	497	self.text_section_size = needed_size;
	498	self.text_section_size_dirty = true;
	499	}
	500	self.last_text_block = text_block;
	501	}
	502	text_block.text_offset = @intCast(u32, vaddr - self.text_section_virtual_address);
	503	text_block.size = @intCast(u32, new_block_size);
	504
	505	// This function can also reallocate a text block.
	506	// In this case we need to "unplug" it from its previous location before
	507	// plugging it in to its new location.
	508	if (text_block.prev) \|prev\| {
	509	prev.next = text_block.next;
	510	}
	511	if (text_block.next) \|next\| {
	512	next.prev = text_block.prev;
	513	}
	514
	515	if (block_placement) \|big_block\| {
	516	text_block.prev = big_block;
	517	text_block.next = big_block.next;
	518	big_block.next = text_block;
	519	} else {
	520	text_block.prev = null;
	521	text_block.next = null;
	522	}
	523	if (free_list_removal) \|i\| {
	524	_ = self.text_block_free_list.swapRemove(i);
	525	}
	526	return vaddr;
	527	}
	528
	529	fn growTextBlock(self: Coff, text_block: TextBlock, new_block_size: u64, alignment: u64) !u64 {
	530	const block_vaddr = text_block.getVAddr(self.*);
	531	const align_ok = std.mem.alignBackwardGeneric(u64, block_vaddr, alignment) == block_vaddr;
	532	const need_realloc = !align_ok or new_block_size > text_block.capacity();
	533	if (!need_realloc) return @as(u64, block_vaddr);
	534	return self.allocateTextBlock(text_block, new_block_size, alignment);
	535	}
	536
	537	fn shrinkTextBlock(self: Coff, text_block: TextBlock, new_block_size: u64) void {
	538	text_block.size = @intCast(u32, new_block_size);
	539	if (text_block.capacity() - text_block.size >= minimum_text_block_size) {
	540	self.text_block_free_list.append(self.base.allocator, text_block) catch {};
	541	}
	542	}
	543
	544	fn freeTextBlock(self: Coff, text_block: TextBlock) void {
	545	var already_have_free_list_node = false;
	546	{
	547	var i: usize = 0;
	548	// TODO turn text_block_free_list into a hash map
	549	while (i < self.text_block_free_list.items.len) {
	550	if (self.text_block_free_list.items[i] == text_block) {
	551	_ = self.text_block_free_list.swapRemove(i);
	552	continue;
	553	}
	554	if (self.text_block_free_list.items[i] == text_block.prev) {
	555	already_have_free_list_node = true;
	556	}
	557	i += 1;
	558	}
	559	}
	560	if (self.last_text_block == text_block) {
	561	self.last_text_block = text_block.prev;
	562	}
	563	if (text_block.prev) \|prev\| {
	564	prev.next = text_block.next;
	565
	566	if (!already_have_free_list_node and prev.freeListEligible()) {
	567	// The free list is heuristics, it doesn't have to be perfect, so we can
	568	// ignore the OOM here.
	569	self.text_block_free_list.append(self.base.allocator, prev) catch {};
	570	}
	571	}
	572
	573	if (text_block.next) \|next\| {
	574	next.prev = text_block.prev;
	575	}
	576	}
	577
	578	fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
	579	const entry_size = self.base.options.target.cpu.arch.ptrBitWidth() / 8;
	580	const endian = self.base.options.target.cpu.arch.endian();
	581
	582	const offset_table_start = self.section_data_offset;
	583	if (self.offset_table_size_dirty) {
	584	const current_raw_size = self.offset_table_size;
	585	const new_raw_size = self.offset_table_size * 2;
	586	log.debug("growing offset table from raw size {} to {}\n", .{ current_raw_size, new_raw_size });
	587
	588	// Move the text section to a new place in the executable
	589	const current_text_section_start = self.section_data_offset + current_raw_size;
	590	const new_text_section_start = self.section_data_offset + new_raw_size;
	591
	592	const amt = try self.base.file.?.copyRangeAll(current_text_section_start, self.base.file.?, new_text_section_start, self.text_section_size);
	593	if (amt != self.text_section_size) return error.InputOutput;
	594
	595	// Write the new raw size in the .got header
	596	var buf: [8]u8 = undefined;
	597	std.mem.writeIntLittle(u32, buf[0..4], new_raw_size);
	598	try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 16);
	599	// Write the new .text section file offset in the .text section header
	600	std.mem.writeIntLittle(u32, buf[0..4], new_text_section_start);
	601	try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 40 + 20);
	602
	603	const current_virtual_size = std.mem.alignForwardGeneric(u32, self.offset_table_size, section_alignment);
	604	const new_virtual_size = std.mem.alignForwardGeneric(u32, new_raw_size, section_alignment);
	605	// If we had to move in the virtual address space, we need to fix the VAs in the offset table, as well as the virtual address of the `.text` section
	606	// and the virutal size of the `.got` section
	607
	608	if (new_virtual_size != current_virtual_size) {
	609	log.debug("growing offset table from virtual size {} to {}\n", .{ current_virtual_size, new_virtual_size });
	610	self.size_of_image_dirty = true;
	611	const va_offset = new_virtual_size - current_virtual_size;
	612
	613	// Write .got virtual size
	614	std.mem.writeIntLittle(u32, buf[0..4], new_virtual_size);
	615	try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 8);
	616
	617	// Write .text new virtual address
	618	self.text_section_virtual_address = self.text_section_virtual_address + va_offset;
	619	std.mem.writeIntLittle(u32, buf[0..4], self.text_section_virtual_address - image_base);
	620	try self.base.file.?.pwriteAll(buf[0..4], self.section_table_offset + 40 + 12);
	621
	622	// Fix the VAs in the offset table
	623	for (self.offset_table.items) \|*va, idx\| {
	624	if (va.* != 0) {
	625	va.* += va_offset;
	626
	627	switch (entry_size) {
	628	4 => {
	629	std.mem.writeInt(u32, buf[0..4], @intCast(u32, va.*), endian);
	630	try self.base.file.?.pwriteAll(buf[0..4], offset_table_start + idx * entry_size);
	631	},
	632	8 => {
	633	std.mem.writeInt(u64, &buf, va.*, endian);
	634	try self.base.file.?.pwriteAll(&buf, offset_table_start + idx * entry_size);
	635	},
	636	else => unreachable,
	637	}
	638	}
	639	}
	640	}
	641	self.offset_table_size = new_raw_size;
	642	self.offset_table_size_dirty = false;
	643	}
	644	// Write the new entry
	645	switch (entry_size) {
	646	4 => {
	647	var buf: [4]u8 = undefined;
	648	std.mem.writeInt(u32, &buf, @intCast(u32, self.offset_table.items[index]), endian);
	649	try self.base.file.?.pwriteAll(&buf, offset_table_start + index * entry_size);
	650	},
	651	8 => {
	652	var buf: [8]u8 = undefined;
	653	std.mem.writeInt(u64, &buf, self.offset_table.items[index], endian);
	654	try self.base.file.?.pwriteAll(&buf, offset_table_start + index * entry_size);
	655	},
	656	else => unreachable,
	657	}
	658	}
	659
	660	pub fn updateDecl(self: Coff, module: Module, decl: *Module.Decl) !void {
	661	// TODO COFF/PE debug information
	662	// TODO Implement exports
	663	const tracy = trace(@src());
	664	defer tracy.end();
	665
	666	var code_buffer = std.ArrayList(u8).init(self.base.allocator);
	667	defer code_buffer.deinit();
	668
	669	const typed_value = decl.typed_value.most_recent.typed_value;
	670	const res = try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .none);
	671	const code = switch (res) {
	672	.externally_managed => \|x\| x,
	673	.appended => code_buffer.items,
	674	.fail => \|em\| {
	675	decl.analysis = .codegen_failure;
	676	try module.failed_decls.put(module.gpa, decl, em);
	677	return;
	678	},
	679	};
	680
	681	const required_alignment = typed_value.ty.abiAlignment(self.base.options.target);
	682	const curr_size = decl.link.coff.size;
	683	if (curr_size != 0) {
	684	const capacity = decl.link.coff.capacity();
	685	const need_realloc = code.len > capacity or
	686	!std.mem.isAlignedGeneric(u32, decl.link.coff.text_offset, required_alignment);
	687	if (need_realloc) {
	688	const curr_vaddr = self.getDeclVAddr(decl);
	689	const vaddr = try self.growTextBlock(&decl.link.coff, code.len, required_alignment);
	690	log.debug("growing {} from 0x{x} to 0x{x}\n", .{ decl.name, curr_vaddr, vaddr });
	691	if (vaddr != curr_vaddr) {
	692	log.debug(" (writing new offset table entry)\n", .{});
	693	self.offset_table.items[decl.link.coff.offset_table_index] = vaddr;
	694	try self.writeOffsetTableEntry(decl.link.coff.offset_table_index);
	695	}
	696	} else if (code.len < curr_size) {
	697	self.shrinkTextBlock(&decl.link.coff, code.len);
	698	}
	699	} else {
	700	const vaddr = try self.allocateTextBlock(&decl.link.coff, code.len, required_alignment);
	701	log.debug("allocated text block for {} at 0x{x} (size: {Bi})\n", .{ std.mem.spanZ(decl.name), vaddr, code.len });
	702	errdefer self.freeTextBlock(&decl.link.coff);
	703	self.offset_table.items[decl.link.coff.offset_table_index] = vaddr;
	704	try self.writeOffsetTableEntry(decl.link.coff.offset_table_index);
	705	}
	706
	707	// Write the code into the file
	708	try self.base.file.?.pwriteAll(code, self.section_data_offset + self.offset_table_size + decl.link.coff.text_offset);
	709
	710	// Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
	711	const decl_exports = module.decl_exports.get(decl) orelse &[0]*Module.Export{};
	712	return self.updateDeclExports(module, decl, decl_exports);
	713	}
	714
	715	pub fn freeDecl(self: Coff, decl: Module.Decl) void {
	716	// Appending to free lists is allowed to fail because the free lists are heuristics based anyway.
	717	self.freeTextBlock(&decl.link.coff);
	718	self.offset_table_free_list.append(self.base.allocator, decl.link.coff.offset_table_index) catch {};
	719	}
	720
	721	pub fn updateDeclExports(self: Coff, module: Module, decl: const Module.Decl, exports: []const Module.Export) !void {
	722	for (exports) \|exp\| {
	723	if (exp.options.section) \|section_name\| {
	724	if (!std.mem.eql(u8, section_name, ".text")) {
	725	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
	726	module.failed_exports.putAssumeCapacityNoClobber(
	727	exp,
	728	try Module.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: ExportOptions.section", .{}),
	729	);
	730	continue;
	731	}
	732	}
	733	if (std.mem.eql(u8, exp.options.name, "_start")) {
	734	self.entry_addr = decl.link.coff.getVAddr(self.*) - image_base;
	735	} else {
	736	try module.failed_exports.ensureCapacity(module.gpa, module.failed_exports.items().len + 1);
	737	module.failed_exports.putAssumeCapacityNoClobber(
	738	exp,
	739	try Module.ErrorMsg.create(self.base.allocator, 0, "Unimplemented: Exports other than '_start'", .{}),
	740	);
	741	continue;
	742	}
	743	}
	744	}
	745
	746	pub fn flush(self: Coff, module: Module) !void {
	747	if (self.text_section_size_dirty) {
	748	// Write the new raw size in the .text header
	749	var buf: [4]u8 = undefined;
	750	std.mem.writeIntLittle(u32, &buf, self.text_section_size);
	751	try self.base.file.?.pwriteAll(&buf, self.section_table_offset + 40 + 16);
	752	try self.base.file.?.setEndPos(self.section_data_offset + self.offset_table_size + self.text_section_size);
	753	self.text_section_size_dirty = false;
	754	}
	755
	756	if (self.base.options.output_mode == .Exe and self.size_of_image_dirty) {
	757	const new_size_of_image = std.mem.alignForwardGeneric(u32, self.text_section_virtual_address - image_base + self.text_section_size, section_alignment);
	758	var buf: [4]u8 = undefined;
	759	std.mem.writeIntLittle(u32, &buf, new_size_of_image);
	760	try self.base.file.?.pwriteAll(&buf, self.optional_header_offset + 56);
	761	self.size_of_image_dirty = false;
	762	}
	763
	764	if (self.entry_addr == null and self.base.options.output_mode == .Exe) {
	765	log.debug("flushing. no_entry_point_found = true\n", .{});
	766	self.error_flags.no_entry_point_found = true;
	767	} else {
	768	log.debug("flushing. no_entry_point_found = false\n", .{});
	769	self.error_flags.no_entry_point_found = false;
	770
	771	if (self.base.options.output_mode == .Exe) {
	772	// Write AddressOfEntryPoint
	773	var buf: [4]u8 = undefined;
	774	std.mem.writeIntLittle(u32, &buf, self.entry_addr.?);
	775	try self.base.file.?.pwriteAll(&buf, self.optional_header_offset + 16);
	776	}
	777	}
	778	}
	779
	780	pub fn getDeclVAddr(self: Coff, decl: const Module.Decl) u64 {
	781	return self.text_section_virtual_address + decl.link.coff.text_offset;
	782	}
	783
	784	pub fn updateDeclLineNumber(self: Coff, module: Module, decl: *Module.Decl) !void {
	785	// TODO Implement this
	786	}
	787
	788	pub fn deinit(self: *Coff) void {
	789	self.text_block_free_list.deinit(self.base.allocator);
	790	self.offset_table.deinit(self.base.allocator);
	791	self.offset_table_free_list.deinit(self.base.allocator);
	792	}

src-self-hosted/link/Elf.zig+11-5

...	...	@@ -1656,8 +1656,8 @@ pub fn updateDecl(self: Elf, module: Module, decl: *Module.Decl) !void {
1656	1656	try dbg_line_buffer.ensureCapacity(26);
1657	1657
1658	1658	const line_off: u28 = blk: {
1659		if (decl.scope.cast(Module.Scope.File)) \|scope_file\| {
1660		const tree = scope_file.contents.tree;
	1659	if (decl.scope.cast(Module.Scope.Container)) \|container_scope\| {
	1660	const tree = container_scope.file_scope.contents.tree;
1661	1661	const file_ast_decls = tree.root_node.decls();
1662	1662	// TODO Look into improving the performance here by adding a token-index-to-line
1663	1663	// lookup table. Currently this involves scanning over the source code for newlines.
...	...	@@ -1735,7 +1735,13 @@ pub fn updateDecl(self: Elf, module: Module, decl: *Module.Decl) !void {
1735	1735	} else {
1736	1736	// TODO implement .debug_info for global variables
1737	1737	}
1738		const res = try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, &dbg_line_buffer, &dbg_info_buffer, &dbg_info_type_relocs);
	1738	const res = try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .{
	1739	.dwarf = .{
	1740	.dbg_line = &dbg_line_buffer,
	1741	.dbg_info = &dbg_info_buffer,
	1742	.dbg_info_type_relocs = &dbg_info_type_relocs,
	1743	},
	1744	});
1739	1745	const code = switch (res) {
1740	1746	.externally_managed => \|x\| x,
1741	1747	.appended => code_buffer.items,
...	...	@@ -2157,8 +2163,8 @@ pub fn updateDeclLineNumber(self: Elf, module: Module, decl: *const Module.Dec
2157	2163	const tracy = trace(@src());
2158	2164	defer tracy.end();
2159	2165
2160		const scope_file = decl.scope.cast(Module.Scope.File).?;
2161		const tree = scope_file.contents.tree;
	2166	const container_scope = decl.scope.cast(Module.Scope.Container).?;
	2167	const tree = container_scope.file_scope.contents.tree;
2162	2168	const file_ast_decls = tree.root_node.decls();
2163	2169	// TODO Look into improving the performance here by adding a token-index-to-line
2164	2170	// lookup table. Currently this involves scanning over the source code for newlines.

src-self-hosted/link/MachO.zig+502-159

...	...	@@ -18,36 +18,66 @@ const File = link.File;
18	18
19	19	pub const base_tag: File.Tag = File.Tag.macho;
20	20
	21	const LoadCommand = union(enum) {
	22	Segment: macho.segment_command_64,
	23	LinkeditData: macho.linkedit_data_command,
	24	Symtab: macho.symtab_command,
	25	Dysymtab: macho.dysymtab_command,
	26
	27	pub fn cmdsize(self: LoadCommand) u32 {
	28	return switch (self) {
	29	.Segment => \|x\| x.cmdsize,
	30	.LinkeditData => \|x\| x.cmdsize,
	31	.Symtab => \|x\| x.cmdsize,
	32	.Dysymtab => \|x\| x.cmdsize,
	33	};
	34	}
	35	};
	36
21	37	base: File,
22	38
23		/// List of all load command headers that are in the file.
24		/// We use it to track number and size of all commands needed by the header.
25		commands: std.ArrayListUnmanaged(macho.load_command) = std.ArrayListUnmanaged(macho.load_command){},
26		command_file_offset: ?u64 = null,
	39	/// Table of all load commands
	40	load_commands: std.ArrayListUnmanaged(LoadCommand) = .{},
	41	segment_cmd_index: ?u16 = null,
	42	symtab_cmd_index: ?u16 = null,
	43	dysymtab_cmd_index: ?u16 = null,
	44	data_in_code_cmd_index: ?u16 = null,
27	45
28		/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
29		/// Same order as in the file.
30		segments: std.ArrayListUnmanaged(macho.segment_command_64) = std.ArrayListUnmanaged(macho.segment_command_64){},
31		/// Section (headers) always follow segment (load commands) directly!
32		sections: std.ArrayListUnmanaged(macho.section_64) = std.ArrayListUnmanaged(macho.section_64){},
	46	/// Table of all sections
	47	sections: std.ArrayListUnmanaged(macho.section_64) = .{},
33	48
34		/// Offset (index) into __TEXT segment load command.
35		text_segment_offset: ?u64 = null,
36		/// Offset (index) into __LINKEDIT segment load command.
37		linkedit_segment_offset: ?u664 = null,
	49	/// __TEXT segment sections
	50	text_section_index: ?u16 = null,
	51	cstring_section_index: ?u16 = null,
	52	const_text_section_index: ?u16 = null,
	53	stubs_section_index: ?u16 = null,
	54	stub_helper_section_index: ?u16 = null,
	55
	56	/// __DATA segment sections
	57	got_section_index: ?u16 = null,
	58	const_data_section_index: ?u16 = null,
38	59
39		/// Entry point load command
40		entry_point_cmd: ?macho.entry_point_command = null,
41	60	entry_addr: ?u64 = null,
42	61
43		/// The first 4GB of process' memory is reserved for the null (__PAGEZERO) segment.
44		/// This is also the start address for our binary.
45		vm_start_address: u64 = 0x100000000,
	62	/// Table of all symbols used.
	63	/// Internally references string table for names (which are optional).
	64	symbol_table: std.ArrayListUnmanaged(macho.nlist_64) = .{},
	65
	66	/// Table of symbol names aka the string table.
	67	string_table: std.ArrayListUnmanaged(u8) = .{},
46	68
47		seg_table_dirty: bool = false,
	69	/// Table of symbol vaddr values. The values is the absolute vaddr value.
	70	/// If the vaddr of the executable __TEXT segment vaddr changes, the entire offset
	71	/// table needs to be rewritten.
	72	offset_table: std.ArrayListUnmanaged(u64) = .{},
48	73
49	74	error_flags: File.ErrorFlags = File.ErrorFlags{},
50	75
	76	cmd_table_dirty: bool = false,
	77
	78	/// Pointer to the last allocated text block
	79	last_text_block: ?*TextBlock = null,
	80
51	81	/// `alloc_num / alloc_den` is the factor of padding when allocating.
52	82	const alloc_num = 4;
53	83	const alloc_den = 3;
...	...	@@ -67,7 +97,23 @@ const LIB_SYSTEM_NAME: [*:0]const u8 = "System";
67	97	const LIB_SYSTEM_PATH: [*:0]const u8 = DEFAULT_LIB_SEARCH_PATH ++ "/libSystem.B.dylib";
68	98
69	99	pub const TextBlock = struct {
70		pub const empty = TextBlock{};
	100	/// Index into the symbol table
	101	symbol_table_index: ?u32,
	102	/// Index into offset table
	103	offset_table_index: ?u32,
	104	/// Size of this text block
	105	size: u64,
	106	/// Points to the previous and next neighbours
	107	prev: ?*TextBlock,
	108	next: ?*TextBlock,
	109
	110	pub const empty = TextBlock{
	111	.symbol_table_index = null,
	112	.offset_table_index = null,
	113	.size = 0,
	114	.prev = null,
	115	.next = null,
	116	};
71	117	};
72	118
73	119	pub const SrcFn = struct {
...	...	@@ -117,6 +163,12 @@ fn openFile(allocator: *Allocator, file: fs.File, options: link.Options) !MachO
117	163	/// Truncates the existing file contents and overwrites the contents.
118	164	/// Returns an error if `file` is not already open with +read +write +seek abilities.
119	165	fn createFile(allocator: *Allocator, file: fs.File, options: link.Options) !MachO {
	166	switch (options.output_mode) {
	167	.Exe => {},
	168	.Obj => {},
	169	.Lib => return error.TODOImplementWritingLibFiles,
	170	}
	171
120	172	var self: MachO = .{
121	173	.base = .{
122	174	.file = file,
...	...	@@ -127,104 +179,15 @@ fn createFile(allocator: *Allocator, file: fs.File, options: link.Options) !Mach
127	179	};
128	180	errdefer self.deinit();
129	181
130		switch (options.output_mode) {
131		.Exe => {
132		// The first segment command for executables is always a __PAGEZERO segment.
133		const pagezero = .{
134		.cmd = macho.LC_SEGMENT_64,
135		.cmdsize = commandSize(@sizeOf(macho.segment_command_64)),
136		.segname = makeString("__PAGEZERO"),
137		.vmaddr = 0,
138		.vmsize = self.vm_start_address,
139		.fileoff = 0,
140		.filesize = 0,
141		.maxprot = macho.VM_PROT_NONE,
142		.initprot = macho.VM_PROT_NONE,
143		.nsects = 0,
144		.flags = 0,
145		};
146		try self.commands.append(allocator, .{
147		.cmd = pagezero.cmd,
148		.cmdsize = pagezero.cmdsize,
149		});
150		try self.segments.append(allocator, pagezero);
151		},
152		.Obj => return error.TODOImplementWritingObjFiles,
153		.Lib => return error.TODOImplementWritingLibFiles,
154		}
155
156	182	try self.populateMissingMetadata();
157	183
158	184	return self;
159	185	}
160	186
161		fn writeMachOHeader(self: *MachO) !void {
162		var hdr: macho.mach_header_64 = undefined;
163		hdr.magic = macho.MH_MAGIC_64;
164
165		const CpuInfo = struct {
166		cpu_type: macho.cpu_type_t,
167		cpu_subtype: macho.cpu_subtype_t,
168		};
169
170		const cpu_info: CpuInfo = switch (self.base.options.target.cpu.arch) {
171		.aarch64 => .{
172		.cpu_type = macho.CPU_TYPE_ARM64,
173		.cpu_subtype = macho.CPU_SUBTYPE_ARM_ALL,
174		},
175		.x86_64 => .{
176		.cpu_type = macho.CPU_TYPE_X86_64,
177		.cpu_subtype = macho.CPU_SUBTYPE_X86_64_ALL,
178		},
179		else => return error.UnsupportedMachOArchitecture,
180		};
181		hdr.cputype = cpu_info.cpu_type;
182		hdr.cpusubtype = cpu_info.cpu_subtype;
183
184		const filetype: u32 = switch (self.base.options.output_mode) {
185		.Exe => macho.MH_EXECUTE,
186		.Obj => macho.MH_OBJECT,
187		.Lib => switch (self.base.options.link_mode) {
188		.Static => return error.TODOStaticLibMachOType,
189		.Dynamic => macho.MH_DYLIB,
190		},
191		};
192		hdr.filetype = filetype;
193
194		const ncmds = try math.cast(u32, self.commands.items.len);
195		hdr.ncmds = ncmds;
196
197		var sizeof_cmds: u32 = 0;
198		for (self.commands.items) \|cmd\| {
199		sizeof_cmds += cmd.cmdsize;
200		}
201		hdr.sizeofcmds = sizeof_cmds;
202
203		// TODO should these be set to something else?
204		hdr.flags = 0;
205		hdr.reserved = 0;
206
207		try self.base.file.?.pwriteAll(@ptrCast([*]const u8, &hdr)[0..@sizeOf(macho.mach_header_64)], 0);
208		}
209
210	187	pub fn flush(self: MachO, module: Module) !void {
211		// Save segments first
212		{
213		const buf = try self.base.allocator.alloc(macho.segment_command_64, self.segments.items.len);
214		defer self.base.allocator.free(buf);
215
216		self.command_file_offset = @sizeOf(macho.mach_header_64);
217
218		for (buf) \|*seg, i\| {
219		seg.* = self.segments.items[i];
220		self.command_file_offset.? += self.segments.items[i].cmdsize;
221		}
222
223		try self.base.file.?.pwriteAll(mem.sliceAsBytes(buf), @sizeOf(macho.mach_header_64));
224		}
225
226	188	switch (self.base.options.output_mode) {
227	189	.Exe => {
	190	var last_cmd_offset: usize = @sizeOf(macho.mach_header_64);
228	191	{
229	192	// Specify path to dynamic linker dyld
230	193	const cmdsize = commandSize(@sizeOf(macho.dylinker_command) + mem.lenZ(DEFAULT_DYLD_PATH));
...	...	@@ -235,18 +198,14 @@ pub fn flush(self: MachO, module: Module) !void {
235	198	.name = @sizeOf(macho.dylinker_command),
236	199	},
237	200	};
238		try self.commands.append(self.base.allocator, .{
239		.cmd = macho.LC_LOAD_DYLINKER,
240		.cmdsize = cmdsize,
241		});
242	201
243		try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylinker[0..1]), self.command_file_offset.?);
	202	try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylinker[0..1]), last_cmd_offset);
244	203
245		const file_offset = self.command_file_offset.? + @sizeOf(macho.dylinker_command);
	204	const file_offset = last_cmd_offset + @sizeOf(macho.dylinker_command);
246	205	try self.addPadding(cmdsize - @sizeOf(macho.dylinker_command), file_offset);
247	206
248	207	try self.base.file.?.pwriteAll(mem.spanZ(DEFAULT_DYLD_PATH), file_offset);
249		self.command_file_offset.? += cmdsize;
	208	last_cmd_offset += cmdsize;
250	209	}
251	210
252	211	{
...	...	@@ -268,21 +227,44 @@ pub fn flush(self: MachO, module: Module) !void {
268	227	.dylib = dylib,
269	228	},
270	229	};
271		try self.commands.append(self.base.allocator, .{
272		.cmd = macho.LC_LOAD_DYLIB,
273		.cmdsize = cmdsize,
274		});
275	230
276		try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylib[0..1]), self.command_file_offset.?);
	231	try self.base.file.?.pwriteAll(mem.sliceAsBytes(load_dylib[0..1]), last_cmd_offset);
277	232
278		const file_offset = self.command_file_offset.? + @sizeOf(macho.dylib_command);
	233	const file_offset = last_cmd_offset + @sizeOf(macho.dylib_command);
279	234	try self.addPadding(cmdsize - @sizeOf(macho.dylib_command), file_offset);
280	235
281	236	try self.base.file.?.pwriteAll(mem.spanZ(LIB_SYSTEM_PATH), file_offset);
282		self.command_file_offset.? += cmdsize;
	237	last_cmd_offset += cmdsize;
	238	}
	239	},
	240	.Obj => {
	241	{
	242	const symtab = &self.load_commands.items[self.symtab_cmd_index.?].Symtab;
	243	symtab.nsyms = @intCast(u32, self.symbol_table.items.len);
	244	const allocated_size = self.allocatedSize(symtab.stroff);
	245	const needed_size = self.string_table.items.len;
	246	log.debug("allocated_size = 0x{x}, needed_size = 0x{x}\n", .{ allocated_size, needed_size });
	247
	248	if (needed_size > allocated_size) {
	249	symtab.strsize = 0;
	250	symtab.stroff = @intCast(u32, self.findFreeSpace(needed_size, 1));
	251	}
	252	symtab.strsize = @intCast(u32, needed_size);
	253
	254	log.debug("writing string table from 0x{x} to 0x{x}\n", .{ symtab.stroff, symtab.stroff + symtab.strsize });
	255
	256	try self.base.file.?.pwriteAll(self.string_table.items, symtab.stroff);
	257	}
	258
	259	var last_cmd_offset: usize = @sizeOf(macho.mach_header_64);
	260	for (self.load_commands.items) \|cmd\| {
	261	const cmd_to_write = [1]@TypeOf(cmd){cmd};
	262	try self.base.file.?.pwriteAll(mem.sliceAsBytes(cmd_to_write[0..1]), last_cmd_offset);
	263	last_cmd_offset += cmd.cmdsize();
283	264	}
	265	const off = @sizeOf(macho.mach_header_64) + @sizeOf(macho.segment_command_64);
	266	try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items), off);
284	267	},
285		.Obj => return error.TODOImplementWritingObjFiles,
286	268	.Lib => return error.TODOImplementWritingLibFiles,
287	269	}
288	270
...	...	@@ -297,14 +279,87 @@ pub fn flush(self: MachO, module: Module) !void {
297	279	}
298	280
299	281	pub fn deinit(self: *MachO) void {
300		self.commands.deinit(self.base.allocator);
301		self.segments.deinit(self.base.allocator);
	282	self.offset_table.deinit(self.base.allocator);
	283	self.string_table.deinit(self.base.allocator);
	284	self.symbol_table.deinit(self.base.allocator);
302	285	self.sections.deinit(self.base.allocator);
	286	self.load_commands.deinit(self.base.allocator);
	287	}
	288
	289	pub fn allocateDeclIndexes(self: MachO, decl: Module.Decl) !void {
	290	if (decl.link.macho.symbol_table_index) \|_\| return;
	291
	292	try self.symbol_table.ensureCapacity(self.base.allocator, self.symbol_table.items.len + 1);
	293	try self.offset_table.ensureCapacity(self.base.allocator, self.offset_table.items.len + 1);
	294
	295	log.debug("allocating symbol index {} for {}\n", .{ self.symbol_table.items.len, decl.name });
	296	decl.link.macho.symbol_table_index = @intCast(u32, self.symbol_table.items.len);
	297	_ = self.symbol_table.addOneAssumeCapacity();
	298
	299	decl.link.macho.offset_table_index = @intCast(u32, self.offset_table.items.len);
	300	_ = self.offset_table.addOneAssumeCapacity();
	301
	302	self.symbol_table.items[decl.link.macho.symbol_table_index.?] = .{
	303	.n_strx = 0,
	304	.n_type = 0,
	305	.n_sect = 0,
	306	.n_desc = 0,
	307	.n_value = 0,
	308	};
	309	self.offset_table.items[decl.link.macho.offset_table_index.?] = 0;
303	310	}
304	311
305		pub fn allocateDeclIndexes(self: MachO, decl: Module.Decl) !void {}
	312	pub fn updateDecl(self: MachO, module: Module, decl: *Module.Decl) !void {
	313	const tracy = trace(@src());
	314	defer tracy.end();
	315
	316	var code_buffer = std.ArrayList(u8).init(self.base.allocator);
	317	defer code_buffer.deinit();
306	318
307		pub fn updateDecl(self: MachO, module: Module, decl: *Module.Decl) !void {}
	319	const typed_value = decl.typed_value.most_recent.typed_value;
	320	const res = try codegen.generateSymbol(&self.base, decl.src(), typed_value, &code_buffer, .none);
	321
	322	const code = switch (res) {
	323	.externally_managed => \|x\| x,
	324	.appended => code_buffer.items,
	325	.fail => \|em\| {
	326	decl.analysis = .codegen_failure;
	327	try module.failed_decls.put(module.gpa, decl, em);
	328	return;
	329	},
	330	};
	331	log.debug("generated code {}\n", .{code});
	332
	333	const required_alignment = typed_value.ty.abiAlignment(self.base.options.target);
	334	const symbol = &self.symbol_table.items[decl.link.macho.symbol_table_index.?];
	335
	336	const decl_name = mem.spanZ(decl.name);
	337	const name_str_index = try self.makeString(decl_name);
	338	const addr = try self.allocateTextBlock(&decl.link.macho, code.len, required_alignment);
	339	log.debug("allocated text block for {} at 0x{x}\n", .{ decl_name, addr });
	340	log.debug("updated text section {}\n", .{self.sections.items[self.text_section_index.?]});
	341
	342	symbol.* = .{
	343	.n_strx = name_str_index,
	344	.n_type = macho.N_SECT,
	345	.n_sect = @intCast(u8, self.text_section_index.?) + 1,
	346	.n_desc = 0,
	347	.n_value = addr,
	348	};
	349	self.offset_table.items[decl.link.macho.offset_table_index.?] = addr;
	350
	351	try self.writeSymbol(decl.link.macho.symbol_table_index.?);
	352
	353	const text_section = self.sections.items[self.text_section_index.?];
	354	const section_offset = symbol.n_value - text_section.addr;
	355	const file_offset = text_section.offset + section_offset;
	356	log.debug("file_offset 0x{x}\n", .{file_offset});
	357	try self.base.file.?.pwriteAll(code, file_offset);
	358
	359	// Since we updated the vaddr and the size, each corresponding export symbol also needs to be updated.
	360	const decl_exports = module.decl_exports.get(decl) orelse &[0]*Module.Export{};
	361	return self.updateDeclExports(module, decl, decl_exports);
	362	}
308	363
309	364	pub fn updateDeclLineNumber(self: MachO, module: Module, decl: *const Module.Decl) !void {}
310	365
...	...	@@ -313,51 +368,191 @@ pub fn updateDeclExports(
313	368	module: *Module,
314	369	decl: *const Module.Decl,
315	370	exports: []const *Module.Export,
316		) !void {}
	371	) !void {
	372	const tracy = trace(@src());
	373	defer tracy.end();
	374
	375	if (decl.link.macho.symbol_table_index == null) return;
	376
	377	var decl_sym = self.symbol_table.items[decl.link.macho.symbol_table_index.?];
	378	// TODO implement
	379	if (exports.len == 0) return;
	380
	381	const exp = exports[0];
	382	self.entry_addr = decl_sym.n_value;
	383	decl_sym.n_type \|= macho.N_EXT;
	384	exp.link.sym_index = 0;
	385	}
317	386
318	387	pub fn freeDecl(self: MachO, decl: Module.Decl) void {}
319	388
320	389	pub fn getDeclVAddr(self: MachO, decl: const Module.Decl) u64 {
321		@panic("TODO implement getDeclVAddr for MachO");
	390	return self.symbol_table.items[decl.link.macho.symbol_table_index.?].n_value;
322	391	}
323	392
324	393	pub fn populateMissingMetadata(self: *MachO) !void {
325		if (self.text_segment_offset == null) {
326		self.text_segment_offset = @intCast(u64, self.segments.items.len);
327		const file_size = alignSize(u64, self.base.options.program_code_size_hint, 0x1000);
328		log.debug("vmsize/filesize = {}", .{file_size});
329		const file_offset = 0;
330		const vm_address = self.vm_start_address; // the end of __PAGEZERO segment in VM
331		const protection = macho.VM_PROT_READ \| macho.VM_PROT_EXECUTE;
332		const cmdsize = commandSize(@sizeOf(macho.segment_command_64));
333		const text_segment = .{
334		.cmd = macho.LC_SEGMENT_64,
335		.cmdsize = cmdsize,
336		.segname = makeString("__TEXT"),
337		.vmaddr = vm_address,
338		.vmsize = file_size,
339		.fileoff = 0, // __TEXT segment always starts at 0 file offset
340		.filesize = 0, //file_size,
341		.maxprot = protection,
342		.initprot = protection,
343		.nsects = 0,
344		.flags = 0,
345		};
346		try self.commands.append(self.base.allocator, .{
347		.cmd = macho.LC_SEGMENT_64,
348		.cmdsize = cmdsize,
	394	if (self.segment_cmd_index == null) {
	395	self.segment_cmd_index = @intCast(u16, self.load_commands.items.len);
	396	try self.load_commands.append(self.base.allocator, .{
	397	.Segment = .{
	398	.cmd = macho.LC_SEGMENT_64,
	399	.cmdsize = @sizeOf(macho.segment_command_64),
	400	.segname = makeStaticString(""),
	401	.vmaddr = 0,
	402	.vmsize = 0,
	403	.fileoff = 0,
	404	.filesize = 0,
	405	.maxprot = 0,
	406	.initprot = 0,
	407	.nsects = 0,
	408	.flags = 0,
	409	},
	410	});
	411	self.cmd_table_dirty = true;
	412	}
	413	if (self.symtab_cmd_index == null) {
	414	self.symtab_cmd_index = @intCast(u16, self.load_commands.items.len);
	415	try self.load_commands.append(self.base.allocator, .{
	416	.Symtab = .{
	417	.cmd = macho.LC_SYMTAB,
	418	.cmdsize = @sizeOf(macho.symtab_command),
	419	.symoff = 0,
	420	.nsyms = 0,
	421	.stroff = 0,
	422	.strsize = 0,
	423	},
	424	});
	425	self.cmd_table_dirty = true;
	426	}
	427	if (self.text_section_index == null) {
	428	self.text_section_index = @intCast(u16, self.sections.items.len);
	429	const segment = &self.load_commands.items[self.segment_cmd_index.?].Segment;
	430	segment.cmdsize += @sizeOf(macho.section_64);
	431	segment.nsects += 1;
	432
	433	const file_size = self.base.options.program_code_size_hint;
	434	const off = @intCast(u32, self.findFreeSpace(file_size, 1));
	435	const flags = macho.S_REGULAR \| macho.S_ATTR_PURE_INSTRUCTIONS \| macho.S_ATTR_SOME_INSTRUCTIONS;
	436
	437	log.debug("found __text section free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
	438
	439	try self.sections.append(self.base.allocator, .{
	440	.sectname = makeStaticString("__text"),
	441	.segname = makeStaticString("__TEXT"),
	442	.addr = 0,
	443	.size = file_size,
	444	.offset = off,
	445	.@"align" = 0x1000,
	446	.reloff = 0,
	447	.nreloc = 0,
	448	.flags = flags,
	449	.reserved1 = 0,
	450	.reserved2 = 0,
	451	.reserved3 = 0,
349	452	});
350		try self.segments.append(self.base.allocator, text_segment);
	453
	454	segment.vmsize += file_size;
	455	segment.filesize += file_size;
	456	segment.fileoff = off;
	457
	458	log.debug("initial text section {}\n", .{self.sections.items[self.text_section_index.?]});
	459	}
	460	{
	461	const symtab = &self.load_commands.items[self.symtab_cmd_index.?].Symtab;
	462	if (symtab.symoff == 0) {
	463	const p_align = @sizeOf(macho.nlist_64);
	464	const nsyms = self.base.options.symbol_count_hint;
	465	const file_size = p_align * nsyms;
	466	const off = @intCast(u32, self.findFreeSpace(file_size, p_align));
	467	log.debug("found symbol table free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
	468	symtab.symoff = off;
	469	symtab.nsyms = @intCast(u32, nsyms);
	470	}
	471	if (symtab.stroff == 0) {
	472	try self.string_table.append(self.base.allocator, 0);
	473	const file_size = @intCast(u32, self.string_table.items.len);
	474	const off = @intCast(u32, self.findFreeSpace(file_size, 1));
	475	log.debug("found string table free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
	476	symtab.stroff = off;
	477	symtab.strsize = file_size;
	478	}
	479	}
	480	}
	481
	482	fn allocateTextBlock(self: MachO, text_block: TextBlock, new_block_size: u64, alignment: u64) !u64 {
	483	const segment = &self.load_commands.items[self.segment_cmd_index.?].Segment;
	484	const text_section = &self.sections.items[self.text_section_index.?];
	485	const new_block_ideal_capacity = new_block_size * alloc_num / alloc_den;
	486
	487	var block_placement: ?*TextBlock = null;
	488	const addr = blk: {
	489	if (self.last_text_block) \|last\| {
	490	const last_symbol = self.symbol_table.items[last.symbol_table_index.?];
	491	const ideal_capacity = last.size * alloc_num / alloc_den;
	492	const ideal_capacity_end_addr = last_symbol.n_value + ideal_capacity;
	493	const new_start_addr = mem.alignForwardGeneric(u64, ideal_capacity_end_addr, alignment);
	494	block_placement = last;
	495	break :blk new_start_addr;
	496	} else {
	497	break :blk text_section.addr;
	498	}
	499	};
	500	log.debug("computed symbol address 0x{x}\n", .{addr});
	501
	502	const expand_text_section = block_placement == null or block_placement.?.next == null;
	503	if (expand_text_section) {
	504	const text_capacity = self.allocatedSize(text_section.offset);
	505	const needed_size = (addr + new_block_size) - text_section.addr;
	506	log.debug("text capacity 0x{x}, needed size 0x{x}\n", .{ text_capacity, needed_size });
	507
	508	if (needed_size > text_capacity) {
	509	// TODO handle growth
	510	}
	511
	512	self.last_text_block = text_block;
	513	text_section.size = needed_size;
	514	segment.vmsize = needed_size;
	515	segment.filesize = needed_size;
	516	if (alignment < text_section.@"align") {
	517	text_section.@"align" = @intCast(u32, alignment);
	518	}
	519	}
	520	text_block.size = new_block_size;
	521
	522	if (text_block.prev) \|prev\| {
	523	prev.next = text_block.next;
	524	}
	525	if (text_block.next) \|next\| {
	526	next.prev = text_block.prev;
	527	}
	528
	529	if (block_placement) \|big_block\| {
	530	text_block.prev = big_block;
	531	text_block.next = big_block.next;
	532	big_block.next = text_block;
	533	} else {
	534	text_block.prev = null;
	535	text_block.next = null;
351	536	}
	537
	538	return addr;
352	539	}
353	540
354		fn makeString(comptime bytes: []const u8) [16]u8 {
	541	fn makeStaticString(comptime bytes: []const u8) [16]u8 {
355	542	var buf = [_]u8{0} ** 16;
356		if (bytes.len > buf.len) @compileError("MachO segment/section name too long");
	543	if (bytes.len > buf.len) @compileError("string too long; max 16 bytes");
357	544	mem.copy(u8, buf[0..], bytes);
358	545	return buf;
359	546	}
360	547
	548	fn makeString(self: *MachO, bytes: []const u8) !u32 {
	549	try self.string_table.ensureCapacity(self.base.allocator, self.string_table.items.len + bytes.len + 1);
	550	const result = self.string_table.items.len;
	551	self.string_table.appendSliceAssumeCapacity(bytes);
	552	self.string_table.appendAssumeCapacity(0);
	553	return @intCast(u32, result);
	554	}
	555
361	556	fn alignSize(comptime Int: type, min_size: anytype, alignment: Int) Int {
362	557	const size = @intCast(Int, min_size);
363	558	if (size % alignment == 0) return size;
...	...	@@ -370,7 +565,7 @@ fn commandSize(min_size: anytype) u32 {
370	565	return alignSize(u32, min_size, @sizeOf(u64));
371	566	}
372	567
373		fn addPadding(self: *MachO, size: u32, file_offset: u64) !void {
	568	fn addPadding(self: *MachO, size: u64, file_offset: u64) !void {
374	569	if (size == 0) return;
375	570
376	571	const buf = try self.base.allocator.alloc(u8, size);
...	...	@@ -380,3 +575,151 @@ fn addPadding(self: *MachO, size: u32, file_offset: u64) !void {
380	575
381	576	try self.base.file.?.pwriteAll(buf, file_offset);
382	577	}
	578
	579	fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {
	580	const hdr_size: u64 = @sizeOf(macho.mach_header_64);
	581	if (start < hdr_size)
	582	return hdr_size;
	583
	584	const end = start + satMul(size, alloc_num) / alloc_den;
	585
	586	{
	587	const off = @sizeOf(macho.mach_header_64);
	588	var tight_size: u64 = 0;
	589	for (self.load_commands.items) \|cmd\| {
	590	tight_size += cmd.cmdsize();
	591	}
	592	const increased_size = satMul(tight_size, alloc_num) / alloc_den;
	593	const test_end = off + increased_size;
	594	if (end > off and start < test_end) {
	595	return test_end;
	596	}
	597	}
	598
	599	for (self.sections.items) \|section\| {
	600	const increased_size = satMul(section.size, alloc_num) / alloc_den;
	601	const test_end = section.offset + increased_size;
	602	if (end > section.offset and start < test_end) {
	603	return test_end;
	604	}
	605	}
	606
	607	if (self.symtab_cmd_index) \|symtab_index\| {
	608	const symtab = self.load_commands.items[symtab_index].Symtab;
	609	{
	610	const tight_size = @sizeOf(macho.nlist_64) * symtab.nsyms;
	611	const increased_size = satMul(tight_size, alloc_num) / alloc_den;
	612	const test_end = symtab.symoff + increased_size;
	613	if (end > symtab.symoff and start < test_end) {
	614	return test_end;
	615	}
	616	}
	617	{
	618	const increased_size = satMul(symtab.strsize, alloc_num) / alloc_den;
	619	const test_end = symtab.stroff + increased_size;
	620	if (end > symtab.stroff and start < test_end) {
	621	return test_end;
	622	}
	623	}
	624	}
	625
	626	return null;
	627	}
	628
	629	fn allocatedSize(self: *MachO, start: u64) u64 {
	630	if (start == 0)
	631	return 0;
	632	var min_pos: u64 = std.math.maxInt(u64);
	633	{
	634	const off = @sizeOf(macho.mach_header_64);
	635	if (off > start and off < min_pos) min_pos = off;
	636	}
	637	for (self.sections.items) \|section\| {
	638	if (section.offset <= start) continue;
	639	if (section.offset < min_pos) min_pos = section.offset;
	640	}
	641	if (self.symtab_cmd_index) \|symtab_index\| {
	642	const symtab = self.load_commands.items[symtab_index].Symtab;
	643	if (symtab.symoff > start and symtab.symoff < min_pos) min_pos = symtab.symoff;
	644	if (symtab.stroff > start and symtab.stroff < min_pos) min_pos = symtab.stroff;
	645	}
	646	return min_pos - start;
	647	}
	648
	649	fn findFreeSpace(self: *MachO, object_size: u64, min_alignment: u16) u64 {
	650	var start: u64 = 0;
	651	while (self.detectAllocCollision(start, object_size)) \|item_end\| {
	652	start = mem.alignForwardGeneric(u64, item_end, min_alignment);
	653	}
	654	return start;
	655	}
	656
	657	fn writeSymbol(self: *MachO, index: usize) !void {
	658	const tracy = trace(@src());
	659	defer tracy.end();
	660
	661	const symtab = &self.load_commands.items[self.symtab_cmd_index.?].Symtab;
	662	var sym = [1]macho.nlist_64{self.symbol_table.items[index]};
	663	const off = symtab.symoff + @sizeOf(macho.nlist_64) * index;
	664	log.debug("writing symbol {} at 0x{x}\n", .{ sym[0], off });
	665	try self.base.file.?.pwriteAll(mem.sliceAsBytes(sym[0..1]), off);
	666	}
	667
	668	/// Writes Mach-O file header.
	669	/// Should be invoked last as it needs up-to-date values of ncmds and sizeof_cmds bookkeeping
	670	/// variables.
	671	fn writeMachOHeader(self: *MachO) !void {
	672	var hdr: macho.mach_header_64 = undefined;
	673	hdr.magic = macho.MH_MAGIC_64;
	674
	675	const CpuInfo = struct {
	676	cpu_type: macho.cpu_type_t,
	677	cpu_subtype: macho.cpu_subtype_t,
	678	};
	679
	680	const cpu_info: CpuInfo = switch (self.base.options.target.cpu.arch) {
	681	.aarch64 => .{
	682	.cpu_type = macho.CPU_TYPE_ARM64,
	683	.cpu_subtype = macho.CPU_SUBTYPE_ARM_ALL,
	684	},
	685	.x86_64 => .{
	686	.cpu_type = macho.CPU_TYPE_X86_64,
	687	.cpu_subtype = macho.CPU_SUBTYPE_X86_64_ALL,
	688	},
	689	else => return error.UnsupportedMachOArchitecture,
	690	};
	691	hdr.cputype = cpu_info.cpu_type;
	692	hdr.cpusubtype = cpu_info.cpu_subtype;
	693
	694	const filetype: u32 = switch (self.base.options.output_mode) {
	695	.Exe => macho.MH_EXECUTE,
	696	.Obj => macho.MH_OBJECT,
	697	.Lib => switch (self.base.options.link_mode) {
	698	.Static => return error.TODOStaticLibMachOType,
	699	.Dynamic => macho.MH_DYLIB,
	700	},
	701	};
	702	hdr.filetype = filetype;
	703	hdr.ncmds = @intCast(u32, self.load_commands.items.len);
	704
	705	var sizeofcmds: u32 = 0;
	706	for (self.load_commands.items) \|cmd\| {
	707	sizeofcmds += cmd.cmdsize();
	708	}
	709
	710	hdr.sizeofcmds = sizeofcmds;
	711
	712	// TODO should these be set to something else?
	713	hdr.flags = 0;
	714	hdr.reserved = 0;
	715
	716	log.debug("writing Mach-O header {}\n", .{hdr});
	717
	718	try self.base.file.?.pwriteAll(@ptrCast([*]const u8, &hdr)[0..@sizeOf(macho.mach_header_64)], 0);
	719	}
	720
	721	/// Saturating multiplication
	722	fn satMul(a: anytype, b: anytype) @TypeOf(a, b) {
	723	const T = @TypeOf(a, b);
	724	return std.math.mul(T, a, b) catch std.math.maxInt(T);
	725	}

src-self-hosted/link/msdos-stub.bin created

Binary files /dev/null and b/src-self-hosted/link/msdos-stub.bin differ

src-self-hosted/main.zig+18-8

...	...	@@ -153,8 +153,8 @@ const usage_build_generic =
153	153	\\ elf Executable and Linking Format
154	154	\\ c Compile to C source code
155	155	\\ wasm WebAssembly
	156	\\ pe Portable Executable (Windows)
156	157	\\ coff (planned) Common Object File Format (Windows)
157		\\ pe (planned) Portable Executable (Windows)
158	158	\\ macho (planned) macOS relocatables
159	159	\\ hex (planned) Intel IHEX
160	160	\\ raw (planned) Dump machine code directly
...	...	@@ -451,7 +451,7 @@ fn buildOutputType(
451	451	} else if (mem.eql(u8, ofmt, "coff")) {
452	452	break :blk .coff;
453	453	} else if (mem.eql(u8, ofmt, "pe")) {
454		break :blk .coff;
	454	break :blk .pe;
455	455	} else if (mem.eql(u8, ofmt, "macho")) {
456	456	break :blk .macho;
457	457	} else if (mem.eql(u8, ofmt, "wasm")) {
...	...	@@ -524,17 +524,19 @@ fn buildOutputType(
524	524	try stderr.print("\nUnable to parse command: {}\n", .{@errorName(err)});
525	525	continue;
526	526	}) \|line\| {
527		if (mem.eql(u8, line, "update")) {
	527	const actual_line = mem.trimRight(u8, line, "\r\n ");
	528
	529	if (mem.eql(u8, actual_line, "update")) {
528	530	if (output_mode == .Exe) {
529	531	try module.makeBinFileWritable();
530	532	}
531	533	try updateModule(gpa, &module, zir_out_path);
532		} else if (mem.eql(u8, line, "exit")) {
	534	} else if (mem.eql(u8, actual_line, "exit")) {
533	535	break;
534		} else if (mem.eql(u8, line, "help")) {
	536	} else if (mem.eql(u8, actual_line, "help")) {
535	537	try stderr.writeAll(repl_help);
536	538	} else {
537		try stderr.print("unknown command: {}\n", .{line});
	539	try stderr.print("unknown command: {}\n", .{actual_line});
538	540	}
539	541	} else {
540	542	break;
...	...	@@ -742,6 +744,7 @@ const FmtError = error{
742	744	LinkQuotaExceeded,
743	745	FileBusy,
744	746	EndOfStream,
	747	Unseekable,
745	748	NotOpenForWriting,
746	749	} \|\| fs.File.OpenError;
747	750
...	...	@@ -805,7 +808,13 @@ fn fmtPathFile(
805	808	if (stat.kind == .Directory)
806	809	return error.IsDir;
807	810
808		const source_code = source_file.readAllAlloc(fmt.gpa, stat.size, max_src_size) catch \|err\| switch (err) {
	811	const source_code = source_file.readToEndAllocOptions(
	812	fmt.gpa,
	813	max_src_size,
	814	stat.size,
	815	@alignOf(u8),
	816	null,
	817	) catch \|err\| switch (err) {
809	818	error.ConnectionResetByPeer => unreachable,
810	819	error.ConnectionTimedOut => unreachable,
811	820	error.NotOpenForReading => unreachable,
...	...	@@ -839,7 +848,8 @@ fn fmtPathFile(
839	848	// As a heuristic, we make enough capacity for the same as the input source.
840	849	try fmt.out_buffer.ensureCapacity(source_code.len);
841	850	fmt.out_buffer.items.len = 0;
842		const anything_changed = try std.zig.render(fmt.gpa, fmt.out_buffer.writer(), tree);
	851	const writer = fmt.out_buffer.writer();
	852	const anything_changed = try std.zig.render(fmt.gpa, writer, tree);
843	853	if (!anything_changed)
844	854	return; // Good thing we didn't waste any file system access on this.
845	855

src-self-hosted/stage2.zig-1

...	...	@@ -615,7 +615,6 @@ export fn stage2_libc_parse(stage1_libc: *Stage2LibCInstallation, libc_file_z: [
615	615	error.NotOpenForWriting => unreachable,
616	616	error.NotOpenForReading => unreachable,
617	617	error.Unexpected => return .Unexpected,
618		error.EndOfStream => return .EndOfFile,
619	618	error.IsDir => return .IsDir,
620	619	error.ConnectionResetByPeer => unreachable,
621	620	error.ConnectionTimedOut => unreachable,

src-self-hosted/type.zig+98-20

...	...	@@ -163,7 +163,7 @@ pub const Type = extern union {
163	163	// Hot path for common case:
164	164	if (a.castPointer()) \|a_payload\| {
165	165	if (b.castPointer()) \|b_payload\| {
166		return eql(a_payload.pointee_type, b_payload.pointee_type);
	166	return a.tag() == b.tag() and eql(a_payload.pointee_type, b_payload.pointee_type);
167	167	}
168	168	}
169	169	const is_slice_a = isSlice(a);
...	...	@@ -189,10 +189,10 @@ pub const Type = extern union {
189	189	.Array => {
190	190	if (a.arrayLen() != b.arrayLen())
191	191	return false;
192		if (a.elemType().eql(b.elemType()))
	192	if (!a.elemType().eql(b.elemType()))
193	193	return false;
194		const sentinel_a = a.arraySentinel();
195		const sentinel_b = b.arraySentinel();
	194	const sentinel_a = a.sentinel();
	195	const sentinel_b = b.sentinel();
196	196	if (sentinel_a) \|sa\| {
197	197	if (sentinel_b) \|sb\| {
198	198	return sa.eql(sb);
...	...	@@ -501,9 +501,9 @@ pub const Type = extern union {
501	501	.noreturn,
502	502	=> return out_stream.writeAll(@tagName(t)),
503	503
504		.enum_literal => return out_stream.writeAll("@TypeOf(.EnumLiteral)"),
505		.@"null" => return out_stream.writeAll("@TypeOf(null)"),
506		.@"undefined" => return out_stream.writeAll("@TypeOf(undefined)"),
	504	.enum_literal => return out_stream.writeAll("@Type(.EnumLiteral)"),
	505	.@"null" => return out_stream.writeAll("@Type(.Null)"),
	506	.@"undefined" => return out_stream.writeAll("@Type(.Undefined)"),
507	507
508	508	.@"anyframe" => return out_stream.writeAll("anyframe"),
509	509	.anyerror_void_error_union => return out_stream.writeAll("anyerror!void"),
...	...	@@ -630,8 +630,8 @@ pub const Type = extern union {
630	630	const payload = @fieldParentPtr(Payload.Pointer, "base", ty.ptr_otherwise);
631	631	if (payload.sentinel) \|some\| switch (payload.size) {
632	632	.One, .C => unreachable,
633		.Many => try out_stream.writeAll("[*:{}]"),
634		.Slice => try out_stream.writeAll("[:{}]"),
	633	.Many => try out_stream.print("[*:{}]", .{some}),
	634	.Slice => try out_stream.print("[:{}]", .{some}),
635	635	} else switch (payload.size) {
636	636	.One => try out_stream.writeAll("*"),
637	637	.Many => try out_stream.writeAll("[*]"),
...	...	@@ -1341,6 +1341,81 @@ pub const Type = extern union {
1341	1341	};
1342	1342	}
1343	1343
	1344	pub fn isAllowzeroPtr(self: Type) bool {
	1345	return switch (self.tag()) {
	1346	.u8,
	1347	.i8,
	1348	.u16,
	1349	.i16,
	1350	.u32,
	1351	.i32,
	1352	.u64,
	1353	.i64,
	1354	.usize,
	1355	.isize,
	1356	.c_short,
	1357	.c_ushort,
	1358	.c_int,
	1359	.c_uint,
	1360	.c_long,
	1361	.c_ulong,
	1362	.c_longlong,
	1363	.c_ulonglong,
	1364	.c_longdouble,
	1365	.f16,
	1366	.f32,
	1367	.f64,
	1368	.f128,
	1369	.c_void,
	1370	.bool,
	1371	.void,
	1372	.type,
	1373	.anyerror,
	1374	.comptime_int,
	1375	.comptime_float,
	1376	.noreturn,
	1377	.@"null",
	1378	.@"undefined",
	1379	.array,
	1380	.array_sentinel,
	1381	.array_u8,
	1382	.array_u8_sentinel_0,
	1383	.fn_noreturn_no_args,
	1384	.fn_void_no_args,
	1385	.fn_naked_noreturn_no_args,
	1386	.fn_ccc_void_no_args,
	1387	.function,
	1388	.int_unsigned,
	1389	.int_signed,
	1390	.single_mut_pointer,
	1391	.single_const_pointer,
	1392	.many_const_pointer,
	1393	.many_mut_pointer,
	1394	.c_const_pointer,
	1395	.c_mut_pointer,
	1396	.const_slice,
	1397	.mut_slice,
	1398	.single_const_pointer_to_comptime_int,
	1399	.const_slice_u8,
	1400	.optional,
	1401	.optional_single_mut_pointer,
	1402	.optional_single_const_pointer,
	1403	.enum_literal,
	1404	.error_union,
	1405	.@"anyframe",
	1406	.anyframe_T,
	1407	.anyerror_void_error_union,
	1408	.error_set,
	1409	.error_set_single,
	1410	=> false,
	1411
	1412	.pointer => {
	1413	const payload = @fieldParentPtr(Payload.Pointer, "base", self.ptr_otherwise);
	1414	return payload.@"allowzero";
	1415	},
	1416	};
	1417	}
	1418
1344	1419	/// Asserts that the type is an optional
1345	1420	pub fn isPtrLikeOptional(self: Type) bool {
1346	1421	switch (self.tag()) {
...	...	@@ -1585,8 +1660,8 @@ pub const Type = extern union {
1585	1660	};
1586	1661	}
1587	1662
1588		/// Asserts the type is an array or vector.
1589		pub fn arraySentinel(self: Type) ?Value {
	1663	/// Asserts the type is an array, pointer or vector.
	1664	pub fn sentinel(self: Type) ?Value {
1590	1665	return switch (self.tag()) {
1591	1666	.u8,
1592	1667	.i8,
...	...	@@ -1626,16 +1701,8 @@ pub const Type = extern union {
1626	1701	.fn_naked_noreturn_no_args,
1627	1702	.fn_ccc_void_no_args,
1628	1703	.function,
1629		.pointer,
1630		.single_const_pointer,
1631		.single_mut_pointer,
1632		.many_const_pointer,
1633		.many_mut_pointer,
1634		.c_const_pointer,
1635		.c_mut_pointer,
1636	1704	.const_slice,
1637	1705	.mut_slice,
1638		.single_const_pointer_to_comptime_int,
1639	1706	.const_slice_u8,
1640	1707	.int_unsigned,
1641	1708	.int_signed,
...	...	@@ -1651,7 +1718,18 @@ pub const Type = extern union {
1651	1718	.error_set_single,
1652	1719	=> unreachable,
1653	1720
1654		.array, .array_u8 => return null,
	1721	.single_const_pointer,
	1722	.single_mut_pointer,
	1723	.many_const_pointer,
	1724	.many_mut_pointer,
	1725	.c_const_pointer,
	1726	.c_mut_pointer,
	1727	.single_const_pointer_to_comptime_int,
	1728	.array,
	1729	.array_u8,
	1730	=> return null,
	1731
	1732	.pointer => return self.cast(Payload.Pointer).?.sentinel,
1655	1733	.array_sentinel => return self.cast(Payload.ArraySentinel).?.sentinel,
1656	1734	.array_u8_sentinel_0 => return Value.initTag(.zero),
1657	1735	};

src-self-hosted/value.zig+3-3

...	...	@@ -301,15 +301,15 @@ pub const Value = extern union {
301	301	.comptime_int_type => return out_stream.writeAll("comptime_int"),
302	302	.comptime_float_type => return out_stream.writeAll("comptime_float"),
303	303	.noreturn_type => return out_stream.writeAll("noreturn"),
304		.null_type => return out_stream.writeAll("@TypeOf(null)"),
305		.undefined_type => return out_stream.writeAll("@TypeOf(undefined)"),
	304	.null_type => return out_stream.writeAll("@Type(.Null)"),
	305	.undefined_type => return out_stream.writeAll("@Type(.Undefined)"),
306	306	.fn_noreturn_no_args_type => return out_stream.writeAll("fn() noreturn"),
307	307	.fn_void_no_args_type => return out_stream.writeAll("fn() void"),
308	308	.fn_naked_noreturn_no_args_type => return out_stream.writeAll("fn() callconv(.Naked) noreturn"),
309	309	.fn_ccc_void_no_args_type => return out_stream.writeAll("fn() callconv(.C) void"),
310	310	.single_const_pointer_to_comptime_int_type => return out_stream.writeAll("*const comptime_int"),
311	311	.const_slice_u8_type => return out_stream.writeAll("[]const u8"),
312		.enum_literal_type => return out_stream.writeAll("@TypeOf(.EnumLiteral)"),
	312	.enum_literal_type => return out_stream.writeAll("@Type(.EnumLiteral)"),
313	313	.anyframe_type => return out_stream.writeAll("anyframe"),
314	314
315	315	.null_value => return out_stream.writeAll("null"),

src-self-hosted/zir.zig+23-1

...	...	@@ -231,6 +231,10 @@ pub const Inst = struct {
231	231	const_slice_type,
232	232	/// Create a pointer type with attributes
233	233	ptr_type,
	234	/// Slice operation `array_ptr[start..end:sentinel]`
	235	slice,
	236	/// Slice operation with just start `lhs[rhs..]`
	237	slice_start,
234	238	/// Write a value to a pointer. For loading, see `deref`.
235	239	store,
236	240	/// String Literal. Makes an anonymous Decl and then takes a pointer to it.
...	...	@@ -343,6 +347,7 @@ pub const Inst = struct {
343	347	.xor,
344	348	.error_union_type,
345	349	.merge_error_sets,
	350	.slice_start,
346	351	=> BinOp,
347	352
348	353	.block,
...	...	@@ -380,6 +385,7 @@ pub const Inst = struct {
380	385	.ptr_type => PtrType,
381	386	.enum_literal => EnumLiteral,
382	387	.error_set => ErrorSet,
	388	.slice => Slice,
383	389	};
384	390	}
385	391
...	...	@@ -481,6 +487,8 @@ pub const Inst = struct {
481	487	.error_union_type,
482	488	.bitnot,
483	489	.error_set,
	490	.slice,
	491	.slice_start,
484	492	=> false,
485	493
486	494	.@"break",
...	...	@@ -961,6 +969,20 @@ pub const Inst = struct {
961	969	},
962	970	kw_args: struct {},
963	971	};
	972
	973	pub const Slice = struct {
	974	pub const base_tag = Tag.slice;
	975	base: Inst,
	976
	977	positionals: struct {
	978	array_ptr: *Inst,
	979	start: *Inst,
	980	},
	981	kw_args: struct {
	982	end: ?*Inst = null,
	983	sentinel: ?*Inst = null,
	984	},
	985	};
964	986	};
965	987
966	988	pub const ErrorMsg = struct {
...	...	@@ -2574,7 +2596,7 @@ const EmitZIR = struct {
2574	2596	var len_pl = Value.Payload.Int_u64{ .int = ty.arrayLen() };
2575	2597	const len = Value.initPayload(&len_pl.base);
2576	2598
2577		const inst = if (ty.arraySentinel()) \|sentinel\| blk: {
	2599	const inst = if (ty.sentinel()) \|sentinel\| blk: {
2578	2600	const inst = try self.arena.allocator.create(Inst.ArrayTypeSentinel);
2579	2601	inst.* = .{
2580	2602	.base = .{

src-self-hosted/zir_sema.zig+24

...	...	@@ -132,6 +132,8 @@ pub fn analyzeInst(mod: Module, scope: Scope, old_inst: *zir.Inst) InnerError!
132	132	.error_union_type => return analyzeInstErrorUnionType(mod, scope, old_inst.castTag(.error_union_type).?),
133	133	.anyframe_type => return analyzeInstAnyframeType(mod, scope, old_inst.castTag(.anyframe_type).?),
134	134	.error_set => return analyzeInstErrorSet(mod, scope, old_inst.castTag(.error_set).?),
	135	.slice => return analyzeInstSlice(mod, scope, old_inst.castTag(.slice).?),
	136	.slice_start => return analyzeInstSliceStart(mod, scope, old_inst.castTag(.slice_start).?),
135	137	}
136	138	}
137	139
...	...	@@ -1172,6 +1174,22 @@ fn analyzeInstElemPtr(mod: Module, scope: Scope, inst: *zir.Inst.ElemPtr) Inne
1172	1174	return mod.fail(scope, inst.base.src, "TODO implement more analyze elemptr", .{});
1173	1175	}
1174	1176
	1177	fn analyzeInstSlice(mod: Module, scope: Scope, inst: zir.Inst.Slice) InnerError!Inst {
	1178	const array_ptr = try resolveInst(mod, scope, inst.positionals.array_ptr);
	1179	const start = try resolveInst(mod, scope, inst.positionals.start);
	1180	const end = if (inst.kw_args.end) \|end\| try resolveInst(mod, scope, end) else null;
	1181	const sentinel = if (inst.kw_args.sentinel) \|sentinel\| try resolveInst(mod, scope, sentinel) else null;
	1182
	1183	return mod.analyzeSlice(scope, inst.base.src, array_ptr, start, end, sentinel);
	1184	}
	1185
	1186	fn analyzeInstSliceStart(mod: Module, scope: Scope, inst: zir.Inst.BinOp) InnerError!Inst {
	1187	const array_ptr = try resolveInst(mod, scope, inst.positionals.lhs);
	1188	const start = try resolveInst(mod, scope, inst.positionals.rhs);
	1189
	1190	return mod.analyzeSlice(scope, inst.base.src, array_ptr, start, null, null);
	1191	}
	1192
1175	1193	fn analyzeInstShl(mod: Module, scope: Scope, inst: zir.Inst.BinOp) InnerError!Inst {
1176	1194	return mod.fail(scope, inst.base.src, "TODO implement analyzeInstShl", .{});
1177	1195	}
...	...	@@ -1239,6 +1257,12 @@ fn analyzeInstArithmetic(mod: Module, scope: Scope, inst: *zir.Inst.BinOp) Inn
1239	1257
1240	1258	if (casted_lhs.value()) \|lhs_val\| {
1241	1259	if (casted_rhs.value()) \|rhs_val\| {
	1260	if (lhs_val.isUndef() or rhs_val.isUndef()) {
	1261	return mod.constInst(scope, inst.base.src, .{
	1262	.ty = resolved_type,
	1263	.val = Value.initTag(.undef),
	1264	});
	1265	}
1242	1266	return analyzeInstComptimeOp(mod, scope, scalar_type, inst, lhs_val, rhs_val);
1243	1267	}
1244	1268	}

src/analyze.cpp+1-1

...	...	@@ -1810,7 +1810,7 @@ Error type_allowed_in_extern(CodeGen g, ZigType type_entry, bool *result) {
1810	1810	ZigType get_auto_err_set_type(CodeGen g, ZigFn *fn_entry) {
1811	1811	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
1812	1812	buf_resize(&err_set_type->name, 0);
1813		buf_appendf(&err_set_type->name, "@TypeOf(%s).ReturnType.ErrorSet", buf_ptr(&fn_entry->symbol_name));
	1813	buf_appendf(&err_set_type->name, "@typeInfo(@typeInfo(@TypeOf(%s)).Fn.return_type.?).ErrorUnion.error_set", buf_ptr(&fn_entry->symbol_name));
1814	1814	err_set_type->data.error_set.err_count = 0;
1815	1815	err_set_type->data.error_set.errors = nullptr;
1816	1816	err_set_type->data.error_set.infer_fn = fn_entry;

src/ir.cpp+9-162

...	...	@@ -15341,9 +15341,14 @@ static IrInstGen ir_analyze_cast(IrAnalyze ira, IrInst *source_instr,
15341	15341	ZigType *array_type = actual_type->data.pointer.child_type;
15342	15342	bool const_ok = (slice_ptr_type->data.pointer.is_const \|\| array_type->data.array.len == 0
15343	15343	\|\| !actual_type->data.pointer.is_const);
	15344
15344	15345	if (const_ok && types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
15345	15346	array_type->data.array.child_type, source_node,
15346		!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
	15347	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk &&
	15348	(slice_ptr_type->data.pointer.sentinel == nullptr \|\|
	15349	(array_type->data.array.sentinel != nullptr &&
	15350	const_values_equal(ira->codegen, array_type->data.array.sentinel,
	15351	slice_ptr_type->data.pointer.sentinel))))
15347	15352	{
15348	15353	// If the pointers both have ABI align, it works.
15349	15354	// Or if the array length is 0, alignment doesn't matter.
...	...	@@ -22830,167 +22835,9 @@ static IrInstGen ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstSrcFiel
22830	22835	bool ptr_is_volatile = false;
22831	22836	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base, const_val,
22832	22837	err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22833		} else if (child_type->id == ZigTypeIdInt) {
22834		if (buf_eql_str(field_name, "bit_count")) {
22835		bool ptr_is_const = true;
22836		bool ptr_is_volatile = false;
22837		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22838		create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22839		child_type->data.integral.bit_count, false),
22840		ira->codegen->builtin_types.entry_num_lit_int,
22841		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22842		} else if (buf_eql_str(field_name, "is_signed")) {
22843		bool ptr_is_const = true;
22844		bool ptr_is_volatile = false;
22845		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22846		create_const_bool(ira->codegen, child_type->data.integral.is_signed),
22847		ira->codegen->builtin_types.entry_bool,
22848		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22849		} else {
22850		ir_add_error(ira, &field_ptr_instruction->base.base,
22851		buf_sprintf("type '%s' has no member called '%s'",
22852		buf_ptr(&child_type->name), buf_ptr(field_name)));
22853		return ira->codegen->invalid_inst_gen;
22854		}
22855		} else if (child_type->id == ZigTypeIdFloat) {
22856		if (buf_eql_str(field_name, "bit_count")) {
22857		bool ptr_is_const = true;
22858		bool ptr_is_volatile = false;
22859		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22860		create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22861		child_type->data.floating.bit_count, false),
22862		ira->codegen->builtin_types.entry_num_lit_int,
22863		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22864		} else {
22865		ir_add_error(ira, &field_ptr_instruction->base.base,
22866		buf_sprintf("type '%s' has no member called '%s'",
22867		buf_ptr(&child_type->name), buf_ptr(field_name)));
22868		return ira->codegen->invalid_inst_gen;
22869		}
22870		} else if (child_type->id == ZigTypeIdPointer) {
22871		if (buf_eql_str(field_name, "Child")) {
22872		bool ptr_is_const = true;
22873		bool ptr_is_volatile = false;
22874		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22875		create_const_type(ira->codegen, child_type->data.pointer.child_type),
22876		ira->codegen->builtin_types.entry_type,
22877		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22878		} else if (buf_eql_str(field_name, "alignment")) {
22879		bool ptr_is_const = true;
22880		bool ptr_is_volatile = false;
22881		if ((err = type_resolve(ira->codegen, child_type->data.pointer.child_type,
22882		ResolveStatusAlignmentKnown)))
22883		{
22884		return ira->codegen->invalid_inst_gen;
22885		}
22886		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22887		create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22888		get_ptr_align(ira->codegen, child_type), false),
22889		ira->codegen->builtin_types.entry_num_lit_int,
22890		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22891		} else {
22892		ir_add_error(ira, &field_ptr_instruction->base.base,
22893		buf_sprintf("type '%s' has no member called '%s'",
22894		buf_ptr(&child_type->name), buf_ptr(field_name)));
22895		return ira->codegen->invalid_inst_gen;
22896		}
22897		} else if (child_type->id == ZigTypeIdArray) {
22898		if (buf_eql_str(field_name, "Child")) {
22899		bool ptr_is_const = true;
22900		bool ptr_is_volatile = false;
22901		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22902		create_const_type(ira->codegen, child_type->data.array.child_type),
22903		ira->codegen->builtin_types.entry_type,
22904		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22905		} else if (buf_eql_str(field_name, "len")) {
22906		bool ptr_is_const = true;
22907		bool ptr_is_volatile = false;
22908		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22909		create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22910		child_type->data.array.len, false),
22911		ira->codegen->builtin_types.entry_num_lit_int,
22912		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22913		} else {
22914		ir_add_error(ira, &field_ptr_instruction->base.base,
22915		buf_sprintf("type '%s' has no member called '%s'",
22916		buf_ptr(&child_type->name), buf_ptr(field_name)));
22917		return ira->codegen->invalid_inst_gen;
22918		}
22919		} else if (child_type->id == ZigTypeIdErrorUnion) {
22920		if (buf_eql_str(field_name, "Payload")) {
22921		bool ptr_is_const = true;
22922		bool ptr_is_volatile = false;
22923		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22924		create_const_type(ira->codegen, child_type->data.error_union.payload_type),
22925		ira->codegen->builtin_types.entry_type,
22926		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22927		} else if (buf_eql_str(field_name, "ErrorSet")) {
22928		bool ptr_is_const = true;
22929		bool ptr_is_volatile = false;
22930		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22931		create_const_type(ira->codegen, child_type->data.error_union.err_set_type),
22932		ira->codegen->builtin_types.entry_type,
22933		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22934		} else {
22935		ir_add_error(ira, &field_ptr_instruction->base.base,
22936		buf_sprintf("type '%s' has no member called '%s'",
22937		buf_ptr(&child_type->name), buf_ptr(field_name)));
22938		return ira->codegen->invalid_inst_gen;
22939		}
22940		} else if (child_type->id == ZigTypeIdOptional) {
22941		if (buf_eql_str(field_name, "Child")) {
22942		bool ptr_is_const = true;
22943		bool ptr_is_volatile = false;
22944		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22945		create_const_type(ira->codegen, child_type->data.maybe.child_type),
22946		ira->codegen->builtin_types.entry_type,
22947		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22948		} else {
22949		ir_add_error(ira, &field_ptr_instruction->base.base,
22950		buf_sprintf("type '%s' has no member called '%s'",
22951		buf_ptr(&child_type->name), buf_ptr(field_name)));
22952		return ira->codegen->invalid_inst_gen;
22953		}
22954		} else if (child_type->id == ZigTypeIdFn) {
22955		if (buf_eql_str(field_name, "ReturnType")) {
22956		if (child_type->data.fn.fn_type_id.return_type == nullptr) {
22957		// Return type can only ever be null, if the function is generic
22958		assert(child_type->data.fn.is_generic);
22959
22960		ir_add_error(ira, &field_ptr_instruction->base.base,
22961		buf_sprintf("ReturnType has not been resolved because '%s' is generic", buf_ptr(&child_type->name)));
22962		return ira->codegen->invalid_inst_gen;
22963		}
22964
22965		bool ptr_is_const = true;
22966		bool ptr_is_volatile = false;
22967		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22968		create_const_type(ira->codegen, child_type->data.fn.fn_type_id.return_type),
22969		ira->codegen->builtin_types.entry_type,
22970		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22971		} else if (buf_eql_str(field_name, "is_var_args")) {
22972		bool ptr_is_const = true;
22973		bool ptr_is_volatile = false;
22974		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22975		create_const_bool(ira->codegen, child_type->data.fn.fn_type_id.is_var_args),
22976		ira->codegen->builtin_types.entry_bool,
22977		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22978		} else if (buf_eql_str(field_name, "arg_count")) {
22979		bool ptr_is_const = true;
22980		bool ptr_is_volatile = false;
22981		return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22982		create_const_usize(ira->codegen, child_type->data.fn.fn_type_id.param_count),
22983		ira->codegen->builtin_types.entry_usize,
22984		ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22985		} else {
22986		ir_add_error(ira, &field_ptr_instruction->base.base,
22987		buf_sprintf("type '%s' has no member called '%s'",
22988		buf_ptr(&child_type->name), buf_ptr(field_name)));
22989		return ira->codegen->invalid_inst_gen;
22990		}
22991	22838	} else {
22992	22839	ir_add_error(ira, &field_ptr_instruction->base.base,
22993		buf_sprintf("type '%s' does not support field access", buf_ptr(&child_type->name)));
	22840	buf_sprintf("type '%s' does not support field access", buf_ptr(&container_type->name)));
22994	22841	return ira->codegen->invalid_inst_gen;
22995	22842	}
22996	22843	} else if (field_ptr_instruction->initializing) {
...	...	@@ -26747,7 +26594,7 @@ static IrInstGen ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstSrcCmpxch
26747	26594
26748	26595	if (operand_type->id == ZigTypeIdFloat) {
26749	26596	ir_add_error(ira, &instruction->type_value->child->base,
26750		buf_sprintf("expected integer, enum or pointer type, found '%s'", buf_ptr(&operand_type->name)));
	26597	buf_sprintf("expected bool, integer, enum or pointer type, found '%s'", buf_ptr(&operand_type->name)));
26751	26598	return ira->codegen->invalid_inst_gen;
26752	26599	}
26753	26600
...	...	@@ -30402,7 +30249,7 @@ static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstGen *op) {
30402	30249	return ira->codegen->builtin_types.entry_invalid;
30403	30250	if (operand_ptr_type == nullptr) {
30404	30251	ir_add_error(ira, &op->base,
30405		buf_sprintf("expected integer, float, enum or pointer type, found '%s'",
	30252	buf_sprintf("expected bool, integer, float, enum or pointer type, found '%s'",
30406	30253	buf_ptr(&operand_type->name)));
30407	30254	return ira->codegen->builtin_types.entry_invalid;
30408	30255	}

test/compile_errors.zig+16-17

...	...	@@ -2,6 +2,14 @@ const tests = @import("tests.zig");
2	2	const std = @import("std");
3	3
4	4	pub fn addCases(cases: *tests.CompileErrorContext) void {
	5	cases.add("slice sentinel mismatch",
	6	\\export fn entry() void {
	7	\\ const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
	8	\\}
	9	, &[_][]const u8{
	10	"tmp.zig:2:37: error: expected type '[:1]const u8', found '*const [2:2]u8'",
	11	});
	12
5	13	cases.add("@Type with undefined",
6	14	\\comptime {
7	15	\\ _ = @Type(.{ .Array = .{ .len = 0, .child = u8, .sentinel = undefined } });
...	...	@@ -168,11 +176,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
168	176	, &[_][]const u8{
169	177	"tmp.zig:2:17: error: expected type 'u32', found 'error{Ohno}'",
170	178	"tmp.zig:1:17: note: function cannot return an error",
171		"tmp.zig:8:5: error: expected type 'void', found '@TypeOf(bar).ReturnType.ErrorSet'",
	179	"tmp.zig:8:5: error: expected type 'void', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set'",
172	180	"tmp.zig:7:17: note: function cannot return an error",
173		"tmp.zig:11:15: error: expected type 'u32', found '@TypeOf(bar).ReturnType.ErrorSet!u32'",
	181	"tmp.zig:11:15: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'",
174	182	"tmp.zig:10:17: note: function cannot return an error",
175		"tmp.zig:15:14: error: expected type 'u32', found '@TypeOf(bar).ReturnType.ErrorSet!u32'",
	183	"tmp.zig:15:14: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'",
176	184	"tmp.zig:14:5: note: cannot store an error in type 'u32'",
177	185	});
178	186
...	...	@@ -891,7 +899,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
891	899	\\ _ = @cmpxchgWeak(f32, &x, 1, 2, .SeqCst, .SeqCst);
892	900	\\}
893	901	, &[_][]const u8{
894		"tmp.zig:3:22: error: expected integer, enum or pointer type, found 'f32'",
	902	"tmp.zig:3:22: error: expected bool, integer, enum or pointer type, found 'f32'",
895	903	});
896	904
897	905	cases.add("atomicrmw with float op not .Xchg, .Add or .Sub",
...	...	@@ -1216,7 +1224,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1216	1224	\\ };
1217	1225	\\}
1218	1226	, &[_][]const u8{
1219		"tmp.zig:11:25: error: expected type 'u32', found '@TypeOf(get_uval).ReturnType.ErrorSet!u32'",
	1227	"tmp.zig:11:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'",
1220	1228	});
1221	1229
1222	1230	cases.add("assigning to struct or union fields that are not optionals with a function that returns an optional",
...	...	@@ -1921,7 +1929,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
1921	1929	\\ const info = @TypeOf(slice).unknown;
1922	1930	\\}
1923	1931	, &[_][]const u8{
1924		"tmp.zig:3:32: error: type '[]i32' does not support field access",
	1932	"tmp.zig:3:32: error: type 'type' does not support field access",
1925	1933	});
1926	1934
1927	1935	cases.add("peer cast then implicit cast const pointer to mutable C pointer",
...	...	@@ -3534,7 +3542,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3534	3542	\\ }
3535	3543	\\}
3536	3544	, &[_][]const u8{
3537		"tmp.zig:5:14: error: duplicate switch value: '@TypeOf(foo).ReturnType.ErrorSet.Foo'",
	3545	"tmp.zig:5:14: error: duplicate switch value: '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set.Foo'",
3538	3546	"tmp.zig:3:14: note: other value is here",
3539	3547	});
3540	3548
...	...	@@ -3666,7 +3674,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3666	3674	\\ try foo();
3667	3675	\\}
3668	3676	, &[_][]const u8{
3669		"tmp.zig:5:5: error: cannot resolve inferred error set '@TypeOf(foo).ReturnType.ErrorSet': function 'foo' not fully analyzed yet",
	3677	"tmp.zig:5:5: error: cannot resolve inferred error set '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set': function 'foo' not fully analyzed yet",
3670	3678	});
3671	3679
3672	3680	cases.add("implicit cast of error set not a subset",
...	...	@@ -7198,15 +7206,6 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
7198	7206	"tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set",
7199	7207	});
7200	7208
7201		cases.add("getting return type of generic function",
7202		\\fn generic(a: anytype) void {}
7203		\\comptime {
7204		\\ _ = @TypeOf(generic).ReturnType;
7205		\\}
7206		, &[_][]const u8{
7207		"tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(anytype) anytype' is generic",
7208		});
7209
7210	7209	cases.add("unsupported modifier at start of asm output constraint",
7211	7210	\\export fn foo() void {
7212	7211	\\ var bar: u32 = 3;

test/stage1/behavior/align.zig+1-1

...	...	@@ -5,7 +5,7 @@ const builtin = @import("builtin");
5	5	var foo: u8 align(4) = 100;
6	6
7	7	test "global variable alignment" {
8		comptime expect(@TypeOf(&foo).alignment == 4);
	8	comptime expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
9	9	comptime expect(@TypeOf(&foo) == *align(4) u8);
10	10	{
11	11	const slice = @as(*[1]u8, &foo)[0..];

test/stage1/behavior/array.zig-10

...	...	@@ -136,16 +136,6 @@ test "array literal with specified size" {
136	136	expect(array[1] == 2);
137	137	}
138	138
139		test "array child property" {
140		var x: [5]i32 = undefined;
141		expect(@TypeOf(x).Child == i32);
142		}
143
144		test "array len property" {
145		var x: [5]i32 = undefined;
146		expect(@TypeOf(x).len == 5);
147		}
148
149	139	test "array len field" {
150	140	var arr = [4]u8{ 0, 0, 0, 0 };
151	141	var ptr = &arr;

test/stage1/behavior/async_fn.zig+3-3

...	...	@@ -331,7 +331,7 @@ test "async fn with inferred error set" {
331	331	fn doTheTest() void {
332	332	var frame: [1]@Frame(middle) = undefined;
333	333	var fn_ptr = middle;
334		var result: @TypeOf(fn_ptr).ReturnType.ErrorSet!void = undefined;
	334	var result: @typeInfo(@typeInfo(@TypeOf(fn_ptr)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
335	335	_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, fn_ptr, .{});
336	336	resume global_frame;
337	337	std.testing.expectError(error.Fail, result);
...	...	@@ -950,7 +950,7 @@ test "@asyncCall with comptime-known function, but not awaited directly" {
950	950
951	951	fn doTheTest() void {
952	952	var frame: [1]@Frame(middle) = undefined;
953		var result: @TypeOf(middle).ReturnType.ErrorSet!void = undefined;
	953	var result: @typeInfo(@typeInfo(@TypeOf(middle)).Fn.return_type.?).ErrorUnion.error_set!void = undefined;
954	954	_ = @asyncCall(std.mem.sliceAsBytes(frame[0..]), &result, middle, .{});
955	955	resume global_frame;
956	956	std.testing.expectError(error.Fail, result);
...	...	@@ -1018,7 +1018,7 @@ test "@TypeOf an async function call of generic fn with error union type" {
1018	1018	const S = struct {
1019	1019	fn func(comptime x: anytype) anyerror!i32 {
1020	1020	const T = @TypeOf(async func(x));
1021		comptime expect(T == @TypeOf(@frame()).Child);
	1021	comptime expect(T == @typeInfo(@TypeOf(@frame())).Pointer.child);
1022	1022	return undefined;
1023	1023	}
1024	1024	};

test/stage1/behavior/bit_shifting.zig+7-5

...	...	@@ -2,16 +2,18 @@ const std = @import("std");
2	2	const expect = std.testing.expect;
3	3
4	4	fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type {
5		expect(Key == std.meta.Int(false, Key.bit_count));
6		expect(Key.bit_count >= mask_bit_count);
	5	const key_bits = @typeInfo(Key).Int.bits;
	6	expect(Key == std.meta.Int(false, key_bits));
	7	expect(key_bits >= mask_bit_count);
	8	const shard_key_bits = mask_bit_count;
7	9	const ShardKey = std.meta.Int(false, mask_bit_count);
8		const shift_amount = Key.bit_count - ShardKey.bit_count;
	10	const shift_amount = key_bits - shard_key_bits;
9	11	return struct {
10	12	const Self = @This();
11		shards: [1 << ShardKey.bit_count]?*Node,
	13	shards: [1 << shard_key_bits]?*Node,
12	14
13	15	pub fn create() Self {
14		return Self{ .shards = [_]?Node{null} * (1 << ShardKey.bit_count) };
	16	return Self{ .shards = [_]?Node{null} * (1 << shard_key_bits) };
15	17	}
16	18
17	19	fn getShardKey(key: Key) ShardKey {

test/stage1/behavior/bugs/5487.zig+2-2

...	...	@@ -3,8 +3,8 @@ const io = @import("std").io;
3	3	pub fn write(_: void, bytes: []const u8) !usize {
4	4	return 0;
5	5	}
6		pub fn outStream() io.OutStream(void, @TypeOf(write).ReturnType.ErrorSet, write) {
7		return io.OutStream(void, @TypeOf(write).ReturnType.ErrorSet, write){ .context = {} };
	6	pub fn outStream() io.OutStream(void, @typeInfo(@typeInfo(@TypeOf(write)).Fn.return_type.?).ErrorUnion.error_set, write) {
	7	return io.OutStream(void, @typeInfo(@typeInfo(@TypeOf(write)).Fn.return_type.?).ErrorUnion.error_set, write){ .context = {} };
8	8	}
9	9
10	10	test "crash" {

test/stage1/behavior/error.zig+2-2

...	...	@@ -84,8 +84,8 @@ fn testErrorUnionType() void {
84	84	const x: anyerror!i32 = 1234;
85	85	if (x) \|value\| expect(value == 1234) else \|_\| unreachable;
86	86	expect(@typeInfo(@TypeOf(x)) == .ErrorUnion);
87		expect(@typeInfo(@TypeOf(x).ErrorSet) == .ErrorSet);
88		expect(@TypeOf(x).ErrorSet == anyerror);
	87	expect(@typeInfo(@typeInfo(@TypeOf(x)).ErrorUnion.error_set) == .ErrorSet);
	88	expect(@typeInfo(@TypeOf(x)).ErrorUnion.error_set == anyerror);
89	89	}
90	90
91	91	test "error set type" {

test/stage1/behavior/misc.zig-10

...	...	@@ -24,12 +24,6 @@ test "call disabled extern fn" {
24	24	disabledExternFn();
25	25	}
26	26
27		test "floating point primitive bit counts" {
28		expect(f16.bit_count == 16);
29		expect(f32.bit_count == 32);
30		expect(f64.bit_count == 64);
31		}
32
33	27	test "short circuit" {
34	28	testShortCircuit(false, true);
35	29	comptime testShortCircuit(false, true);
...	...	@@ -577,10 +571,6 @@ test "slice string literal has correct type" {
577	571	comptime expect(@TypeOf(array[runtime_zero..]) == []const i32);
578	572	}
579	573
580		test "pointer child field" {
581		expect((*u32).Child == u32);
582		}
583
584	574	test "struct inside function" {
585	575	testStructInFn();
586	576	comptime testStructInFn();

test/stage1/behavior/reflection.zig+7-15

...	...	@@ -2,23 +2,15 @@ const expect = @import("std").testing.expect;
2	2	const mem = @import("std").mem;
3	3	const reflection = @This();
4	4
5		test "reflection: array, pointer, optional, error union type child" {
6		comptime {
7		expect(([10]u8).Child == u8);
8		expect((*u8).Child == u8);
9		expect((anyerror!u8).Payload == u8);
10		expect((?u8).Child == u8);
11		}
12		}
13
14	5	test "reflection: function return type, var args, and param types" {
15	6	comptime {
16		expect(@TypeOf(dummy).ReturnType == i32);
17		expect(!@TypeOf(dummy).is_var_args);
18		expect(@TypeOf(dummy).arg_count == 3);
19		expect(@typeInfo(@TypeOf(dummy)).Fn.args[0].arg_type.? == bool);
20		expect(@typeInfo(@TypeOf(dummy)).Fn.args[1].arg_type.? == i32);
21		expect(@typeInfo(@TypeOf(dummy)).Fn.args[2].arg_type.? == f32);
	7	const info = @typeInfo(@TypeOf(dummy)).Fn;
	8	expect(info.return_type.? == i32);
	9	expect(!info.is_var_args);
	10	expect(info.args.len == 3);
	11	expect(info.args[0].arg_type.? == bool);
	12	expect(info.args[1].arg_type.? == i32);
	13	expect(info.args[2].arg_type.? == f32);
22	14	}
23	15	}
24	16

author	Bas <BarabasGitHub@users.noreply.github.com> 2020-09-08 11:56:59+02:00
committer	GitHub <noreply@github.com> 2020-09-08 11:56:59+02:00
log	4a6ca735d9b3d466aba37c4488c1235b06a0bc84
tree	10ef029ccaefe15c5152c1512a952ca6fdb01358
parent	0a40a61548ad9f666ed5300a8910f9040cc1390b
parent	389c26025283edef2206d19d9ad1ddc41e98f007
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge branch 'master' into improve-windows-networking