Commit 41bbadbb9a27107da539e27e175f5bdb52656bd5 | zig

doc/langref.html.in+10-10

...	@@ -2156,7 +2156,7 @@ test "pointer casting" {	...	@@ -2156,7 +2156,7 @@ test "pointer casting" {
2156		2156
2157	test "pointer child type" {	2157	test "pointer child type" {
2158	// pointer types have a `child` field which tells you the type they point to.	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	{#code_end#}	2161	{#code_end#}
2162	{#header_open\|Alignment#}	2162	{#header_open\|Alignment#}
...	@@ -2184,7 +2184,7 @@ test "variable alignment" {	...	@@ -2184,7 +2184,7 @@ test "variable alignment" {
2184	assert(@TypeOf(&x) == *i32);	2184	assert(@TypeOf(&x) == *i32);
2185	assert(i32 == align(align_of_i32) i32);	2185	assert(i32 == align(align_of_i32) i32);
2186	if (std.Target.current.cpu.arch == .x86_64) {	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	{#code_end#}	2190	{#code_end#}
...	@@ -2202,7 +2202,7 @@ const assert = @import("std").debug.assert;	...	@@ -2202,7 +2202,7 @@ const assert = @import("std").debug.assert;
2202	var foo: u8 align(4) = 100;	2202	var foo: u8 align(4) = 100;
2203		2203
2204	test "global variable alignment" {	2204	test "global variable alignment" {
2205	assert(@TypeOf(&foo).alignment == 4);	2205	assert(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
2206	assert(@TypeOf(&foo) == *align(4) u8);	2206	assert(@TypeOf(&foo) == *align(4) u8);
2207	const as_pointer_to_array: *[1]u8 = &foo;	2207	const as_pointer_to_array: *[1]u8 = &foo;
2208	const as_slice: []u8 = as_pointer_to_array;	2208	const as_slice: []u8 = as_pointer_to_array;
...	@@ -4310,8 +4310,8 @@ test "fn type inference" {	...	@@ -4310,8 +4310,8 @@ test "fn type inference" {
4310	const assert = @import("std").debug.assert;	4310	const assert = @import("std").debug.assert;
4311		4311
4312	test "fn reflection" {	4312	test "fn reflection" {
4313	assert(@TypeOf(assert).ReturnType == void);	4313	assert(@typeInfo(@TypeOf(assert)).Fn.return_type.? == void);
4314	assert(@TypeOf(assert).is_var_args == false);	4314	assert(@typeInfo(@TypeOf(assert)).Fn.is_var_args == false);
4315	}	4315	}
4316	{#code_end#}	4316	{#code_end#}
4317	{#header_close#}	4317	{#header_close#}
...	@@ -4611,10 +4611,10 @@ test "error union" {	...	@@ -4611,10 +4611,10 @@ test "error union" {
4611	foo = error.SomeError;	4611	foo = error.SomeError;
4612		4612
4613	// Use compile-time reflection to access the payload type of an error union:	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	// Use compile-time reflection to access the error set type of an error union:	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	{#code_end#}	4619	{#code_end#}
4620	{#header_open\|Merging Error Sets#}	4620	{#header_open\|Merging Error Sets#}
...	@@ -4991,7 +4991,7 @@ test "optional type" {	...	@@ -4991,7 +4991,7 @@ test "optional type" {
4991	foo = 1234;	4991	foo = 1234;
4992		4992
4993	// Use compile-time reflection to access the child type of the optional:	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	{#code_end#}	4996	{#code_end#}
4997	{#header_close#}	4997	{#header_close#}
...	@@ -7211,7 +7211,7 @@ fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_v	...	@@ -7211,7 +7211,7 @@ fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_v
7211	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,	7211	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
7212	an integer or an enum.	7212	an integer or an enum.
7213	</p>	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	{#see_also\|Compile Variables\|cmpxchgWeak#}	7215	{#see_also\|Compile Variables\|cmpxchgWeak#}
7216	{#header_close#}	7216	{#header_close#}
7217	{#header_open\|@cmpxchgWeak#}	7217	{#header_open\|@cmpxchgWeak#}
...	@@ -7240,7 +7240,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val	...	@@ -7240,7 +7240,7 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
7240	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,	7240	{#syntax#}T{#endsyntax#} must be a pointer, a {#syntax#}bool{#endsyntax#}, a float,
7241	an integer or an enum.	7241	an integer or an enum.
7242	</p>	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	{#see_also\|Compile Variables\|cmpxchgStrong#}	7244	{#see_also\|Compile Variables\|cmpxchgStrong#}
7245	{#header_close#}	7245	{#header_close#}
7246		7246

lib/std/child_process.zig+1-3

 @@ -275,9 +275,7 @@ pub const ChildProcess = struct {
     }
     fn handleWaitResult(self: *ChildProcess, status: u32) void {
-        // TODO https://github.com/ziglang/zig/issues/3190
+        self.term = self.cleanupAfterWait(status);
-        var term = self.cleanupAfterWait(status);
-        self.term = term;
     }
     fn cleanupStreams(self: *ChildProcess) void {

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

 @@ -9,10 +9,10 @@ const testing = std.testing;
 /// Read a single unsigned LEB128 value from the given reader as type T,
 /// or error.Overflow if the value cannot fit.
 pub fn readULEB128(comptime T: type, reader: anytype) !T {
-    const U = if (T.bit_count < 8) u8 else T;
+    const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
     const ShiftT = std.math.Log2Int(U);
-    const max_group = (U.bit_count + 6) / 7;
+    const max_group = (@typeInfo(U).Int.bits + 6) / 7;
     var value = @as(U, 0);
     var group = @as(ShiftT, 0);
 @@ -40,7 +40,7 @@ pub fn readULEB128(comptime T: type, reader: anytype) !T {
 /// Write a single unsigned integer as unsigned LEB128 to the given writer.
 pub fn writeULEB128(writer: anytype, uint_value: anytype) !void {
     const T = @TypeOf(uint_value);
-    const U = if (T.bit_count < 8) u8 else T;
+    const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
     var value = @intCast(U, uint_value);
     while (true) {
 @@ -68,7 +68,7 @@ pub fn readULEB128Mem(comptime T: type, ptr: *[]const u8) !T {
 /// returning the number of bytes written.
 pub fn writeULEB128Mem(ptr: []u8, uint_value: anytype) !usize {
     const T = @TypeOf(uint_value);
-    const max_group = (T.bit_count + 6) / 7;
+    const max_group = (@typeInfo(T).Int.bits + 6) / 7;
     var buf = std.io.fixedBufferStream(ptr);
     try writeULEB128(buf.writer(), uint_value);
     return buf.pos;
 @@ -77,11 +77,11 @@ pub fn writeULEB128Mem(ptr: []u8, uint_value: anytype) !usize {
 /// Read a single signed LEB128 value from the given reader as type T,
 /// or error.Overflow if the value cannot fit.
 pub fn readILEB128(comptime T: type, reader: anytype) !T {
-    const S = if (T.bit_count < 8) i8 else T;
+    const S = if (@typeInfo(T).Int.bits < 8) i8 else T;
-    const U = std.meta.Int(false, S.bit_count);
+    const U = std.meta.Int(false, @typeInfo(S).Int.bits);
     const ShiftU = std.math.Log2Int(U);
-    const max_group = (U.bit_count + 6) / 7;
+    const max_group = (@typeInfo(U).Int.bits + 6) / 7;
     var value = @as(U, 0);
     var group = @as(ShiftU, 0);
 @@ -97,7 +97,7 @@ pub fn readILEB128(comptime T: type, reader: anytype) !T {
             if (@bitCast(S, temp) >= 0) return error.Overflow;
             // and all the overflowed bits are 1
-            const remaining_shift = @intCast(u3, U.bit_count - @as(u16, shift));
+            const remaining_shift = @intCast(u3, @typeInfo(U).Int.bits - @as(u16, shift));
             const remaining_bits = @bitCast(i8, byte | 0x80) >> remaining_shift;
             if (remaining_bits != -1) return error.Overflow;
         }
 @@ -127,8 +127,8 @@ pub fn readILEB128(comptime T: type, reader: anytype) !T {
 /// Write a single signed integer as signed LEB128 to the given writer.
 pub fn writeILEB128(writer: anytype, int_value: anytype) !void {
     const T = @TypeOf(int_value);
-    const S = if (T.bit_count < 8) i8 else T;
+    const S = if (@typeInfo(T).Int.bits < 8) i8 else T;
-    const U = std.meta.Int(false, S.bit_count);
+    const U = std.meta.Int(false, @typeInfo(S).Int.bits);
     var value = @intCast(S, int_value);
 @@ -173,7 +173,7 @@ pub fn writeILEB128Mem(ptr: []u8, int_value: anytype) !usize {
 /// different value without shifting all the following code.
 pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: std.meta.Int(false, l * 7)) void {
     const T = @TypeOf(int);
-    const U = if (T.bit_count < 8) u8 else T;
+    const U = if (@typeInfo(T).Int.bits < 8) u8 else T;
     var value = @intCast(U, int);
     comptime var i = 0;
 @@ -346,28 +346,29 @@ test "deserialize unsigned LEB128" {
 fn test_write_leb128(value: anytype) !void {
     const T = @TypeOf(value);
+    const t_signed = @typeInfo(T).Int.is_signed;
-    const writeStream = if (T.is_signed) writeILEB128 else writeULEB128;
+    const writeStream = if (t_signed) writeILEB128 else writeULEB128;
-    const writeMem = if (T.is_signed) writeILEB128Mem else writeULEB128Mem;
+    const writeMem = if (t_signed) writeILEB128Mem else writeULEB128Mem;
-    const readStream = if (T.is_signed) readILEB128 else readULEB128;
+    const readStream = if (t_signed) readILEB128 else readULEB128;
-    const readMem = if (T.is_signed) readILEB128Mem else readULEB128Mem;
+    const readMem = if (t_signed) readILEB128Mem else readULEB128Mem;
     // decode to a larger bit size too, to ensure sign extension
     // is working as expected
-    const larger_type_bits = ((T.bit_count + 8) / 8) * 8;
+    const larger_type_bits = ((@typeInfo(T).Int.bits + 8) / 8) * 8;
-    const B = std.meta.Int(T.is_signed, larger_type_bits);
+    const B = std.meta.Int(t_signed, larger_type_bits);
     const bytes_needed = bn: {
-        const S = std.meta.Int(T.is_signed, @sizeOf(T) * 8);
+        const S = std.meta.Int(t_signed, @sizeOf(T) * 8);
-        if (T.bit_count <= 7) break :bn @as(u16, 1);
+        if (@typeInfo(T).Int.bits <= 7) break :bn @as(u16, 1);
         const unused_bits = if (value < 0) @clz(T, ~value) else @clz(T, value);
-        const used_bits: u16 = (T.bit_count - unused_bits) + @boolToInt(T.is_signed);
+        const used_bits: u16 = (@typeInfo(T).Int.bits - unused_bits) + @boolToInt(t_signed);
         if (used_bits <= 7) break :bn @as(u16, 1);
         break :bn ((used_bits + 6) / 7);
     };
-    const max_groups = if (T.bit_count == 0) 1 else (T.bit_count + 6) / 7;
+    const max_groups = if (@typeInfo(T).Int.bits == 0) 1 else (@typeInfo(T).Int.bits + 6) / 7;
     var buf: [max_groups]u8 = undefined;
     var fbs = std.io.fixedBufferStream(&buf);
 @@ -414,7 +415,7 @@ test "serialize unsigned LEB128" {
         const T = std.meta.Int(false, t);
         const min = std.math.minInt(T);
         const max = std.math.maxInt(T);
-        var i = @as(std.meta.Int(false, T.bit_count + 1), min);
+        var i = @as(std.meta.Int(false, @typeInfo(T).Int.bits + 1), min);
         while (i <= max) : (i += 1) try test_write_leb128(@intCast(T, i));
     }
 @@ -432,7 +433,7 @@ test "serialize signed LEB128" {
         const T = std.meta.Int(true, t);
         const min = std.math.minInt(T);
         const max = std.math.maxInt(T);
-        var i = @as(std.meta.Int(true, T.bit_count + 1), min);
+        var i = @as(std.meta.Int(true, @typeInfo(T).Int.bits + 1), min);
         while (i <= max) : (i += 1) try test_write_leb128(@intCast(T, i));
     }

lib/std/fmt.zig+11-10

...	@@ -93,7 +93,7 @@ pub fn format(	...	@@ -93,7 +93,7 @@ pub fn format(
93	if (@typeInfo(@TypeOf(args)) != .Struct) {	93	if (@typeInfo(@TypeOf(args)) != .Struct) {
94	@compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(args)));	94	@compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(args)));
95	}	95	}
96	if (args.len > ArgSetType.bit_count) {	96	if (args.len > @typeInfo(ArgSetType).Int.bits) {
97	@compileError("32 arguments max are supported per format call");	97	@compileError("32 arguments max are supported per format call");
98	}	98	}
99		99
...	@@ -327,7 +327,7 @@ pub fn formatType(	...	@@ -327,7 +327,7 @@ pub fn formatType(
327	max_depth: usize,	327	max_depth: usize,
328	) @TypeOf(writer).Error!void {	328	) @TypeOf(writer).Error!void {
329	if (comptime std.mem.eql(u8, fmt, "*")) {	329	if (comptime std.mem.eql(u8, fmt, "*")) {
330	try writer.writeAll(@typeName(@TypeOf(value).Child));	330	try writer.writeAll(@typeName(@typeInfo(@TypeOf(value)).Pointer.child));
331	try writer.writeAll("@");	331	try writer.writeAll("@");
332	try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, writer);	332	try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, writer);
333	return;	333	return;
...	@@ -432,12 +432,12 @@ pub fn formatType(	...	@@ -432,12 +432,12 @@ pub fn formatType(
432	if (info.child == u8) {	432	if (info.child == u8) {
433	return formatText(value, fmt, options, writer);	433	return formatText(value, fmt, options, writer);
434	}	434	}
435	return format(writer, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });	435	return format(writer, "{}@{x}", .{ @typeName(@typeInfo(T).Pointer.child), @ptrToInt(value) });
436	},	436	},
437	.Enum, .Union, .Struct => {	437	.Enum, .Union, .Struct => {
438	return formatType(value.*, fmt, options, writer, max_depth);	438	return formatType(value.*, fmt, options, writer, max_depth);
439	},	439	},
440	else => return format(writer, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) }),	440	else => return format(writer, "{}@{x}", .{ @typeName(@typeInfo(T).Pointer.child), @ptrToInt(value) }),
441	},	441	},
442	.Many, .C => {	442	.Many, .C => {
443	if (ptr_info.sentinel) \|sentinel\| {	443	if (ptr_info.sentinel) \|sentinel\| {
...	@@ -448,7 +448,7 @@ pub fn formatType(	...	@@ -448,7 +448,7 @@ pub fn formatType(
448	return formatText(mem.span(value), fmt, options, writer);	448	return formatText(mem.span(value), fmt, options, writer);
449	}	449	}
450	}	450	}
451	return format(writer, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });	451	return format(writer, "{}@{x}", .{ @typeName(@typeInfo(T).Pointer.child), @ptrToInt(value) });
452	},	452	},
453	.Slice => {	453	.Slice => {
454	if (fmt.len > 0 and ((fmt[0] == 'x') or (fmt[0] == 'X'))) {	454	if (fmt.len > 0 and ((fmt[0] == 'x') or (fmt[0] == 'X'))) {
...	@@ -538,7 +538,7 @@ pub fn formatIntValue(	...	@@ -538,7 +538,7 @@ pub fn formatIntValue(
538	radix = 10;	538	radix = 10;
539	uppercase = false;	539	uppercase = false;
540	} else if (comptime std.mem.eql(u8, fmt, "c")) {	540	} else if (comptime std.mem.eql(u8, fmt, "c")) {
541	if (@TypeOf(int_value).bit_count <= 8) {	541	if (@typeInfo(@TypeOf(int_value)).Int.bits <= 8) {
542	return formatAsciiChar(@as(u8, int_value), options, writer);	542	return formatAsciiChar(@as(u8, int_value), options, writer);
543	} else {	543	} else {
544	@compileError("Cannot print integer that is larger than 8 bits as a ascii");	544	@compileError("Cannot print integer that is larger than 8 bits as a ascii");
...	@@ -947,7 +947,7 @@ pub fn formatInt(	...	@@ -947,7 +947,7 @@ pub fn formatInt(
947	} else	947	} else
948	value;	948	value;
949		949
950	if (@TypeOf(int_value).is_signed) {	950	if (@typeInfo(@TypeOf(int_value)).Int.is_signed) {
951	return formatIntSigned(int_value, base, uppercase, options, writer);	951	return formatIntSigned(int_value, base, uppercase, options, writer);
952	} else {	952	} else {
953	return formatIntUnsigned(int_value, base, uppercase, options, writer);	953	return formatIntUnsigned(int_value, base, uppercase, options, writer);
...	@@ -989,9 +989,10 @@ fn formatIntUnsigned(	...	@@ -989,9 +989,10 @@ fn formatIntUnsigned(
989	writer: anytype,	989	writer: anytype,
990	) !void {	990	) !void {
991	assert(base >= 2);	991	assert(base >= 2);
992	var buf: [math.max(@TypeOf(value).bit_count, 1)]u8 = undefined;	992	const value_info = @typeInfo(@TypeOf(value)).Int;
993	const min_int_bits = comptime math.max(@TypeOf(value).bit_count, @TypeOf(base).bit_count);	993	var buf: [math.max(value_info.bits, 1)]u8 = undefined;
994	const MinInt = std.meta.Int(@TypeOf(value).is_signed, min_int_bits);	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);
995	var a: MinInt = value;	996	var a: MinInt = value;
996	var index: usize = buf.len;	997	var index: usize = buf.len;
997		998

lib/std/fmt/parse_float.zig+1-1

...	@@ -374,7 +374,7 @@ test "fmt.parseFloat" {	...	@@ -374,7 +374,7 @@ test "fmt.parseFloat" {
374	const epsilon = 1e-7;	374	const epsilon = 1e-7;
375		375
376	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {	376	inline for ([_]type{ f16, f32, f64, f128 }) \|T\| {
377	const Z = std.meta.Int(false, T.bit_count);	377	const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
378		378
379	testing.expectError(error.InvalidCharacter, parseFloat(T, ""));	379	testing.expectError(error.InvalidCharacter, parseFloat(T, ""));
380	testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));	380	testing.expectError(error.InvalidCharacter, parseFloat(T, " 1"));

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

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

lib/std/heap.zig+1-1

...	@@ -952,7 +952,7 @@ pub fn testAllocatorLargeAlignment(base_allocator: *mem.Allocator) mem.Allocator	...	@@ -952,7 +952,7 @@ pub fn testAllocatorLargeAlignment(base_allocator: *mem.Allocator) mem.Allocator
952	// very near usize?	952	// very near usize?
953	if (mem.page_size << 2 > maxInt(usize)) return;	953	if (mem.page_size << 2 > maxInt(usize)) return;
954		954
955	const USizeShift = std.meta.Int(false, std.math.log2(usize.bit_count));	955	const USizeShift = std.meta.Int(false, std.math.log2(std.meta.bitCount(usize)));
956	const large_align = @as(u29, mem.page_size << 2);	956	const large_align = @as(u29, mem.page_size << 2);
957		957
958	var align_mask: usize = undefined;	958	var align_mask: usize = undefined;

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

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

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

lib/std/math.zig+32-31

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

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

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

...	@@ -6,6 +6,7 @@	...	@@ -6,6 +6,7 @@
6	const std = @import("../../std.zig");	6	const std = @import("../../std.zig");
7	const math = std.math;	7	const math = std.math;
8	const Limb = std.math.big.Limb;	8	const Limb = std.math.big.Limb;
		9	const limb_bits = @typeInfo(Limb).Int.bits;
9	const DoubleLimb = std.math.big.DoubleLimb;	10	const DoubleLimb = std.math.big.DoubleLimb;
10	const SignedDoubleLimb = std.math.big.SignedDoubleLimb;	11	const SignedDoubleLimb = std.math.big.SignedDoubleLimb;
11	const Log2Limb = std.math.big.Log2Limb;	12	const Log2Limb = std.math.big.Log2Limb;
...	@@ -28,7 +29,7 @@ pub fn calcLimbLen(scalar: anytype) usize {	...	@@ -28,7 +29,7 @@ pub fn calcLimbLen(scalar: anytype) usize {
28	},	29	},
29	.ComptimeInt => {	30	.ComptimeInt => {
30	const w_value = if (scalar < 0) -scalar else scalar;	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	else => @compileError("parameter must be a primitive integer type"),	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,7 +55,7 @@ pub fn calcSetStringLimbsBufferLen(base: u8, string_len: usize) usize {
54	}	55	}
55		56
56	pub fn calcSetStringLimbCount(base: u8, string_len: usize) usize {	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	/// a + b * c + *carry, sets carry to the overflow bits	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,7 +69,7 @@ pub fn addMulLimbWithCarry(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {
68	// r2 = b * c	69	// r2 = b * c
69	const bc = @as(DoubleLimb, math.mulWide(Limb, b, c));	70	const bc = @as(DoubleLimb, math.mulWide(Limb, b, c));
70	const r2 = @truncate(Limb, bc);	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	// r1 = r1 + r2	74	// r1 = r1 + r2
74	const c3: Limb = @boolToInt(@addWithOverflow(Limb, r1, r2, &r1));	75	const c3: Limb = @boolToInt(@addWithOverflow(Limb, r1, r2, &r1));
...	@@ -181,7 +182,7 @@ pub const Mutable = struct {	...	@@ -181,7 +182,7 @@ pub const Mutable = struct {
181		182
182	switch (@typeInfo(T)) {	183	switch (@typeInfo(T)) {
183	.Int => \|info\| {	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	const needed_limbs = @sizeOf(UT) / @sizeOf(Limb);	187	const needed_limbs = @sizeOf(UT) / @sizeOf(Limb);
187	assert(needed_limbs <= self.limbs.len); // value too big	188	assert(needed_limbs <= self.limbs.len); // value too big
...	@@ -190,7 +191,7 @@ pub const Mutable = struct {	...	@@ -190,7 +191,7 @@ pub const Mutable = struct {
190		191
191	var w_value: UT = if (value < 0) @intCast(UT, -value) else @intCast(UT, value);	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	self.limbs[0] = @as(Limb, w_value);	195	self.limbs[0] = @as(Limb, w_value);
195	self.len += 1;	196	self.len += 1;
196	} else {	197	} else {
...	@@ -200,15 +201,15 @@ pub const Mutable = struct {	...	@@ -200,15 +201,15 @@ pub const Mutable = struct {
200	self.len += 1;	201	self.len += 1;
201		202
202	// TODO: shift == 64 at compile-time fails. Fails on u128 limbs.	203	// TODO: shift == 64 at compile-time fails. Fails on u128 limbs.
203	w_value >>= Limb.bit_count / 2;	204	w_value >>= limb_bits / 2;
204	w_value >>= Limb.bit_count / 2;	205	w_value >>= limb_bits / 2;
205	}	206	}
206	}	207	}
207	},	208	},
208	.ComptimeInt => {	209	.ComptimeInt => {
209	comptime var w_value = if (value < 0) -value else value;	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	assert(req_limbs <= self.limbs.len); // value too big	213	assert(req_limbs <= self.limbs.len); // value too big
213		214
214	self.len = req_limbs;	215	self.len = req_limbs;
...	@@ -217,14 +218,14 @@ pub const Mutable = struct {	...	@@ -217,14 +218,14 @@ pub const Mutable = struct {
217	if (w_value <= maxInt(Limb)) {	218	if (w_value <= maxInt(Limb)) {
218	self.limbs[0] = w_value;	219	self.limbs[0] = w_value;
219	} else {	220	} else {
220	const mask = (1 << Limb.bit_count) - 1;	221	const mask = (1 << limb_bits) - 1;
221		222
222	comptime var i = 0;	223	comptime var i = 0;
223	inline while (w_value != 0) : (i += 1) {	224	inline while (w_value != 0) : (i += 1) {
224	self.limbs[i] = w_value & mask;	225	self.limbs[i] = w_value & mask;
225		226
226	w_value >>= Limb.bit_count / 2;	227	w_value >>= limb_bits / 2;
227	w_value >>= Limb.bit_count / 2;	228	w_value >>= limb_bits / 2;
228	}	229	}
229	}	230	}
230	},	231	},
...	@@ -506,7 +507,7 @@ pub const Mutable = struct {	...	@@ -506,7 +507,7 @@ pub const Mutable = struct {
506	/// `a.limbs.len + (shift / (@sizeOf(Limb) * 8))`.	507	/// `a.limbs.len + (shift / (@sizeOf(Limb) * 8))`.
507	pub fn shiftLeft(r: *Mutable, a: Const, shift: usize) void {	508	pub fn shiftLeft(r: *Mutable, a: Const, shift: usize) void {
508	llshl(r.limbs[0..], a.limbs[0..a.limbs.len], shift);	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	r.positive = a.positive;	511	r.positive = a.positive;
511	}	512	}
512		513
...	@@ -516,7 +517,7 @@ pub const Mutable = struct {	...	@@ -516,7 +517,7 @@ pub const Mutable = struct {
516	/// Asserts there is enough memory to fit the result. The upper bound Limb count is	517	/// Asserts there is enough memory to fit the result. The upper bound Limb count is
517	/// `a.limbs.len - (shift / (@sizeOf(Limb) * 8))`.	518	/// `a.limbs.len - (shift / (@sizeOf(Limb) * 8))`.
518	pub fn shiftRight(r: *Mutable, a: Const, shift: usize) void {	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	r.len = 1;	521	r.len = 1;
521	r.positive = true;	522	r.positive = true;
522	r.limbs[0] = 0;	523	r.limbs[0] = 0;
...	@@ -524,7 +525,7 @@ pub const Mutable = struct {	...	@@ -524,7 +525,7 @@ pub const Mutable = struct {
524	}	525	}
525		526
526	const r_len = llshr(r.limbs[0..], a.limbs[0..a.limbs.len], shift);	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	r.positive = a.positive;	529	r.positive = a.positive;
529	}	530	}
530		531
...	@@ -772,7 +773,7 @@ pub const Mutable = struct {	...	@@ -772,7 +773,7 @@ pub const Mutable = struct {
772	}	773	}
773		774
774	if (ab_zero_limb_count != 0) {	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,10 +804,10 @@ pub const Mutable = struct {
803	};	804	};
804	tmp.limbs[0] = 0;	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	var norm_shift = @clz(Limb, y.limbs[y.len - 1]);	808	var norm_shift = @clz(Limb, y.limbs[y.len - 1]);
808	if (norm_shift == 0 and y.toConst().isOdd()) {	809	if (norm_shift == 0 and y.toConst().isOdd()) {
809	norm_shift = Limb.bit_count;	810	norm_shift = limb_bits;
810	}	811	}
811	x.shiftLeft(x.toConst(), norm_shift);	812	x.shiftLeft(x.toConst(), norm_shift);
812	y.shiftLeft(y.toConst(), norm_shift);	813	y.shiftLeft(y.toConst(), norm_shift);
...	@@ -820,7 +821,7 @@ pub const Mutable = struct {	...	@@ -820,7 +821,7 @@ pub const Mutable = struct {
820	mem.set(Limb, q.limbs[0..q.len], 0);	821	mem.set(Limb, q.limbs[0..q.len], 0);
821		822
822	// 2.	823	// 2.
823	tmp.shiftLeft(y.toConst(), Limb.bit_count * (n - t));	824	tmp.shiftLeft(y.toConst(), limb_bits * (n - t));
824	while (x.toConst().order(tmp.toConst()) != .lt) {	825	while (x.toConst().order(tmp.toConst()) != .lt) {
825	q.limbs[n - t] += 1;	826	q.limbs[n - t] += 1;
826	x.sub(x.toConst(), tmp.toConst());	827	x.sub(x.toConst(), tmp.toConst());
...	@@ -833,7 +834,7 @@ pub const Mutable = struct {	...	@@ -833,7 +834,7 @@ pub const Mutable = struct {
833	if (x.limbs[i] == y.limbs[t]) {	834	if (x.limbs[i] == y.limbs[t]) {
834	q.limbs[i - t - 1] = maxInt(Limb);	835	q.limbs[i - t - 1] = maxInt(Limb);
835	} else {	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	const z = @intCast(Limb, num / @as(DoubleLimb, y.limbs[t]));	838	const z = @intCast(Limb, num / @as(DoubleLimb, y.limbs[t]));
838	q.limbs[i - t - 1] = if (z > maxInt(Limb)) maxInt(Limb) else @as(Limb, z);	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,11 +863,11 @@ pub const Mutable = struct {
862	// 3.3	863	// 3.3
863	tmp.set(q.limbs[i - t - 1]);	864	tmp.set(q.limbs[i - t - 1]);
864	tmp.mul(tmp.toConst(), y.toConst(), mul_limb_buf, allocator);	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	x.sub(x.toConst(), tmp.toConst());	867	x.sub(x.toConst(), tmp.toConst());
867		868
868	if (!x.positive) {	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	x.add(x.toConst(), tmp.toConst());	871	x.add(x.toConst(), tmp.toConst());
871	q.limbs[i - t - 1] -= 1;	872	q.limbs[i - t - 1] -= 1;
872	}	873	}
...	@@ -949,7 +950,7 @@ pub const Const = struct {	...	@@ -949,7 +950,7 @@ pub const Const = struct {
949		950
950	/// Returns the number of bits required to represent the absolute value of an integer.	951	/// Returns the number of bits required to represent the absolute value of an integer.
951	pub fn bitCountAbs(self: Const) usize {	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	/// Returns the number of bits required to represent the integer in twos-complement form.	956	/// Returns the number of bits required to represent the integer in twos-complement form.
...	@@ -1019,10 +1020,10 @@ pub const Const = struct {	...	@@ -1019,10 +1020,10 @@ pub const Const = struct {
1019	/// Returns an error if self cannot be narrowed into the requested type without truncation.	1020	/// Returns an error if self cannot be narrowed into the requested type without truncation.
1020	pub fn to(self: Const, comptime T: type) ConvertError!T {	1021	pub fn to(self: Const, comptime T: type) ConvertError!T {
1021	switch (@typeInfo(T)) {	1022	switch (@typeInfo(T)) {
1022	.Int => {	1023	.Int => \|info\| {
1023	const UT = std.meta.Int(false, T.bit_count);	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	return error.TargetTooSmall;	1027	return error.TargetTooSmall;
1027	}	1028	}
1028		1029
...	@@ -1033,12 +1034,12 @@ pub const Const = struct {	...	@@ -1033,12 +1034,12 @@ pub const Const = struct {
1033	} else {	1034	} else {
1034	for (self.limbs[0..self.limbs.len]) \|_, ri\| {	1035	for (self.limbs[0..self.limbs.len]) \|_, ri\| {
1035	const limb = self.limbs[self.limbs.len - ri - 1];	1036	const limb = self.limbs[self.limbs.len - ri - 1];
1036	r <<= Limb.bit_count;	1037	r <<= limb_bits;
1037	r \|= limb;	1038	r \|= limb;
1038	}	1039	}
1039	}	1040	}
1040		1041
1041	if (!T.is_signed) {	1042	if (!info.is_signed) {
1042	return if (self.positive) @intCast(T, r) else error.NegativeIntoUnsigned;	1043	return if (self.positive) @intCast(T, r) else error.NegativeIntoUnsigned;
1043	} else {	1044	} else {
1044	if (self.positive) {	1045	if (self.positive) {
...	@@ -1149,7 +1150,7 @@ pub const Const = struct {	...	@@ -1149,7 +1150,7 @@ pub const Const = struct {
1149		1150
1150	outer: for (self.limbs[0..self.limbs.len]) \|limb\| {	1151	outer: for (self.limbs[0..self.limbs.len]) \|limb\| {
1151	var shift: usize = 0;	1152	var shift: usize = 0;
1152	while (shift < Limb.bit_count) : (shift += base_shift) {	1153	while (shift < limb_bits) : (shift += base_shift) {
1153	const r = @intCast(u8, (limb >> @intCast(Log2Limb, shift)) & @as(Limb, base - 1));	1154	const r = @intCast(u8, (limb >> @intCast(Log2Limb, shift)) & @as(Limb, base - 1));
1154	const ch = std.fmt.digitToChar(r, uppercase);	1155	const ch = std.fmt.digitToChar(r, uppercase);
1155	string[digits_len] = ch;	1156	string[digits_len] = ch;
...	@@ -1295,7 +1296,7 @@ pub const Const = struct {	...	@@ -1295,7 +1296,7 @@ pub const Const = struct {
1295	/// Memory is allocated as needed to ensure operations never overflow. The range	1296	/// Memory is allocated as needed to ensure operations never overflow. The range
1296	/// is bounded only by available memory.	1297	/// is bounded only by available memory.
1297	pub const Managed = struct {	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	/// Default number of limbs to allocate on creation of a `Managed`.	1301	/// Default number of limbs to allocate on creation of a `Managed`.
1301	pub const default_capacity = 4;	1302	pub const default_capacity = 4;
...	@@ -1716,7 +1717,7 @@ pub const Managed = struct {	...	@@ -1716,7 +1717,7 @@ pub const Managed = struct {
1716		1717
1717	/// r = a << shift, in other words, r = a * 2^shift	1718	/// r = a << shift, in other words, r = a * 2^shift
1718	pub fn shiftLeft(r: *Managed, a: Managed, shift: usize) !void {	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	var m = r.toMutable();	1721	var m = r.toMutable();
1721	m.shiftLeft(a.toConst(), shift);	1722	m.shiftLeft(a.toConst(), shift);
1722	r.setMetadata(m.positive, m.len);	1723	r.setMetadata(m.positive, m.len);
...	@@ -1724,13 +1725,13 @@ pub const Managed = struct {	...	@@ -1724,13 +1725,13 @@ pub const Managed = struct {
1724		1725
1725	/// r = a >> shift	1726	/// r = a >> shift
1726	pub fn shiftRight(r: *Managed, a: Managed, shift: usize) !void {	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	r.metadata = 1;	1729	r.metadata = 1;
1729	r.limbs[0] = 0;	1730	r.limbs[0] = 0;
1730	return;	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	var m = r.toMutable();	1735	var m = r.toMutable();
1735	m.shiftRight(a.toConst(), shift);	1736	m.shiftRight(a.toConst(), shift);
1736	r.setMetadata(m.positive, m.len);	1737	r.setMetadata(m.positive, m.len);
...	@@ -2021,7 +2022,7 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {	...	@@ -2021,7 +2022,7 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
2021	rem.* = 0;	2022	rem.* = 0;
2022	for (a) \|_, ri\| {	2023	for (a) \|_, ri\| {
2023	const i = a.len - ri - 1;	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	if (pdiv == 0) {	2027	if (pdiv == 0) {
2027	quo[i] = 0;	2028	quo[i] = 0;
...	@@ -2042,10 +2043,10 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {	...	@@ -2042,10 +2043,10 @@ fn lldiv1(quo: []Limb, rem: *Limb, a: []const Limb, b: Limb) void {
2042	fn llshl(r: []Limb, a: []const Limb, shift: usize) void {	2043	fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
2043	@setRuntimeSafety(debug_safety);	2044	@setRuntimeSafety(debug_safety);
2044	assert(a.len >= 1);	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 limb_shift = shift / limb_bits + 1;
2048	const interior_limb_shift = @intCast(Log2Limb, shift % Limb.bit_count);	2049	const interior_limb_shift = @intCast(Log2Limb, shift % limb_bits);
2049		2050
2050	var carry: Limb = 0;	2051	var carry: Limb = 0;
2051	var i: usize = 0;	2052	var i: usize = 0;
...	@@ -2057,7 +2058,7 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {	...	@@ -2057,7 +2058,7 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
2057	r[dst_i] = carry \| @call(.{ .modifier = .always_inline }, math.shr, .{	2058	r[dst_i] = carry \| @call(.{ .modifier = .always_inline }, math.shr, .{
2058	Limb,	2059	Limb,
2059	src_digit,	2060	src_digit,
2060	Limb.bit_count - @intCast(Limb, interior_limb_shift),	2061	limb_bits - @intCast(Limb, interior_limb_shift),
2061	});	2062	});
2062	carry = (src_digit << interior_limb_shift);	2063	carry = (src_digit << interior_limb_shift);
2063	}	2064	}
...	@@ -2069,10 +2070,10 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {	...	@@ -2069,10 +2070,10 @@ fn llshl(r: []Limb, a: []const Limb, shift: usize) void {
2069	fn llshr(r: []Limb, a: []const Limb, shift: usize) void {	2070	fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
2070	@setRuntimeSafety(debug_safety);	2071	@setRuntimeSafety(debug_safety);
2071	assert(a.len >= 1);	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 limb_shift = shift / limb_bits;
2075	const interior_limb_shift = @intCast(Log2Limb, shift % Limb.bit_count);	2076	const interior_limb_shift = @intCast(Log2Limb, shift % limb_bits);
2076		2077
2077	var carry: Limb = 0;	2078	var carry: Limb = 0;
2078	var i: usize = 0;	2079	var i: usize = 0;
...	@@ -2085,7 +2086,7 @@ fn llshr(r: []Limb, a: []const Limb, shift: usize) void {	...	@@ -2085,7 +2086,7 @@ fn llshr(r: []Limb, a: []const Limb, shift: usize) void {
2085	carry = @call(.{ .modifier = .always_inline }, math.shl, .{	2086	carry = @call(.{ .modifier = .always_inline }, math.shl, .{
2086	Limb,	2087	Limb,
2087	src_digit,	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,7 +2136,7 @@ fn fixedIntFromSignedDoubleLimb(A: SignedDoubleLimb, storage: []Limb) Mutable {
2135	const A_is_positive = A >= 0;	2136	const A_is_positive = A >= 0;
2136	const Au = @intCast(DoubleLimb, if (A < 0) -A else A);	2137	const Au = @intCast(DoubleLimb, if (A < 0) -A else A);
2137	storage[0] = @truncate(Limb, Au);	2138	storage[0] = @truncate(Limb, Au);
2138	storage[1] = @truncate(Limb, Au >> Limb.bit_count);	2139	storage[1] = @truncate(Limb, Au >> limb_bits);
2139	return .{	2140	return .{
2140	.limbs = storage[0..2],	2141	.limbs = storage[0..2],
2141	.positive = A_is_positive,	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,13 +23,13 @@ test "big.int comptime_int set" {
23	var a = try Managed.initSet(testing.allocator, s);	23	var a = try Managed.initSet(testing.allocator, s);
24	defer a.deinit();	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	comptime var i: usize = 0;	28	comptime var i: usize = 0;
29	inline while (i < s_limb_count) : (i += 1) {	29	inline while (i < s_limb_count) : (i += 1) {
30	const result = @as(Limb, s & maxInt(Limb));	30	const result = @as(Limb, s & maxInt(Limb));
31	s >>= Limb.bit_count / 2;	31	s >>= @typeInfo(Limb).Int.bits / 2;
32	s >>= Limb.bit_count / 2;	32	s >>= @typeInfo(Limb).Int.bits / 2;
33	testing.expect(a.limbs[i] == result);	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 {
         // Translated from golang.go/src/math/big/rat.go.
         debug.assert(@typeInfo(T) == .Float);
-        const UnsignedInt = std.meta.Int(false, T.bit_count);
+        const UnsignedInt = std.meta.Int(false, @typeInfo(T).Float.bits);
         const f_bits = @bitCast(UnsignedInt, f);
         const exponent_bits = math.floatExponentBits(T);
 @@ -194,8 +194,8 @@ pub const Rational = struct {
         // TODO: Indicate whether the result is not exact.
         debug.assert(@typeInfo(T) == .Float);
-        const fsize = T.bit_count;
+        const fsize = @typeInfo(T).Float.bits;
-        const BitReprType = std.meta.Int(false, T.bit_count);
+        const BitReprType = std.meta.Int(false, fsize);
         const msize = math.floatMantissaBits(T);
         const msize1 = msize + 1;
 @@ -475,16 +475,18 @@ pub const Rational = struct {
 fn extractLowBits(a: Int, comptime T: type) T {
     testing.expect(@typeInfo(T) == .Int);
-    if (T.bit_count <= Limb.bit_count) {
+    const t_bits = @typeInfo(T).Int.bits;
+    const limb_bits = @typeInfo(Limb).Int.bits;
+    if (t_bits <= limb_bits) {
         return @truncate(T, a.limbs[0]);
     } else {
         var r: T = 0;
         comptime var i: usize = 0;
-        // Remainder is always 0 since if T.bit_count >= Limb.bit_count -> Limb | T and both
+        // Remainder is always 0 since if t_bits >= limb_bits -> Limb | T and both
         // are powers of two.
-        inline while (i < T.bit_count / Limb.bit_count) : (i += 1) {
+        inline while (i < t_bits / limb_bits) : (i += 1) {
-            r |= math.shl(T, a.limbs[i], i * Limb.bit_count);
+            r |= math.shl(T, a.limbs[i], i * limb_bits);
         }
         return r;

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

...	@@ -49,7 +49,7 @@ const pi4c = 2.69515142907905952645E-15;	...	@@ -49,7 +49,7 @@ const pi4c = 2.69515142907905952645E-15;
49	const m4pi = 1.273239544735162542821171882678754627704620361328125;	49	const m4pi = 1.273239544735162542821171882678754627704620361328125;
50		50
51	fn cos_(comptime T: type, x_: T) T {	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	var x = x_;	54	var x = x_;
55	if (math.isNan(x) or math.isInf(x)) {	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,7 +128,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
128	if (yf != 0 and x < 0) {	128	if (yf != 0 and x < 0) {
129	return math.nan(T);	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	return math.exp(y * math.ln(x));	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,7 +150,7 @@ pub fn pow(comptime T: type, x: T, y: T) T {
150	var xe = r2.exponent;	150	var xe = r2.exponent;
151	var x1 = r2.significand;	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	while (i != 0) : (i >>= 1) {	154	while (i != 0) : (i >>= 1) {
155	const overflow_shift = math.floatExponentBits(T) + 1;	155	const overflow_shift = math.floatExponentBits(T) + 1;
156	if (xe < -(1 << overflow_shift) or (1 << overflow_shift) < xe) {	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,7 +50,7 @@ const pi4c = 2.69515142907905952645E-15;
50	const m4pi = 1.273239544735162542821171882678754627704620361328125;	50	const m4pi = 1.273239544735162542821171882678754627704620361328125;
51		51
52	fn sin_(comptime T: type, x_: T) T {	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	var x = x_;	55	var x = x_;
56	if (x == 0 or math.isNan(x)) {	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,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	var op = value;	40	var op = value;
41	var res: T = 0;	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	// "one" starts at the highest power of four <= than the argument.	44	// "one" starts at the highest power of four <= than the argument.
45	while (one > op) {	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,7 +55,7 @@ fn sqrt_int(comptime T: type, value: T) std.meta.Int(false, T.bit_count / 2) {
55	one >>= 2;	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	return @intCast(ResultType, res);	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,7 +43,7 @@ const pi4c = 2.69515142907905952645E-15;
43	const m4pi = 1.273239544735162542821171882678754627704620361328125;	43	const m4pi = 1.273239544735162542821171882678754627704620361328125;
44		44
45	fn tan_(comptime T: type, x_: T) T {	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	var x = x_;	48	var x = x_;
49	if (x == 0 or math.isNan(x)) {	49	if (x == 0 or math.isNan(x)) {

lib/std/mem.zig+21-21

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

 @@ -167,11 +167,11 @@ pub fn create(self: *Allocator, comptime T: type) Error!*T {
 /// `ptr` should be the return value of `create`, or otherwise
 /// have the same address and alignment property.
 pub fn destroy(self: *Allocator, ptr: anytype) void {
-    const T = @TypeOf(ptr).Child;
+    const info = @typeInfo(@TypeOf(ptr)).Pointer;
+    const T = info.child;
     if (@sizeOf(T) == 0) return;
     const non_const_ptr = @intToPtr([*]u8, @ptrToInt(ptr));
-    const ptr_align = @typeInfo(@TypeOf(ptr)).Pointer.alignment;
+    _ = self.shrinkBytes(non_const_ptr[0..@sizeOf(T)], info.alignment, 0, 0, @returnAddress());
-    _ = self.shrinkBytes(non_const_ptr[0..@sizeOf(T)], ptr_align, 0, 0, @returnAddress());
 }
 /// Allocates an array of `n` items of type `T` and sets all the

lib/std/os.zig+1-1

...	@@ -4526,7 +4526,7 @@ pub fn res_mkquery(	...	@@ -4526,7 +4526,7 @@ pub fn res_mkquery(
4526	// Make a reasonably unpredictable id	4526	// Make a reasonably unpredictable id
4527	var ts: timespec = undefined;	4527	var ts: timespec = undefined;
4528	clock_gettime(CLOCK_REALTIME, &ts) catch {};	4528	clock_gettime(CLOCK_REALTIME, &ts) catch {};
4529	const UInt = std.meta.Int(false, @TypeOf(ts.tv_nsec).bit_count);	4529	const UInt = std.meta.Int(false, std.meta.bitCount(@TypeOf(ts.tv_nsec)));
4530	const unsec = @bitCast(UInt, ts.tv_nsec);	4530	const unsec = @bitCast(UInt, ts.tv_nsec);
4531	const id = @truncate(u32, unsec + unsec / 65536);	4531	const id = @truncate(u32, unsec + unsec / 65536);
4532	q[0] = @truncate(u8, id / 256);	4532	q[0] = @truncate(u8, id / 256);

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

...	@@ -846,7 +846,7 @@ pub const SIG_ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));	...	@@ -846,7 +846,7 @@ pub const SIG_ERR = @intToPtr(?Sigaction.sigaction_fn, maxInt(usize));
846	pub const SIG_DFL = @intToPtr(?Sigaction.sigaction_fn, 0);	846	pub const SIG_DFL = @intToPtr(?Sigaction.sigaction_fn, 0);
847	pub const SIG_IGN = @intToPtr(?Sigaction.sigaction_fn, 1);	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	pub const signalfd_siginfo = extern struct {	851	pub const signalfd_siginfo = extern struct {
852	signo: u32,	852	signo: u32,

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

 @@ -829,17 +829,19 @@ pub fn sigaction(sig: u6, noalias act: *const Sigaction, noalias oact: ?*Sigacti
     return 0;
 }
+const usize_bits = @typeInfo(usize).Int.bits;
 pub fn sigaddset(set: *sigset_t, sig: u6) void {
     const s = sig - 1;
     // shift in musl: s&8*sizeof *set->__bits-1
-    const shift = @intCast(u5, s & (usize.bit_count - 1));
+    const shift = @intCast(u5, s & (usize_bits - 1));
     const val = @intCast(u32, 1) << shift;
-    (set.*)[@intCast(usize, s) / usize.bit_count] |= val;
+    (set.*)[@intCast(usize, s) / usize_bits] |= val;
 }
 pub fn sigismember(set: *const sigset_t, sig: u6) bool {
     const s = sig - 1;
-    return ((set.*)[@intCast(usize, s) / usize.bit_count] & (@intCast(usize, 1) << (s & (usize.bit_count - 1)))) != 0;
+    return ((set.*)[@intCast(usize, s) / usize_bits] & (@intCast(usize, 1) << (s & (usize_bits - 1)))) != 0;
 }
 pub fn getsockname(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize {

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

...	@@ -12,7 +12,7 @@ pub const SOCKET_ERROR = -1;	...	@@ -12,7 +12,7 @@ pub const SOCKET_ERROR = -1;
12	pub const WSADESCRIPTION_LEN = 256;	12	pub const WSADESCRIPTION_LEN = 256;
13	pub const WSASYS_STATUS_LEN = 128;	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	extern struct {	16	extern struct {
17	wVersion: WORD,	17	wVersion: WORD,
18	wHighVersion: WORD,	18	wHighVersion: WORD,

lib/std/pdb.zig+1-1

...	@@ -636,7 +636,7 @@ const MsfStream = struct {	...	@@ -636,7 +636,7 @@ const MsfStream = struct {
636	blocks: []u32 = undefined,	636	blocks: []u32 = undefined,
637	block_size: u32 = undefined,	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	fn init(block_size: u32, file: File, blocks: []u32) MsfStream {	641	fn init(block_size: u32, file: File, blocks: []u32) MsfStream {
642	const stream = MsfStream{	642	const stream = MsfStream{

lib/std/rand.zig+33-24

 @@ -51,8 +51,9 @@ pub const Random = struct {
     /// Returns a random int `i` such that `0 <= i <= maxInt(T)`.
     /// `i` is evenly distributed.
     pub fn int(r: *Random, comptime T: type) T {
-        const UnsignedT = std.meta.Int(false, T.bit_count);
+        const bits = @typeInfo(T).Int.bits;
-        const ByteAlignedT = std.meta.Int(false, @divTrunc(T.bit_count + 7, 8) * 8);
+        const UnsignedT = std.meta.Int(false, bits);
+        const ByteAlignedT = std.meta.Int(false, @divTrunc(bits + 7, 8) * 8);
         var rand_bytes: [@sizeOf(ByteAlignedT)]u8 = undefined;
         r.bytes(rand_bytes[0..]);
 @@ -68,10 +69,11 @@ pub const Random = struct {
     /// Constant-time implementation off `uintLessThan`.
     /// The results of this function may be biased.
     pub fn uintLessThanBiased(r: *Random, comptime T: type, less_than: T) T {
-        comptime assert(T.is_signed == false);
+        comptime assert(@typeInfo(T).Int.is_signed == false);
-        comptime assert(T.bit_count <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
+        const bits = @typeInfo(T).Int.bits;
+        comptime assert(bits <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
         assert(0 < less_than);
-        if (T.bit_count <= 32) {
+        if (bits <= 32) {
             return @intCast(T, limitRangeBiased(u32, r.int(u32), less_than));
         } else {
             return @intCast(T, limitRangeBiased(u64, r.int(u64), less_than));
 @@ -87,13 +89,15 @@ pub const Random = struct {
     /// this function is guaranteed to return.
     /// If you need deterministic runtime bounds, use `uintLessThanBiased`.
     pub fn uintLessThan(r: *Random, comptime T: type, less_than: T) T {
-        comptime assert(T.is_signed == false);
+        comptime assert(@typeInfo(T).Int.is_signed == false);
-        comptime assert(T.bit_count <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
+        const bits = @typeInfo(T).Int.bits;
+        comptime assert(bits <= 64); // TODO: workaround: LLVM ERROR: Unsupported library call operation!
         assert(0 < less_than);
         // Small is typically u32
-        const Small = std.meta.Int(false, @divTrunc(T.bit_count + 31, 32) * 32);
+        const small_bits = @divTrunc(bits + 31, 32) * 32;
+        const Small = std.meta.Int(false, small_bits);
         // Large is typically u64
-        const Large = std.meta.Int(false, Small.bit_count * 2);
+        const Large = std.meta.Int(false, small_bits * 2);
         // adapted from:
         //   http://www.pcg-random.org/posts/bounded-rands.html
 @@ -105,7 +109,7 @@ pub const Random = struct {
             // TODO: workaround for https://github.com/ziglang/zig/issues/1770
             // should be:
             //   var t: Small = -%less_than;
-            var t: Small = @bitCast(Small, -%@bitCast(std.meta.Int(true, Small.bit_count), @as(Small, less_than)));
+            var t: Small = @bitCast(Small, -%@bitCast(std.meta.Int(true, small_bits), @as(Small, less_than)));
             if (t >= less_than) {
                 t -= less_than;
 @@ -119,13 +123,13 @@ pub const Random = struct {
                 l = @truncate(Small, m);
             }
         }
-        return @intCast(T, m >> Small.bit_count);
+        return @intCast(T, m >> small_bits);
     }
     /// Constant-time implementation off `uintAtMost`.
     /// The results of this function may be biased.
     pub fn uintAtMostBiased(r: *Random, comptime T: type, at_most: T) T {
-        assert(T.is_signed == false);
+        assert(@typeInfo(T).Int.is_signed == false);
         if (at_most == maxInt(T)) {
             // have the full range
             return r.int(T);
 @@ -137,7 +141,7 @@ pub const Random = struct {
     /// See `uintLessThan`, which this function uses in most cases,
     /// for commentary on the runtime of this function.
     pub fn uintAtMost(r: *Random, comptime T: type, at_most: T) T {
-        assert(T.is_signed == false);
+        assert(@typeInfo(T).Int.is_signed == false);
         if (at_most == maxInt(T)) {
             // have the full range
             return r.int(T);
 @@ -149,9 +153,10 @@ pub const Random = struct {
     /// The results of this function may be biased.
     pub fn intRangeLessThanBiased(r: *Random, comptime T: type, at_least: T, less_than: T) T {
         assert(at_least < less_than);
-        if (T.is_signed) {
+        const info = @typeInfo(T).Int;
+        if (info.is_signed) {
             // Two's complement makes this math pretty easy.
-            const UnsignedT = std.meta.Int(false, T.bit_count);
+            const UnsignedT = std.meta.Int(false, info.bits);
             const lo = @bitCast(UnsignedT, at_least);
             const hi = @bitCast(UnsignedT, less_than);
             const result = lo +% r.uintLessThanBiased(UnsignedT, hi -% lo);
 @@ -167,9 +172,10 @@ pub const Random = struct {
     /// for commentary on the runtime of this function.
     pub fn intRangeLessThan(r: *Random, comptime T: type, at_least: T, less_than: T) T {
         assert(at_least < less_than);
-        if (T.is_signed) {
+        const info = @typeInfo(T).Int;
+        if (info.is_signed) {
             // Two's complement makes this math pretty easy.
-            const UnsignedT = std.meta.Int(false, T.bit_count);
+            const UnsignedT = std.meta.Int(false, info.bits);
             const lo = @bitCast(UnsignedT, at_least);
             const hi = @bitCast(UnsignedT, less_than);
             const result = lo +% r.uintLessThan(UnsignedT, hi -% lo);
 @@ -184,9 +190,10 @@ pub const Random = struct {
     /// The results of this function may be biased.
     pub fn intRangeAtMostBiased(r: *Random, comptime T: type, at_least: T, at_most: T) T {
         assert(at_least <= at_most);
-        if (T.is_signed) {
+        const info = @typeInfo(T).Int;
+        if (info.is_signed) {
             // Two's complement makes this math pretty easy.
-            const UnsignedT = std.meta.Int(false, T.bit_count);
+            const UnsignedT = std.meta.Int(false, info.bits);
             const lo = @bitCast(UnsignedT, at_least);
             const hi = @bitCast(UnsignedT, at_most);
             const result = lo +% r.uintAtMostBiased(UnsignedT, hi -% lo);
 @@ -202,9 +209,10 @@ pub const Random = struct {
     /// for commentary on the runtime of this function.
     pub fn intRangeAtMost(r: *Random, comptime T: type, at_least: T, at_most: T) T {
         assert(at_least <= at_most);
-        if (T.is_signed) {
+        const info = @typeInfo(T).Int;
+        if (info.is_signed) {
             // Two's complement makes this math pretty easy.
-            const UnsignedT = std.meta.Int(false, T.bit_count);
+            const UnsignedT = std.meta.Int(false, info.bits);
             const lo = @bitCast(UnsignedT, at_least);
             const hi = @bitCast(UnsignedT, at_most);
             const result = lo +% r.uintAtMost(UnsignedT, hi -% lo);
 @@ -280,14 +288,15 @@ pub const Random = struct {
 /// into an integer 0 <= result < less_than.
 /// This function introduces a minor bias.
 pub fn limitRangeBiased(comptime T: type, random_int: T, less_than: T) T {
-    comptime assert(T.is_signed == false);
+    comptime assert(@typeInfo(T).Int.is_signed == false);
-    const T2 = std.meta.Int(false, T.bit_count * 2);
+    const bits = @typeInfo(T).Int.bits;
+    const T2 = std.meta.Int(false, bits * 2);
     // adapted from:
     //   http://www.pcg-random.org/posts/bounded-rands.html
     //   "Integer Multiplication (Biased)"
     var m: T2 = @as(T2, random_int) * @as(T2, less_than);
-    return @intCast(T, m >> T.bit_count);
+    return @intCast(T, m >> bits);
 }
 const SequentialPrng = struct {

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

...	@@ -133,7 +133,7 @@ pub fn main() !void {	...	@@ -133,7 +133,7 @@ pub fn main() !void {
133	}	133	}
134		134
135	fn runBuild(builder: *Builder) anyerror!void {	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	.Void => root.build(builder),	137	.Void => root.build(builder),
138	.ErrorUnion => try root.build(builder),	138	.ErrorUnion => try root.build(builder),
139	else => @compileError("expected return type of build to be 'void' or '!void'"),	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 {
 fn generic_fmod(comptime T: type, x: T, y: T) T {
     @setRuntimeSafety(false);
-    const uint = std.meta.Int(false, T.bit_count);
+    const bits = @typeInfo(T).Float.bits;
+    const uint = std.meta.Int(false, bits);
     const log2uint = math.Log2Int(uint);
     const digits = if (T == f32) 23 else 52;
     const exp_bits = if (T == f32) 9 else 12;
-    const bits_minus_1 = T.bit_count - 1;
+    const bits_minus_1 = bits - 1;
     const mask = if (T == f32) 0xff else 0x7ff;
     var ux = @bitCast(uint, x);
     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 {
 }
 // TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
-fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
+fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
-    const Z = std.meta.Int(false, T.bit_count);
+    const bits = @typeInfo(T).Float.bits;
-    const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
+    const Z = std.meta.Int(false, bits);
+    const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
     const significandBits = std.math.floatMantissaBits(T);
     const implicitBit = @as(Z, 1) << significandBits;
-    const shift = @clz(std.meta.Int(false, T.bit_count), significand.*) - @clz(Z, implicitBit);
+    const shift = @clz(std.meta.Int(false, bits), significand.*) - @clz(Z, implicitBit);
     significand.* <<= @intCast(S, shift);
     return 1 - shift;
 }
 // TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
 fn addXf3(comptime T: type, a: T, b: T) T {
-    const Z = std.meta.Int(false, T.bit_count);
+    const bits = @typeInfo(T).Float.bits;
-    const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
+    const Z = std.meta.Int(false, bits);
+    const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
-    const typeWidth = T.bit_count;
+    const typeWidth = bits;
     const significandBits = std.math.floatMantissaBits(T);
     const exponentBits = std.math.floatExponentBits(T);
 @@ -187,7 +189,7 @@ fn addXf3(comptime T: type, a: T, b: T) T {
         // If partial cancellation occured, we need to left-shift the result
         // and adjust the exponent:
         if (aSignificand < implicitBit << 3) {
-            const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(false, T.bit_count), implicitBit << 3));
+            const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(false, bits), implicitBit << 3));
             aSignificand <<= @intCast(S, shift);
             aExponent -= shift;
         }

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

...	@@ -7,8 +7,8 @@ const builtin = @import("builtin");	...	@@ -7,8 +7,8 @@ const builtin = @import("builtin");
7		7
8	pub fn _alldiv(a: i64, b: i64) callconv(.Stdcall) i64 {	8	pub fn _alldiv(a: i64, b: i64) callconv(.Stdcall) i64 {
9	@setRuntimeSafety(builtin.is_test);	9	@setRuntimeSafety(builtin.is_test);
10	const s_a = a >> (i64.bit_count - 1);	10	const s_a = a >> (64 - 1);
11	const s_b = b >> (i64.bit_count - 1);	11	const s_b = b >> (64 - 1);
12		12
13	const an = (a ^ s_a) -% s_a;	13	const an = (a ^ s_a) -% s_a;
14	const bn = (b ^ s_b) -% s_b;	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,8 +7,8 @@ const builtin = @import("builtin");
7		7
8	pub fn _allrem(a: i64, b: i64) callconv(.Stdcall) i64 {	8	pub fn _allrem(a: i64, b: i64) callconv(.Stdcall) i64 {
9	@setRuntimeSafety(builtin.is_test);	9	@setRuntimeSafety(builtin.is_test);
10	const s_a = a >> (i64.bit_count - 1);	10	const s_a = a >> (64 - 1);
11	const s_b = b >> (i64.bit_count - 1);	11	const s_b = b >> (64 - 1);
12		12
13	const an = (a ^ s_a) -% s_a;	13	const an = (a ^ s_a) -% s_a;
14	const bn = (b ^ s_b) -% s_b;	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,8 +27,9 @@ const GE = extern enum(i32) {
27	pub fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {	27	pub fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {
28	@setRuntimeSafety(builtin.is_test);	28	@setRuntimeSafety(builtin.is_test);
29		29
30	const srep_t = std.meta.Int(true, T.bit_count);	30	const bits = @typeInfo(T).Float.bits;
31	const rep_t = std.meta.Int(false, T.bit_count);	31	const srep_t = std.meta.Int(true, bits);
		32	const rep_t = std.meta.Int(false, bits);
32		33
33	const significandBits = std.math.floatMantissaBits(T);	34	const significandBits = std.math.floatMantissaBits(T);
34	const exponentBits = std.math.floatExponentBits(T);	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,7 +74,7 @@ pub fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {
73	pub fn unordcmp(comptime T: type, a: T, b: T) i32 {	74	pub fn unordcmp(comptime T: type, a: T, b: T) i32 {
74	@setRuntimeSafety(builtin.is_test);	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	const significandBits = std.math.floatMantissaBits(T);	79	const significandBits = std.math.floatMantissaBits(T);
79	const exponentBits = std.math.floatExponentBits(T);	80	const exponentBits = std.math.floatExponentBits(T);

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

 @@ -12,10 +12,9 @@ const builtin = @import("builtin");
 pub fn __divdf3(a: f64, b: f64) callconv(.C) f64 {
     @setRuntimeSafety(builtin.is_test);
-    const Z = std.meta.Int(false, f64.bit_count);
+    const Z = std.meta.Int(false, 64);
-    const SignedZ = std.meta.Int(true, f64.bit_count);
+    const SignedZ = std.meta.Int(true, 64);
-    const typeWidth = f64.bit_count;
     const significandBits = std.math.floatMantissaBits(f64);
     const exponentBits = std.math.floatExponentBits(f64);
 @@ -317,9 +316,9 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
     }
 }
-pub fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
+pub fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
     @setRuntimeSafety(builtin.is_test);
-    const Z = std.meta.Int(false, T.bit_count);
+    const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
     const significandBits = std.math.floatMantissaBits(T);
     const implicitBit = @as(Z, 1) << significandBits;

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

 @@ -12,9 +12,8 @@ const builtin = @import("builtin");
 pub fn __divsf3(a: f32, b: f32) callconv(.C) f32 {
     @setRuntimeSafety(builtin.is_test);
-    const Z = std.meta.Int(false, f32.bit_count);
+    const Z = std.meta.Int(false, 32);
-    const typeWidth = f32.bit_count;
     const significandBits = std.math.floatMantissaBits(f32);
     const exponentBits = std.math.floatExponentBits(f32);
 @@ -190,9 +189,9 @@ pub fn __divsf3(a: f32, b: f32) callconv(.C) f32 {
     }
 }
-fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i32 {
+fn normalize(comptime T: type, significand: *std.meta.Int(false, @typeInfo(T).Float.bits)) i32 {
     @setRuntimeSafety(builtin.is_test);
-    const Z = std.meta.Int(false, T.bit_count);
+    const Z = std.meta.Int(false, @typeInfo(T).Float.bits);
     const significandBits = std.math.floatMantissaBits(T);
     const implicitBit = @as(Z, 1) << significandBits;

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

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

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

...	@@ -9,8 +9,8 @@ const builtin = @import("builtin");	...	@@ -9,8 +9,8 @@ const builtin = @import("builtin");
9	pub fn __divti3(a: i128, b: i128) callconv(.C) i128 {	9	pub fn __divti3(a: i128, b: i128) callconv(.C) i128 {
10	@setRuntimeSafety(builtin.is_test);	10	@setRuntimeSafety(builtin.is_test);
11		11
12	const s_a = a >> (i128.bit_count - 1);	12	const s_a = a >> (128 - 1);
13	const s_b = b >> (i128.bit_count - 1);	13	const s_b = b >> (128 - 1);
14		14
15	const an = (a ^ s_a) -% s_a;	15	const an = (a ^ s_a) -% s_a;
16	const bn = (b ^ s_b) -% s_b;	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 {
         else => unreachable,
     };
-    const typeWidth = rep_t.bit_count;
+    const typeWidth = @typeInfo(rep_t).Int.bits;
     const exponentBits = (typeWidth - significandBits - 1);
     const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
     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 {
     if (exponent < 0) return 0;
     // The unsigned result needs to be large enough to handle an fixint_t or rep_t
-    const fixuint_t = std.meta.Int(false, fixint_t.bit_count);
+    const fixint_bits = @typeInfo(fixint_t).Int.bits;
-    const UintResultType = if (fixint_t.bit_count > rep_t.bit_count) fixuint_t else rep_t;
+    const fixuint_t = std.meta.Int(false, fixint_bits);
+    const UintResultType = if (fixint_bits > typeWidth) fixuint_t else rep_t;
     var uint_result: UintResultType = undefined;
     // If the value is too large for the integer type, saturate.
-    if (@intCast(usize, exponent) >= fixint_t.bit_count) {
+    if (@intCast(usize, exponent) >= fixint_bits) {
         return if (negative) @as(fixint_t, minInt(fixint_t)) else @as(fixint_t, maxInt(fixint_t));
     }

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
         f128 => u128,
         else => unreachable,
     };
-    const srep_t = @import("std").meta.Int(true, rep_t.bit_count);
+    const typeWidth = @typeInfo(rep_t).Int.bits;
+    const srep_t = @import("std").meta.Int(true, typeWidth);
     const significandBits = switch (fp_t) {
         f32 => 23,
         f64 => 52,
         f128 => 112,
         else => unreachable,
     };
-    const typeWidth = rep_t.bit_count;
     const exponentBits = (typeWidth - significandBits - 1);
     const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
     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
     if (sign == -1 or exponent < 0) return 0;
     // If the value is too large for the integer type, saturate.
-    if (@intCast(c_uint, exponent) >= fixuint_t.bit_count) return ~@as(fixuint_t, 0);
+    if (@intCast(c_uint, exponent) >= @typeInfo(fixuint_t).Int.bits) return ~@as(fixuint_t, 0);
     // If 0 <= exponent < significandBits, right shift to get the result.
     // Otherwise, shift left.

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

 @@ -12,15 +12,16 @@ const FLT_MANT_DIG = 24;
 fn __floatXisf(comptime T: type, arg: T) f32 {
     @setRuntimeSafety(builtin.is_test);
-    const Z = std.meta.Int(false, T.bit_count);
+    const bits = @typeInfo(T).Int.bits;
-    const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
+    const Z = std.meta.Int(false, bits);
+    const S = std.meta.Int(false, bits - @clz(Z, @as(Z, bits) - 1));
     if (arg == 0) {
         return @as(f32, 0.0);
     }
     var ai = arg;
-    const N: u32 = T.bit_count;
+    const N: u32 = bits;
     const si = ai >> @intCast(S, (N - 1));
     ai = ((ai ^ si) -% si);
     var a = @bitCast(Z, ai);
 @@ -66,7 +67,7 @@ fn __floatXisf(comptime T: type, arg: T) f32 {
         // a is now rounded to FLT_MANT_DIG bits
     }
-    const s = @bitCast(Z, arg) >> (T.bit_count - 32);
+    const s = @bitCast(Z, arg) >> (@typeInfo(T).Int.bits - 32);
     const r = (@intCast(u32, s) & 0x80000000) | // sign
         (@intCast(u32, (e + 127)) << 23) | // exponent
         (@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,8 +10,9 @@ const maxInt = std.math.maxInt;
10	fn floatsiXf(comptime T: type, a: i32) T {	10	fn floatsiXf(comptime T: type, a: i32) T {
11	@setRuntimeSafety(builtin.is_test);	11	@setRuntimeSafety(builtin.is_test);
12		12
13	const Z = std.meta.Int(false, T.bit_count);	13	const bits = @typeInfo(T).Float.bits;
14	const S = std.meta.Int(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));	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	if (a == 0) {	17	if (a == 0) {
17	return @as(T, 0.0);	18	return @as(T, 0.0);
...	@@ -22,7 +23,7 @@ fn floatsiXf(comptime T: type, a: i32) T {	...	@@ -22,7 +23,7 @@ fn floatsiXf(comptime T: type, a: i32) T {
22	const exponentBias = ((1 << exponentBits - 1) - 1);	23	const exponentBias = ((1 << exponentBits - 1) - 1);
23		24
24	const implicitBit = @as(Z, 1) << significandBits;	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	const sign = a >> 31;	28	const sign = a >> 31;
28	// Take absolute value of a via abs(x) = (x^(x >> 31)) - (x >> 31).	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,7 +15,7 @@ pub fn __floatundisf(arg: u64) callconv(.C) f32 {
15	if (arg == 0) return 0;	15	if (arg == 0) return 0;
16		16
17	var a = arg;	17	var a = arg;
18	const N: usize = @TypeOf(a).bit_count;	18	const N: usize = @typeInfo(@TypeOf(a)).Int.bits;
19	// Number of significant digits	19	// Number of significant digits
20	const sd = N - @clz(u64, a);	20	const sd = N - @clz(u64, a);
21	// 8 exponent	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,7 +19,7 @@ pub fn __floatunditf(a: u64) callconv(.C) f128 {
19	const exponent_bias = (1 << (exponent_bits - 1)) - 1;	19	const exponent_bias = (1 << (exponent_bits - 1)) - 1;
20	const implicit_bit = 1 << mantissa_bits;	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	const shift: u7 = mantissa_bits - @intCast(u7, exp);	23	const shift: u7 = mantissa_bits - @intCast(u7, exp);
24		24
25	var result: u128 = (@intCast(u128, a) << shift) ^ implicit_bit;	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,7 +19,7 @@ pub fn __floatunsitf(a: u64) callconv(.C) f128 {
19	const exponent_bias = (1 << (exponent_bits - 1)) - 1;	19	const exponent_bias = (1 << (exponent_bits - 1)) - 1;
20	const implicit_bit = 1 << mantissa_bits;	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	const shift = mantissa_bits - @intCast(u7, exp);	23	const shift = mantissa_bits - @intCast(u7, exp);
24		24
25	// TODO(#1148): @bitCast alignment error	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,7 +219,7 @@ fn test_one_divsi3(a: i32, b: i32, expected_q: i32) void {
219	pub fn __udivsi3(n: u32, d: u32) callconv(.C) u32 {	219	pub fn __udivsi3(n: u32, d: u32) callconv(.C) u32 {
220	@setRuntimeSafety(builtin.is_test);	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	// special cases	223	// special cases
224	if (d == 0) return 0; // ?!	224	if (d == 0) return 0; // ?!
225	if (n == 0) return 0;	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,8 +14,8 @@ const compiler_rt = @import("../compiler_rt.zig");
14	pub fn __modti3(a: i128, b: i128) callconv(.C) i128 {	14	pub fn __modti3(a: i128, b: i128) callconv(.C) i128 {
15	@setRuntimeSafety(builtin.is_test);	15	@setRuntimeSafety(builtin.is_test);
16		16
17	const s_a = a >> (i128.bit_count - 1); // s = a < 0 ? -1 : 0	17	const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0
18	const s_b = b >> (i128.bit_count - 1); // s = b < 0 ? -1 : 0	18	const s_b = b >> (128 - 1); // s = b < 0 ? -1 : 0
19		19
20	const an = (a ^ s_a) -% s_a; // negate if s == -1	20	const an = (a ^ s_a) -% s_a; // negate if s == -1
21	const bn = (b ^ s_b) -% s_b; // negate if s == -1	21	const bn = (b ^ s_b) -% s_b; // negate if s == -1

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

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

...	@@ -11,7 +11,7 @@ const minInt = std.math.minInt;	...	@@ -11,7 +11,7 @@ const minInt = std.math.minInt;
11	pub fn __mulodi4(a: i64, b: i64, overflow: *c_int) callconv(.C) i64 {	11	pub fn __mulodi4(a: i64, b: i64, overflow: *c_int) callconv(.C) i64 {
12	@setRuntimeSafety(builtin.is_test);	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	const max = ~min;	15	const max = ~min;
16		16
17	overflow.* = 0;	17	overflow.* = 0;

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

...	@@ -9,7 +9,7 @@ const compiler_rt = @import("../compiler_rt.zig");	...	@@ -9,7 +9,7 @@ const compiler_rt = @import("../compiler_rt.zig");
9	pub fn __muloti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 {	9	pub fn __muloti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 {
10	@setRuntimeSafety(builtin.is_test);	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	const max = ~min;	13	const max = ~min;
14	overflow.* = 0;	14	overflow.* = 0;
15		15
...	@@ -27,9 +27,9 @@ pub fn __muloti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 {	...	@@ -27,9 +27,9 @@ pub fn __muloti4(a: i128, b: i128, overflow: *c_int) callconv(.C) i128 {
27	return r;	27	return r;
28	}	28	}
29		29
30	const sa = a >> (i128.bit_count - 1);	30	const sa = a >> (128 - 1);
31	const abs_a = (a ^ sa) -% sa;	31	const abs_a = (a ^ sa) -% sa;
32	const sb = b >> (i128.bit_count - 1);	32	const sb = b >> (128 - 1);
33	const abs_b = (b ^ sb) -% sb;	33	const abs_b = (b ^ sb) -% sb;
34		34
35	if (abs_a < 2 or abs_b < 2) {	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,9 +24,8 @@ pub fn __aeabi_dneg(arg: f64) callconv(.AAPCS) f64 {
24	}	24	}
25		25
26	fn negXf2(comptime T: type, a: T) T {	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	const significandBits = std.math.floatMantissaBits(T);	29	const significandBits = std.math.floatMantissaBits(T);
31	const exponentBits = std.math.floatExponentBits(T);	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;
 fn Dwords(comptime T: type, comptime signed_half: bool) type {
     return extern union {
-        pub const HalfTU = std.meta.Int(false, @divExact(T.bit_count, 2));
+        pub const bits = @divExact(@typeInfo(T).Int.bits, 2);
-        pub const HalfTS = std.meta.Int(true, @divExact(T.bit_count, 2));
+        pub const HalfTU = std.meta.Int(false, bits);
+        pub const HalfTS = std.meta.Int(true, bits);
         pub const HalfT = if (signed_half) HalfTS else HalfTU;
         all: T,
 @@ -30,15 +31,15 @@ pub fn ashlXi3(comptime T: type, a: T, b: i32) T {
     const input = dwords{ .all = a };
     var output: dwords = undefined;
-    if (b >= dwords.HalfT.bit_count) {
+    if (b >= dwords.bits) {
         output.s.low = 0;
-        output.s.high = input.s.low << @intCast(S, b - dwords.HalfT.bit_count);
+        output.s.high = input.s.low << @intCast(S, b - dwords.bits);
     } else if (b == 0) {
         return a;
     } else {
         output.s.low = input.s.low << @intCast(S, b);
         output.s.high = input.s.high << @intCast(S, b);
-        output.s.high |= input.s.low >> @intCast(S, dwords.HalfT.bit_count - b);
+        output.s.high |= input.s.low >> @intCast(S, dwords.bits - b);
     }
     return output.all;
 @@ -53,14 +54,14 @@ pub fn ashrXi3(comptime T: type, a: T, b: i32) T {
     const input = dwords{ .all = a };
     var output: dwords = undefined;
-    if (b >= dwords.HalfT.bit_count) {
+    if (b >= dwords.bits) {
-        output.s.high = input.s.high >> (dwords.HalfT.bit_count - 1);
+        output.s.high = input.s.high >> (dwords.bits - 1);
-        output.s.low = input.s.high >> @intCast(S, b - dwords.HalfT.bit_count);
+        output.s.low = input.s.high >> @intCast(S, b - dwords.bits);
     } else if (b == 0) {
         return a;
     } else {
         output.s.high = input.s.high >> @intCast(S, b);
-        output.s.low = input.s.high << @intCast(S, dwords.HalfT.bit_count - b);
+        output.s.low = input.s.high << @intCast(S, dwords.bits - b);
         // Avoid sign-extension here
         output.s.low |= @bitCast(
             dwords.HalfT,
 @@ -80,14 +81,14 @@ pub fn lshrXi3(comptime T: type, a: T, b: i32) T {
     const input = dwords{ .all = a };
     var output: dwords = undefined;
-    if (b >= dwords.HalfT.bit_count) {
+    if (b >= dwords.bits) {
         output.s.high = 0;
-        output.s.low = input.s.high >> @intCast(S, b - dwords.HalfT.bit_count);
+        output.s.low = input.s.high >> @intCast(S, b - dwords.bits);
     } else if (b == 0) {
         return a;
     } else {
         output.s.high = input.s.high >> @intCast(S, b);
-        output.s.low = input.s.high << @intCast(S, dwords.HalfT.bit_count - b);
+        output.s.low = input.s.high << @intCast(S, dwords.bits - b);
         output.s.low |= input.s.low >> @intCast(S, b);
     }

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

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

 @@ -15,8 +15,10 @@ const high = 1 - low;
 pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem: ?*DoubleInt) DoubleInt {
     @setRuntimeSafety(is_test);
-    const SingleInt = @import("std").meta.Int(false, @divExact(DoubleInt.bit_count, 2));
+    const double_int_bits = @typeInfo(DoubleInt).Int.bits;
-    const SignedDoubleInt = @import("std").meta.Int(true, DoubleInt.bit_count);
+    const single_int_bits = @divExact(double_int_bits, 2);
+    const SingleInt = @import("std").meta.Int(false, single_int_bits);
+    const SignedDoubleInt = @import("std").meta.Int(true, double_int_bits);
     const Log2SingleInt = @import("std").math.Log2Int(SingleInt);
     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:
         // ---
         // K 0
         sr = @bitCast(c_uint, @as(c_int, @clz(SingleInt, d[high])) - @as(c_int, @clz(SingleInt, n[high])));
-        // 0 <= sr <= SingleInt.bit_count - 2 or sr large
+        // 0 <= sr <= single_int_bits - 2 or sr large
-        if (sr > SingleInt.bit_count - 2) {
+        if (sr > single_int_bits - 2) {
             if (maybe_rem) |rem| {
                 rem.* = a;
             }
             return 0;
         }
         sr += 1;
-        // 1 <= sr <= SingleInt.bit_count - 1
+        // 1 <= sr <= single_int_bits - 1
-        // q.all = a << (DoubleInt.bit_count - sr);
+        // q.all = a << (double_int_bits - sr);
         q[low] = 0;
-        q[high] = n[low] << @intCast(Log2SingleInt, SingleInt.bit_count - sr);
+        q[high] = n[low] << @intCast(Log2SingleInt, single_int_bits - sr);
         // r.all = a >> sr;
         r[high] = n[high] >> @intCast(Log2SingleInt, sr);
-        r[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
+        r[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
     } else {
         // d[low] != 0
         if (d[high] == 0) {
 @@ -113,74 +115,74 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
                 }
                 sr = @ctz(SingleInt, d[low]);
                 q[high] = n[high] >> @intCast(Log2SingleInt, sr);
-                q[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
+                q[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
                 return @ptrCast(*align(@alignOf(SingleInt)) DoubleInt, &q[0]).*; // TODO issue #421
             }
             // K X
             // ---
             // 0 K
-            sr = 1 + SingleInt.bit_count + @as(c_uint, @clz(SingleInt, d[low])) - @as(c_uint, @clz(SingleInt, n[high]));
+            sr = 1 + single_int_bits + @as(c_uint, @clz(SingleInt, d[low])) - @as(c_uint, @clz(SingleInt, n[high]));
-            // 2 <= sr <= DoubleInt.bit_count - 1
+            // 2 <= sr <= double_int_bits - 1
-            // q.all = a << (DoubleInt.bit_count - sr);
+            // q.all = a << (double_int_bits - sr);
             // r.all = a >> sr;
-            if (sr == SingleInt.bit_count) {
+            if (sr == single_int_bits) {
                 q[low] = 0;
                 q[high] = n[low];
                 r[high] = 0;
                 r[low] = n[high];
-            } else if (sr < SingleInt.bit_count) {
+            } else if (sr < single_int_bits) {
-                // 2 <= sr <= SingleInt.bit_count - 1
+                // 2 <= sr <= single_int_bits - 1
                 q[low] = 0;
-                q[high] = n[low] << @intCast(Log2SingleInt, SingleInt.bit_count - sr);
+                q[high] = n[low] << @intCast(Log2SingleInt, single_int_bits - sr);
                 r[high] = n[high] >> @intCast(Log2SingleInt, sr);
-                r[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
+                r[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
             } else {
-                // SingleInt.bit_count + 1 <= sr <= DoubleInt.bit_count - 1
+                // single_int_bits + 1 <= sr <= double_int_bits - 1
-                q[low] = n[low] << @intCast(Log2SingleInt, DoubleInt.bit_count - sr);
+                q[low] = n[low] << @intCast(Log2SingleInt, double_int_bits - sr);
-                q[high] = (n[high] << @intCast(Log2SingleInt, DoubleInt.bit_count - sr)) | (n[low] >> @intCast(Log2SingleInt, sr - SingleInt.bit_count));
+                q[high] = (n[high] << @intCast(Log2SingleInt, double_int_bits - sr)) | (n[low] >> @intCast(Log2SingleInt, sr - single_int_bits));
                 r[high] = 0;
-                r[low] = n[high] >> @intCast(Log2SingleInt, sr - SingleInt.bit_count);
+                r[low] = n[high] >> @intCast(Log2SingleInt, sr - single_int_bits);
             }
         } else {
             // K X
             // ---
             // K K
             sr = @bitCast(c_uint, @as(c_int, @clz(SingleInt, d[high])) - @as(c_int, @clz(SingleInt, n[high])));
-            // 0 <= sr <= SingleInt.bit_count - 1 or sr large
+            // 0 <= sr <= single_int_bits - 1 or sr large
-            if (sr > SingleInt.bit_count - 1) {
+            if (sr > single_int_bits - 1) {
                 if (maybe_rem) |rem| {
                     rem.* = a;
                 }
                 return 0;
             }
             sr += 1;
-            // 1 <= sr <= SingleInt.bit_count
+            // 1 <= sr <= single_int_bits
-            // q.all = a << (DoubleInt.bit_count - sr);
+            // q.all = a << (double_int_bits - sr);
             // r.all = a >> sr;
             q[low] = 0;
-            if (sr == SingleInt.bit_count) {
+            if (sr == single_int_bits) {
                 q[high] = n[low];
                 r[high] = 0;
                 r[low] = n[high];
             } else {
                 r[high] = n[high] >> @intCast(Log2SingleInt, sr);
-                r[low] = (n[high] << @intCast(Log2SingleInt, SingleInt.bit_count - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
+                r[low] = (n[high] << @intCast(Log2SingleInt, single_int_bits - sr)) | (n[low] >> @intCast(Log2SingleInt, sr));
-                q[high] = n[low] << @intCast(Log2SingleInt, SingleInt.bit_count - sr);
+                q[high] = n[low] << @intCast(Log2SingleInt, single_int_bits - sr);
             }
         }
     }
     // Not a special case
     // q and r are initialized with:
-    // q.all = a << (DoubleInt.bit_count - sr);
+    // q.all = a << (double_int_bits - sr);
     // r.all = a >> sr;
-    // 1 <= sr <= DoubleInt.bit_count - 1
+    // 1 <= sr <= double_int_bits - 1
     var carry: u32 = 0;
     var r_all: DoubleInt = undefined;
     while (sr > 0) : (sr -= 1) {
         // r:q = ((r:q)  << 1) | carry
-        r[high] = (r[high] << 1) | (r[low] >> (SingleInt.bit_count - 1));
+        r[high] = (r[high] << 1) | (r[low] >> (single_int_bits - 1));
-        r[low] = (r[low] << 1) | (q[high] >> (SingleInt.bit_count - 1));
+        r[low] = (r[low] << 1) | (q[high] >> (single_int_bits - 1));
-        q[high] = (q[high] << 1) | (q[low] >> (SingleInt.bit_count - 1));
+        q[high] = (q[high] << 1) | (q[low] >> (single_int_bits - 1));
         q[low] = (q[low] << 1) | carry;
         // carry = 0;
         // if (r.all >= b)
 @@ -189,7 +191,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
         //      carry = 1;
         // }
         r_all = @ptrCast(*align(@alignOf(SingleInt)) DoubleInt, &r[0]).*; // TODO issue #421
-        const s: SignedDoubleInt = @bitCast(SignedDoubleInt, b -% r_all -% 1) >> (DoubleInt.bit_count - 1);
+        const s: SignedDoubleInt = @bitCast(SignedDoubleInt, b -% r_all -% 1) >> (double_int_bits - 1);
         carry = @intCast(u32, s & 1);
         r_all -= b & @bitCast(DoubleInt, s);
         r = @ptrCast(*[2]SingleInt, &r_all).*; // TODO issue #421

lib/std/start.zig+2-2

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

lib/std/thread.zig+3-3

...	@@ -166,7 +166,7 @@ pub const Thread = struct {	...	@@ -166,7 +166,7 @@ pub const Thread = struct {
166	fn threadMain(raw_arg: windows.LPVOID) callconv(.C) windows.DWORD {	166	fn threadMain(raw_arg: windows.LPVOID) callconv(.C) windows.DWORD {
167	const arg = if (@sizeOf(Context) == 0) {} else @ptrCast(Context, @alignCast(@alignOf(Context), raw_arg)).;	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	.NoReturn => {	170	.NoReturn => {
171	startFn(arg);	171	startFn(arg);
172	},	172	},
...	@@ -227,7 +227,7 @@ pub const Thread = struct {	...	@@ -227,7 +227,7 @@ pub const Thread = struct {
227	fn linuxThreadMain(ctx_addr: usize) callconv(.C) u8 {	227	fn linuxThreadMain(ctx_addr: usize) callconv(.C) u8 {
228	const arg = if (@sizeOf(Context) == 0) {} else @intToPtr(const Context, ctx_addr).;	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	.NoReturn => {	231	.NoReturn => {
232	startFn(arg);	232	startFn(arg);
233	},	233	},
...	@@ -259,7 +259,7 @@ pub const Thread = struct {	...	@@ -259,7 +259,7 @@ pub const Thread = struct {
259	fn posixThreadMain(ctx: ?c_void) callconv(.C) ?c_void {	259	fn posixThreadMain(ctx: ?c_void) callconv(.C) ?c_void {
260	const arg = if (@sizeOf(Context) == 0) {} else @ptrCast(Context, @alignCast(@alignOf(Context), ctx)).;	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	.NoReturn => {	263	.NoReturn => {
264	startFn(arg);	264	startFn(arg);
265	},	265	},

lib/std/zig.zig+1-1

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

src/analyze.cpp+1-1

...	@@ -1810,7 +1810,7 @@ Error type_allowed_in_extern(CodeGen g, ZigType type_entry, bool *result) {	...	@@ -1810,7 +1810,7 @@ Error type_allowed_in_extern(CodeGen g, ZigType type_entry, bool *result) {
1810	ZigType get_auto_err_set_type(CodeGen g, ZigFn *fn_entry) {	1810	ZigType get_auto_err_set_type(CodeGen g, ZigFn *fn_entry) {
1811	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);	1811	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
1812	buf_resize(&err_set_type->name, 0);	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	err_set_type->data.error_set.err_count = 0;	1814	err_set_type->data.error_set.err_count = 0;
1815	err_set_type->data.error_set.errors = nullptr;	1815	err_set_type->data.error_set.errors = nullptr;
1816	err_set_type->data.error_set.infer_fn = fn_entry;	1816	err_set_type->data.error_set.infer_fn = fn_entry;

src/ir.cpp+1-159

...	@@ -22835,167 +22835,9 @@ static IrInstGen ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstSrcFiel	...	@@ -22835,167 +22835,9 @@ static IrInstGen ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstSrcFiel
22835	bool ptr_is_volatile = false;	22835	bool ptr_is_volatile = false;
22836	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base, const_val,	22836	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base, const_val,
22837	err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);	22837	err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22838	} else if (child_type->id == ZigTypeIdInt) {
22839	if (buf_eql_str(field_name, "bit_count")) {
22840	bool ptr_is_const = true;
22841	bool ptr_is_volatile = false;
22842	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22843	create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22844	child_type->data.integral.bit_count, false),
22845	ira->codegen->builtin_types.entry_num_lit_int,
22846	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22847	} else if (buf_eql_str(field_name, "is_signed")) {
22848	bool ptr_is_const = true;
22849	bool ptr_is_volatile = false;
22850	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22851	create_const_bool(ira->codegen, child_type->data.integral.is_signed),
22852	ira->codegen->builtin_types.entry_bool,
22853	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22854	} else {
22855	ir_add_error(ira, &field_ptr_instruction->base.base,
22856	buf_sprintf("type '%s' has no member called '%s'",
22857	buf_ptr(&child_type->name), buf_ptr(field_name)));
22858	return ira->codegen->invalid_inst_gen;
22859	}
22860	} else if (child_type->id == ZigTypeIdFloat) {
22861	if (buf_eql_str(field_name, "bit_count")) {
22862	bool ptr_is_const = true;
22863	bool ptr_is_volatile = false;
22864	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22865	create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22866	child_type->data.floating.bit_count, false),
22867	ira->codegen->builtin_types.entry_num_lit_int,
22868	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22869	} else {
22870	ir_add_error(ira, &field_ptr_instruction->base.base,
22871	buf_sprintf("type '%s' has no member called '%s'",
22872	buf_ptr(&child_type->name), buf_ptr(field_name)));
22873	return ira->codegen->invalid_inst_gen;
22874	}
22875	} else if (child_type->id == ZigTypeIdPointer) {
22876	if (buf_eql_str(field_name, "Child")) {
22877	bool ptr_is_const = true;
22878	bool ptr_is_volatile = false;
22879	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22880	create_const_type(ira->codegen, child_type->data.pointer.child_type),
22881	ira->codegen->builtin_types.entry_type,
22882	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22883	} else if (buf_eql_str(field_name, "alignment")) {
22884	bool ptr_is_const = true;
22885	bool ptr_is_volatile = false;
22886	if ((err = type_resolve(ira->codegen, child_type->data.pointer.child_type,
22887	ResolveStatusAlignmentKnown)))
22888	{
22889	return ira->codegen->invalid_inst_gen;
22890	}
22891	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22892	create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22893	get_ptr_align(ira->codegen, child_type), false),
22894	ira->codegen->builtin_types.entry_num_lit_int,
22895	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22896	} else {
22897	ir_add_error(ira, &field_ptr_instruction->base.base,
22898	buf_sprintf("type '%s' has no member called '%s'",
22899	buf_ptr(&child_type->name), buf_ptr(field_name)));
22900	return ira->codegen->invalid_inst_gen;
22901	}
22902	} else if (child_type->id == ZigTypeIdArray) {
22903	if (buf_eql_str(field_name, "Child")) {
22904	bool ptr_is_const = true;
22905	bool ptr_is_volatile = false;
22906	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22907	create_const_type(ira->codegen, child_type->data.array.child_type),
22908	ira->codegen->builtin_types.entry_type,
22909	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22910	} else if (buf_eql_str(field_name, "len")) {
22911	bool ptr_is_const = true;
22912	bool ptr_is_volatile = false;
22913	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22914	create_const_unsigned_negative(ira->codegen, ira->codegen->builtin_types.entry_num_lit_int,
22915	child_type->data.array.len, false),
22916	ira->codegen->builtin_types.entry_num_lit_int,
22917	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22918	} else {
22919	ir_add_error(ira, &field_ptr_instruction->base.base,
22920	buf_sprintf("type '%s' has no member called '%s'",
22921	buf_ptr(&child_type->name), buf_ptr(field_name)));
22922	return ira->codegen->invalid_inst_gen;
22923	}
22924	} else if (child_type->id == ZigTypeIdErrorUnion) {
22925	if (buf_eql_str(field_name, "Payload")) {
22926	bool ptr_is_const = true;
22927	bool ptr_is_volatile = false;
22928	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22929	create_const_type(ira->codegen, child_type->data.error_union.payload_type),
22930	ira->codegen->builtin_types.entry_type,
22931	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22932	} else if (buf_eql_str(field_name, "ErrorSet")) {
22933	bool ptr_is_const = true;
22934	bool ptr_is_volatile = false;
22935	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22936	create_const_type(ira->codegen, child_type->data.error_union.err_set_type),
22937	ira->codegen->builtin_types.entry_type,
22938	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22939	} else {
22940	ir_add_error(ira, &field_ptr_instruction->base.base,
22941	buf_sprintf("type '%s' has no member called '%s'",
22942	buf_ptr(&child_type->name), buf_ptr(field_name)));
22943	return ira->codegen->invalid_inst_gen;
22944	}
22945	} else if (child_type->id == ZigTypeIdOptional) {
22946	if (buf_eql_str(field_name, "Child")) {
22947	bool ptr_is_const = true;
22948	bool ptr_is_volatile = false;
22949	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22950	create_const_type(ira->codegen, child_type->data.maybe.child_type),
22951	ira->codegen->builtin_types.entry_type,
22952	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22953	} else {
22954	ir_add_error(ira, &field_ptr_instruction->base.base,
22955	buf_sprintf("type '%s' has no member called '%s'",
22956	buf_ptr(&child_type->name), buf_ptr(field_name)));
22957	return ira->codegen->invalid_inst_gen;
22958	}
22959	} else if (child_type->id == ZigTypeIdFn) {
22960	if (buf_eql_str(field_name, "ReturnType")) {
22961	if (child_type->data.fn.fn_type_id.return_type == nullptr) {
22962	// Return type can only ever be null, if the function is generic
22963	assert(child_type->data.fn.is_generic);
22964
22965	ir_add_error(ira, &field_ptr_instruction->base.base,
22966	buf_sprintf("ReturnType has not been resolved because '%s' is generic", buf_ptr(&child_type->name)));
22967	return ira->codegen->invalid_inst_gen;
22968	}
22969
22970	bool ptr_is_const = true;
22971	bool ptr_is_volatile = false;
22972	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22973	create_const_type(ira->codegen, child_type->data.fn.fn_type_id.return_type),
22974	ira->codegen->builtin_types.entry_type,
22975	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22976	} else if (buf_eql_str(field_name, "is_var_args")) {
22977	bool ptr_is_const = true;
22978	bool ptr_is_volatile = false;
22979	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22980	create_const_bool(ira->codegen, child_type->data.fn.fn_type_id.is_var_args),
22981	ira->codegen->builtin_types.entry_bool,
22982	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22983	} else if (buf_eql_str(field_name, "arg_count")) {
22984	bool ptr_is_const = true;
22985	bool ptr_is_volatile = false;
22986	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
22987	create_const_usize(ira->codegen, child_type->data.fn.fn_type_id.param_count),
22988	ira->codegen->builtin_types.entry_usize,
22989	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
22990	} else {
22991	ir_add_error(ira, &field_ptr_instruction->base.base,
22992	buf_sprintf("type '%s' has no member called '%s'",
22993	buf_ptr(&child_type->name), buf_ptr(field_name)));
22994	return ira->codegen->invalid_inst_gen;
22995	}
22996	} else {	22838	} else {
22997	ir_add_error(ira, &field_ptr_instruction->base.base,	22839	ir_add_error(ira, &field_ptr_instruction->base.base,
22998	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)));
22999	return ira->codegen->invalid_inst_gen;	22841	return ira->codegen->invalid_inst_gen;
23000	}	22842	}
23001	} else if (field_ptr_instruction->initializing) {	22843	} else if (field_ptr_instruction->initializing) {

test/compile_errors.zig+7-16

 @@ -176,11 +176,11 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     , &[_][]const u8{
         "tmp.zig:2:17: error: expected type 'u32', found 'error{Ohno}'",
         "tmp.zig:1:17: note: function cannot return an error",
-        "tmp.zig:8:5: error: expected type 'void', found '@TypeOf(bar).ReturnType.ErrorSet'",
+        "tmp.zig:8:5: error: expected type 'void', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set'",
         "tmp.zig:7:17: note: function cannot return an error",
-        "tmp.zig:11:15: error: expected type 'u32', found '@TypeOf(bar).ReturnType.ErrorSet!u32'",
+        "tmp.zig:11:15: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'",
         "tmp.zig:10:17: note: function cannot return an error",
-        "tmp.zig:15:14: error: expected type 'u32', found '@TypeOf(bar).ReturnType.ErrorSet!u32'",
+        "tmp.zig:15:14: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'",
         "tmp.zig:14:5: note: cannot store an error in type 'u32'",
     });
 @@ -1224,7 +1224,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    };
         \\}
     , &[_][]const u8{
-        "tmp.zig:11:25: error: expected type 'u32', found '@TypeOf(get_uval).ReturnType.ErrorSet!u32'",
+        "tmp.zig:11:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'",
     });
     cases.add("assigning to struct or union fields that are not optionals with a function that returns an optional",
 @@ -1929,7 +1929,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    const info = @TypeOf(slice).unknown;
         \\}
     , &[_][]const u8{
-        "tmp.zig:3:32: error: type '[]i32' does not support field access",
+        "tmp.zig:3:32: error: type 'type' does not support field access",
     });
     cases.add("peer cast then implicit cast const pointer to mutable C pointer",
 @@ -3542,7 +3542,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    }
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:14: error: duplicate switch value: '@TypeOf(foo).ReturnType.ErrorSet.Foo'",
+        "tmp.zig:5:14: error: duplicate switch value: '@typeInfo(@typeInfo(@TypeOf(foo)).Fn.return_type.?).ErrorUnion.error_set.Foo'",
         "tmp.zig:3:14: note: other value is here",
     });
 @@ -3674,7 +3674,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    try foo();
         \\}
     , &[_][]const u8{
-        "tmp.zig:5:5: error: cannot resolve inferred error set '@TypeOf(foo).ReturnType.ErrorSet': function 'foo' not fully analyzed yet",
+        "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",
     });
     cases.add("implicit cast of error set not a subset",
 @@ -7206,15 +7206,6 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set",
     });
-    cases.add("getting return type of generic function",
-        \\fn generic(a: anytype) void {}
-        \\comptime {
-        \\    _ = @TypeOf(generic).ReturnType;
-        \\}
-    , &[_][]const u8{
-        "tmp.zig:3:25: error: ReturnType has not been resolved because 'fn(anytype) anytype' is generic",
-    });
     cases.add("unsupported modifier at start of asm output constraint",
         \\export fn foo() void {
         \\    var bar: u32 = 3;

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

...	@@ -5,7 +5,7 @@ const builtin = @import("builtin");	...	@@ -5,7 +5,7 @@ const builtin = @import("builtin");
5	var foo: u8 align(4) = 100;	5	var foo: u8 align(4) = 100;
6		6
7	test "global variable alignment" {	7	test "global variable alignment" {
8	comptime expect(@TypeOf(&foo).alignment == 4);	8	comptime expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
9	comptime expect(@TypeOf(&foo) == *align(4) u8);	9	comptime expect(@TypeOf(&foo) == *align(4) u8);
10	{	10	{
11	const slice = @as(*[1]u8, &foo)[0..];	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,16 +136,6 @@ test "array literal with specified size" {
136	expect(array[1] == 2);	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	test "array len field" {	139	test "array len field" {
150	var arr = [4]u8{ 0, 0, 0, 0 };	140	var arr = [4]u8{ 0, 0, 0, 0 };
151	var ptr = &arr;	141	var ptr = &arr;

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

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

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

 @@ -2,16 +2,18 @@ const std = @import("std");
 const expect = std.testing.expect;
 fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, comptime V: type) type {
-    expect(Key == std.meta.Int(false, Key.bit_count));
+    const key_bits = @typeInfo(Key).Int.bits;
-    expect(Key.bit_count >= mask_bit_count);
+    expect(Key == std.meta.Int(false, key_bits));
+    expect(key_bits >= mask_bit_count);
+    const shard_key_bits = mask_bit_count;
     const ShardKey = std.meta.Int(false, mask_bit_count);
-    const shift_amount = Key.bit_count - ShardKey.bit_count;
+    const shift_amount = key_bits - shard_key_bits;
     return struct {
         const Self = @This();
-        shards: [1 << ShardKey.bit_count]?*Node,
+        shards: [1 << shard_key_bits]?*Node,
         pub fn create() Self {
-            return Self{ .shards = [_]?*Node{null} ** (1 << ShardKey.bit_count) };
+            return Self{ .shards = [_]?*Node{null} ** (1 << shard_key_bits) };
         }
         fn getShardKey(key: Key) ShardKey {

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

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

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

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

test/stage1/behavior/misc.zig-10

 @@ -24,12 +24,6 @@ test "call disabled extern fn" {
     disabledExternFn();
 }
-test "floating point primitive bit counts" {
-    expect(f16.bit_count == 16);
-    expect(f32.bit_count == 32);
-    expect(f64.bit_count == 64);
-}
 test "short circuit" {
     testShortCircuit(false, true);
     comptime testShortCircuit(false, true);
 @@ -577,10 +571,6 @@ test "slice string literal has correct type" {
     comptime expect(@TypeOf(array[runtime_zero..]) == []const i32);
 }
-test "pointer child field" {
-    expect((*u32).Child == u32);
-}
 test "struct inside function" {
     testStructInFn();
     comptime testStructInFn();

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

 @@ -2,23 +2,15 @@ const expect = @import("std").testing.expect;
 const mem = @import("std").mem;
 const reflection = @This();
-test "reflection: array, pointer, optional, error union type child" {
-    comptime {
-        expect(([10]u8).Child == u8);
-        expect((*u8).Child == u8);
-        expect((anyerror!u8).Payload == u8);
-        expect((?u8).Child == u8);
-    }
-}
 test "reflection: function return type, var args, and param types" {
     comptime {
-        expect(@TypeOf(dummy).ReturnType == i32);
+        const info = @typeInfo(@TypeOf(dummy)).Fn;
-        expect(!@TypeOf(dummy).is_var_args);
+        expect(info.return_type.? == i32);
-        expect(@TypeOf(dummy).arg_count == 3);
+        expect(!info.is_var_args);
-        expect(@typeInfo(@TypeOf(dummy)).Fn.args[0].arg_type.? == bool);
+        expect(info.args.len == 3);
-        expect(@typeInfo(@TypeOf(dummy)).Fn.args[1].arg_type.? == i32);
+        expect(info.args[0].arg_type.? == bool);
-        expect(@typeInfo(@TypeOf(dummy)).Fn.args[2].arg_type.? == f32);
+        expect(info.args[1].arg_type.? == i32);
+        expect(info.args[2].arg_type.? == f32);
     }
 }

author	Veikka Tuominen <git@vexu.eu> 2020-09-05 13:58:02+03:00
committer	GitHub <noreply@github.com> 2020-09-05 13:58:02+03:00
log	41bbadbb9a27107da539e27e175f5bdb52656bd5
tree	48a89b9ef19eedded7d5b8f3ab9e5e40efacf528
parent	cff14dc2c67d9a35ae2c3e07bd6d2c5594d8a0a1
parent	09c861b829480be525a787e54117c108705256e6
signature	Signed by PGP key 4AEE18F83AFDEB23

...	@@ -198,28 +198,28 @@ pub fn Reader(	...	@@ -198,28 +198,28 @@ pub fn Reader(
198		198
199	/// Reads a native-endian integer	199	/// Reads a native-endian integer
200	pub fn readIntNative(self: Self, comptime T: type) !T {	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	return mem.readIntNative(T, &bytes);	202	return mem.readIntNative(T, &bytes);
203	}	203	}
204		204
205	/// Reads a foreign-endian integer	205	/// Reads a foreign-endian integer
206	pub fn readIntForeign(self: Self, comptime T: type) !T {	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	return mem.readIntForeign(T, &bytes);	208	return mem.readIntForeign(T, &bytes);
209	}	209	}
210		210
211	pub fn readIntLittle(self: Self, comptime T: type) !T {	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	return mem.readIntLittle(T, &bytes);	213	return mem.readIntLittle(T, &bytes);
214	}	214	}
215		215
216	pub fn readIntBig(self: Self, comptime T: type) !T {	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	return mem.readIntBig(T, &bytes);	218	return mem.readIntBig(T, &bytes);
219	}	219	}
220		220
221	pub fn readInt(self: Self, comptime T: type, endian: builtin.Endian) !T {	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	return mem.readInt(T, &bytes, endian);	223	return mem.readInt(T, &bytes, endian);
224	}	224	}
225		225

...	@@ -60,7 +60,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,	...	@@ -60,7 +60,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
60		60
61	const U = std.meta.Int(false, t_bit_count);	61	const U = std.meta.Int(false, t_bit_count);
62	const Log2U = math.Log2Int(U);	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	if (packing == .Bit) {	65	if (packing == .Bit) {
66	const result = try self.in_stream.readBitsNoEof(U, t_bit_count);	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,7 +73,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
73		73
74	if (int_size == 1) {	74	if (int_size == 1) {
75	if (t_bit_count == 8) return @bitCast(T, buffer[0]);	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	return @truncate(T, @bitCast(PossiblySignedByte, buffer[0]));	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,7 +247,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
247		247
248	const U = std.meta.Int(false, t_bit_count);	248	const U = std.meta.Int(false, t_bit_count);
249	const Log2U = math.Log2Int(U);	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	const u_value = @bitCast(U, value);	252	const u_value = @bitCast(U, value);
253		253

...	@@ -53,7 +53,7 @@ pub fn Writer(	...	@@ -53,7 +53,7 @@ pub fn Writer(
53	/// Write a native-endian integer.	53	/// Write a native-endian integer.
54	/// TODO audit non-power-of-two int sizes	54	/// TODO audit non-power-of-two int sizes
55	pub fn writeIntNative(self: Self, comptime T: type, value: T) Error!void {	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	mem.writeIntNative(T, &bytes, value);	57	mem.writeIntNative(T, &bytes, value);
58	return self.writeAll(&bytes);	58	return self.writeAll(&bytes);
59	}	59	}
...	@@ -61,28 +61,28 @@ pub fn Writer(	...	@@ -61,28 +61,28 @@ pub fn Writer(
61	/// Write a foreign-endian integer.	61	/// Write a foreign-endian integer.
62	/// TODO audit non-power-of-two int sizes	62	/// TODO audit non-power-of-two int sizes
63	pub fn writeIntForeign(self: Self, comptime T: type, value: T) Error!void {	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	mem.writeIntForeign(T, &bytes, value);	65	mem.writeIntForeign(T, &bytes, value);
66	return self.writeAll(&bytes);	66	return self.writeAll(&bytes);
67	}	67	}
68		68
69	/// TODO audit non-power-of-two int sizes	69	/// TODO audit non-power-of-two int sizes
70	pub fn writeIntLittle(self: Self, comptime T: type, value: T) Error!void {	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	mem.writeIntLittle(T, &bytes, value);	72	mem.writeIntLittle(T, &bytes, value);
73	return self.writeAll(&bytes);	73	return self.writeAll(&bytes);
74	}	74	}
75		75
76	/// TODO audit non-power-of-two int sizes	76	/// TODO audit non-power-of-two int sizes
77	pub fn writeIntBig(self: Self, comptime T: type, value: T) Error!void {	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	mem.writeIntBig(T, &bytes, value);	79	mem.writeIntBig(T, &bytes, value);
80	return self.writeAll(&bytes);	80	return self.writeAll(&bytes);
81	}	81	}
82		82
83	/// TODO audit non-power-of-two int sizes	83	/// TODO audit non-power-of-two int sizes
84	pub fn writeInt(self: Self, comptime T: type, value: T, endian: builtin.Endian) Error!void {	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	mem.writeInt(T, &bytes, value, endian);	86	mem.writeInt(T, &bytes, value, endian);
87	return self.writeAll(&bytes);	87	return self.writeAll(&bytes);
88	}	88	}

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

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

...	@@ -33,9 +33,9 @@ pub fn __aeabi_dmul(a: f64, b: f64) callconv(.C) f64 {	...	@@ -33,9 +33,9 @@ pub fn __aeabi_dmul(a: f64, b: f64) callconv(.C) f64 {
33		33
34	fn mulXf3(comptime T: type, a: T, b: T) T {	34	fn mulXf3(comptime T: type, a: T, b: T) T {
35	@setRuntimeSafety(builtin.is_test);	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	const significandBits = std.math.floatMantissaBits(T);	39	const significandBits = std.math.floatMantissaBits(T);
40	const exponentBits = std.math.floatExponentBits(T);	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,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	@setRuntimeSafety(builtin.is_test);	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	const significandBits = std.math.floatMantissaBits(T);	275	const significandBits = std.math.floatMantissaBits(T);
276	const implicitBit = @as(Z, 1) << significandBits;	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,7 +282,7 @@ fn normalize(comptime T: type, significand: *std.meta.Int(false, T.bit_count)) i
282		282
283	fn wideRightShiftWithSticky(comptime Z: type, hi: Z, lo: Z, count: u32) void {	283	fn wideRightShiftWithSticky(comptime Z: type, hi: Z, lo: Z, count: u32) void {
284	@setRuntimeSafety(builtin.is_test);	284	@setRuntimeSafety(builtin.is_test);
285	const typeWidth = Z.bit_count;	285	const typeWidth = @typeInfo(Z).Int.bits;
286	const S = std.math.Log2Int(Z);	286	const S = std.math.Log2Int(Z);
287	if (count < typeWidth) {	287	if (count < typeWidth) {
288	const sticky = @truncate(u8, lo.* << @intCast(S, typeWidth -% count));	288	const sticky = @truncate(u8, lo.* << @intCast(S, typeWidth -% count));

Merge pull request #6246 from Vexu/field