Commit ea58f4a5a95662637d2142727a0452542bcdb196 | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-05-30 16:09:11-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-05-30 16:09:11-04:00
log	ea58f4a5a95662637d2142727a0452542bcdb196
tree	d72b41fea06f8526e899014fd10c2bf9d1a4d759
parent	b082cd4580890190218f876bf28816b4878ae85c

run zig fmt on the codebase

48 files changed, 140 insertions(+), 140 deletions(-)

src-self-hosted
- main.zig
std
- array_list.zig
- base64.zig
- build.zig
- c
  - darwin.zig
  - index.zig
- crypto
- event.zig
- fmt
  - errol
    index.zig
  - index.zig
- hash
  - crc.zig
  - siphash.zig
- hash_map.zig
- io.zig
- io_test.zig
- json.zig
- mem.zig
- os
  - darwin.zig
  - index.zig
  - linux
    index.zig
    x86_64.zig
  - path.zig
  - windows
    index.zig
    util.zig
  - zen.zig
- rand
  - index.zig
  - ziggurat.zig
- sort.zig
- special
  - build_runner.zig
- unicode.zig
- zig
  - tokenizer.zig
test
- cases

src-self-hosted/main.zig+2-2

...	...	@@ -41,7 +41,7 @@ const usage =
41	41
42	42	const Command = struct {
43	43	name: []const u8,
44		exec: fn(&Allocator, []const []const u8) error!void,
	44	exec: fn (&Allocator, []const []const u8) error!void,
45	45	};
46	46
47	47	pub fn main() !void {
...	...	@@ -862,7 +862,7 @@ fn cmdRun(allocator: &Allocator, args: []const []const u8) !void {
862	862	for (args) \|argv, i\| {
863	863	if (mem.eql(u8, argv, "--")) {
864	864	compile_args = args[0..i];
865		runtime_args = args[i + 1..];
	865	runtime_args = args[i + 1 ..];
866	866	break;
867	867	}
868	868	}

std/array_list.zig+3-3

...	...	@@ -71,7 +71,7 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
71	71	try l.ensureCapacity(l.len + 1);
72	72	l.len += 1;
73	73
74		mem.copy(T, l.items[n + 1..l.len], l.items[n..l.len - 1]);
	74	mem.copy(T, l.items[n + 1 .. l.len], l.items[n .. l.len - 1]);
75	75	l.items[n] = item.*;
76	76	}
77	77
...	...	@@ -79,8 +79,8 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type {
79	79	try l.ensureCapacity(l.len + items.len);
80	80	l.len += items.len;
81	81
82		mem.copy(T, l.items[n + items.len..l.len], l.items[n..l.len - items.len]);
83		mem.copy(T, l.items[n..n + items.len], items);
	82	mem.copy(T, l.items[n + items.len .. l.len], l.items[n .. l.len - items.len]);
	83	mem.copy(T, l.items[n .. n + items.len], items);
84	84	}
85	85
86	86	pub fn append(l: &Self, item: &const T) !void {

std/base64.zig+1-1

...	...	@@ -450,7 +450,7 @@ fn testError(encoded: []const u8, expected_err: error) !void {
450	450	fn testOutputTooSmallError(encoded: []const u8) !void {
451	451	const standard_decoder_ignore_space = Base64DecoderWithIgnore.init(standard_alphabet_chars, standard_pad_char, " ");
452	452	var buffer: [0x100]u8 = undefined;
453		var decoded = buffer[0..calcDecodedSizeExactUnsafe(encoded, standard_pad_char) - 1];
	453	var decoded = buffer[0 .. calcDecodedSizeExactUnsafe(encoded, standard_pad_char) - 1];
454	454	if (standard_decoder_ignore_space.decode(decoded, encoded)) \|_\| {
455	455	return error.ExpectedError;
456	456	} else \|err\| if (err != error.OutputTooSmall) return err;

std/build.zig+2-2

...	...	@@ -1912,12 +1912,12 @@ pub const RemoveDirStep = struct {
1912	1912
1913	1913	pub const Step = struct {
1914	1914	name: []const u8,
1915		makeFn: fn(self: &Step) error!void,
	1915	makeFn: fn (self: &Step) error!void,
1916	1916	dependencies: ArrayList(&Step),
1917	1917	loop_flag: bool,
1918	1918	done_flag: bool,
1919	1919
1920		pub fn init(name: []const u8, allocator: &Allocator, makeFn: fn(&Step) error!void) Step {
	1920	pub fn init(name: []const u8, allocator: &Allocator, makeFn: fn (&Step) error!void) Step {
1921	1921	return Step{
1922	1922	.name = name,
1923	1923	.makeFn = makeFn,

std/c/darwin.zig+1-1

...	...	@@ -60,7 +60,7 @@ pub const sigset_t = u32;
60	60
61	61	/// Renamed from `sigaction` to `Sigaction` to avoid conflict with function name.
62	62	pub const Sigaction = extern struct {
63		handler: extern fn(c_int) void,
	63	handler: extern fn (c_int) void,
64	64	sa_mask: sigset_t,
65	65	sa_flags: c_int,
66	66	};

std/c/index.zig+1-1

...	...	@@ -52,7 +52,7 @@ pub extern "c" fn realloc(&c_void, usize) ?&c_void;
52	52	pub extern "c" fn free(&c_void) void;
53	53	pub extern "c" fn posix_memalign(memptr: &&c_void, alignment: usize, size: usize) c_int;
54	54
55		pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t, noalias attr: ?&const pthread_attr_t, start_routine: extern fn(?&c_void) ?&c_void, noalias arg: ?&c_void) c_int;
	55	pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t, noalias attr: ?&const pthread_attr_t, start_routine: extern fn (?&c_void) ?&c_void, noalias arg: ?&c_void) c_int;
56	56	pub extern "pthread" fn pthread_attr_init(attr: &pthread_attr_t) c_int;
57	57	pub extern "pthread" fn pthread_attr_setstack(attr: &pthread_attr_t, stackaddr: &c_void, stacksize: usize) c_int;
58	58	pub extern "pthread" fn pthread_attr_destroy(attr: &pthread_attr_t) c_int;

std/crypto/blake2.zig+8-8

...	...	@@ -105,7 +105,7 @@ fn Blake2s(comptime out_len: usize) type {
105	105	// Full middle blocks.
106	106	while (off + 64 <= b.len) : (off += 64) {
107	107	d.t += 64;
108		d.round(b[off..off + 64], false);
	108	d.round(b[off .. off + 64], false);
109	109	}
110	110
111	111	// Copy any remainder for next pass.
...	...	@@ -120,10 +120,10 @@ fn Blake2s(comptime out_len: usize) type {
120	120	d.t += d.buf_len;
121	121	d.round(d.buf[0..], true);
122	122
123		const rr = d.h[0..out_len / 32];
	123	const rr = d.h[0 .. out_len / 32];
124	124
125	125	for (rr) \|s, j\| {
126		mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Little);
	126	mem.writeInt(out[4 * j .. 4 * j + 4], s, builtin.Endian.Little);
127	127	}
128	128	}
129	129
...	...	@@ -134,7 +134,7 @@ fn Blake2s(comptime out_len: usize) type {
134	134	var v: [16]u32 = undefined;
135	135
136	136	for (m) \|*r, i\| {
137		r.* = mem.readIntLE(u32, b[4 * i..4 * i + 4]);
	137	r.* = mem.readIntLE(u32, b[4 * i .. 4 * i + 4]);
138	138	}
139	139
140	140	var k: usize = 0;
...	...	@@ -340,7 +340,7 @@ fn Blake2b(comptime out_len: usize) type {
340	340	// Full middle blocks.
341	341	while (off + 128 <= b.len) : (off += 128) {
342	342	d.t += 128;
343		d.round(b[off..off + 128], false);
	343	d.round(b[off .. off + 128], false);
344	344	}
345	345
346	346	// Copy any remainder for next pass.
...	...	@@ -353,10 +353,10 @@ fn Blake2b(comptime out_len: usize) type {
353	353	d.t += d.buf_len;
354	354	d.round(d.buf[0..], true);
355	355
356		const rr = d.h[0..out_len / 64];
	356	const rr = d.h[0 .. out_len / 64];
357	357
358	358	for (rr) \|s, j\| {
359		mem.writeInt(out[8 * j..8 * j + 8], s, builtin.Endian.Little);
	359	mem.writeInt(out[8 * j .. 8 * j + 8], s, builtin.Endian.Little);
360	360	}
361	361	}
362	362
...	...	@@ -367,7 +367,7 @@ fn Blake2b(comptime out_len: usize) type {
367	367	var v: [16]u64 = undefined;
368	368
369	369	for (m) \|*r, i\| {
370		r.* = mem.readIntLE(u64, b[8 * i..8 * i + 8]);
	370	r.* = mem.readIntLE(u64, b[8 * i .. 8 * i + 8]);
371	371	}
372	372
373	373	var k: usize = 0;

std/crypto/md5.zig+2-2

...	...	@@ -73,7 +73,7 @@ pub const Md5 = struct {
73	73
74	74	// Full middle blocks.
75	75	while (off + 64 <= b.len) : (off += 64) {
76		d.round(b[off..off + 64]);
	76	d.round(b[off .. off + 64]);
77	77	}
78	78
79	79	// Copy any remainder for next pass.
...	...	@@ -112,7 +112,7 @@ pub const Md5 = struct {
112	112	d.round(d.buf[0..]);
113	113
114	114	for (d.s) \|s, j\| {
115		mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Little);
	115	mem.writeInt(out[4 * j .. 4 * j + 4], s, builtin.Endian.Little);
116	116	}
117	117	}
118	118

std/crypto/sha1.zig+2-2

...	...	@@ -73,7 +73,7 @@ pub const Sha1 = struct {
73	73
74	74	// Full middle blocks.
75	75	while (off + 64 <= b.len) : (off += 64) {
76		d.round(b[off..off + 64]);
	76	d.round(b[off .. off + 64]);
77	77	}
78	78
79	79	// Copy any remainder for next pass.
...	...	@@ -111,7 +111,7 @@ pub const Sha1 = struct {
111	111	d.round(d.buf[0..]);
112	112
113	113	for (d.s) \|s, j\| {
114		mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Big);
	114	mem.writeInt(out[4 * j .. 4 * j + 4], s, builtin.Endian.Big);
115	115	}
116	116	}
117	117

std/crypto/sha2.zig+6-6

...	...	@@ -126,7 +126,7 @@ fn Sha2_32(comptime params: Sha2Params32) type {
126	126
127	127	// Full middle blocks.
128	128	while (off + 64 <= b.len) : (off += 64) {
129		d.round(b[off..off + 64]);
	129	d.round(b[off .. off + 64]);
130	130	}
131	131
132	132	// Copy any remainder for next pass.
...	...	@@ -164,10 +164,10 @@ fn Sha2_32(comptime params: Sha2Params32) type {
164	164	d.round(d.buf[0..]);
165	165
166	166	// May truncate for possible 224 output
167		const rr = d.s[0..params.out_len / 32];
	167	const rr = d.s[0 .. params.out_len / 32];
168	168
169	169	for (rr) \|s, j\| {
170		mem.writeInt(out[4 * j..4 * j + 4], s, builtin.Endian.Big);
	170	mem.writeInt(out[4 * j .. 4 * j + 4], s, builtin.Endian.Big);
171	171	}
172	172	}
173	173
...	...	@@ -467,7 +467,7 @@ fn Sha2_64(comptime params: Sha2Params64) type {
467	467
468	468	// Full middle blocks.
469	469	while (off + 128 <= b.len) : (off += 128) {
470		d.round(b[off..off + 128]);
	470	d.round(b[off .. off + 128]);
471	471	}
472	472
473	473	// Copy any remainder for next pass.
...	...	@@ -505,10 +505,10 @@ fn Sha2_64(comptime params: Sha2Params64) type {
505	505	d.round(d.buf[0..]);
506	506
507	507	// May truncate for possible 384 output
508		const rr = d.s[0..params.out_len / 64];
	508	const rr = d.s[0 .. params.out_len / 64];
509	509
510	510	for (rr) \|s, j\| {
511		mem.writeInt(out[8 * j..8 * j + 8], s, builtin.Endian.Big);
	511	mem.writeInt(out[8 * j .. 8 * j + 8], s, builtin.Endian.Big);
512	512	}
513	513	}
514	514

std/crypto/sha3.zig+4-4

...	...	@@ -46,7 +46,7 @@ fn Keccak(comptime bits: usize, comptime delim: u8) type {
46	46
47	47	// absorb
48	48	while (len >= rate) {
49		for (d.s[offset..offset + rate]) \|*r, i\|
	49	for (d.s[offset .. offset + rate]) \|*r, i\|
50	50	r.* ^= b[ip..][i];
51	51
52	52	keccak_f(1600, d.s[0..]);
...	...	@@ -57,7 +57,7 @@ fn Keccak(comptime bits: usize, comptime delim: u8) type {
57	57	offset = 0;
58	58	}
59	59
60		for (d.s[offset..offset + len]) \|*r, i\|
	60	for (d.s[offset .. offset + len]) \|*r, i\|
61	61	r.* ^= b[ip..][i];
62	62
63	63	d.offset = offset + len;
...	...	@@ -193,7 +193,7 @@ fn keccak_f(comptime F: usize, d: []u8) void {
193	193	var c = []const u64{0} ** 5;
194	194
195	195	for (s) \|*r, i\| {
196		r.* = mem.readIntLE(u64, d[8 * i..8 * i + 8]);
	196	r.* = mem.readIntLE(u64, d[8 * i .. 8 * i + 8]);
197	197	}
198	198
199	199	comptime var x: usize = 0;
...	...	@@ -240,7 +240,7 @@ fn keccak_f(comptime F: usize, d: []u8) void {
240	240	}
241	241
242	242	for (s) \|r, i\| {
243		mem.writeInt(d[8 * i..8 * i + 8], r, builtin.Endian.Little);
	243	mem.writeInt(d[8 * i .. 8 * i + 8], r, builtin.Endian.Little);
244	244	}
245	245	}
246	246

std/crypto/test.zig+1-1

...	...	@@ -14,7 +14,7 @@ pub fn assertEqualHash(comptime Hasher: var, comptime expected: []const u8, inpu
14	14	pub fn assertEqual(comptime expected: []const u8, input: []const u8) void {
15	15	var expected_bytes: [expected.len / 2]u8 = undefined;
16	16	for (expected_bytes) \|*r, i\| {
17		r.* = fmt.parseInt(u8, expected[2 * i..2 * i + 2], 16) catch unreachable;
	17	r.* = fmt.parseInt(u8, expected[2 * i .. 2 * i + 2], 16) catch unreachable;
18	18	}
19	19
20	20	debug.assert(mem.eql(u8, expected_bytes, input));

std/event.zig+2-2

...	...	@@ -6,7 +6,7 @@ const mem = std.mem;
6	6	const posix = std.os.posix;
7	7
8	8	pub const TcpServer = struct {
9		handleRequestFn: async<&mem.Allocator> fn(&TcpServer, &const std.net.Address, &const std.os.File) void,
	9	handleRequestFn: async<&mem.Allocator> fn (&TcpServer, &const std.net.Address, &const std.os.File) void,
10	10
11	11	loop: &Loop,
12	12	sockfd: i32,
...	...	@@ -32,7 +32,7 @@ pub const TcpServer = struct {
32	32	};
33	33	}
34	34
35		pub fn listen(self: &TcpServer, address: &const std.net.Address, handleRequestFn: async<&mem.Allocator> fn(&TcpServer, &const std.net.Address, &const std.os.File) void) !void {
	35	pub fn listen(self: &TcpServer, address: &const std.net.Address, handleRequestFn: async<&mem.Allocator> fn (&TcpServer, &const std.net.Address, &const std.os.File) void) !void {
36	36	self.handleRequestFn = handleRequestFn;
37	37
38	38	try std.os.posixBind(self.sockfd, &address.os_addr);

std/fmt/errol/index.zig+2-2

...	...	@@ -60,7 +60,7 @@ pub fn roundToPrecision(float_decimal: &FloatDecimal, precision: usize, mode: Ro
60	60
61	61	// Re-size the buffer to use the reserved leading byte.
62	62	const one_before = @intToPtr(&u8, @ptrToInt(&float_decimal.digits[0]) - 1);
63		float_decimal.digits = one_before[0..float_decimal.digits.len + 1];
	63	float_decimal.digits = one_before[0 .. float_decimal.digits.len + 1];
64	64	float_decimal.digits[0] = '1';
65	65	return;
66	66	}
...	...	@@ -84,7 +84,7 @@ pub fn errol3(value: f64, buffer: []u8) FloatDecimal {
84	84	const i = tableLowerBound(bits);
85	85	if (i < enum3.len and enum3[i] == bits) {
86	86	const data = enum3_data[i];
87		const digits = buffer[1..data.str.len + 1];
	87	const digits = buffer[1 .. data.str.len + 1];
88	88	mem.copy(u8, digits, data.str);
89	89	return FloatDecimal{
90	90	.digits = digits,

std/fmt/index.zig+13-13

...	...	@@ -11,7 +11,7 @@ const max_int_digits = 65;
11	11	/// Renders fmt string with args, calling output with slices of bytes.
12	12	/// If `output` returns an error, the error is returned from `format` and
13	13	/// `output` is not called again.
14		pub fn format(context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void, comptime fmt: []const u8, args: ...) Errors!void {
	14	pub fn format(context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void, comptime fmt: []const u8, args: ...) Errors!void {
15	15	const State = enum {
16	16	Start,
17	17	OpenBrace,
...	...	@@ -268,7 +268,7 @@ pub fn format(context: var, comptime Errors: type, output: fn(@typeOf(context),
268	268	}
269	269	}
270	270
271		pub fn formatValue(value: var, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	271	pub fn formatValue(value: var, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
272	272	const T = @typeOf(value);
273	273	switch (@typeId(T)) {
274	274	builtin.TypeId.Int => {
...	...	@@ -317,11 +317,11 @@ pub fn formatValue(value: var, context: var, comptime Errors: type, output: fn(@
317	317	}
318	318	}
319	319
320		pub fn formatAsciiChar(c: u8, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	320	pub fn formatAsciiChar(c: u8, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
321	321	return output(context, (&c)[0..1]);
322	322	}
323	323
324		pub fn formatBuf(buf: []const u8, width: usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	324	pub fn formatBuf(buf: []const u8, width: usize, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
325	325	try output(context, buf);
326	326
327	327	var leftover_padding = if (width > buf.len) (width - buf.len) else return;
...	...	@@ -334,7 +334,7 @@ pub fn formatBuf(buf: []const u8, width: usize, context: var, comptime Errors: t
334	334	// Print a float in scientific notation to the specified precision. Null uses full precision.
335	335	// It should be the case that every full precision, printed value can be re-parsed back to the
336	336	// same type unambiguously.
337		pub fn formatFloatScientific(value: var, maybe_precision: ?usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	337	pub fn formatFloatScientific(value: var, maybe_precision: ?usize, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
338	338	var x = f64(value);
339	339
340	340	// Errol doesn't handle these special cases.
...	...	@@ -423,7 +423,7 @@ pub fn formatFloatScientific(value: var, maybe_precision: ?usize, context: var,
423	423
424	424	// Print a float of the format x.yyyyy where the number of y is specified by the precision argument.
425	425	// By default floats are printed at full precision (no rounding).
426		pub fn formatFloatDecimal(value: var, maybe_precision: ?usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	426	pub fn formatFloatDecimal(value: var, maybe_precision: ?usize, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
427	427	var x = f64(value);
428	428
429	429	// Errol doesn't handle these special cases.
...	...	@@ -512,7 +512,7 @@ pub fn formatFloatDecimal(value: var, maybe_precision: ?usize, context: var, com
512	512	// Remaining fractional portion, zero-padding if insufficient.
513	513	debug.assert(precision >= printed);
514	514	if (num_digits_whole_no_pad + precision - printed < float_decimal.digits.len) {
515		try output(context, float_decimal.digits[num_digits_whole_no_pad..num_digits_whole_no_pad + precision - printed]);
	515	try output(context, float_decimal.digits[num_digits_whole_no_pad .. num_digits_whole_no_pad + precision - printed]);
516	516	return;
517	517	} else {
518	518	try output(context, float_decimal.digits[num_digits_whole_no_pad..]);
...	...	@@ -568,7 +568,7 @@ pub fn formatBytes(
568	568	comptime radix: usize,
569	569	context: var,
570	570	comptime Errors: type,
571		output: fn(@typeOf(context), []const u8) Errors!void,
	571	output: fn (@typeOf(context), []const u8) Errors!void,
572	572	) Errors!void {
573	573	if (value == 0) {
574	574	return output(context, "0B");
...	...	@@ -604,7 +604,7 @@ pub fn formatInt(
604	604	width: usize,
605	605	context: var,
606	606	comptime Errors: type,
607		output: fn(@typeOf(context), []const u8) Errors!void,
	607	output: fn (@typeOf(context), []const u8) Errors!void,
608	608	) Errors!void {
609	609	if (@typeOf(value).is_signed) {
610	610	return formatIntSigned(value, base, uppercase, width, context, Errors, output);
...	...	@@ -613,7 +613,7 @@ pub fn formatInt(
613	613	}
614	614	}
615	615
616		fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	616	fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
617	617	const uint = @IntType(false, @typeOf(value).bit_count);
618	618	if (value < 0) {
619	619	const minus_sign: u8 = '-';
...	...	@@ -632,7 +632,7 @@ fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize, context:
632	632	}
633	633	}
634	634
635		fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void) Errors!void {
	635	fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize, context: var, comptime Errors: type, output: fn (@typeOf(context), []const u8) Errors!void) Errors!void {
636	636	// max_int_digits accounts for the minus sign. when printing an unsigned
637	637	// number we don't need to do that.
638	638	var buf: [max_int_digits - 1]u8 = undefined;
...	...	@@ -661,7 +661,7 @@ fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize, contex
661	661	mem.set(u8, buf[0..index], '0');
662	662	return output(context, buf);
663	663	} else {
664		const padded_buf = buf[index - padding..];
	664	const padded_buf = buf[index - padding ..];
665	665	mem.set(u8, padded_buf[0..padding], '0');
666	666	return output(context, padded_buf);
667	667	}
...	...	@@ -760,7 +760,7 @@ fn bufPrintWrite(context: &BufPrintContext, bytes: []const u8) !void {
760	760	pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: ...) ![]u8 {
761	761	var context = BufPrintContext{ .remaining = buf };
762	762	try format(&context, error{BufferTooSmall}, bufPrintWrite, fmt, args);
763		return buf[0..buf.len - context.remaining.len];
	763	return buf[0 .. buf.len - context.remaining.len];
764	764	}
765	765
766	766	pub fn allocPrint(allocator: &mem.Allocator, comptime fmt: []const u8, args: ...) ![]u8 {

std/hash/crc.zig+1-1

...	...	@@ -61,7 +61,7 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
61	61	pub fn update(self: &Self, input: []const u8) void {
62	62	var i: usize = 0;
63	63	while (i + 8 <= input.len) : (i += 8) {
64		const p = input[i..i + 8];
	64	const p = input[i .. i + 8];
65	65
66	66	// Unrolling this way gives ~50Mb/s increase
67	67	self.crc ^= (u32(p[0]) << 0);

std/hash/siphash.zig+1-1

...	...	@@ -76,7 +76,7 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
76	76
77	77	// Full middle blocks.
78	78	while (off + 8 <= b.len) : (off += 8) {
79		d.round(b[off..off + 8]);
	79	d.round(b[off .. off + 8]);
80	80	}
81	81
82	82	// Remainder for next pass.

std/hash_map.zig+1-1

...	...	@@ -9,7 +9,7 @@ const builtin = @import("builtin");
9	9	const want_modification_safety = builtin.mode != builtin.Mode.ReleaseFast;
10	10	const debug_u32 = if (want_modification_safety) u32 else void;
11	11
12		pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn(key: K) u32, comptime eql: fn(a: K, b: K) bool) type {
	12	pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u32, comptime eql: fn (a: K, b: K) bool) type {
13	13	return struct {
14	14	entries: []Entry,
15	15	size: usize,

std/io.zig+3-3

...	...	@@ -82,7 +82,7 @@ pub fn InStream(comptime ReadError: type) type {
82	82	/// Return the number of bytes read. If the number read is smaller than buf.len, it
83	83	/// means the stream reached the end. Reaching the end of a stream is not an error
84	84	/// condition.
85		readFn: fn(self: &Self, buffer: []u8) Error!usize,
	85	readFn: fn (self: &Self, buffer: []u8) Error!usize,
86	86
87	87	/// Replaces `buffer` contents by reading from the stream until it is finished.
88	88	/// If `buffer.len()` would exceed `max_size`, `error.StreamTooLong` is returned and
...	...	@@ -208,7 +208,7 @@ pub fn OutStream(comptime WriteError: type) type {
208	208	const Self = this;
209	209	pub const Error = WriteError;
210	210
211		writeFn: fn(self: &Self, bytes: []const u8) Error!void,
	211	writeFn: fn (self: &Self, bytes: []const u8) Error!void,
212	212
213	213	pub fn print(self: &Self, comptime format: []const u8, args: ...) !void {
214	214	return std.fmt.format(self, Error, self.writeFn, format, args);
...	...	@@ -369,7 +369,7 @@ pub fn BufferedOutStreamCustom(comptime buffer_size: usize, comptime OutStreamEr
369	369	while (src_index < bytes.len) {
370	370	const dest_space_left = self.buffer.len - self.index;
371	371	const copy_amt = math.min(dest_space_left, bytes.len - src_index);
372		mem.copy(u8, self.buffer[self.index..], bytes[src_index..src_index + copy_amt]);
	372	mem.copy(u8, self.buffer[self.index..], bytes[src_index .. src_index + copy_amt]);
373	373	self.index += copy_amt;
374	374	assert(self.index <= self.buffer.len);
375	375	if (self.index == self.buffer.len) {

std/io_test.zig+2-2

...	...	@@ -41,8 +41,8 @@ test "write a file, read it, then delete it" {
41	41	defer allocator.free(contents);
42	42
43	43	assert(mem.eql(u8, contents[0.."begin".len], "begin"));
44		assert(mem.eql(u8, contents["begin".len..contents.len - "end".len], data));
45		assert(mem.eql(u8, contents[contents.len - "end".len..], "end"));
	44	assert(mem.eql(u8, contents["begin".len .. contents.len - "end".len], data));
	45	assert(mem.eql(u8, contents[contents.len - "end".len ..], "end"));
46	46	}
47	47	try os.deleteFile(allocator, tmp_file_name);
48	48	}

std/json.zig+1-1

...	...	@@ -77,7 +77,7 @@ pub const Token = struct {
77	77
78	78	// Slice into the underlying input string.
79	79	pub fn slice(self: &const Token, input: []const u8, i: usize) []const u8 {
80		return input[i + self.offset - self.count..i + self.offset];
	80	return input[i + self.offset - self.count .. i + self.offset];
81	81	}
82	82	};
83	83

std/mem.zig+6-6

...	...	@@ -13,7 +13,7 @@ pub const Allocator = struct {
13	13	/// The returned newly allocated memory is undefined.
14	14	/// `alignment` is guaranteed to be >= 1
15	15	/// `alignment` is guaranteed to be a power of 2
16		allocFn: fn(self: &Allocator, byte_count: usize, alignment: u29) Error![]u8,
	16	allocFn: fn (self: &Allocator, byte_count: usize, alignment: u29) Error![]u8,
17	17
18	18	/// If `new_byte_count > old_mem.len`:
19	19	/// * `old_mem.len` is the same as what was returned from allocFn or reallocFn.
...	...	@@ -26,10 +26,10 @@ pub const Allocator = struct {
26	26	/// The returned newly allocated memory is undefined.
27	27	/// `alignment` is guaranteed to be >= 1
28	28	/// `alignment` is guaranteed to be a power of 2
29		reallocFn: fn(self: &Allocator, old_mem: []u8, new_byte_count: usize, alignment: u29) Error![]u8,
	29	reallocFn: fn (self: &Allocator, old_mem: []u8, new_byte_count: usize, alignment: u29) Error![]u8,
30	30
31	31	/// Guaranteed: `old_mem.len` is the same as what was returned from `allocFn` or `reallocFn`
32		freeFn: fn(self: &Allocator, old_mem: []u8) void,
	32	freeFn: fn (self: &Allocator, old_mem: []u8) void,
33	33
34	34	fn create(self: &Allocator, comptime T: type) !&T {
35	35	if (@sizeOf(T) == 0) return &{};
...	...	@@ -282,7 +282,7 @@ pub fn lastIndexOf(comptime T: type, haystack: []const T, needle: []const T) ?us
282	282
283	283	var i: usize = haystack.len - needle.len;
284	284	while (true) : (i -= 1) {
285		if (mem.eql(T, haystack[i..i + needle.len], needle)) return i;
	285	if (mem.eql(T, haystack[i .. i + needle.len], needle)) return i;
286	286	if (i == 0) return null;
287	287	}
288	288	}
...	...	@@ -294,7 +294,7 @@ pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, nee
294	294	var i: usize = start_index;
295	295	const end = haystack.len - needle.len;
296	296	while (i <= end) : (i += 1) {
297		if (eql(T, haystack[i..i + needle.len], needle)) return i;
	297	if (eql(T, haystack[i .. i + needle.len], needle)) return i;
298	298	}
299	299	return null;
300	300	}
...	...	@@ -444,7 +444,7 @@ test "mem.startsWith" {
444	444	}
445	445
446	446	pub fn endsWith(comptime T: type, haystack: []const T, needle: []const T) bool {
447		return if (needle.len > haystack.len) false else eql(T, haystack[haystack.len - needle.len..], needle);
	447	return if (needle.len > haystack.len) false else eql(T, haystack[haystack.len - needle.len ..], needle);
448	448	}
449	449
450	450	test "mem.endsWith" {

std/os/darwin.zig+3-3

...	...	@@ -437,7 +437,7 @@ pub fn sigaction(sig: u5, noalias act: &const Sigaction, noalias oact: ?&Sigacti
437	437	assert(sig != SIGKILL);
438	438	assert(sig != SIGSTOP);
439	439	var cact = c.Sigaction{
440		.handler = @ptrCast(extern fn(c_int) void, act.handler),
	440	.handler = @ptrCast(extern fn (c_int) void, act.handler),
441	441	.sa_flags = @bitCast(c_int, act.flags),
442	442	.sa_mask = act.mask,
443	443	};
...	...	@@ -448,7 +448,7 @@ pub fn sigaction(sig: u5, noalias act: &const Sigaction, noalias oact: ?&Sigacti
448	448	}
449	449	if (oact) \|old\| {
450	450	old.* = Sigaction{
451		.handler = @ptrCast(extern fn(i32) void, coact.handler),
	451	.handler = @ptrCast(extern fn (i32) void, coact.handler),
452	452	.flags = @bitCast(u32, coact.sa_flags),
453	453	.mask = coact.sa_mask,
454	454	};
...	...	@@ -468,7 +468,7 @@ pub const sockaddr = c.sockaddr;
468	468
469	469	/// Renamed from `sigaction` to `Sigaction` to avoid conflict with the syscall.
470	470	pub const Sigaction = struct {
471		handler: extern fn(i32) void,
	471	handler: extern fn (i32) void,
472	472	mask: sigset_t,
473	473	flags: u32,
474	474	};

std/os/index.zig+8-8

...	...	@@ -399,7 +399,7 @@ pub fn createNullDelimitedEnvMap(allocator: &Allocator, env_map: &const BufMap)
399	399
400	400	pub fn freeNullDelimitedEnvMap(allocator: &Allocator, envp_buf: []?&u8) void {
401	401	for (envp_buf) \|env\| {
402		const env_buf = if (env) \|ptr\| ptr[0..cstr.len(ptr) + 1] else break;
	402	const env_buf = if (env) \|ptr\| ptr[0 .. cstr.len(ptr) + 1] else break;
403	403	allocator.free(env_buf);
404	404	}
405	405	allocator.free(envp_buf);
...	...	@@ -449,7 +449,7 @@ pub fn posixExecve(argv: []const []const u8, env_map: &const BufMap, allocator:
449	449	while (it.next()) \|search_path\| {
450	450	mem.copy(u8, path_buf, search_path);
451	451	path_buf[search_path.len] = '/';
452		mem.copy(u8, path_buf[search_path.len + 1..], exe_path);
	452	mem.copy(u8, path_buf[search_path.len + 1 ..], exe_path);
453	453	path_buf[search_path.len + exe_path.len + 1] = 0;
454	454	err = posix.getErrno(posix.execve(path_buf.ptr, argv_buf.ptr, envp_buf.ptr));
455	455	assert(err > 0);
...	...	@@ -532,7 +532,7 @@ pub fn getEnvMap(allocator: &Allocator) !BufMap {
532	532
533	533	var end_i: usize = line_i;
534	534	while (ptr[end_i] != 0) : (end_i += 1) {}
535		const value = ptr[line_i + 1..end_i];
	535	const value = ptr[line_i + 1 .. end_i];
536	536
537	537	try result.set(key, value);
538	538	}
...	...	@@ -549,7 +549,7 @@ pub fn getEnvPosix(key: []const u8) ?[]const u8 {
549	549
550	550	var end_i: usize = line_i;
551	551	while (ptr[end_i] != 0) : (end_i += 1) {}
552		const this_value = ptr[line_i + 1..end_i];
	552	const this_value = ptr[line_i + 1 .. end_i];
553	553
554	554	return this_value;
555	555	}
...	...	@@ -691,7 +691,7 @@ pub fn symLinkPosix(allocator: &Allocator, existing_path: []const u8, new_path:
691	691	mem.copy(u8, existing_buf, existing_path);
692	692	existing_buf[existing_path.len] = 0;
693	693
694		const new_buf = full_buf[existing_path.len + 1..];
	694	const new_buf = full_buf[existing_path.len + 1 ..];
695	695	mem.copy(u8, new_buf, new_path);
696	696	new_buf[new_path.len] = 0;
697	697
...	...	@@ -735,7 +735,7 @@ pub fn atomicSymLink(allocator: &Allocator, existing_path: []const u8, new_path:
735	735	tmp_path[dirname.len] = os.path.sep;
736	736	while (true) {
737	737	try getRandomBytes(rand_buf[0..]);
738		b64_fs_encoder.encode(tmp_path[dirname.len + 1..], rand_buf);
	738	b64_fs_encoder.encode(tmp_path[dirname.len + 1 ..], rand_buf);
739	739
740	740	if (symLink(allocator, existing_path, tmp_path)) {
741	741	return rename(allocator, tmp_path, new_path);
...	...	@@ -914,7 +914,7 @@ pub fn rename(allocator: &Allocator, old_path: []const u8, new_path: []const u8)
914	914	mem.copy(u8, old_buf, old_path);
915	915	old_buf[old_path.len] = 0;
916	916
917		const new_buf = full_buf[old_path.len + 1..];
	917	const new_buf = full_buf[old_path.len + 1 ..];
918	918	mem.copy(u8, new_buf, new_path);
919	919	new_buf[new_path.len] = 0;
920	920
...	...	@@ -1141,7 +1141,7 @@ pub fn deleteTree(allocator: &Allocator, full_path: []const u8) DeleteTreeError!
1141	1141	const full_entry_path = full_entry_buf.toSlice();
1142	1142	mem.copy(u8, full_entry_path, full_path);
1143	1143	full_entry_path[full_path.len] = '/';
1144		mem.copy(u8, full_entry_path[full_path.len + 1..], entry.name);
	1144	mem.copy(u8, full_entry_path[full_path.len + 1 ..], entry.name);
1145	1145
1146	1146	try deleteTree(allocator, full_entry_path);
1147	1147	}

std/os/linux/index.zig+7-7

...	...	@@ -939,7 +939,7 @@ pub fn sigaction(sig: u6, noalias act: &const Sigaction, noalias oact: ?&Sigacti
939	939	.handler = act.handler,
940	940	.flags = act.flags \| SA_RESTORER,
941	941	.mask = undefined,
942		.restorer = @ptrCast(extern fn() void, restore_rt),
	942	.restorer = @ptrCast(extern fn () void, restore_rt),
943	943	};
944	944	var ksa_old: k_sigaction = undefined;
945	945	@memcpy(@ptrCast(&u8, &ksa.mask), @ptrCast(&const u8, &act.mask), 8);
...	...	@@ -962,22 +962,22 @@ const all_mask = []usize{@maxValue(usize)};
962	962	const app_mask = []usize{0xfffffffc7fffffff};
963	963
964	964	const k_sigaction = extern struct {
965		handler: extern fn(i32) void,
	965	handler: extern fn (i32) void,
966	966	flags: usize,
967		restorer: extern fn() void,
	967	restorer: extern fn () void,
968	968	mask: [2]u32,
969	969	};
970	970
971	971	/// Renamed from `sigaction` to `Sigaction` to avoid conflict with the syscall.
972	972	pub const Sigaction = struct {
973		handler: extern fn(i32) void,
	973	handler: extern fn (i32) void,
974	974	mask: sigset_t,
975	975	flags: u32,
976	976	};
977	977
978		pub const SIG_ERR = @intToPtr(extern fn(i32) void, @maxValue(usize));
979		pub const SIG_DFL = @intToPtr(extern fn(i32) void, 0);
980		pub const SIG_IGN = @intToPtr(extern fn(i32) void, 1);
	978	pub const SIG_ERR = @intToPtr(extern fn (i32) void, @maxValue(usize));
	979	pub const SIG_DFL = @intToPtr(extern fn (i32) void, 0);
	980	pub const SIG_IGN = @intToPtr(extern fn (i32) void, 1);
981	981	pub const empty_sigset = []usize{0} ** sigset_t.len;
982	982
983	983	pub fn raise(sig: i32) usize {

std/os/linux/x86_64.zig+1-1

...	...	@@ -463,7 +463,7 @@ pub fn syscall6(
463	463	}
464	464
465	465	/// This matches the libc clone function.
466		pub extern fn clone(func: extern fn(arg: usize) u8, stack: usize, flags: usize, arg: usize, ptid: &i32, tls: usize, ctid: &i32) usize;
	466	pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: usize, arg: usize, ptid: &i32, tls: usize, ctid: &i32) usize;
467	467
468	468	pub nakedcc fn restore_rt() void {
469	469	return asm volatile ("syscall"

std/os/path.zig+3-3

...	...	@@ -793,7 +793,7 @@ pub fn basenamePosix(path: []const u8) []const u8 {
793	793	start_index -= 1;
794	794	}
795	795
796		return path[start_index + 1..end_index];
	796	return path[start_index + 1 .. end_index];
797	797	}
798	798
799	799	pub fn basenameWindows(path: []const u8) []const u8 {
...	...	@@ -825,7 +825,7 @@ pub fn basenameWindows(path: []const u8) []const u8 {
825	825	start_index -= 1;
826	826	}
827	827
828		return path[start_index + 1..end_index];
	828	return path[start_index + 1 .. end_index];
829	829	}
830	830
831	831	test "os.path.basename" {
...	...	@@ -999,7 +999,7 @@ pub fn relativePosix(allocator: &Allocator, from: []const u8, to: []const u8) ![
999	999	}
1000	1000	if (to_rest.len == 0) {
1001	1001	// shave off the trailing slash
1002		return result[0..result_index - 1];
	1002	return result[0 .. result_index - 1];
1003	1003	}
1004	1004
1005	1005	mem.copy(u8, result[result_index..], to_rest);

std/os/windows/index.zig+1-1

...	...	@@ -369,7 +369,7 @@ pub const HEAP_CREATE_ENABLE_EXECUTE = 0x00040000;
369	369	pub const HEAP_GENERATE_EXCEPTIONS = 0x00000004;
370	370	pub const HEAP_NO_SERIALIZE = 0x00000001;
371	371
372		pub const PTHREAD_START_ROUTINE = extern fn(LPVOID) DWORD;
	372	pub const PTHREAD_START_ROUTINE = extern fn (LPVOID) DWORD;
373	373	pub const LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
374	374
375	375	test "import" {

std/os/windows/util.zig+1-1

...	...	@@ -73,7 +73,7 @@ pub fn windowsIsCygwinPty(handle: windows.HANDLE) bool {
73	73	}
74	74
75	75	const name_info = @ptrCast(&const windows.FILE_NAME_INFO, &name_info_bytes[0]);
76		const name_bytes = name_info_bytes[size..size + usize(name_info.FileNameLength)];
	76	const name_bytes = name_info_bytes[size .. size + usize(name_info.FileNameLength)];
77	77	const name_wide = ([]u16)(name_bytes);
78	78	return mem.indexOf(u16, name_wide, []u16{ 'm', 's', 'y', 's', '-' }) != null or
79	79	mem.indexOf(u16, name_wide, []u16{ '-', 'p', 't', 'y' }) != null;

std/os/zen.zig+1-1

...	...	@@ -153,7 +153,7 @@ pub fn map(v_addr: usize, p_addr: usize, size: usize, writable: bool) bool {
153	153	return syscall4(Syscall.map, v_addr, p_addr, size, usize(writable)) != 0;
154	154	}
155	155
156		pub fn createThread(function: fn() void) u16 {
	156	pub fn createThread(function: fn () void) u16 {
157	157	return u16(syscall1(Syscall.createThread, @ptrToInt(function)));
158	158	}
159	159

std/rand/index.zig+1-1

...	...	@@ -28,7 +28,7 @@ pub const DefaultPrng = Xoroshiro128;
28	28	pub const DefaultCsprng = Isaac64;
29	29
30	30	pub const Random = struct {
31		fillFn: fn(r: &Random, buf: []u8) void,
	31	fillFn: fn (r: &Random, buf: []u8) void,
32	32
33	33	/// Read random bytes into the specified buffer until fill.
34	34	pub fn bytes(r: &Random, buf: []u8) void {

std/rand/ziggurat.zig+5-5

...	...	@@ -56,11 +56,11 @@ pub const ZigTable = struct {
56	56	f: [257]f64,
57	57
58	58	// probability density function used as a fallback
59		pdf: fn(f64) f64,
	59	pdf: fn (f64) f64,
60	60	// whether the distribution is symmetric
61	61	is_symmetric: bool,
62	62	// fallback calculation in the case we are in the 0 block
63		zero_case: fn(&Random, f64) f64,
	63	zero_case: fn (&Random, f64) f64,
64	64	};
65	65
66	66	// zigNorInit
...	...	@@ -68,9 +68,9 @@ fn ZigTableGen(
68	68	comptime is_symmetric: bool,
69	69	comptime r: f64,
70	70	comptime v: f64,
71		comptime f: fn(f64) f64,
72		comptime f_inv: fn(f64) f64,
73		comptime zero_case: fn(&Random, f64) f64,
	71	comptime f: fn (f64) f64,
	72	comptime f_inv: fn (f64) f64,
	73	comptime zero_case: fn (&Random, f64) f64,
74	74	) ZigTable {
75	75	var tables: ZigTable = undefined;
76	76

std/sort.zig+21-21

...	...	@@ -5,7 +5,7 @@ const math = std.math;
5	5	const builtin = @import("builtin");
6	6
7	7	/// Stable in-place sort. O(n) best case, O(pow(n, 2)) worst case. O(1) memory (no allocator required).
8		pub fn insertionSort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) void {
	8	pub fn insertionSort(comptime T: type, items: []T, lessThan: fn (lhs: &const T, rhs: &const T) bool) void {
9	9	{
10	10	var i: usize = 1;
11	11	while (i < items.len) : (i += 1) {
...	...	@@ -108,7 +108,7 @@ const Pull = struct {
108	108
109	109	/// Stable in-place sort. O(n) best case, O(n*log(n)) worst case and average case. O(1) memory (no allocator required).
110	110	/// Currently implemented as block sort.
111		pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) void {
	111	pub fn sort(comptime T: type, items: []T, lessThan: fn (lhs: &const T, rhs: &const T) bool) void {
112	112	// Implementation ported from https://github.com/BonzaiThePenguin/WikiSort/blob/master/WikiSort.c
113	113	var cache: [512]T = undefined;
114	114
...	...	@@ -257,7 +257,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
257	257	// merge A2 and B2 into the cache
258	258	if (lessThan(items[B2.end - 1], items[A2.start])) {
259	259	// the two ranges are in reverse order, so copy them in reverse order into the cache
260		mem.copy(T, cache[A1.length() + B2.length()..], items[A2.start..A2.end]);
	260	mem.copy(T, cache[A1.length() + B2.length() ..], items[A2.start..A2.end]);
261	261	mem.copy(T, cache[A1.length()..], items[B2.start..B2.end]);
262	262	} else if (lessThan(items[B2.start], items[A2.end - 1])) {
263	263	// these two ranges weren't already in order, so merge them into the cache
...	...	@@ -265,7 +265,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
265	265	} else {
266	266	// copy A2 and B2 into the cache in the same order
267	267	mem.copy(T, cache[A1.length()..], items[A2.start..A2.end]);
268		mem.copy(T, cache[A1.length() + A2.length()..], items[B2.start..B2.end]);
	268	mem.copy(T, cache[A1.length() + A2.length() ..], items[B2.start..B2.end]);
269	269	}
270	270	A2 = Range.init(A2.start, B2.end);
271	271
...	...	@@ -275,7 +275,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
275	275
276	276	if (lessThan(cache[B3.end - 1], cache[A3.start])) {
277	277	// the two ranges are in reverse order, so copy them in reverse order into the items
278		mem.copy(T, items[A1.start + A2.length()..], cache[A3.start..A3.end]);
	278	mem.copy(T, items[A1.start + A2.length() ..], cache[A3.start..A3.end]);
279	279	mem.copy(T, items[A1.start..], cache[B3.start..B3.end]);
280	280	} else if (lessThan(cache[B3.start], cache[A3.end - 1])) {
281	281	// these two ranges weren't already in order, so merge them back into the items
...	...	@@ -283,7 +283,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
283	283	} else {
284	284	// copy A3 and B3 into the items in the same order
285	285	mem.copy(T, items[A1.start..], cache[A3.start..A3.end]);
286		mem.copy(T, items[A1.start + A1.length()..], cache[B3.start..B3.end]);
	286	mem.copy(T, items[A1.start + A1.length() ..], cache[B3.start..B3.end]);
287	287	}
288	288	}
289	289
...	...	@@ -640,7 +640,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
640	640	if (buffer2.length() > 0 or block_size <= cache.len) {
641	641	// copy the previous A block into the cache or buffer2, since that's where we need it to be when we go to merge it anyway
642	642	if (block_size <= cache.len) {
643		mem.copy(T, cache[0..], items[blockA.start..blockA.start + block_size]);
	643	mem.copy(T, cache[0..], items[blockA.start .. blockA.start + block_size]);
644	644	} else {
645	645	blockSwap(T, items, blockA.start, buffer2.start, block_size);
646	646	}
...	...	@@ -651,7 +651,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
651	651	blockSwap(T, items, B_split, blockA.start + block_size - B_remaining, B_remaining);
652	652	} else {
653	653	// we are unable to use the 'buffer2' trick to speed up the rotation operation since buffer2 doesn't exist, so perform a normal rotation
654		mem.rotate(T, items[B_split..blockA.start + block_size], blockA.start - B_split);
	654	mem.rotate(T, items[B_split .. blockA.start + block_size], blockA.start - B_split);
655	655	}
656	656
657	657	// update the range for the remaining A blocks, and the range remaining from the B block after it was split
...	...	@@ -741,7 +741,7 @@ pub fn sort(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &cons
741	741	}
742	742
743	743	// merge operation without a buffer
744		fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const Range, lessThan: fn(&const T, &const T) bool) void {
	744	fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const Range, lessThan: fn (&const T, &const T) bool) void {
745	745	if (A_arg.length() == 0 or B_arg.length() == 0) return;
746	746
747	747	// this just repeatedly binary searches into B and rotates A into position.
...	...	@@ -783,7 +783,7 @@ fn mergeInPlace(comptime T: type, items: []T, A_arg: &const Range, B_arg: &const
783	783	}
784	784
785	785	// merge operation using an internal buffer
786		fn mergeInternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn(&const T, &const T) bool, buffer: &const Range) void {
	786	fn mergeInternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn (&const T, &const T) bool, buffer: &const Range) void {
787	787	// whenever we find a value to add to the final array, swap it with the value that's already in that spot
788	788	// when this algorithm is finished, 'buffer' will contain its original contents, but in a different order
789	789	var A_count: usize = 0;
...	...	@@ -819,7 +819,7 @@ fn blockSwap(comptime T: type, items: []T, start1: usize, start2: usize, block_s
819	819
820	820	// combine a linear search with a binary search to reduce the number of comparisons in situations
821	821	// where have some idea as to how many unique values there are and where the next value might be
822		fn findFirstForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
	822	fn findFirstForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn (&const T, &const T) bool, unique: usize) usize {
823	823	if (range.length() == 0) return range.start;
824	824	const skip = math.max(range.length() / unique, usize(1));
825	825
...	...	@@ -833,7 +833,7 @@ fn findFirstForward(comptime T: type, items: []T, value: &const T, range: &const
833	833	return binaryFirst(T, items, value, Range.init(index - skip, index), lessThan);
834	834	}
835	835
836		fn findFirstBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
	836	fn findFirstBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn (&const T, &const T) bool, unique: usize) usize {
837	837	if (range.length() == 0) return range.start;
838	838	const skip = math.max(range.length() / unique, usize(1));
839	839
...	...	@@ -847,7 +847,7 @@ fn findFirstBackward(comptime T: type, items: []T, value: &const T, range: &cons
847	847	return binaryFirst(T, items, value, Range.init(index, index + skip), lessThan);
848	848	}
849	849
850		fn findLastForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
	850	fn findLastForward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn (&const T, &const T) bool, unique: usize) usize {
851	851	if (range.length() == 0) return range.start;
852	852	const skip = math.max(range.length() / unique, usize(1));
853	853
...	...	@@ -861,7 +861,7 @@ fn findLastForward(comptime T: type, items: []T, value: &const T, range: &const
861	861	return binaryLast(T, items, value, Range.init(index - skip, index), lessThan);
862	862	}
863	863
864		fn findLastBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool, unique: usize) usize {
	864	fn findLastBackward(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn (&const T, &const T) bool, unique: usize) usize {
865	865	if (range.length() == 0) return range.start;
866	866	const skip = math.max(range.length() / unique, usize(1));
867	867
...	...	@@ -875,7 +875,7 @@ fn findLastBackward(comptime T: type, items: []T, value: &const T, range: &const
875	875	return binaryLast(T, items, value, Range.init(index, index + skip), lessThan);
876	876	}
877	877
878		fn binaryFirst(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool) usize {
	878	fn binaryFirst(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn (&const T, &const T) bool) usize {
879	879	var start = range.start;
880	880	var end = range.end - 1;
881	881	if (range.start >= range.end) return range.end;
...	...	@@ -893,7 +893,7 @@ fn binaryFirst(comptime T: type, items: []T, value: &const T, range: &const Rang
893	893	return start;
894	894	}
895	895
896		fn binaryLast(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn(&const T, &const T) bool) usize {
	896	fn binaryLast(comptime T: type, items: []T, value: &const T, range: &const Range, lessThan: fn (&const T, &const T) bool) usize {
897	897	var start = range.start;
898	898	var end = range.end - 1;
899	899	if (range.start >= range.end) return range.end;
...	...	@@ -911,7 +911,7 @@ fn binaryLast(comptime T: type, items: []T, value: &const T, range: &const Range
911	911	return start;
912	912	}
913	913
914		fn mergeInto(comptime T: type, from: []T, A: &const Range, B: &const Range, lessThan: fn(&const T, &const T) bool, into: []T) void {
	914	fn mergeInto(comptime T: type, from: []T, A: &const Range, B: &const Range, lessThan: fn (&const T, &const T) bool, into: []T) void {
915	915	var A_index: usize = A.start;
916	916	var B_index: usize = B.start;
917	917	const A_last = A.end;
...	...	@@ -941,7 +941,7 @@ fn mergeInto(comptime T: type, from: []T, A: &const Range, B: &const Range, less
941	941	}
942	942	}
943	943
944		fn mergeExternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn(&const T, &const T) bool, cache: []T) void {
	944	fn mergeExternal(comptime T: type, items: []T, A: &const Range, B: &const Range, lessThan: fn (&const T, &const T) bool, cache: []T) void {
945	945	// A fits into the cache, so use that instead of the internal buffer
946	946	var A_index: usize = 0;
947	947	var B_index: usize = B.start;
...	...	@@ -969,7 +969,7 @@ fn mergeExternal(comptime T: type, items: []T, A: &const Range, B: &const Range,
969	969	mem.copy(T, items[insert_index..], cache[A_index..A_last]);
970	970	}
971	971
972		fn swap(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool, order: &[8]u8, x: usize, y: usize) void {
	972	fn swap(comptime T: type, items: []T, lessThan: fn (lhs: &const T, rhs: &const T) bool, order: &[8]u8, x: usize, y: usize) void {
973	973	if (lessThan(items[y], items[x]) or ((order.)[x] > (order.)[y] and !lessThan(items[x], items[y]))) {
974	974	mem.swap(T, &items[x], &items[y]);
975	975	mem.swap(u8, &(order.)[x], &(order.)[y]);
...	...	@@ -1345,7 +1345,7 @@ fn fuzzTest(rng: &std.rand.Random) void {
1345	1345	}
1346	1346	}
1347	1347
1348		pub fn min(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) T {
	1348	pub fn min(comptime T: type, items: []T, lessThan: fn (lhs: &const T, rhs: &const T) bool) T {
1349	1349	var i: usize = 0;
1350	1350	var smallest = items[0];
1351	1351	for (items[1..]) \|item\| {
...	...	@@ -1356,7 +1356,7 @@ pub fn min(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const
1356	1356	return smallest;
1357	1357	}
1358	1358
1359		pub fn max(comptime T: type, items: []T, lessThan: fn(lhs: &const T, rhs: &const T) bool) T {
	1359	pub fn max(comptime T: type, items: []T, lessThan: fn (lhs: &const T, rhs: &const T) bool) T {
1360	1360	var i: usize = 0;
1361	1361	var biggest = items[0];
1362	1362	for (items[1..]) \|item\| {

std/special/build_runner.zig+1-1

...	...	@@ -71,7 +71,7 @@ pub fn main() !void {
71	71	}
72	72	if (mem.indexOfScalar(u8, option_contents, '=')) \|name_end\| {
73	73	const option_name = option_contents[0..name_end];
74		const option_value = option_contents[name_end + 1..];
	74	const option_value = option_contents[name_end + 1 ..];
75	75	if (builder.addUserInputOption(option_name, option_value))
76	76	return usageAndErr(&builder, false, try stderr_stream);
77	77	} else {

std/unicode.zig+2-2

...	...	@@ -151,7 +151,7 @@ pub fn utf8ValidateSlice(s: []const u8) bool {
151	151	return false;
152	152	}
153	153
154		if (utf8Decode(s[i..i + cp_len])) \|_\| {} else \|_\| {
	154	if (utf8Decode(s[i .. i + cp_len])) \|_\| {} else \|_\| {
155	155	return false;
156	156	}
157	157	i += cp_len;
...	...	@@ -216,7 +216,7 @@ const Utf8Iterator = struct {
216	216	const cp_len = utf8ByteSequenceLength(it.bytes[it.i]) catch unreachable;
217	217
218	218	it.i += cp_len;
219		return it.bytes[it.i - cp_len..it.i];
	219	return it.bytes[it.i - cp_len .. it.i];
220	220	}
221	221
222	222	pub fn nextCodepoint(it: &Utf8Iterator) ?u32 {

std/zig/tokenizer.zig+1-1

...	...	@@ -1116,7 +1116,7 @@ pub const Tokenizer = struct {
1116	1116	if (self.index + length > self.buffer.len) {
1117	1117	return u3(self.buffer.len - self.index);
1118	1118	}
1119		const bytes = self.buffer[self.index..self.index + length];
	1119	const bytes = self.buffer[self.index .. self.index + length];
1120	1120	switch (length) {
1121	1121	2 => {
1122	1122	const value = std.unicode.utf8Decode2(bytes) catch return length;

test/cases/align.zig+5-5

...	...	@@ -18,8 +18,8 @@ fn noop4() align(4) void {}
18	18
19	19	test "function alignment" {
20	20	assert(derp() == 1234);
21		assert(@typeOf(noop1) == fn() align(1) void);
22		assert(@typeOf(noop4) == fn() align(4) void);
	21	assert(@typeOf(noop1) == fn () align(1) void);
	22	assert(@typeOf(noop4) == fn () align(4) void);
23	23	noop1();
24	24	noop4();
25	25	}
...	...	@@ -127,7 +127,7 @@ test "implicitly decreasing fn alignment" {
127	127	testImplicitlyDecreaseFnAlign(alignedBig, 5678);
128	128	}
129	129
130		fn testImplicitlyDecreaseFnAlign(ptr: fn() align(1) i32, answer: i32) void {
	130	fn testImplicitlyDecreaseFnAlign(ptr: fn () align(1) i32, answer: i32) void {
131	131	assert(ptr() == answer);
132	132	}
133	133
...	...	@@ -141,10 +141,10 @@ fn alignedBig() align(16) i32 {
141	141	test "@alignCast functions" {
142	142	assert(fnExpectsOnly1(simple4) == 0x19);
143	143	}
144		fn fnExpectsOnly1(ptr: fn() align(1) i32) i32 {
	144	fn fnExpectsOnly1(ptr: fn () align(1) i32) i32 {
145	145	return fnExpects4(@alignCast(4, ptr));
146	146	}
147		fn fnExpects4(ptr: fn() align(4) i32) i32 {
	147	fn fnExpects4(ptr: fn () align(4) i32) i32 {
148	148	return ptr();
149	149	}
150	150	fn simple4() align(4) i32 {

test/cases/bugs/920.zig+3-3

...	...	@@ -7,12 +7,12 @@ const ZigTable = struct {
7	7	x: [257]f64,
8	8	f: [257]f64,
9	9
10		pdf: fn(f64) f64,
	10	pdf: fn (f64) f64,
11	11	is_symmetric: bool,
12		zero_case: fn(&Random, f64) f64,
	12	zero_case: fn (&Random, f64) f64,
13	13	};
14	14
15		fn ZigTableGen(comptime is_symmetric: bool, comptime r: f64, comptime v: f64, comptime f: fn(f64) f64, comptime f_inv: fn(f64) f64, comptime zero_case: fn(&Random, f64) f64) ZigTable {
	15	fn ZigTableGen(comptime is_symmetric: bool, comptime r: f64, comptime v: f64, comptime f: fn (f64) f64, comptime f_inv: fn (f64) f64, comptime zero_case: fn (&Random, f64) f64) ZigTable {
16	16	var tables: ZigTable = undefined;
17	17
18	18	tables.is_symmetric = is_symmetric;

test/cases/coroutines.zig+1-1

...	...	@@ -154,7 +154,7 @@ test "async function with dot syntax" {
154	154	test "async fn pointer in a struct field" {
155	155	var data: i32 = 1;
156	156	const Foo = struct {
157		bar: async<&std.mem.Allocator> fn(&i32) void,
	157	bar: async<&std.mem.Allocator> fn (&i32) void,
158	158	};
159	159	var foo = Foo{ .bar = simpleAsyncFn2 };
160	160	const p = (async<std.debug.global_allocator> foo.bar(&data)) catch unreachable;

test/cases/error.zig+1-1

...	...	@@ -193,7 +193,7 @@ fn entry() void {
193	193	foo2(bar2);
194	194	}
195	195
196		fn foo2(f: fn() error!void) void {
	196	fn foo2(f: fn () error!void) void {
197	197	const x = f();
198	198	}
199	199

test/cases/eval.zig+1-1

...	...	@@ -215,7 +215,7 @@ test "inlined block and runtime block phi" {
215	215
216	216	const CmdFn = struct {
217	217	name: []const u8,
218		func: fn(i32) i32,
	218	func: fn (i32) i32,
219	219	};
220	220
221	221	const cmd_fns = []CmdFn{

test/cases/fn.zig+1-1

...	...	@@ -66,7 +66,7 @@ test "implicit cast function unreachable return" {
66	66	wantsFnWithVoid(fnWithUnreachable);
67	67	}
68	68
69		fn wantsFnWithVoid(f: fn() void) void {}
	69	fn wantsFnWithVoid(f: fn () void) void {}
70	70
71	71	fn fnWithUnreachable() noreturn {
72	72	unreachable;

test/cases/fn_in_struct_in_comptime.zig+1-1

...	...	@@ -1,6 +1,6 @@
1	1	const assert = @import("std").debug.assert;
2	2
3		fn get_foo() fn(&u8) usize {
	3	fn get_foo() fn (&u8) usize {
4	4	comptime {
5	5	return struct {
6	6	fn func(ptr: &u8) usize {

test/cases/generics.zig+1-1

...	...	@@ -133,7 +133,7 @@ fn getFirstByte(comptime T: type, mem: []const T) u8 {
133	133	return getByte(@ptrCast(&const u8, &mem[0]));
134	134	}
135	135
136		const foos = []fn(var) bool{
	136	const foos = []fn (var) bool{
137	137	foo1,
138	138	foo2,
139	139	};

test/cases/misc.zig+1-1

...	...	@@ -511,7 +511,7 @@ test "@typeId" {
511	511	assert(@typeId(@typeOf(AUnionEnum.One)) == Tid.Enum);
512	512	assert(@typeId(AUnionEnum) == Tid.Union);
513	513	assert(@typeId(AUnion) == Tid.Union);
514		assert(@typeId(fn() void) == Tid.Fn);
	514	assert(@typeId(fn () void) == Tid.Fn);
515	515	assert(@typeId(@typeOf(builtin)) == Tid.Namespace);
516	516	assert(@typeId(@typeOf(x: {
517	517	break :x this;

test/cases/struct.zig+2-2

...	...	@@ -105,7 +105,7 @@ test "fn call of struct field" {
105	105	}
106	106
107	107	const Foo = struct {
108		ptr: fn() i32,
	108	ptr: fn () i32,
109	109	};
110	110
111	111	fn aFunc() i32 {
...	...	@@ -302,7 +302,7 @@ test "packed array 24bits" {
302	302
303	303	var bytes = []u8{0} ** (@sizeOf(FooArray24Bits) + 1);
304	304	bytes[bytes.len - 1] = 0xaa;
305		const ptr = &([]FooArray24Bits)(bytes[0..bytes.len - 1])[0];
	305	const ptr = &([]FooArray24Bits)(bytes[0 .. bytes.len - 1])[0];
306	306	assert(ptr.a == 0);
307	307	assert(ptr.b[0].field == 0);
308	308	assert(ptr.b[1].field == 0);

test/cases/type_info.zig+1-1

...	...	@@ -196,7 +196,7 @@ fn testStruct() void {
196	196	assert(!struct_info.Struct.defs[0].data.Fn.is_extern);
197	197	assert(struct_info.Struct.defs[0].data.Fn.lib_name == null);
198	198	assert(struct_info.Struct.defs[0].data.Fn.return_type == void);
199		assert(struct_info.Struct.defs[0].data.Fn.fn_type == fn(&const TestStruct) void);
	199	assert(struct_info.Struct.defs[0].data.Fn.fn_type == fn (&const TestStruct) void);
200	200	}
201	201
202	202	const TestStruct = packed struct {

test/cases/var_args.zig+1-1

...	...	@@ -58,7 +58,7 @@ fn extraFn(extra: u32, args: ...) usize {
58	58	return args.len;
59	59	}
60	60
61		const foos = []fn(...) bool{
	61	const foos = []fn (...) bool{
62	62	foo1,
63	63	foo2,
64	64	};