Commit e0db54e89d
Changed files (206)
lib
std
debug
event
fs
http
math
big
meta
os
rand
special
compiler_rt
test
stage1
behavior
lib/std/atomic/queue.zig
@@ -214,8 +214,8 @@ test "std.atomic.Queue" {
std.debug.panic(
"failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}",
context.get_count,
- u32(puts_per_thread),
- u32(put_thread_count),
+ @as(u32, puts_per_thread),
+ @as(u32, put_thread_count),
);
}
}
lib/std/atomic/stack.zig
@@ -11,7 +11,7 @@ pub fn Stack(comptime T: type) type {
root: ?*Node,
lock: @typeOf(lock_init),
- const lock_init = if (builtin.single_threaded) {} else u8(0);
+ const lock_init = if (builtin.single_threaded) {} else @as(u8, 0);
pub const Self = @This();
@@ -141,8 +141,8 @@ test "std.atomic.stack" {
std.debug.panic(
"failure\nget_count:{} != puts_per_thread:{} * put_thread_count:{}",
context.get_count,
- u32(puts_per_thread),
- u32(put_thread_count),
+ @as(u32, puts_per_thread),
+ @as(u32, put_thread_count),
);
}
}
lib/std/c/darwin.zig
@@ -53,7 +53,7 @@ pub extern "c" fn host_get_clock_service(host: host_t, clock_id: clock_id_t, clo
pub extern "c" fn mach_port_deallocate(task: ipc_space_t, name: mach_port_name_t) kern_return_t;
pub fn sigaddset(set: *sigset_t, signo: u5) void {
- set.* |= u32(1) << (signo - 1);
+ set.* |= @as(u32, 1) << (signo - 1);
}
pub extern "c" fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) c_int;
lib/std/crypto/aes.zig
@@ -6,7 +6,7 @@ const testing = std.testing;
// Apply sbox0 to each byte in w.
fn subw(w: u32) u32 {
- return u32(sbox0[w >> 24]) << 24 | u32(sbox0[w >> 16 & 0xff]) << 16 | u32(sbox0[w >> 8 & 0xff]) << 8 | u32(sbox0[w & 0xff]);
+ return @as(u32, sbox0[w >> 24]) << 24 | @as(u32, sbox0[w >> 16 & 0xff]) << 16 | @as(u32, sbox0[w >> 8 & 0xff]) << 8 | @as(u32, sbox0[w & 0xff]);
}
fn rotw(w: u32) u32 {
@@ -48,10 +48,10 @@ fn encryptBlock(xk: []const u32, dst: []u8, src: []const u8) void {
}
// Last round uses s-box directly and XORs to produce output.
- s0 = u32(sbox0[t0 >> 24]) << 24 | u32(sbox0[t1 >> 16 & 0xff]) << 16 | u32(sbox0[t2 >> 8 & 0xff]) << 8 | u32(sbox0[t3 & 0xff]);
- s1 = u32(sbox0[t1 >> 24]) << 24 | u32(sbox0[t2 >> 16 & 0xff]) << 16 | u32(sbox0[t3 >> 8 & 0xff]) << 8 | u32(sbox0[t0 & 0xff]);
- s2 = u32(sbox0[t2 >> 24]) << 24 | u32(sbox0[t3 >> 16 & 0xff]) << 16 | u32(sbox0[t0 >> 8 & 0xff]) << 8 | u32(sbox0[t1 & 0xff]);
- s3 = u32(sbox0[t3 >> 24]) << 24 | u32(sbox0[t0 >> 16 & 0xff]) << 16 | u32(sbox0[t1 >> 8 & 0xff]) << 8 | u32(sbox0[t2 & 0xff]);
+ s0 = @as(u32, sbox0[t0 >> 24]) << 24 | @as(u32, sbox0[t1 >> 16 & 0xff]) << 16 | @as(u32, sbox0[t2 >> 8 & 0xff]) << 8 | @as(u32, sbox0[t3 & 0xff]);
+ s1 = @as(u32, sbox0[t1 >> 24]) << 24 | @as(u32, sbox0[t2 >> 16 & 0xff]) << 16 | @as(u32, sbox0[t3 >> 8 & 0xff]) << 8 | @as(u32, sbox0[t0 & 0xff]);
+ s2 = @as(u32, sbox0[t2 >> 24]) << 24 | @as(u32, sbox0[t3 >> 16 & 0xff]) << 16 | @as(u32, sbox0[t0 >> 8 & 0xff]) << 8 | @as(u32, sbox0[t1 & 0xff]);
+ s3 = @as(u32, sbox0[t3 >> 24]) << 24 | @as(u32, sbox0[t0 >> 16 & 0xff]) << 16 | @as(u32, sbox0[t1 >> 8 & 0xff]) << 8 | @as(u32, sbox0[t2 & 0xff]);
s0 ^= xk[k + 0];
s1 ^= xk[k + 1];
@@ -99,10 +99,10 @@ pub fn decryptBlock(xk: []const u32, dst: []u8, src: []const u8) void {
}
// Last round uses s-box directly and XORs to produce output.
- s0 = u32(sbox1[t0 >> 24]) << 24 | u32(sbox1[t3 >> 16 & 0xff]) << 16 | u32(sbox1[t2 >> 8 & 0xff]) << 8 | u32(sbox1[t1 & 0xff]);
- s1 = u32(sbox1[t1 >> 24]) << 24 | u32(sbox1[t0 >> 16 & 0xff]) << 16 | u32(sbox1[t3 >> 8 & 0xff]) << 8 | u32(sbox1[t2 & 0xff]);
- s2 = u32(sbox1[t2 >> 24]) << 24 | u32(sbox1[t1 >> 16 & 0xff]) << 16 | u32(sbox1[t0 >> 8 & 0xff]) << 8 | u32(sbox1[t3 & 0xff]);
- s3 = u32(sbox1[t3 >> 24]) << 24 | u32(sbox1[t2 >> 16 & 0xff]) << 16 | u32(sbox1[t1 >> 8 & 0xff]) << 8 | u32(sbox1[t0 & 0xff]);
+ s0 = @as(u32, sbox1[t0 >> 24]) << 24 | @as(u32, sbox1[t3 >> 16 & 0xff]) << 16 | @as(u32, sbox1[t2 >> 8 & 0xff]) << 8 | @as(u32, sbox1[t1 & 0xff]);
+ s1 = @as(u32, sbox1[t1 >> 24]) << 24 | @as(u32, sbox1[t0 >> 16 & 0xff]) << 16 | @as(u32, sbox1[t3 >> 8 & 0xff]) << 8 | @as(u32, sbox1[t2 & 0xff]);
+ s2 = @as(u32, sbox1[t2 >> 24]) << 24 | @as(u32, sbox1[t1 >> 16 & 0xff]) << 16 | @as(u32, sbox1[t0 >> 8 & 0xff]) << 8 | @as(u32, sbox1[t3 & 0xff]);
+ s3 = @as(u32, sbox1[t3 >> 24]) << 24 | @as(u32, sbox1[t2 >> 16 & 0xff]) << 16 | @as(u32, sbox1[t1 >> 8 & 0xff]) << 8 | @as(u32, sbox1[t0 & 0xff]);
s0 ^= xk[k + 0];
s1 ^= xk[k + 1];
@@ -256,7 +256,7 @@ fn expandKey(key: []const u8, enc: []u32, dec: []u32) void {
while (i < enc.len) : (i += 1) {
var t = enc[i - 1];
if (i % nk == 0) {
- t = subw(rotw(t)) ^ (u32(powx[i / nk - 1]) << 24);
+ t = subw(rotw(t)) ^ (@as(u32, powx[i / nk - 1]) << 24);
} else if (nk > 6 and i % nk == 4) {
t = subw(t);
}
lib/std/crypto/blake2.zig
@@ -164,13 +164,13 @@ fn Blake2s(comptime out_len: usize) type {
inline while (j < 10) : (j += 1) {
inline for (rounds) |r| {
v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.x]];
- v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], usize(16));
+ v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], @as(usize, 16));
v[r.c] = v[r.c] +% v[r.d];
- v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], usize(12));
+ v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], @as(usize, 12));
v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.y]];
- v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], usize(8));
+ v[r.d] = math.rotr(u32, v[r.d] ^ v[r.a], @as(usize, 8));
v[r.c] = v[r.c] +% v[r.d];
- v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], usize(7));
+ v[r.b] = math.rotr(u32, v[r.b] ^ v[r.c], @as(usize, 7));
}
}
@@ -398,13 +398,13 @@ fn Blake2b(comptime out_len: usize) type {
inline while (j < 12) : (j += 1) {
inline for (rounds) |r| {
v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.x]];
- v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], usize(32));
+ v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], @as(usize, 32));
v[r.c] = v[r.c] +% v[r.d];
- v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], usize(24));
+ v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], @as(usize, 24));
v[r.a] = v[r.a] +% v[r.b] +% m[sigma[j][r.y]];
- v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], usize(16));
+ v[r.d] = math.rotr(u64, v[r.d] ^ v[r.a], @as(usize, 16));
v[r.c] = v[r.c] +% v[r.d];
- v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], usize(63));
+ v[r.b] = math.rotr(u64, v[r.b] ^ v[r.c], @as(usize, 63));
}
}
lib/std/crypto/chacha20.zig
@@ -49,13 +49,13 @@ fn salsa20_wordtobyte(out: []u8, input: [16]u32) void {
// two-round cycles
inline for (rounds) |r| {
x[r.a] +%= x[r.b];
- x[r.d] = std.math.rotl(u32, x[r.d] ^ x[r.a], u32(16));
+ x[r.d] = std.math.rotl(u32, x[r.d] ^ x[r.a], @as(u32, 16));
x[r.c] +%= x[r.d];
- x[r.b] = std.math.rotl(u32, x[r.b] ^ x[r.c], u32(12));
+ x[r.b] = std.math.rotl(u32, x[r.b] ^ x[r.c], @as(u32, 12));
x[r.a] +%= x[r.b];
- x[r.d] = std.math.rotl(u32, x[r.d] ^ x[r.a], u32(8));
+ x[r.d] = std.math.rotl(u32, x[r.d] ^ x[r.a], @as(u32, 8));
x[r.c] +%= x[r.d];
- x[r.b] = std.math.rotl(u32, x[r.b] ^ x[r.c], u32(7));
+ x[r.b] = std.math.rotl(u32, x[r.b] ^ x[r.c], @as(u32, 7));
}
}
lib/std/crypto/gimli.zig
@@ -34,9 +34,9 @@ pub const State = struct {
pub fn permute(self: *Self) void {
const state = &self.data;
- var round = u32(24);
+ var round = @as(u32, 24);
while (round > 0) : (round -= 1) {
- var column = usize(0);
+ var column = @as(usize, 0);
while (column < 4) : (column += 1) {
const x = math.rotl(u32, state[column], 24);
const y = math.rotl(u32, state[4 + column], 9);
@@ -61,7 +61,7 @@ pub const State = struct {
}
pub fn squeeze(self: *Self, out: []u8) void {
- var i = usize(0);
+ var i = @as(usize, 0);
while (i + RATE <= out.len) : (i += RATE) {
self.permute();
mem.copy(u8, out[i..], self.toSliceConst()[0..RATE]);
@@ -79,7 +79,7 @@ test "permute" {
var state = State{
.data = blk: {
var input: [12]u32 = undefined;
- var i = u32(0);
+ var i = @as(u32, 0);
while (i < 12) : (i += 1) {
input[i] = i * i * i + i *% 0x9e3779b9;
}
lib/std/crypto/md5.zig
@@ -126,10 +126,10 @@ pub const Md5 = struct {
while (i < 16) : (i += 1) {
// NOTE: Performing or's separately improves perf by ~10%
s[i] = 0;
- s[i] |= u32(b[i * 4 + 0]);
- s[i] |= u32(b[i * 4 + 1]) << 8;
- s[i] |= u32(b[i * 4 + 2]) << 16;
- s[i] |= u32(b[i * 4 + 3]) << 24;
+ s[i] |= @as(u32, b[i * 4 + 0]);
+ s[i] |= @as(u32, b[i * 4 + 1]) << 8;
+ s[i] |= @as(u32, b[i * 4 + 2]) << 16;
+ s[i] |= @as(u32, b[i * 4 + 3]) << 24;
}
var v: [4]u32 = [_]u32{
lib/std/crypto/poly1305.zig
@@ -87,11 +87,11 @@ pub const Poly1305 = struct {
// ctx->h <= 4_ffffffff_ffffffff_ffffffff_ffffffff
fn polyBlock(ctx: *Self) void {
// s = h + c, without carry propagation
- const s0 = u64(ctx.h[0]) + ctx.c[0]; // s0 <= 1_fffffffe
- const s1 = u64(ctx.h[1]) + ctx.c[1]; // s1 <= 1_fffffffe
- const s2 = u64(ctx.h[2]) + ctx.c[2]; // s2 <= 1_fffffffe
- const s3 = u64(ctx.h[3]) + ctx.c[3]; // s3 <= 1_fffffffe
- const s4 = u64(ctx.h[4]) + ctx.c[4]; // s4 <= 5
+ const s0 = @as(u64, ctx.h[0]) + ctx.c[0]; // s0 <= 1_fffffffe
+ const s1 = @as(u64, ctx.h[1]) + ctx.c[1]; // s1 <= 1_fffffffe
+ const s2 = @as(u64, ctx.h[2]) + ctx.c[2]; // s2 <= 1_fffffffe
+ const s3 = @as(u64, ctx.h[3]) + ctx.c[3]; // s3 <= 1_fffffffe
+ const s4 = @as(u64, ctx.h[4]) + ctx.c[4]; // s4 <= 5
// Local all the things!
const r0 = ctx.r[0]; // r0 <= 0fffffff
@@ -197,7 +197,7 @@ pub const Poly1305 = struct {
// check if we should subtract 2^130-5 by performing the
// corresponding carry propagation.
- const _u0 = u64(5) + ctx.h[0]; // <= 1_00000004
+ const _u0 = @as(u64, 5) + ctx.h[0]; // <= 1_00000004
const _u1 = (_u0 >> 32) + ctx.h[1]; // <= 1_00000000
const _u2 = (_u1 >> 32) + ctx.h[2]; // <= 1_00000000
const _u3 = (_u2 >> 32) + ctx.h[3]; // <= 1_00000000
lib/std/crypto/sha1.zig
@@ -146,10 +146,10 @@ pub const Sha1 = struct {
Rp(0, 1, 2, 3, 4, 15),
};
inline for (round0a) |r| {
- s[r.i] = (u32(b[r.i * 4 + 0]) << 24) | (u32(b[r.i * 4 + 1]) << 16) | (u32(b[r.i * 4 + 2]) << 8) | (u32(b[r.i * 4 + 3]) << 0);
+ s[r.i] = (@as(u32, b[r.i * 4 + 0]) << 24) | (@as(u32, b[r.i * 4 + 1]) << 16) | (@as(u32, b[r.i * 4 + 2]) << 8) | (@as(u32, b[r.i * 4 + 3]) << 0);
- v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
- v[r.b] = math.rotl(u32, v[r.b], u32(30));
+ v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], @as(u32, 5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
+ v[r.b] = math.rotl(u32, v[r.b], @as(u32, 30));
}
const round0b = comptime [_]RoundParam{
@@ -160,10 +160,10 @@ pub const Sha1 = struct {
};
inline for (round0b) |r| {
const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
- s[r.i & 0xf] = math.rotl(u32, t, u32(1));
+ s[r.i & 0xf] = math.rotl(u32, t, @as(u32, 1));
- v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
- v[r.b] = math.rotl(u32, v[r.b], u32(30));
+ v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], @as(u32, 5)) +% 0x5A827999 +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) | (~v[r.b] & v[r.d]));
+ v[r.b] = math.rotl(u32, v[r.b], @as(u32, 30));
}
const round1 = comptime [_]RoundParam{
@@ -190,10 +190,10 @@ pub const Sha1 = struct {
};
inline for (round1) |r| {
const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
- s[r.i & 0xf] = math.rotl(u32, t, u32(1));
+ s[r.i & 0xf] = math.rotl(u32, t, @as(u32, 1));
- v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x6ED9EBA1 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
- v[r.b] = math.rotl(u32, v[r.b], u32(30));
+ v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], @as(u32, 5)) +% 0x6ED9EBA1 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
+ v[r.b] = math.rotl(u32, v[r.b], @as(u32, 30));
}
const round2 = comptime [_]RoundParam{
@@ -220,10 +220,10 @@ pub const Sha1 = struct {
};
inline for (round2) |r| {
const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
- s[r.i & 0xf] = math.rotl(u32, t, u32(1));
+ s[r.i & 0xf] = math.rotl(u32, t, @as(u32, 1));
- v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0x8F1BBCDC +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) ^ (v[r.b] & v[r.d]) ^ (v[r.c] & v[r.d]));
- v[r.b] = math.rotl(u32, v[r.b], u32(30));
+ v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], @as(u32, 5)) +% 0x8F1BBCDC +% s[r.i & 0xf] +% ((v[r.b] & v[r.c]) ^ (v[r.b] & v[r.d]) ^ (v[r.c] & v[r.d]));
+ v[r.b] = math.rotl(u32, v[r.b], @as(u32, 30));
}
const round3 = comptime [_]RoundParam{
@@ -250,10 +250,10 @@ pub const Sha1 = struct {
};
inline for (round3) |r| {
const t = s[(r.i - 3) & 0xf] ^ s[(r.i - 8) & 0xf] ^ s[(r.i - 14) & 0xf] ^ s[(r.i - 16) & 0xf];
- s[r.i & 0xf] = math.rotl(u32, t, u32(1));
+ s[r.i & 0xf] = math.rotl(u32, t, @as(u32, 1));
- v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], u32(5)) +% 0xCA62C1D6 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
- v[r.b] = math.rotl(u32, v[r.b], u32(30));
+ v[r.e] = v[r.e] +% math.rotl(u32, v[r.a], @as(u32, 5)) +% 0xCA62C1D6 +% s[r.i & 0xf] +% (v[r.b] ^ v[r.c] ^ v[r.d]);
+ v[r.b] = math.rotl(u32, v[r.b], @as(u32, 30));
}
d.s[0] +%= v[0];
lib/std/crypto/sha2.zig
@@ -180,13 +180,13 @@ fn Sha2_32(comptime params: Sha2Params32) type {
var i: usize = 0;
while (i < 16) : (i += 1) {
s[i] = 0;
- s[i] |= u32(b[i * 4 + 0]) << 24;
- s[i] |= u32(b[i * 4 + 1]) << 16;
- s[i] |= u32(b[i * 4 + 2]) << 8;
- s[i] |= u32(b[i * 4 + 3]) << 0;
+ s[i] |= @as(u32, b[i * 4 + 0]) << 24;
+ s[i] |= @as(u32, b[i * 4 + 1]) << 16;
+ s[i] |= @as(u32, b[i * 4 + 2]) << 8;
+ s[i] |= @as(u32, b[i * 4 + 3]) << 0;
}
while (i < 64) : (i += 1) {
- s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u32, s[i - 15], u32(7)) ^ math.rotr(u32, s[i - 15], u32(18)) ^ (s[i - 15] >> 3)) +% (math.rotr(u32, s[i - 2], u32(17)) ^ math.rotr(u32, s[i - 2], u32(19)) ^ (s[i - 2] >> 10));
+ s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u32, s[i - 15], @as(u32, 7)) ^ math.rotr(u32, s[i - 15], @as(u32, 18)) ^ (s[i - 15] >> 3)) +% (math.rotr(u32, s[i - 2], @as(u32, 17)) ^ math.rotr(u32, s[i - 2], @as(u32, 19)) ^ (s[i - 2] >> 10));
}
var v: [8]u32 = [_]u32{
@@ -267,11 +267,11 @@ fn Sha2_32(comptime params: Sha2Params32) type {
Rp256(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2),
};
inline for (round0) |r| {
- v[r.h] = v[r.h] +% (math.rotr(u32, v[r.e], u32(6)) ^ math.rotr(u32, v[r.e], u32(11)) ^ math.rotr(u32, v[r.e], u32(25))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
+ v[r.h] = v[r.h] +% (math.rotr(u32, v[r.e], @as(u32, 6)) ^ math.rotr(u32, v[r.e], @as(u32, 11)) ^ math.rotr(u32, v[r.e], @as(u32, 25))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
v[r.d] = v[r.d] +% v[r.h];
- v[r.h] = v[r.h] +% (math.rotr(u32, v[r.a], u32(2)) ^ math.rotr(u32, v[r.a], u32(13)) ^ math.rotr(u32, v[r.a], u32(22))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
+ v[r.h] = v[r.h] +% (math.rotr(u32, v[r.a], @as(u32, 2)) ^ math.rotr(u32, v[r.a], @as(u32, 13)) ^ math.rotr(u32, v[r.a], @as(u32, 22))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
}
d.s[0] +%= v[0];
@@ -522,17 +522,19 @@ fn Sha2_64(comptime params: Sha2Params64) type {
var i: usize = 0;
while (i < 16) : (i += 1) {
s[i] = 0;
- s[i] |= u64(b[i * 8 + 0]) << 56;
- s[i] |= u64(b[i * 8 + 1]) << 48;
- s[i] |= u64(b[i * 8 + 2]) << 40;
- s[i] |= u64(b[i * 8 + 3]) << 32;
- s[i] |= u64(b[i * 8 + 4]) << 24;
- s[i] |= u64(b[i * 8 + 5]) << 16;
- s[i] |= u64(b[i * 8 + 6]) << 8;
- s[i] |= u64(b[i * 8 + 7]) << 0;
+ s[i] |= @as(u64, b[i * 8 + 0]) << 56;
+ s[i] |= @as(u64, b[i * 8 + 1]) << 48;
+ s[i] |= @as(u64, b[i * 8 + 2]) << 40;
+ s[i] |= @as(u64, b[i * 8 + 3]) << 32;
+ s[i] |= @as(u64, b[i * 8 + 4]) << 24;
+ s[i] |= @as(u64, b[i * 8 + 5]) << 16;
+ s[i] |= @as(u64, b[i * 8 + 6]) << 8;
+ s[i] |= @as(u64, b[i * 8 + 7]) << 0;
}
while (i < 80) : (i += 1) {
- s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u64, s[i - 15], u64(1)) ^ math.rotr(u64, s[i - 15], u64(8)) ^ (s[i - 15] >> 7)) +% (math.rotr(u64, s[i - 2], u64(19)) ^ math.rotr(u64, s[i - 2], u64(61)) ^ (s[i - 2] >> 6));
+ s[i] = s[i - 16] +% s[i - 7] +%
+ (math.rotr(u64, s[i - 15], @as(u64, 1)) ^ math.rotr(u64, s[i - 15], @as(u64, 8)) ^ (s[i - 15] >> 7)) +%
+ (math.rotr(u64, s[i - 2], @as(u64, 19)) ^ math.rotr(u64, s[i - 2], @as(u64, 61)) ^ (s[i - 2] >> 6));
}
var v: [8]u64 = [_]u64{
@@ -629,11 +631,11 @@ fn Sha2_64(comptime params: Sha2Params64) type {
Rp512(1, 2, 3, 4, 5, 6, 7, 0, 79, 0x6C44198C4A475817),
};
inline for (round0) |r| {
- v[r.h] = v[r.h] +% (math.rotr(u64, v[r.e], u64(14)) ^ math.rotr(u64, v[r.e], u64(18)) ^ math.rotr(u64, v[r.e], u64(41))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
+ v[r.h] = v[r.h] +% (math.rotr(u64, v[r.e], @as(u64, 14)) ^ math.rotr(u64, v[r.e], @as(u64, 18)) ^ math.rotr(u64, v[r.e], @as(u64, 41))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
v[r.d] = v[r.d] +% v[r.h];
- v[r.h] = v[r.h] +% (math.rotr(u64, v[r.a], u64(28)) ^ math.rotr(u64, v[r.a], u64(34)) ^ math.rotr(u64, v[r.a], u64(39))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
+ v[r.h] = v[r.h] +% (math.rotr(u64, v[r.a], @as(u64, 28)) ^ math.rotr(u64, v[r.a], @as(u64, 34)) ^ math.rotr(u64, v[r.a], @as(u64, 39))) +% ((v[r.a] & (v[r.b] | v[r.c])) | (v[r.b] & v[r.c]));
}
d.s[0] +%= v[0];
lib/std/crypto/sha3.zig
@@ -133,7 +133,7 @@ fn keccak_f(comptime F: usize, d: []u8) void {
}
x = 0;
inline while (x < 5) : (x += 1) {
- t[0] = c[M5[x + 4]] ^ math.rotl(u64, c[M5[x + 1]], usize(1));
+ t[0] = c[M5[x + 4]] ^ math.rotl(u64, c[M5[x + 1]], @as(usize, 1));
y = 0;
inline while (y < 5) : (y += 1) {
s[x + y * 5] ^= t[0];
lib/std/crypto/x25519.zig
@@ -256,15 +256,15 @@ const Fe = struct {
var t: [10]i64 = undefined;
t[0] = readIntSliceLittle(u32, s[0..4]);
- t[1] = u32(readIntSliceLittle(u24, s[4..7])) << 6;
- t[2] = u32(readIntSliceLittle(u24, s[7..10])) << 5;
- t[3] = u32(readIntSliceLittle(u24, s[10..13])) << 3;
- t[4] = u32(readIntSliceLittle(u24, s[13..16])) << 2;
+ t[1] = @as(u32, readIntSliceLittle(u24, s[4..7])) << 6;
+ t[2] = @as(u32, readIntSliceLittle(u24, s[7..10])) << 5;
+ t[3] = @as(u32, readIntSliceLittle(u24, s[10..13])) << 3;
+ t[4] = @as(u32, readIntSliceLittle(u24, s[13..16])) << 2;
t[5] = readIntSliceLittle(u32, s[16..20]);
- t[6] = u32(readIntSliceLittle(u24, s[20..23])) << 7;
- t[7] = u32(readIntSliceLittle(u24, s[23..26])) << 5;
- t[8] = u32(readIntSliceLittle(u24, s[26..29])) << 4;
- t[9] = (u32(readIntSliceLittle(u24, s[29..32])) & 0x7fffff) << 2;
+ t[6] = @as(u32, readIntSliceLittle(u24, s[20..23])) << 7;
+ t[7] = @as(u32, readIntSliceLittle(u24, s[23..26])) << 5;
+ t[8] = @as(u32, readIntSliceLittle(u24, s[26..29])) << 4;
+ t[9] = (@as(u32, readIntSliceLittle(u24, s[29..32])) & 0x7fffff) << 2;
carry1(h, t[0..]);
}
@@ -500,7 +500,7 @@ const Fe = struct {
if (i + 1 < 10) {
t[i + 1] += c[i];
}
- t[i] -= c[i] * (i32(1) << shift);
+ t[i] -= c[i] * (@as(i32, 1) << shift);
}
fn toBytes(s: []u8, h: *const Fe) void {
@@ -511,7 +511,7 @@ const Fe = struct {
t[i] = h.b[i];
}
- var q = (19 * t[9] + ((i32(1) << 24))) >> 25;
+ var q = (19 * t[9] + ((@as(i32, 1) << 24))) >> 25;
{
var i: usize = 0;
while (i < 5) : (i += 1) {
lib/std/debug/leb128.zig
@@ -62,13 +62,13 @@ pub fn readILEB128(comptime T: type, in_stream: var) !T {
var shift: usize = 0;
while (true) {
- const byte = u8(try in_stream.readByte());
+ const byte: u8 = try in_stream.readByte();
if (shift > T.bit_count)
return error.Overflow;
var operand: UT = undefined;
- if (@shlWithOverflow(UT, UT(byte & 0x7f), @intCast(ShiftT, shift), &operand)) {
+ if (@shlWithOverflow(UT, @as(UT, byte & 0x7f), @intCast(ShiftT, shift), &operand)) {
if (byte != 0x7f)
return error.Overflow;
}
lib/std/event/fs.zig
@@ -328,11 +328,11 @@ pub fn preadWindows(loop: *Loop, fd: fd_t, data: []u8, offset: u64) !usize {
windows.ERROR.IO_PENDING => unreachable,
windows.ERROR.OPERATION_ABORTED => return error.OperationAborted,
windows.ERROR.BROKEN_PIPE => return error.BrokenPipe,
- windows.ERROR.HANDLE_EOF => return usize(bytes_transferred),
+ windows.ERROR.HANDLE_EOF => return @as(usize, bytes_transferred),
else => |err| return windows.unexpectedError(err),
}
}
- return usize(bytes_transferred);
+ return @as(usize, bytes_transferred);
}
/// iovecs must live until preadv frame completes
lib/std/fmt/errol.zig
@@ -296,7 +296,7 @@ fn hpMul10(hp: *HP) void {
/// @buf: The output buffer.
/// &return: The exponent.
fn errolInt(val: f64, buffer: []u8) FloatDecimal {
- const pow19 = u128(1e19);
+ const pow19 = @as(u128, 1e19);
assert((val > 9.007199254740992e15) and val < (3.40282366920938e38));
@@ -670,7 +670,7 @@ fn fpeint(from: f64) u128 {
const bits = @bitCast(u64, from);
assert((bits & ((1 << 52) - 1)) == 0);
- return u128(1) << @truncate(u7, (bits >> 52) -% 1023);
+ return @as(u128, 1) << @truncate(u7, (bits >> 52) -% 1023);
}
/// Given two different integers with the same length in terms of the number
lib/std/fmt/parse_float.zig
@@ -59,29 +59,29 @@ const Z96 = struct {
// d += s
inline fn add(d: *Z96, s: Z96) void {
- var w = u64(d.d0) + u64(s.d0);
+ var w = @as(u64, d.d0) + @as(u64, s.d0);
d.d0 = @truncate(u32, w);
w >>= 32;
- w += u64(d.d1) + u64(s.d1);
+ w += @as(u64, d.d1) + @as(u64, s.d1);
d.d1 = @truncate(u32, w);
w >>= 32;
- w += u64(d.d2) + u64(s.d2);
+ w += @as(u64, d.d2) + @as(u64, s.d2);
d.d2 = @truncate(u32, w);
}
// d -= s
inline fn sub(d: *Z96, s: Z96) void {
- var w = u64(d.d0) -% u64(s.d0);
+ var w = @as(u64, d.d0) -% @as(u64, s.d0);
d.d0 = @truncate(u32, w);
w >>= 32;
- w += u64(d.d1) -% u64(s.d1);
+ w += @as(u64, d.d1) -% @as(u64, s.d1);
d.d1 = @truncate(u32, w);
w >>= 32;
- w += u64(d.d2) -% u64(s.d2);
+ w += @as(u64, d.d2) -% @as(u64, s.d2);
d.d2 = @truncate(u32, w);
}
};
@@ -160,7 +160,7 @@ fn convertRepr(comptime T: type, n: FloatRepr) T {
break :blk if (n.negative) f64_minus_zero else f64_plus_zero;
} else if (s.d2 != 0) {
const binexs2 = @intCast(u64, binary_exponent) << 52;
- const rr = (u64(s.d2 & ~mask28) << 24) | ((u64(s.d1) + 128) >> 8) | binexs2;
+ const rr = (@as(u64, s.d2 & ~mask28) << 24) | ((@as(u64, s.d1) + 128) >> 8) | binexs2;
break :blk if (n.negative) rr | (1 << 63) else rr;
} else {
break :blk 0;
lib/std/fs/file.zig
@@ -272,9 +272,9 @@ pub const File = struct {
return Stat{
.size = @bitCast(u64, st.size),
.mode = st.mode,
- .atime = i64(atime.tv_sec) * std.time.ns_per_s + atime.tv_nsec,
- .mtime = i64(mtime.tv_sec) * std.time.ns_per_s + mtime.tv_nsec,
- .ctime = i64(ctime.tv_sec) * std.time.ns_per_s + ctime.tv_nsec,
+ .atime = @as(i64, atime.tv_sec) * std.time.ns_per_s + atime.tv_nsec,
+ .mtime = @as(i64, mtime.tv_sec) * std.time.ns_per_s + mtime.tv_nsec,
+ .ctime = @as(i64, ctime.tv_sec) * std.time.ns_per_s + ctime.tv_nsec,
};
}
lib/std/hash/auto_hash.zig
@@ -306,7 +306,7 @@ test "hash struct deep" {
test "testHash optional" {
const a: ?u32 = 123;
const b: ?u32 = null;
- testing.expectEqual(testHash(a), testHash(u32(123)));
+ testing.expectEqual(testHash(a), testHash(@as(u32, 123)));
testing.expect(testHash(a) != testHash(b));
testing.expectEqual(testHash(b), 0);
}
@@ -315,9 +315,9 @@ test "testHash array" {
const a = [_]u32{ 1, 2, 3 };
const h = testHash(a);
var hasher = Wyhash.init(0);
- autoHash(&hasher, u32(1));
- autoHash(&hasher, u32(2));
- autoHash(&hasher, u32(3));
+ autoHash(&hasher, @as(u32, 1));
+ autoHash(&hasher, @as(u32, 2));
+ autoHash(&hasher, @as(u32, 3));
testing.expectEqual(h, hasher.final());
}
@@ -330,9 +330,9 @@ test "testHash struct" {
const f = Foo{};
const h = testHash(f);
var hasher = Wyhash.init(0);
- autoHash(&hasher, u32(1));
- autoHash(&hasher, u32(2));
- autoHash(&hasher, u32(3));
+ autoHash(&hasher, @as(u32, 1));
+ autoHash(&hasher, @as(u32, 2));
+ autoHash(&hasher, @as(u32, 3));
testing.expectEqual(h, hasher.final());
}
lib/std/hash/cityhash.zig
@@ -214,7 +214,7 @@ pub const CityHash64 = struct {
}
fn hashLen0To16(str: []const u8) u64 {
- const len: u64 = u64(str.len);
+ const len: u64 = @as(u64, str.len);
if (len >= 8) {
const mul: u64 = k2 +% len *% 2;
const a: u64 = fetch64(str.ptr) +% k2;
@@ -240,7 +240,7 @@ pub const CityHash64 = struct {
}
fn hashLen17To32(str: []const u8) u64 {
- const len: u64 = u64(str.len);
+ const len: u64 = @as(u64, str.len);
const mul: u64 = k2 +% len *% 2;
const a: u64 = fetch64(str.ptr) *% k1;
const b: u64 = fetch64(str.ptr + 8);
@@ -251,7 +251,7 @@ pub const CityHash64 = struct {
}
fn hashLen33To64(str: []const u8) u64 {
- const len: u64 = u64(str.len);
+ const len: u64 = @as(u64, str.len);
const mul: u64 = k2 +% len *% 2;
const a: u64 = fetch64(str.ptr) *% k2;
const b: u64 = fetch64(str.ptr + 8);
@@ -305,7 +305,7 @@ pub const CityHash64 = struct {
return hashLen33To64(str);
}
- var len: u64 = u64(str.len);
+ var len: u64 = @as(u64, str.len);
var x: u64 = fetch64(str.ptr + str.len - 40);
var y: u64 = fetch64(str.ptr + str.len - 16) +% fetch64(str.ptr + str.len - 56);
lib/std/hash/crc.zig
@@ -65,10 +65,10 @@ pub fn Crc32WithPoly(comptime poly: u32) type {
const p = input[i .. i + 8];
// Unrolling this way gives ~50Mb/s increase
- self.crc ^= (u32(p[0]) << 0);
- self.crc ^= (u32(p[1]) << 8);
- self.crc ^= (u32(p[2]) << 16);
- self.crc ^= (u32(p[3]) << 24);
+ self.crc ^= (@as(u32, p[0]) << 0);
+ self.crc ^= (@as(u32, p[1]) << 8);
+ self.crc ^= (@as(u32, p[2]) << 16);
+ self.crc ^= (@as(u32, p[3]) << 24);
self.crc =
lookup_tables[0][p[7]] ^
lib/std/hash/murmur.zig
@@ -98,7 +98,7 @@ pub const Murmur2_64 = struct {
pub fn hashWithSeed(str: []const u8, seed: u64) u64 {
const m: u64 = 0xc6a4a7935bd1e995;
- const len = u64(str.len);
+ const len = @as(u64, str.len);
var h1: u64 = seed ^ (len *% m);
for (@ptrCast([*]allowzero align(1) const u64, str.ptr)[0..@intCast(usize, len >> 3)]) |v| {
var k1: u64 = v;
lib/std/hash/siphash.zig
@@ -102,7 +102,7 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
}
const b2 = self.v0 ^ self.v1 ^ self.v2 ^ self.v3;
- return (u128(b2) << 64) | b1;
+ return (@as(u128, b2) << 64) | b1;
}
fn round(self: *Self, b: []const u8) void {
@@ -121,19 +121,19 @@ fn SipHashStateless(comptime T: type, comptime c_rounds: usize, comptime d_round
fn sipRound(d: *Self) void {
d.v0 +%= d.v1;
- d.v1 = math.rotl(u64, d.v1, u64(13));
+ d.v1 = math.rotl(u64, d.v1, @as(u64, 13));
d.v1 ^= d.v0;
- d.v0 = math.rotl(u64, d.v0, u64(32));
+ d.v0 = math.rotl(u64, d.v0, @as(u64, 32));
d.v2 +%= d.v3;
- d.v3 = math.rotl(u64, d.v3, u64(16));
+ d.v3 = math.rotl(u64, d.v3, @as(u64, 16));
d.v3 ^= d.v2;
d.v0 +%= d.v3;
- d.v3 = math.rotl(u64, d.v3, u64(21));
+ d.v3 = math.rotl(u64, d.v3, @as(u64, 21));
d.v3 ^= d.v0;
d.v2 +%= d.v1;
- d.v1 = math.rotl(u64, d.v1, u64(17));
+ d.v1 = math.rotl(u64, d.v1, @as(u64, 17));
d.v1 ^= d.v2;
- d.v2 = math.rotl(u64, d.v2, u64(32));
+ d.v2 = math.rotl(u64, d.v2, @as(u64, 32));
}
pub fn hash(key: []const u8, input: []const u8) T {
lib/std/http/headers.zig
@@ -399,7 +399,7 @@ test "Headers.iterator" {
}
count += 1;
}
- testing.expectEqual(i32(2), count);
+ testing.expectEqual(@as(i32, 2), count);
}
test "Headers.contains" {
@@ -420,10 +420,10 @@ test "Headers.delete" {
try h.append("cookie", "somevalue", null);
testing.expectEqual(false, h.delete("not-present"));
- testing.expectEqual(usize(3), h.count());
+ testing.expectEqual(@as(usize, 3), h.count());
testing.expectEqual(true, h.delete("foo"));
- testing.expectEqual(usize(2), h.count());
+ testing.expectEqual(@as(usize, 2), h.count());
{
const e = h.at(0);
testing.expectEqualSlices(u8, "baz", e.name);
@@ -448,7 +448,7 @@ test "Headers.orderedRemove" {
try h.append("cookie", "somevalue", null);
h.orderedRemove(0);
- testing.expectEqual(usize(2), h.count());
+ testing.expectEqual(@as(usize, 2), h.count());
{
const e = h.at(0);
testing.expectEqualSlices(u8, "baz", e.name);
@@ -471,7 +471,7 @@ test "Headers.swapRemove" {
try h.append("cookie", "somevalue", null);
h.swapRemove(0);
- testing.expectEqual(usize(2), h.count());
+ testing.expectEqual(@as(usize, 2), h.count());
{
const e = h.at(0);
testing.expectEqualSlices(u8, "cookie", e.name);
lib/std/io/out_stream.zig
@@ -40,12 +40,12 @@ pub fn OutStream(comptime WriteError: type) type {
}
pub fn writeByte(self: *Self, byte: u8) Error!void {
- const slice = (*const [1]u8)(&byte)[0..];
+ const slice = @as(*const [1]u8, &byte)[0..];
return self.writeFn(self, slice);
}
pub fn writeByteNTimes(self: *Self, byte: u8, n: usize) Error!void {
- const slice = (*const [1]u8)(&byte)[0..];
+ const slice = @as(*const [1]u8, &byte)[0..];
var i: usize = 0;
while (i < n) : (i += 1) {
try self.writeFn(self, slice);
lib/std/io/test.zig
@@ -228,8 +228,8 @@ test "BitOutStream" {
try bit_stream_be.writeBits(u2(1), 1);
try bit_stream_be.writeBits(u5(2), 2);
- try bit_stream_be.writeBits(u128(3), 3);
- try bit_stream_be.writeBits(u8(4), 4);
+ try bit_stream_be.writeBits(@as(u128, 3), 3);
+ try bit_stream_be.writeBits(@as(u8, 4), 4);
try bit_stream_be.writeBits(u9(5), 5);
try bit_stream_be.writeBits(u1(1), 1);
@@ -242,33 +242,33 @@ test "BitOutStream" {
expect(mem_be[0] == 0b11001101 and mem_be[1] == 0b00001010);
mem_out_be.pos = 0;
- try bit_stream_be.writeBits(u32(0b110011010000101), 16);
+ try bit_stream_be.writeBits(@as(u32, 0b110011010000101), 16);
expect(mem_be[0] == 0b01100110 and mem_be[1] == 0b10000101);
- try bit_stream_be.writeBits(u0(0), 0);
+ try bit_stream_be.writeBits(@as(u0, 0), 0);
var mem_out_le = io.SliceOutStream.init(mem_le[0..]);
var bit_stream_le = io.BitOutStream(builtin.Endian.Little, OutError).init(&mem_out_le.stream);
- try bit_stream_le.writeBits(u2(1), 1);
- try bit_stream_le.writeBits(u5(2), 2);
- try bit_stream_le.writeBits(u128(3), 3);
- try bit_stream_le.writeBits(u8(4), 4);
- try bit_stream_le.writeBits(u9(5), 5);
- try bit_stream_le.writeBits(u1(1), 1);
+ try bit_stream_le.writeBits(@as(u2, 1), 1);
+ try bit_stream_le.writeBits(@as(u5, 2), 2);
+ try bit_stream_le.writeBits(@as(u128, 3), 3);
+ try bit_stream_le.writeBits(@as(u8, 4), 4);
+ try bit_stream_le.writeBits(@as(u9, 5), 5);
+ try bit_stream_le.writeBits(@as(u1, 1), 1);
expect(mem_le[0] == 0b00011101 and mem_le[1] == 0b10010101);
mem_out_le.pos = 0;
- try bit_stream_le.writeBits(u15(0b110011010000101), 15);
+ try bit_stream_le.writeBits(@as(u15, 0b110011010000101), 15);
try bit_stream_le.flushBits();
expect(mem_le[0] == 0b10000101 and mem_le[1] == 0b01100110);
mem_out_le.pos = 0;
- try bit_stream_le.writeBits(u32(0b1100110100001011), 16);
+ try bit_stream_le.writeBits(@as(u32, 0b1100110100001011), 16);
expect(mem_le[0] == 0b00001011 and mem_le[1] == 0b11001101);
- try bit_stream_le.writeBits(u0(0), 0);
+ try bit_stream_le.writeBits(@as(u0, 0), 0);
}
test "BitStreams with File Stream" {
@@ -282,12 +282,12 @@ test "BitStreams with File Stream" {
const OutError = File.WriteError;
var bit_stream = io.BitOutStream(builtin.endian, OutError).init(file_out_stream);
- try bit_stream.writeBits(u2(1), 1);
- try bit_stream.writeBits(u5(2), 2);
- try bit_stream.writeBits(u128(3), 3);
- try bit_stream.writeBits(u8(4), 4);
- try bit_stream.writeBits(u9(5), 5);
- try bit_stream.writeBits(u1(1), 1);
+ try bit_stream.writeBits(@as(u2, 1), 1);
+ try bit_stream.writeBits(@as(u5, 2), 2);
+ try bit_stream.writeBits(@as(u128, 3), 3);
+ try bit_stream.writeBits(@as(u8, 4), 4);
+ try bit_stream.writeBits(@as(u9, 5), 5);
+ try bit_stream.writeBits(@as(u1, 1), 1);
try bit_stream.flushBits();
}
{
@@ -603,7 +603,7 @@ test "c out stream" {
}
const out_stream = &io.COutStream.init(out_file).stream;
- try out_stream.print("hi: {}\n", i32(123));
+ try out_stream.print("hi: {}\n", @as(i32, 123));
}
test "File seek ops" {
lib/std/math/big/int.zig
@@ -261,7 +261,7 @@ pub const Int = struct {
/// the minus sign. This is used for determining the number of characters needed to print the
/// value. It is inexact and may exceed the given value by ~1-2 bytes.
pub fn sizeInBase(self: Int, base: usize) usize {
- const bit_count = usize(@boolToInt(!self.isPositive())) + self.bitCountAbs();
+ const bit_count = @as(usize, @boolToInt(!self.isPositive())) + self.bitCountAbs();
return (bit_count / math.log2(base)) + 1;
}
lib/std/math/complex/ldexp.zig
@@ -59,7 +59,7 @@ fn frexp_exp64(x: f64, expt: *i32) f64 {
expt.* = @intCast(i32, hx >> 20) - (0x3ff + 1023) + k;
const high_word = (hx & 0xfffff) | ((0x3ff + 1023) << 20);
- return @bitCast(f64, (u64(high_word) << 32) | lx);
+ return @bitCast(f64, (@as(u64, high_word) << 32) | lx);
}
fn ldexp_cexp64(z: Complex(f64), expt: i32) Complex(f64) {
lib/std/math/complex/sqrt.zig
@@ -52,8 +52,8 @@ fn sqrt32(z: Complex(f32)) Complex(f32) {
// y = nan special case is handled fine below
// double-precision avoids overflow with correct rounding.
- const dx = f64(x);
- const dy = f64(y);
+ const dx = @as(f64, x);
+ const dy = @as(f64, y);
if (dx >= 0) {
const t = math.sqrt((dx + math.hypot(f64, dx, dy)) * 0.5);
lib/std/math/complex/tanh.zig
@@ -76,7 +76,7 @@ fn tanh64(z: Complex(f64)) Complex(f64) {
return Complex(f64).new(x, r);
}
- const xx = @bitCast(f64, (u64(hx - 0x40000000) << 32) | lx);
+ const xx = @bitCast(f64, (@as(u64, hx - 0x40000000) << 32) | lx);
const r = if (math.isInf(y)) y else math.sin(y) * math.cos(y);
return Complex(f64).new(xx, math.copysign(f64, 0, r));
}
lib/std/math/acos.zig
@@ -149,8 +149,8 @@ fn acos64(x: f64) f64 {
}
test "math.acos" {
- expect(acos(f32(0.0)) == acos32(0.0));
- expect(acos(f64(0.0)) == acos64(0.0));
+ expect(acos(@as(f32, 0.0)) == acos32(0.0));
+ expect(acos(@as(f64, 0.0)) == acos64(0.0));
}
test "math.acos32" {
lib/std/math/acosh.zig
@@ -61,8 +61,8 @@ fn acosh64(x: f64) f64 {
}
test "math.acosh" {
- expect(acosh(f32(1.5)) == acosh32(1.5));
- expect(acosh(f64(1.5)) == acosh64(1.5));
+ expect(acosh(@as(f32, 1.5)) == acosh32(1.5));
+ expect(acosh(@as(f64, 1.5)) == acosh64(1.5));
}
test "math.acosh32" {
lib/std/math/asin.zig
@@ -142,8 +142,8 @@ fn asin64(x: f64) f64 {
}
test "math.asin" {
- expect(asin(f32(0.0)) == asin32(0.0));
- expect(asin(f64(0.0)) == asin64(0.0));
+ expect(asin(@as(f32, 0.0)) == asin32(0.0));
+ expect(asin(@as(f64, 0.0)) == asin64(0.0));
}
test "math.asin32" {
lib/std/math/asinh.zig
@@ -89,8 +89,8 @@ fn asinh64(x: f64) f64 {
}
test "math.asinh" {
- expect(asinh(f32(0.0)) == asinh32(0.0));
- expect(asinh(f64(0.0)) == asinh64(0.0));
+ expect(asinh(@as(f32, 0.0)) == asinh32(0.0));
+ expect(asinh(@as(f64, 0.0)) == asinh64(0.0));
}
test "math.asinh32" {
lib/std/math/atan.zig
@@ -212,8 +212,8 @@ fn atan64(x_: f64) f64 {
}
test "math.atan" {
- expect(@bitCast(u32, atan(f32(0.2))) == @bitCast(u32, atan32(0.2)));
- expect(atan(f64(0.2)) == atan64(0.2));
+ expect(@bitCast(u32, atan(@as(f32, 0.2))) == @bitCast(u32, atan32(0.2)));
+ expect(atan(@as(f64, 0.2)) == atan64(0.2));
}
test "math.atan32" {
lib/std/math/atanh.zig
@@ -84,8 +84,8 @@ fn atanh_64(x: f64) f64 {
}
test "math.atanh" {
- expect(atanh(f32(0.0)) == atanh_32(0.0));
- expect(atanh(f64(0.0)) == atanh_64(0.0));
+ expect(atanh(@as(f32, 0.0)) == atanh_32(0.0));
+ expect(atanh(@as(f64, 0.0)) == atanh_64(0.0));
}
test "math.atanh_32" {
lib/std/math/cbrt.zig
@@ -54,11 +54,11 @@ fn cbrt32(x: f32) f32 {
// first step newton to 16 bits
var t: f64 = @bitCast(f32, u);
var r: f64 = t * t * t;
- t = t * (f64(x) + x + r) / (x + r + r);
+ t = t * (@as(f64, x) + x + r) / (x + r + r);
// second step newton to 47 bits
r = t * t * t;
- t = t * (f64(x) + x + r) / (x + r + r);
+ t = t * (@as(f64, x) + x + r) / (x + r + r);
return @floatCast(f32, t);
}
@@ -97,7 +97,7 @@ fn cbrt64(x: f64) f64 {
}
u &= 1 << 63;
- u |= u64(hx) << 32;
+ u |= @as(u64, hx) << 32;
var t = @bitCast(f64, u);
// cbrt to 23 bits
@@ -120,8 +120,8 @@ fn cbrt64(x: f64) f64 {
}
test "math.cbrt" {
- expect(cbrt(f32(0.0)) == cbrt32(0.0));
- expect(cbrt(f64(0.0)) == cbrt64(0.0));
+ expect(cbrt(@as(f32, 0.0)) == cbrt32(0.0));
+ expect(cbrt(@as(f64, 0.0)) == cbrt64(0.0));
}
test "math.cbrt32" {
lib/std/math/ceil.zig
@@ -37,7 +37,7 @@ fn ceil32(x: f32) f32 {
if (e >= 23) {
return x;
} else if (e >= 0) {
- m = u32(0x007FFFFF) >> @intCast(u5, e);
+ m = @as(u32, 0x007FFFFF) >> @intCast(u5, e);
if (u & m == 0) {
return x;
}
@@ -87,8 +87,8 @@ fn ceil64(x: f64) f64 {
}
test "math.ceil" {
- expect(ceil(f32(0.0)) == ceil32(0.0));
- expect(ceil(f64(0.0)) == ceil64(0.0));
+ expect(ceil(@as(f32, 0.0)) == ceil32(0.0));
+ expect(ceil(@as(f64, 0.0)) == ceil64(0.0));
}
test "math.ceil32" {
lib/std/math/copysign.zig
@@ -24,7 +24,7 @@ fn copysign16(x: f16, y: f16) f16 {
const uy = @bitCast(u16, y);
const h1 = ux & (maxInt(u16) / 2);
- const h2 = uy & (u16(1) << 15);
+ const h2 = uy & (@as(u16, 1) << 15);
return @bitCast(f16, h1 | h2);
}
@@ -33,7 +33,7 @@ fn copysign32(x: f32, y: f32) f32 {
const uy = @bitCast(u32, y);
const h1 = ux & (maxInt(u32) / 2);
- const h2 = uy & (u32(1) << 31);
+ const h2 = uy & (@as(u32, 1) << 31);
return @bitCast(f32, h1 | h2);
}
@@ -42,7 +42,7 @@ fn copysign64(x: f64, y: f64) f64 {
const uy = @bitCast(u64, y);
const h1 = ux & (maxInt(u64) / 2);
- const h2 = uy & (u64(1) << 63);
+ const h2 = uy & (@as(u64, 1) << 63);
return @bitCast(f64, h1 | h2);
}
lib/std/math/cos.zig
@@ -83,8 +83,8 @@ fn cos_(comptime T: type, x_: T) T {
}
test "math.cos" {
- expect(cos(f32(0.0)) == cos_(f32, 0.0));
- expect(cos(f64(0.0)) == cos_(f64, 0.0));
+ expect(cos(@as(f32, 0.0)) == cos_(f32, 0.0));
+ expect(cos(@as(f64, 0.0)) == cos_(f64, 0.0));
}
test "math.cos32" {
lib/std/math/cosh.zig
@@ -88,8 +88,8 @@ fn cosh64(x: f64) f64 {
}
test "math.cosh" {
- expect(cosh(f32(1.5)) == cosh32(1.5));
- expect(cosh(f64(1.5)) == cosh64(1.5));
+ expect(cosh(@as(f32, 1.5)) == cosh32(1.5));
+ expect(cosh(@as(f64, 1.5)) == cosh64(1.5));
}
test "math.cosh32" {
lib/std/math/exp.zig
@@ -183,8 +183,8 @@ fn exp64(x_: f64) f64 {
}
test "math.exp" {
- assert(exp(f32(0.0)) == exp32(0.0));
- assert(exp(f64(0.0)) == exp64(0.0));
+ assert(exp(@as(f32, 0.0)) == exp32(0.0));
+ assert(exp(@as(f64, 0.0)) == exp64(0.0));
}
test "math.exp32" {
lib/std/math/exp2.zig
@@ -85,7 +85,7 @@ fn exp2_32(x: f32) f32 {
const k = i_0 / tblsiz;
// NOTE: musl relies on undefined overflow shift behaviour. Appears that this produces the
// intended result but should confirm how GCC/Clang handle this to ensure.
- const uk = @bitCast(f64, u64(0x3FF + k) << 52);
+ const uk = @bitCast(f64, @as(u64, 0x3FF + k) << 52);
i_0 &= tblsiz - 1;
uf -= redux;
@@ -421,8 +421,8 @@ fn exp2_64(x: f64) f64 {
}
test "math.exp2" {
- expect(exp2(f32(0.8923)) == exp2_32(0.8923));
- expect(exp2(f64(0.8923)) == exp2_64(0.8923));
+ expect(exp2(@as(f32, 0.8923)) == exp2_32(0.8923));
+ expect(exp2(@as(f64, 0.8923)) == exp2_64(0.8923));
}
test "math.exp2_32" {
lib/std/math/expm1.zig
@@ -287,8 +287,8 @@ fn expm1_64(x_: f64) f64 {
}
test "math.exp1m" {
- expect(expm1(f32(0.0)) == expm1_32(0.0));
- expect(expm1(f64(0.0)) == expm1_64(0.0));
+ expect(expm1(@as(f32, 0.0)) == expm1_32(0.0));
+ expect(expm1(@as(f64, 0.0)) == expm1_64(0.0));
}
test "math.expm1_32" {
lib/std/math/expo2.zig
@@ -30,6 +30,6 @@ fn expo2d(x: f64) f64 {
const kln2 = 0x1.62066151ADD8BP+10;
const u = (0x3FF + k / 2) << 20;
- const scale = @bitCast(f64, u64(u) << 32);
+ const scale = @bitCast(f64, @as(u64, u) << 32);
return math.exp(x - kln2) * scale * scale;
}
lib/std/math/fabs.zig
@@ -50,10 +50,10 @@ fn fabs128(x: f128) f128 {
}
test "math.fabs" {
- expect(fabs(f16(1.0)) == fabs16(1.0));
- expect(fabs(f32(1.0)) == fabs32(1.0));
- expect(fabs(f64(1.0)) == fabs64(1.0));
- expect(fabs(f128(1.0)) == fabs128(1.0));
+ expect(fabs(@as(f16, 1.0)) == fabs16(1.0));
+ expect(fabs(@as(f32, 1.0)) == fabs32(1.0));
+ expect(fabs(@as(f64, 1.0)) == fabs64(1.0));
+ expect(fabs(@as(f128, 1.0)) == fabs128(1.0));
}
test "math.fabs16" {
lib/std/math/floor.zig
@@ -40,7 +40,7 @@ fn floor16(x: f16) f16 {
}
if (e >= 0) {
- m = u16(1023) >> @intCast(u4, e);
+ m = @as(u16, 1023) >> @intCast(u4, e);
if (u & m == 0) {
return x;
}
@@ -74,7 +74,7 @@ fn floor32(x: f32) f32 {
}
if (e >= 0) {
- m = u32(0x007FFFFF) >> @intCast(u5, e);
+ m = @as(u32, 0x007FFFFF) >> @intCast(u5, e);
if (u & m == 0) {
return x;
}
@@ -123,9 +123,9 @@ fn floor64(x: f64) f64 {
}
test "math.floor" {
- expect(floor(f16(1.3)) == floor16(1.3));
- expect(floor(f32(1.3)) == floor32(1.3));
- expect(floor(f64(1.3)) == floor64(1.3));
+ expect(floor(@as(f16, 1.3)) == floor16(1.3));
+ expect(floor(@as(f32, 1.3)) == floor32(1.3));
+ expect(floor(@as(f64, 1.3)) == floor64(1.3));
}
test "math.floor16" {
lib/std/math/fma.zig
@@ -18,7 +18,7 @@ pub fn fma(comptime T: type, x: T, y: T, z: T) T {
}
fn fma32(x: f32, y: f32, z: f32) f32 {
- const xy = f64(x) * y;
+ const xy = @as(f64, x) * y;
const xy_z = xy + z;
const u = @bitCast(u64, xy_z);
const e = (u >> 52) & 0x7FF;
lib/std/math/frexp.zig
@@ -108,11 +108,11 @@ fn frexp64(x: f64) frexp64_result {
}
test "math.frexp" {
- const a = frexp(f32(1.3));
+ const a = frexp(@as(f32, 1.3));
const b = frexp32(1.3);
expect(a.significand == b.significand and a.exponent == b.exponent);
- const c = frexp(f64(1.3));
+ const c = frexp(@as(f64, 1.3));
const d = frexp64(1.3);
expect(c.significand == d.significand and c.exponent == d.exponent);
}
lib/std/math/hypot.zig
@@ -56,7 +56,7 @@ fn hypot32(x: f32, y: f32) f32 {
yy *= 0x1.0p-90;
}
- return z * math.sqrt(@floatCast(f32, f64(x) * x + f64(y) * y));
+ return z * math.sqrt(@floatCast(f32, @as(f64, x) * x + @as(f64, y) * y));
}
fn sq(hi: *f64, lo: *f64, x: f64) void {
lib/std/math/ilogb.zig
@@ -26,7 +26,7 @@ pub fn ilogb(x: var) i32 {
}
// NOTE: Should these be exposed publicly?
-const fp_ilogbnan = -1 - i32(maxInt(u32) >> 1);
+const fp_ilogbnan = -1 - @as(i32, maxInt(u32) >> 1);
const fp_ilogb0 = fp_ilogbnan;
fn ilogb32(x: f32) i32 {
@@ -101,8 +101,8 @@ fn ilogb64(x: f64) i32 {
}
test "math.ilogb" {
- expect(ilogb(f32(0.2)) == ilogb32(0.2));
- expect(ilogb(f64(0.2)) == ilogb64(0.2));
+ expect(ilogb(@as(f32, 0.2)) == ilogb32(0.2));
+ expect(ilogb(@as(f64, 0.2)) == ilogb64(0.2));
}
test "math.ilogb32" {
lib/std/math/isfinite.zig
@@ -26,12 +26,12 @@ pub fn isFinite(x: var) bool {
}
test "math.isFinite" {
- expect(isFinite(f16(0.0)));
- expect(isFinite(f16(-0.0)));
- expect(isFinite(f32(0.0)));
- expect(isFinite(f32(-0.0)));
- expect(isFinite(f64(0.0)));
- expect(isFinite(f64(-0.0)));
+ expect(isFinite(@as(f16, 0.0)));
+ expect(isFinite(@as(f16, -0.0)));
+ expect(isFinite(@as(f32, 0.0)));
+ expect(isFinite(@as(f32, -0.0)));
+ expect(isFinite(@as(f64, 0.0)));
+ expect(isFinite(@as(f64, -0.0)));
expect(!isFinite(math.inf(f16)));
expect(!isFinite(-math.inf(f16)));
expect(!isFinite(math.inf(f32)));
lib/std/math/isinf.zig
@@ -74,14 +74,14 @@ pub fn isNegativeInf(x: var) bool {
}
test "math.isInf" {
- expect(!isInf(f16(0.0)));
- expect(!isInf(f16(-0.0)));
- expect(!isInf(f32(0.0)));
- expect(!isInf(f32(-0.0)));
- expect(!isInf(f64(0.0)));
- expect(!isInf(f64(-0.0)));
- expect(!isInf(f128(0.0)));
- expect(!isInf(f128(-0.0)));
+ expect(!isInf(@as(f16, 0.0)));
+ expect(!isInf(@as(f16, -0.0)));
+ expect(!isInf(@as(f32, 0.0)));
+ expect(!isInf(@as(f32, -0.0)));
+ expect(!isInf(@as(f64, 0.0)));
+ expect(!isInf(@as(f64, -0.0)));
+ expect(!isInf(@as(f128, 0.0)));
+ expect(!isInf(@as(f128, -0.0)));
expect(isInf(math.inf(f16)));
expect(isInf(-math.inf(f16)));
expect(isInf(math.inf(f32)));
@@ -93,14 +93,14 @@ test "math.isInf" {
}
test "math.isPositiveInf" {
- expect(!isPositiveInf(f16(0.0)));
- expect(!isPositiveInf(f16(-0.0)));
- expect(!isPositiveInf(f32(0.0)));
- expect(!isPositiveInf(f32(-0.0)));
- expect(!isPositiveInf(f64(0.0)));
- expect(!isPositiveInf(f64(-0.0)));
- expect(!isPositiveInf(f128(0.0)));
- expect(!isPositiveInf(f128(-0.0)));
+ expect(!isPositiveInf(@as(f16, 0.0)));
+ expect(!isPositiveInf(@as(f16, -0.0)));
+ expect(!isPositiveInf(@as(f32, 0.0)));
+ expect(!isPositiveInf(@as(f32, -0.0)));
+ expect(!isPositiveInf(@as(f64, 0.0)));
+ expect(!isPositiveInf(@as(f64, -0.0)));
+ expect(!isPositiveInf(@as(f128, 0.0)));
+ expect(!isPositiveInf(@as(f128, -0.0)));
expect(isPositiveInf(math.inf(f16)));
expect(!isPositiveInf(-math.inf(f16)));
expect(isPositiveInf(math.inf(f32)));
@@ -112,14 +112,14 @@ test "math.isPositiveInf" {
}
test "math.isNegativeInf" {
- expect(!isNegativeInf(f16(0.0)));
- expect(!isNegativeInf(f16(-0.0)));
- expect(!isNegativeInf(f32(0.0)));
- expect(!isNegativeInf(f32(-0.0)));
- expect(!isNegativeInf(f64(0.0)));
- expect(!isNegativeInf(f64(-0.0)));
- expect(!isNegativeInf(f128(0.0)));
- expect(!isNegativeInf(f128(-0.0)));
+ expect(!isNegativeInf(@as(f16, 0.0)));
+ expect(!isNegativeInf(@as(f16, -0.0)));
+ expect(!isNegativeInf(@as(f32, 0.0)));
+ expect(!isNegativeInf(@as(f32, -0.0)));
+ expect(!isNegativeInf(@as(f64, 0.0)));
+ expect(!isNegativeInf(@as(f64, -0.0)));
+ expect(!isNegativeInf(@as(f128, 0.0)));
+ expect(!isNegativeInf(@as(f128, -0.0)));
expect(!isNegativeInf(math.inf(f16)));
expect(isNegativeInf(-math.inf(f16)));
expect(!isNegativeInf(math.inf(f32)));
lib/std/math/isnan.zig
@@ -20,8 +20,8 @@ test "math.isNan" {
expect(isNan(math.nan(f32)));
expect(isNan(math.nan(f64)));
expect(isNan(math.nan(f128)));
- expect(!isNan(f16(1.0)));
- expect(!isNan(f32(1.0)));
- expect(!isNan(f64(1.0)));
- expect(!isNan(f128(1.0)));
+ expect(!isNan(@as(f16, 1.0)));
+ expect(!isNan(@as(f32, 1.0)));
+ expect(!isNan(@as(f64, 1.0)));
+ expect(!isNan(@as(f128, 1.0)));
}
lib/std/math/isnormal.zig
@@ -29,10 +29,10 @@ test "math.isNormal" {
expect(!isNormal(math.nan(f16)));
expect(!isNormal(math.nan(f32)));
expect(!isNormal(math.nan(f64)));
- expect(!isNormal(f16(0)));
- expect(!isNormal(f32(0)));
- expect(!isNormal(f64(0)));
- expect(isNormal(f16(1.0)));
- expect(isNormal(f32(1.0)));
- expect(isNormal(f64(1.0)));
+ expect(!isNormal(@as(f16, 0)));
+ expect(!isNormal(@as(f32, 0)));
+ expect(!isNormal(@as(f64, 0)));
+ expect(isNormal(@as(f16, 1.0)));
+ expect(isNormal(@as(f32, 1.0)));
+ expect(isNormal(@as(f64, 1.0)));
}
lib/std/math/ln.zig
@@ -31,10 +31,10 @@ pub fn ln(x: var) @typeOf(x) {
};
},
TypeId.ComptimeInt => {
- return @typeOf(1)(math.floor(ln_64(f64(x))));
+ return @typeOf(1)(math.floor(ln_64(@as(f64, x))));
},
TypeId.Int => {
- return T(math.floor(ln_64(f64(x))));
+ return T(math.floor(ln_64(@as(f64, x))));
},
else => @compileError("ln not implemented for " ++ @typeName(T)),
}
@@ -132,7 +132,7 @@ pub fn ln_64(x_: f64) f64 {
hx += 0x3FF00000 - 0x3FE6A09E;
k += @intCast(i32, hx >> 20) - 0x3FF;
hx = (hx & 0x000FFFFF) + 0x3FE6A09E;
- ix = (u64(hx) << 32) | (ix & 0xFFFFFFFF);
+ ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF);
x = @bitCast(f64, ix);
const f = x - 1.0;
@@ -149,8 +149,8 @@ pub fn ln_64(x_: f64) f64 {
}
test "math.ln" {
- expect(ln(f32(0.2)) == ln_32(0.2));
- expect(ln(f64(0.2)) == ln_64(0.2));
+ expect(ln(@as(f32, 0.2)) == ln_32(0.2));
+ expect(ln(@as(f64, 0.2)) == ln_64(0.2));
}
test "math.ln32" {
lib/std/math/log.zig
@@ -23,10 +23,10 @@ pub fn log(comptime T: type, base: T, x: T) T {
const float_base = math.lossyCast(f64, base);
switch (@typeId(T)) {
TypeId.ComptimeFloat => {
- return @typeOf(1.0)(math.ln(f64(x)) / math.ln(float_base));
+ return @typeOf(1.0)(math.ln(@as(f64, x)) / math.ln(float_base));
},
TypeId.ComptimeInt => {
- return @typeOf(1)(math.floor(math.ln(f64(x)) / math.ln(float_base)));
+ return @typeOf(1)(math.floor(math.ln(@as(f64, x)) / math.ln(float_base)));
},
builtin.TypeId.Int => {
// TODO implement integer log without using float math
@@ -35,7 +35,7 @@ pub fn log(comptime T: type, base: T, x: T) T {
builtin.TypeId.Float => {
switch (T) {
- f32 => return @floatCast(f32, math.ln(f64(x)) / math.ln(float_base)),
+ f32 => return @floatCast(f32, math.ln(@as(f64, x)) / math.ln(float_base)),
f64 => return math.ln(x) / math.ln(float_base),
else => @compileError("log not implemented for " ++ @typeName(T)),
}
@@ -67,6 +67,6 @@ test "math.log float_special" {
expect(log(f32, 2, 0.2301974) == math.log2(f32(0.2301974)));
expect(log(f32, 10, 0.2301974) == math.log10(f32(0.2301974)));
- expect(log(f64, 2, 213.23019799993) == math.log2(f64(213.23019799993)));
- expect(log(f64, 10, 213.23019799993) == math.log10(f64(213.23019799993)));
+ expect(log(f64, 2, 213.23019799993) == math.log2(@as(f64, 213.23019799993)));
+ expect(log(f64, 10, 213.23019799993) == math.log10(@as(f64, 213.23019799993)));
}
lib/std/math/log10.zig
@@ -32,7 +32,7 @@ pub fn log10(x: var) @typeOf(x) {
};
},
TypeId.ComptimeInt => {
- return @typeOf(1)(math.floor(log10_64(f64(x))));
+ return @typeOf(1)(math.floor(log10_64(@as(f64, x))));
},
TypeId.Int => {
return @floatToInt(T, math.floor(log10_64(@intToFloat(f64, x))));
@@ -143,7 +143,7 @@ pub fn log10_64(x_: f64) f64 {
hx += 0x3FF00000 - 0x3FE6A09E;
k += @intCast(i32, hx >> 20) - 0x3FF;
hx = (hx & 0x000FFFFF) + 0x3FE6A09E;
- ix = (u64(hx) << 32) | (ix & 0xFFFFFFFF);
+ ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF);
x = @bitCast(f64, ix);
const f = x - 1.0;
@@ -158,7 +158,7 @@ pub fn log10_64(x_: f64) f64 {
// hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f)
var hi = f - hfsq;
var hii = @bitCast(u64, hi);
- hii &= u64(maxInt(u64)) << 32;
+ hii &= @as(u64, maxInt(u64)) << 32;
hi = @bitCast(f64, hii);
const lo = f - hi - hfsq + s * (hfsq + R);
@@ -178,7 +178,7 @@ pub fn log10_64(x_: f64) f64 {
test "math.log10" {
testing.expect(log10(f32(0.2)) == log10_32(0.2));
- testing.expect(log10(f64(0.2)) == log10_64(0.2));
+ testing.expect(log10(@as(f64, 0.2)) == log10_64(0.2));
}
test "math.log10_32" {
lib/std/math/log1p.zig
@@ -166,7 +166,7 @@ fn log1p_64(x: f64) f64 {
// u into [sqrt(2)/2, sqrt(2)]
iu = (iu & 0x000FFFFF) + 0x3FE6A09E;
- const iq = (u64(iu) << 32) | (hu & 0xFFFFFFFF);
+ const iq = (@as(u64, iu) << 32) | (hu & 0xFFFFFFFF);
f = @bitCast(f64, iq) - 1;
}
@@ -183,8 +183,8 @@ fn log1p_64(x: f64) f64 {
}
test "math.log1p" {
- expect(log1p(f32(0.0)) == log1p_32(0.0));
- expect(log1p(f64(0.0)) == log1p_64(0.0));
+ expect(log1p(@as(f32, 0.0)) == log1p_32(0.0));
+ expect(log1p(@as(f64, 0.0)) == log1p_64(0.0));
}
test "math.log1p_32" {
lib/std/math/log2.zig
@@ -143,7 +143,7 @@ pub fn log2_64(x_: f64) f64 {
hx += 0x3FF00000 - 0x3FE6A09E;
k += @intCast(i32, hx >> 20) - 0x3FF;
hx = (hx & 0x000FFFFF) + 0x3FE6A09E;
- ix = (u64(hx) << 32) | (ix & 0xFFFFFFFF);
+ ix = (@as(u64, hx) << 32) | (ix & 0xFFFFFFFF);
x = @bitCast(f64, ix);
const f = x - 1.0;
@@ -158,7 +158,7 @@ pub fn log2_64(x_: f64) f64 {
// hi + lo = f - hfsq + s * (hfsq + R) ~ log(1 + f)
var hi = f - hfsq;
var hii = @bitCast(u64, hi);
- hii &= u64(maxInt(u64)) << 32;
+ hii &= @as(u64, maxInt(u64)) << 32;
hi = @bitCast(f64, hii);
const lo = f - hi - hfsq + s * (hfsq + R);
@@ -175,8 +175,8 @@ pub fn log2_64(x_: f64) f64 {
}
test "math.log2" {
- expect(log2(f32(0.2)) == log2_32(0.2));
- expect(log2(f64(0.2)) == log2_64(0.2));
+ expect(log2(@as(f32, 0.2)) == log2_32(0.2));
+ expect(log2(@as(f64, 0.2)) == log2_64(0.2));
}
test "math.log2_32" {
lib/std/math/modf.zig
@@ -65,7 +65,7 @@ fn modf32(x: f32) modf32_result {
return result;
}
- const mask = u32(0x007FFFFF) >> @intCast(u5, e);
+ const mask = @as(u32, 0x007FFFFF) >> @intCast(u5, e);
if (u & mask == 0) {
result.ipart = x;
result.fpart = @bitCast(f32, us);
@@ -109,7 +109,7 @@ fn modf64(x: f64) modf64_result {
return result;
}
- const mask = u64(maxInt(u64) >> 12) >> @intCast(u6, e);
+ const mask = @as(u64, maxInt(u64) >> 12) >> @intCast(u6, e);
if (u & mask == 0) {
result.ipart = x;
result.fpart = @bitCast(f64, us);
@@ -123,12 +123,12 @@ fn modf64(x: f64) modf64_result {
}
test "math.modf" {
- const a = modf(f32(1.0));
+ const a = modf(@as(f32, 1.0));
const b = modf32(1.0);
// NOTE: No struct comparison on generic return type function? non-named, makes sense, but still.
expect(a.ipart == b.ipart and a.fpart == b.fpart);
- const c = modf(f64(1.0));
+ const c = modf(@as(f64, 1.0));
const d = modf64(1.0);
expect(a.ipart == b.ipart and a.fpart == b.fpart);
}
lib/std/math/round.zig
@@ -91,8 +91,8 @@ fn round64(x_: f64) f64 {
}
test "math.round" {
- expect(round(f32(1.3)) == round32(1.3));
- expect(round(f64(1.3)) == round64(1.3));
+ expect(round(@as(f32, 1.3)) == round32(1.3));
+ expect(round(@as(f64, 1.3)) == round64(1.3));
}
test "math.round32" {
lib/std/math/scalbn.zig
@@ -79,8 +79,8 @@ fn scalbn64(x: f64, n_: i32) f64 {
}
test "math.scalbn" {
- expect(scalbn(f32(1.5), 4) == scalbn32(1.5, 4));
- expect(scalbn(f64(1.5), 4) == scalbn64(1.5, 4));
+ expect(scalbn(@as(f32, 1.5), 4) == scalbn32(1.5, 4));
+ expect(scalbn(@as(f64, 1.5), 4) == scalbn64(1.5, 4));
}
test "math.scalbn32" {
lib/std/math/signbit.zig
@@ -29,9 +29,9 @@ fn signbit64(x: f64) bool {
}
test "math.signbit" {
- expect(signbit(f16(4.0)) == signbit16(4.0));
- expect(signbit(f32(4.0)) == signbit32(4.0));
- expect(signbit(f64(4.0)) == signbit64(4.0));
+ expect(signbit(@as(f16, 4.0)) == signbit16(4.0));
+ expect(signbit(@as(f32, 4.0)) == signbit32(4.0));
+ expect(signbit(@as(f64, 4.0)) == signbit64(4.0));
}
test "math.signbit16" {
lib/std/math/sin.zig
@@ -88,9 +88,9 @@ test "math.sin" {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
- expect(sin(f32(0.0)) == sin_(f32, 0.0));
- expect(sin(f64(0.0)) == sin_(f64, 0.0));
- expect(comptime (math.sin(f64(2))) == math.sin(f64(2)));
+ expect(sin(@as(f32, 0.0)) == sin_(f32, 0.0));
+ expect(sin(@as(f64, 0.0)) == sin_(f64, 0.0));
+ expect(comptime (math.sin(@as(f64, 2))) == math.sin(@as(f64, 2)));
}
test "math.sin32" {
lib/std/math/sinh.zig
@@ -93,8 +93,8 @@ fn sinh64(x: f64) f64 {
}
test "math.sinh" {
- expect(sinh(f32(1.5)) == sinh32(1.5));
- expect(sinh(f64(1.5)) == sinh64(1.5));
+ expect(sinh(@as(f32, 1.5)) == sinh32(1.5));
+ expect(sinh(@as(f64, 1.5)) == sinh64(1.5));
}
test "math.sinh32" {
lib/std/math/sqrt.zig
@@ -32,9 +32,9 @@ pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typ
}
test "math.sqrt" {
- expect(sqrt(f16(0.0)) == @sqrt(f16, 0.0));
- expect(sqrt(f32(0.0)) == @sqrt(f32, 0.0));
- expect(sqrt(f64(0.0)) == @sqrt(f64, 0.0));
+ expect(sqrt(@as(f16, 0.0)) == @sqrt(f16, 0.0));
+ expect(sqrt(@as(f32, 0.0)) == @sqrt(f32, 0.0));
+ expect(sqrt(@as(f64, 0.0)) == @sqrt(f64, 0.0));
}
test "math.sqrt16" {
lib/std/math/tan.zig
@@ -75,8 +75,8 @@ fn tan_(comptime T: type, x_: T) T {
}
test "math.tan" {
- expect(tan(f32(0.0)) == tan_(f32, 0.0));
- expect(tan(f64(0.0)) == tan_(f64, 0.0));
+ expect(tan(@as(f32, 0.0)) == tan_(f32, 0.0));
+ expect(tan(@as(f64, 0.0)) == tan_(f64, 0.0));
}
test "math.tan32" {
lib/std/math/tanh.zig
@@ -119,8 +119,8 @@ fn tanh64(x: f64) f64 {
}
test "math.tanh" {
- expect(tanh(f32(1.5)) == tanh32(1.5));
- expect(tanh(f64(1.5)) == tanh64(1.5));
+ expect(tanh(@as(f32, 1.5)) == tanh32(1.5));
+ expect(tanh(@as(f64, 1.5)) == tanh64(1.5));
}
test "math.tanh32" {
lib/std/math/trunc.zig
@@ -36,7 +36,7 @@ fn trunc32(x: f32) f32 {
e = 1;
}
- m = u32(maxInt(u32)) >> @intCast(u5, e);
+ m = @as(u32, maxInt(u32)) >> @intCast(u5, e);
if (u & m == 0) {
return x;
} else {
@@ -57,7 +57,7 @@ fn trunc64(x: f64) f64 {
e = 1;
}
- m = u64(maxInt(u64)) >> @intCast(u6, e);
+ m = @as(u64, maxInt(u64)) >> @intCast(u6, e);
if (u & m == 0) {
return x;
} else {
@@ -67,8 +67,8 @@ fn trunc64(x: f64) f64 {
}
test "math.trunc" {
- expect(trunc(f32(1.3)) == trunc32(1.3));
- expect(trunc(f64(1.3)) == trunc64(1.3));
+ expect(trunc(@as(f32, 1.3)) == trunc32(1.3));
+ expect(trunc(@as(f64, 1.3)) == trunc64(1.3));
}
test "math.trunc32" {
lib/std/meta/trait.zig
@@ -327,8 +327,8 @@ pub fn isConstPtr(comptime T: type) bool {
}
test "std.meta.trait.isConstPtr" {
- var t = u8(0);
- const c = u8(0);
+ var t = @as(u8, 0);
+ const c = @as(u8, 0);
testing.expect(isConstPtr(*const @typeOf(t)));
testing.expect(isConstPtr(@typeOf(&c)));
testing.expect(!isConstPtr(*@typeOf(t)));
lib/std/os/bits/dragonfly.zig
@@ -315,7 +315,7 @@ pub const dirent = extern struct {
d_name: [256]u8,
pub fn reclen(self: dirent) u16 {
- return (@byteOffsetOf(dirent, "d_name") + self.d_namlen + 1 + 7) & ~u16(7);
+ return (@byteOffsetOf(dirent, "d_name") + self.d_namlen + 1 + 7) & ~@as(u16, 7);
}
};
lib/std/os/bits/linux.zig
@@ -559,10 +559,10 @@ pub const EPOLLMSG = 0x400;
pub const EPOLLERR = 0x008;
pub const EPOLLHUP = 0x010;
pub const EPOLLRDHUP = 0x2000;
-pub const EPOLLEXCLUSIVE = (u32(1) << 28);
-pub const EPOLLWAKEUP = (u32(1) << 29);
-pub const EPOLLONESHOT = (u32(1) << 30);
-pub const EPOLLET = (u32(1) << 31);
+pub const EPOLLEXCLUSIVE = (@as(u32, 1) << 28);
+pub const EPOLLWAKEUP = (@as(u32, 1) << 29);
+pub const EPOLLONESHOT = (@as(u32, 1) << 30);
+pub const EPOLLET = (@as(u32, 1) << 31);
pub const CLOCK_REALTIME = 0;
pub const CLOCK_MONOTONIC = 1;
@@ -950,7 +950,7 @@ pub fn cap_valid(u8: x) bool {
}
pub fn CAP_TO_MASK(cap: u8) u32 {
- return u32(1) << u5(cap & 31);
+ return @as(u32, 1) << u5(cap & 31);
}
pub fn CAP_TO_INDEX(cap: u8) u8 {
lib/std/os/linux/arm-eabi.zig
@@ -100,7 +100,7 @@ pub extern fn getThreadPointer() usize {
pub nakedcc fn restore() void {
return asm volatile ("svc #0"
:
- : [number] "{r7}" (usize(SYS_sigreturn))
+ : [number] "{r7}" (@as(usize, SYS_sigreturn))
: "memory"
);
}
@@ -108,7 +108,7 @@ pub nakedcc fn restore() void {
pub nakedcc fn restore_rt() void {
return asm volatile ("svc #0"
:
- : [number] "{r7}" (usize(SYS_rt_sigreturn))
+ : [number] "{r7}" (@as(usize, SYS_rt_sigreturn))
: "memory"
);
}
lib/std/os/linux/arm64.zig
@@ -93,7 +93,7 @@ pub const restore = restore_rt;
pub nakedcc fn restore_rt() void {
return asm volatile ("svc #0"
:
- : [number] "{x8}" (usize(SYS_rt_sigreturn))
+ : [number] "{x8}" (@as(usize, SYS_rt_sigreturn))
: "memory", "cc"
);
}
lib/std/os/linux/mipsel.zig
@@ -26,7 +26,7 @@ pub fn syscall_pipe(fd: *[2]i32) usize {
\\ sw $3, 4($4)
\\ 2:
: [ret] "={$2}" (-> usize)
- : [number] "{$2}" (usize(SYS_pipe))
+ : [number] "{$2}" (@as(usize, SYS_pipe))
: "memory", "cc", "$7"
);
}
@@ -147,7 +147,7 @@ pub extern fn clone(func: extern fn (arg: usize) u8, stack: usize, flags: u32, a
pub nakedcc fn restore() void {
return asm volatile ("syscall"
:
- : [number] "{$2}" (usize(SYS_sigreturn))
+ : [number] "{$2}" (@as(usize, SYS_sigreturn))
: "memory", "cc", "$7"
);
}
@@ -155,7 +155,7 @@ pub nakedcc fn restore() void {
pub nakedcc fn restore_rt() void {
return asm volatile ("syscall"
:
- : [number] "{$2}" (usize(SYS_rt_sigreturn))
+ : [number] "{$2}" (@as(usize, SYS_rt_sigreturn))
: "memory", "cc", "$7"
);
}
lib/std/os/linux/riscv64.zig
@@ -92,7 +92,7 @@ pub const restore = restore_rt;
pub nakedcc fn restore_rt() void {
return asm volatile ("ecall"
:
- : [number] "{x17}" (usize(SYS_rt_sigreturn))
+ : [number] "{x17}" (@as(usize, SYS_rt_sigreturn))
: "memory"
);
}
lib/std/os/linux/vdso.zig
@@ -62,8 +62,8 @@ pub fn lookup(vername: []const u8, name: []const u8) usize {
var i: usize = 0;
while (i < hashtab[1]) : (i += 1) {
- if (0 == (u32(1) << @intCast(u5, syms[i].st_info & 0xf) & OK_TYPES)) continue;
- if (0 == (u32(1) << @intCast(u5, syms[i].st_info >> 4) & OK_BINDS)) continue;
+ if (0 == (@as(u32, 1) << @intCast(u5, syms[i].st_info & 0xf) & OK_TYPES)) continue;
+ if (0 == (@as(u32, 1) << @intCast(u5, syms[i].st_info >> 4) & OK_BINDS)) continue;
if (0 == syms[i].st_shndx) continue;
if (!mem.eql(u8, name, mem.toSliceConst(u8, strings + syms[i].st_name))) continue;
if (maybe_versym) |versym| {
lib/std/os/linux/x86_64.zig
@@ -93,7 +93,7 @@ pub const restore = restore_rt;
pub nakedcc fn restore_rt() void {
return asm volatile ("syscall"
:
- : [number] "{rax}" (usize(SYS_rt_sigreturn))
+ : [number] "{rax}" (@as(usize, SYS_rt_sigreturn))
: "rcx", "r11", "memory"
);
}
lib/std/os/linux.zig
@@ -46,22 +46,22 @@ pub fn getErrno(r: usize) u12 {
pub fn dup2(old: i32, new: i32) usize {
if (@hasDecl(@This(), "SYS_dup2")) {
- return syscall2(SYS_dup2, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)));
+ return syscall2(SYS_dup2, @bitCast(usize, @as(isize, old)), @bitCast(usize, @as(isize, new)));
} else {
if (old == new) {
if (std.debug.runtime_safety) {
- const rc = syscall2(SYS_fcntl, @bitCast(usize, isize(old)), F_GETFD);
+ const rc = syscall2(SYS_fcntl, @bitCast(usize, @as(isize, old)), F_GETFD);
if (@bitCast(isize, rc) < 0) return rc;
}
return @intCast(usize, old);
} else {
- return syscall3(SYS_dup3, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)), 0);
+ return syscall3(SYS_dup3, @bitCast(usize, @as(isize, old)), @bitCast(usize, @as(isize, new)), 0);
}
}
}
pub fn dup3(old: i32, new: i32, flags: u32) usize {
- return syscall3(SYS_dup3, @bitCast(usize, isize(old)), @bitCast(usize, isize(new)), flags);
+ return syscall3(SYS_dup3, @bitCast(usize, @as(isize, old)), @bitCast(usize, @as(isize, new)), flags);
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -102,7 +102,7 @@ pub fn futimens(fd: i32, times: *const [2]timespec) usize {
// TODO https://github.com/ziglang/zig/issues/265
pub fn utimensat(dirfd: i32, path: ?[*]const u8, times: *const [2]timespec, flags: u32) usize {
- return syscall4(SYS_utimensat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(times), flags);
+ return syscall4(SYS_utimensat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), @ptrToInt(times), flags);
}
pub fn futex_wait(uaddr: *const i32, futex_op: u32, val: i32, timeout: ?*timespec) usize {
@@ -120,7 +120,7 @@ pub fn getcwd(buf: [*]u8, size: usize) usize {
pub fn getdents(fd: i32, dirp: [*]u8, len: usize) usize {
return syscall3(
SYS_getdents,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@ptrToInt(dirp),
std.math.min(len, maxInt(c_int)),
);
@@ -129,7 +129,7 @@ pub fn getdents(fd: i32, dirp: [*]u8, len: usize) usize {
pub fn getdents64(fd: i32, dirp: [*]u8, len: usize) usize {
return syscall3(
SYS_getdents64,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@ptrToInt(dirp),
std.math.min(len, maxInt(c_int)),
);
@@ -140,11 +140,11 @@ pub fn inotify_init1(flags: u32) usize {
}
pub fn inotify_add_watch(fd: i32, pathname: [*]const u8, mask: u32) usize {
- return syscall3(SYS_inotify_add_watch, @bitCast(usize, isize(fd)), @ptrToInt(pathname), mask);
+ return syscall3(SYS_inotify_add_watch, @bitCast(usize, @as(isize, fd)), @ptrToInt(pathname), mask);
}
pub fn inotify_rm_watch(fd: i32, wd: i32) usize {
- return syscall2(SYS_inotify_rm_watch, @bitCast(usize, isize(fd)), @bitCast(usize, isize(wd)));
+ return syscall2(SYS_inotify_rm_watch, @bitCast(usize, @as(isize, fd)), @bitCast(usize, @as(isize, wd)));
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -152,13 +152,13 @@ pub fn readlink(noalias path: [*]const u8, noalias buf_ptr: [*]u8, buf_len: usiz
if (@hasDecl(@This(), "SYS_readlink")) {
return syscall3(SYS_readlink, @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
} else {
- return syscall4(SYS_readlinkat, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
+ return syscall4(SYS_readlinkat, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
}
}
// TODO https://github.com/ziglang/zig/issues/265
pub fn readlinkat(dirfd: i32, noalias path: [*]const u8, noalias buf_ptr: [*]u8, buf_len: usize) usize {
- return syscall4(SYS_readlinkat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
+ return syscall4(SYS_readlinkat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), @ptrToInt(buf_ptr), buf_len);
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -166,13 +166,13 @@ pub fn mkdir(path: [*]const u8, mode: u32) usize {
if (@hasDecl(@This(), "SYS_mkdir")) {
return syscall2(SYS_mkdir, @ptrToInt(path), mode);
} else {
- return syscall3(SYS_mkdirat, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(path), mode);
+ return syscall3(SYS_mkdirat, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(path), mode);
}
}
// TODO https://github.com/ziglang/zig/issues/265
pub fn mkdirat(dirfd: i32, path: [*]const u8, mode: u32) usize {
- return syscall3(SYS_mkdirat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), mode);
+ return syscall3(SYS_mkdirat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), mode);
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -194,7 +194,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, of
if (@hasDecl(@This(), "SYS_mmap2")) {
// Make sure the offset is also specified in multiples of page size
if ((offset & (MMAP2_UNIT - 1)) != 0)
- return @bitCast(usize, isize(-EINVAL));
+ return @bitCast(usize, @as(isize, -EINVAL));
return syscall6(
SYS_mmap2,
@@ -202,7 +202,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, of
length,
prot,
flags,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@truncate(usize, offset / MMAP2_UNIT),
);
} else {
@@ -212,7 +212,7 @@ pub fn mmap(address: ?[*]u8, length: usize, prot: usize, flags: u32, fd: i32, of
length,
prot,
flags,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
offset,
);
}
@@ -249,13 +249,13 @@ pub fn poll(fds: [*]pollfd, n: nfds_t, timeout: i32) usize {
}
pub fn read(fd: i32, buf: [*]u8, count: usize) usize {
- return syscall3(SYS_read, @bitCast(usize, isize(fd)), @ptrToInt(buf), count);
+ return syscall3(SYS_read, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), count);
}
pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: u64) usize {
return syscall5(
SYS_preadv,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@ptrToInt(iov),
count,
@truncate(usize, offset),
@@ -266,7 +266,7 @@ pub fn preadv(fd: i32, iov: [*]const iovec, count: usize, offset: u64) usize {
pub fn preadv2(fd: i32, iov: [*]const iovec, count: usize, offset: u64, flags: kernel_rwf) usize {
return syscall6(
SYS_preadv2,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@ptrToInt(iov),
count,
@truncate(usize, offset),
@@ -276,17 +276,17 @@ pub fn preadv2(fd: i32, iov: [*]const iovec, count: usize, offset: u64, flags: k
}
pub fn readv(fd: i32, iov: [*]const iovec, count: usize) usize {
- return syscall3(SYS_readv, @bitCast(usize, isize(fd)), @ptrToInt(iov), count);
+ return syscall3(SYS_readv, @bitCast(usize, @as(isize, fd)), @ptrToInt(iov), count);
}
pub fn writev(fd: i32, iov: [*]const iovec_const, count: usize) usize {
- return syscall3(SYS_writev, @bitCast(usize, isize(fd)), @ptrToInt(iov), count);
+ return syscall3(SYS_writev, @bitCast(usize, @as(isize, fd)), @ptrToInt(iov), count);
}
pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64) usize {
return syscall5(
SYS_pwritev,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@ptrToInt(iov),
count,
@truncate(usize, offset),
@@ -297,7 +297,7 @@ pub fn pwritev(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64) us
pub fn pwritev2(fd: i32, iov: [*]const iovec_const, count: usize, offset: u64, flags: kernel_rwf) usize {
return syscall6(
SYS_pwritev2,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@ptrToInt(iov),
count,
@truncate(usize, offset),
@@ -311,7 +311,7 @@ pub fn rmdir(path: [*]const u8) usize {
if (@hasDecl(@This(), "SYS_rmdir")) {
return syscall1(SYS_rmdir, @ptrToInt(path));
} else {
- return syscall3(SYS_unlinkat, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(path), AT_REMOVEDIR);
+ return syscall3(SYS_unlinkat, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(path), AT_REMOVEDIR);
}
}
@@ -320,18 +320,18 @@ pub fn symlink(existing: [*]const u8, new: [*]const u8) usize {
if (@hasDecl(@This(), "SYS_symlink")) {
return syscall2(SYS_symlink, @ptrToInt(existing), @ptrToInt(new));
} else {
- return syscall3(SYS_symlinkat, @ptrToInt(existing), @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(new));
+ return syscall3(SYS_symlinkat, @ptrToInt(existing), @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(new));
}
}
// TODO https://github.com/ziglang/zig/issues/265
pub fn symlinkat(existing: [*]const u8, newfd: i32, newpath: [*]const u8) usize {
- return syscall3(SYS_symlinkat, @ptrToInt(existing), @bitCast(usize, isize(newfd)), @ptrToInt(newpath));
+ return syscall3(SYS_symlinkat, @ptrToInt(existing), @bitCast(usize, @as(isize, newfd)), @ptrToInt(newpath));
}
// TODO https://github.com/ziglang/zig/issues/265
pub fn pread(fd: i32, buf: [*]u8, count: usize, offset: usize) usize {
- return syscall4(SYS_pread, @bitCast(usize, isize(fd)), @ptrToInt(buf), count, offset);
+ return syscall4(SYS_pread, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), count, offset);
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -339,13 +339,13 @@ pub fn access(path: [*]const u8, mode: u32) usize {
if (@hasDecl(@This(), "SYS_access")) {
return syscall2(SYS_access, @ptrToInt(path), mode);
} else {
- return syscall4(SYS_faccessat, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(path), mode, 0);
+ return syscall4(SYS_faccessat, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(path), mode, 0);
}
}
// TODO https://github.com/ziglang/zig/issues/265
pub fn faccessat(dirfd: i32, path: [*]const u8, mode: u32, flags: u32) usize {
- return syscall4(SYS_faccessat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), mode, flags);
+ return syscall4(SYS_faccessat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), mode, flags);
}
pub fn pipe(fd: *[2]i32) usize {
@@ -363,11 +363,11 @@ pub fn pipe2(fd: *[2]i32, flags: u32) usize {
}
pub fn write(fd: i32, buf: [*]const u8, count: usize) usize {
- return syscall3(SYS_write, @bitCast(usize, isize(fd)), @ptrToInt(buf), count);
+ return syscall3(SYS_write, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), count);
}
pub fn pwrite(fd: i32, buf: [*]const u8, count: usize, offset: usize) usize {
- return syscall4(SYS_pwrite, @bitCast(usize, isize(fd)), @ptrToInt(buf), count, offset);
+ return syscall4(SYS_pwrite, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), count, offset);
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -375,9 +375,9 @@ pub fn rename(old: [*]const u8, new: [*]const u8) usize {
if (@hasDecl(@This(), "SYS_rename")) {
return syscall2(SYS_rename, @ptrToInt(old), @ptrToInt(new));
} else if (@hasDecl(@This(), "SYS_renameat")) {
- return syscall4(SYS_renameat, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(old), @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(new));
+ return syscall4(SYS_renameat, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(old), @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(new));
} else {
- return syscall5(SYS_renameat2, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(old), @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(new), 0);
+ return syscall5(SYS_renameat2, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(old), @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(new), 0);
}
}
@@ -385,17 +385,17 @@ pub fn renameat(oldfd: i32, oldpath: [*]const u8, newfd: i32, newpath: [*]const
if (@hasDecl(@This(), "SYS_renameat")) {
return syscall4(
SYS_renameat,
- @bitCast(usize, isize(oldfd)),
+ @bitCast(usize, @as(isize, oldfd)),
@ptrToInt(old),
- @bitCast(usize, isize(newfd)),
+ @bitCast(usize, @as(isize, newfd)),
@ptrToInt(new),
);
} else {
return syscall5(
SYS_renameat2,
- @bitCast(usize, isize(oldfd)),
+ @bitCast(usize, @as(isize, oldfd)),
@ptrToInt(old),
- @bitCast(usize, isize(newfd)),
+ @bitCast(usize, @as(isize, newfd)),
@ptrToInt(new),
0,
);
@@ -406,9 +406,9 @@ pub fn renameat(oldfd: i32, oldpath: [*]const u8, newfd: i32, newpath: [*]const
pub fn renameat2(oldfd: i32, oldpath: [*]const u8, newfd: i32, newpath: [*]const u8, flags: u32) usize {
return syscall5(
SYS_renameat2,
- @bitCast(usize, isize(oldfd)),
+ @bitCast(usize, @as(isize, oldfd)),
@ptrToInt(oldpath),
- @bitCast(usize, isize(newfd)),
+ @bitCast(usize, @as(isize, newfd)),
@ptrToInt(newpath),
flags,
);
@@ -421,7 +421,7 @@ pub fn open(path: [*]const u8, flags: u32, perm: usize) usize {
} else {
return syscall4(
SYS_openat,
- @bitCast(usize, isize(AT_FDCWD)),
+ @bitCast(usize, @as(isize, AT_FDCWD)),
@ptrToInt(path),
flags,
perm,
@@ -437,7 +437,7 @@ pub fn create(path: [*]const u8, perm: usize) usize {
// TODO https://github.com/ziglang/zig/issues/265
pub fn openat(dirfd: i32, path: [*]const u8, flags: u32, mode: usize) usize {
// dirfd could be negative, for example AT_FDCWD is -100
- return syscall4(SYS_openat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), flags, mode);
+ return syscall4(SYS_openat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), flags, mode);
}
/// See also `clone` (from the arch-specific include)
@@ -451,14 +451,14 @@ pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
}
pub fn close(fd: i32) usize {
- return syscall1(SYS_close, @bitCast(usize, isize(fd)));
+ return syscall1(SYS_close, @bitCast(usize, @as(isize, fd)));
}
/// Can only be called on 32 bit systems. For 64 bit see `lseek`.
pub fn llseek(fd: i32, offset: u64, result: ?*u64, whence: usize) usize {
return syscall5(
SYS__llseek,
- @bitCast(usize, isize(fd)),
+ @bitCast(usize, @as(isize, fd)),
@truncate(usize, offset >> 32),
@truncate(usize, offset),
@ptrToInt(result),
@@ -468,16 +468,16 @@ pub fn llseek(fd: i32, offset: u64, result: ?*u64, whence: usize) usize {
/// Can only be called on 64 bit systems. For 32 bit see `llseek`.
pub fn lseek(fd: i32, offset: i64, whence: usize) usize {
- return syscall3(SYS_lseek, @bitCast(usize, isize(fd)), @bitCast(usize, offset), whence);
+ return syscall3(SYS_lseek, @bitCast(usize, @as(isize, fd)), @bitCast(usize, offset), whence);
}
pub fn exit(status: i32) noreturn {
- _ = syscall1(SYS_exit, @bitCast(usize, isize(status)));
+ _ = syscall1(SYS_exit, @bitCast(usize, @as(isize, status)));
unreachable;
}
pub fn exit_group(status: i32) noreturn {
- _ = syscall1(SYS_exit_group, @bitCast(usize, isize(status)));
+ _ = syscall1(SYS_exit_group, @bitCast(usize, @as(isize, status)));
unreachable;
}
@@ -486,7 +486,7 @@ pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize {
}
pub fn kill(pid: i32, sig: i32) usize {
- return syscall2(SYS_kill, @bitCast(usize, isize(pid)), @bitCast(usize, isize(sig)));
+ return syscall2(SYS_kill, @bitCast(usize, @as(isize, pid)), @bitCast(usize, @as(isize, sig)));
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -494,17 +494,17 @@ pub fn unlink(path: [*]const u8) usize {
if (@hasDecl(@This(), "SYS_unlink")) {
return syscall1(SYS_unlink, @ptrToInt(path));
} else {
- return syscall3(SYS_unlinkat, @bitCast(usize, isize(AT_FDCWD)), @ptrToInt(path), 0);
+ return syscall3(SYS_unlinkat, @bitCast(usize, @as(isize, AT_FDCWD)), @ptrToInt(path), 0);
}
}
// TODO https://github.com/ziglang/zig/issues/265
pub fn unlinkat(dirfd: i32, path: [*]const u8, flags: u32) usize {
- return syscall3(SYS_unlinkat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), flags);
+ return syscall3(SYS_unlinkat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), flags);
}
pub fn waitpid(pid: i32, status: *u32, flags: u32) usize {
- return syscall4(SYS_wait4, @bitCast(usize, isize(pid)), @ptrToInt(status), flags, 0);
+ return syscall4(SYS_wait4, @bitCast(usize, @as(isize, pid)), @ptrToInt(status), flags, 0);
}
var vdso_clock_gettime = @ptrCast(?*const c_void, init_vdso_clock_gettime);
@@ -519,12 +519,12 @@ pub fn clock_gettime(clk_id: i32, tp: *timespec) usize {
const f = @ptrCast(vdso_clock_gettime_ty, fn_ptr);
const rc = f(clk_id, tp);
switch (rc) {
- 0, @bitCast(usize, isize(-EINVAL)) => return rc,
+ 0, @bitCast(usize, @as(isize, -EINVAL)) => return rc,
else => {},
}
}
}
- return syscall2(SYS_clock_gettime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
+ return syscall2(SYS_clock_gettime, @bitCast(usize, @as(isize, clk_id)), @ptrToInt(tp));
}
extern fn init_vdso_clock_gettime(clk: i32, ts: *timespec) usize {
@@ -537,15 +537,15 @@ extern fn init_vdso_clock_gettime(clk: i32, ts: *timespec) usize {
const f = @ptrCast(vdso_clock_gettime_ty, fn_ptr);
return f(clk, ts);
}
- return @bitCast(usize, isize(-ENOSYS));
+ return @bitCast(usize, @as(isize, -ENOSYS));
}
pub fn clock_getres(clk_id: i32, tp: *timespec) usize {
- return syscall2(SYS_clock_getres, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
+ return syscall2(SYS_clock_getres, @bitCast(usize, @as(isize, clk_id)), @ptrToInt(tp));
}
pub fn clock_settime(clk_id: i32, tp: *const timespec) usize {
- return syscall2(SYS_clock_settime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
+ return syscall2(SYS_clock_settime, @bitCast(usize, @as(isize, clk_id)), @ptrToInt(tp));
}
pub fn gettimeofday(tv: *timeval, tz: *timezone) usize {
@@ -594,33 +594,33 @@ pub fn setregid(rgid: u32, egid: u32) usize {
pub fn getuid() u32 {
if (@hasDecl(@This(), "SYS_getuid32")) {
- return u32(syscall0(SYS_getuid32));
+ return @as(u32, syscall0(SYS_getuid32));
} else {
- return u32(syscall0(SYS_getuid));
+ return @as(u32, syscall0(SYS_getuid));
}
}
pub fn getgid() u32 {
if (@hasDecl(@This(), "SYS_getgid32")) {
- return u32(syscall0(SYS_getgid32));
+ return @as(u32, syscall0(SYS_getgid32));
} else {
- return u32(syscall0(SYS_getgid));
+ return @as(u32, syscall0(SYS_getgid));
}
}
pub fn geteuid() u32 {
if (@hasDecl(@This(), "SYS_geteuid32")) {
- return u32(syscall0(SYS_geteuid32));
+ return @as(u32, syscall0(SYS_geteuid32));
} else {
- return u32(syscall0(SYS_geteuid));
+ return @as(u32, syscall0(SYS_geteuid));
}
}
pub fn getegid() u32 {
if (@hasDecl(@This(), "SYS_getegid32")) {
- return u32(syscall0(SYS_getegid32));
+ return @as(u32, syscall0(SYS_getegid32));
} else {
- return u32(syscall0(SYS_getegid));
+ return @as(u32, syscall0(SYS_getegid));
}
}
@@ -743,11 +743,11 @@ pub fn sigismember(set: *const sigset_t, sig: u6) bool {
}
pub fn getsockname(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize {
- return syscall3(SYS_getsockname, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len));
+ return syscall3(SYS_getsockname, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len));
}
pub fn getpeername(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize {
- return syscall3(SYS_getpeername, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len));
+ return syscall3(SYS_getpeername, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len));
}
pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize {
@@ -755,15 +755,15 @@ pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize {
}
pub fn setsockopt(fd: i32, level: u32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize {
- return syscall5(SYS_setsockopt, @bitCast(usize, isize(fd)), level, optname, @ptrToInt(optval), @intCast(usize, optlen));
+ return syscall5(SYS_setsockopt, @bitCast(usize, @as(isize, fd)), level, optname, @ptrToInt(optval), @intCast(usize, optlen));
}
pub fn getsockopt(fd: i32, level: u32, optname: u32, noalias optval: [*]u8, noalias optlen: *socklen_t) usize {
- return syscall5(SYS_getsockopt, @bitCast(usize, isize(fd)), level, optname, @ptrToInt(optval), @ptrToInt(optlen));
+ return syscall5(SYS_getsockopt, @bitCast(usize, @as(isize, fd)), level, optname, @ptrToInt(optval), @ptrToInt(optlen));
}
pub fn sendmsg(fd: i32, msg: *msghdr_const, flags: u32) usize {
- return syscall3(SYS_sendmsg, @bitCast(usize, isize(fd)), @ptrToInt(msg), flags);
+ return syscall3(SYS_sendmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(msg), flags);
}
pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize {
@@ -781,7 +781,7 @@ pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize
// batch-send all messages up to the current message
if (next_unsent < i) {
const batch_size = i - next_unsent;
- const r = syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
+ const r = syscall4(SYS_sendmmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
if (getErrno(r) != 0) return next_unsent;
if (r < batch_size) return next_unsent + r;
}
@@ -797,41 +797,41 @@ pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize
}
if (next_unsent < kvlen or next_unsent == 0) { // want to make sure at least one syscall occurs (e.g. to trigger MSG_EOR)
const batch_size = kvlen - next_unsent;
- const r = syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
+ const r = syscall4(SYS_sendmmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(&msgvec[next_unsent]), batch_size, flags);
if (getErrno(r) != 0) return r;
return next_unsent + r;
}
return kvlen;
}
- return syscall4(SYS_sendmmsg, @bitCast(usize, isize(fd)), @ptrToInt(msgvec), vlen, flags);
+ return syscall4(SYS_sendmmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(msgvec), vlen, flags);
}
pub fn connect(fd: i32, addr: *const c_void, len: socklen_t) usize {
- return syscall3(SYS_connect, @bitCast(usize, isize(fd)), @ptrToInt(addr), len);
+ return syscall3(SYS_connect, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), len);
}
pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize {
- return syscall3(SYS_recvmsg, @bitCast(usize, isize(fd)), @ptrToInt(msg), flags);
+ return syscall3(SYS_recvmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(msg), flags);
}
pub fn recvfrom(fd: i32, noalias buf: [*]u8, len: usize, flags: u32, noalias addr: ?*sockaddr, noalias alen: ?*socklen_t) usize {
- return syscall6(SYS_recvfrom, @bitCast(usize, isize(fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
+ return syscall6(SYS_recvfrom, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
}
pub fn shutdown(fd: i32, how: i32) usize {
- return syscall2(SYS_shutdown, @bitCast(usize, isize(fd)), @bitCast(usize, isize(how)));
+ return syscall2(SYS_shutdown, @bitCast(usize, @as(isize, fd)), @bitCast(usize, @as(isize, how)));
}
pub fn bind(fd: i32, addr: *const sockaddr, len: socklen_t) usize {
- return syscall3(SYS_bind, @bitCast(usize, isize(fd)), @ptrToInt(addr), @intCast(usize, len));
+ return syscall3(SYS_bind, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @intCast(usize, len));
}
pub fn listen(fd: i32, backlog: u32) usize {
- return syscall2(SYS_listen, @bitCast(usize, isize(fd)), backlog);
+ return syscall2(SYS_listen, @bitCast(usize, @as(isize, fd)), backlog);
}
pub fn sendto(fd: i32, buf: [*]const u8, len: usize, flags: u32, addr: ?*const sockaddr, alen: socklen_t) usize {
- return syscall6(SYS_sendto, @bitCast(usize, isize(fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen));
+ return syscall6(SYS_sendto, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen));
}
pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) usize {
@@ -843,14 +843,14 @@ pub fn accept(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize {
}
pub fn accept4(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t, flags: u32) usize {
- return syscall4(SYS_accept4, @bitCast(usize, isize(fd)), @ptrToInt(addr), @ptrToInt(len), flags);
+ return syscall4(SYS_accept4, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len), flags);
}
pub fn fstat(fd: i32, stat_buf: *Stat) usize {
if (@hasDecl(@This(), "SYS_fstat64")) {
- return syscall2(SYS_fstat64, @bitCast(usize, isize(fd)), @ptrToInt(stat_buf));
+ return syscall2(SYS_fstat64, @bitCast(usize, @as(isize, fd)), @ptrToInt(stat_buf));
} else {
- return syscall2(SYS_fstat, @bitCast(usize, isize(fd)), @ptrToInt(stat_buf));
+ return syscall2(SYS_fstat, @bitCast(usize, @as(isize, fd)), @ptrToInt(stat_buf));
}
}
@@ -875,9 +875,9 @@ pub fn lstat(pathname: [*]const u8, statbuf: *Stat) usize {
// TODO https://github.com/ziglang/zig/issues/265
pub fn fstatat(dirfd: i32, path: [*]const u8, stat_buf: *Stat, flags: u32) usize {
if (@hasDecl(@This(), "SYS_fstatat64")) {
- return syscall4(SYS_fstatat64, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
+ return syscall4(SYS_fstatat64, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
} else {
- return syscall4(SYS_fstatat, @bitCast(usize, isize(dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
+ return syscall4(SYS_fstatat, @bitCast(usize, @as(isize, dirfd)), @ptrToInt(path), @ptrToInt(stat_buf), flags);
}
}
@@ -885,14 +885,14 @@ pub fn statx(dirfd: i32, path: [*]const u8, flags: u32, mask: u32, statx_buf: *S
if (@hasDecl(@This(), "SYS_statx")) {
return syscall5(
SYS_statx,
- @bitCast(usize, isize(dirfd)),
+ @bitCast(usize, @as(isize, dirfd)),
@ptrToInt(path),
flags,
mask,
@ptrToInt(statx_buf),
);
}
- return @bitCast(usize, isize(-ENOSYS));
+ return @bitCast(usize, @as(isize, -ENOSYS));
}
// TODO https://github.com/ziglang/zig/issues/265
@@ -959,7 +959,7 @@ pub fn sched_yield() usize {
}
pub fn sched_getaffinity(pid: i32, size: usize, set: *cpu_set_t) usize {
- const rc = syscall3(SYS_sched_getaffinity, @bitCast(usize, isize(pid)), size, @ptrToInt(set));
+ const rc = syscall3(SYS_sched_getaffinity, @bitCast(usize, @as(isize, pid)), size, @ptrToInt(set));
if (@bitCast(isize, rc) < 0) return rc;
if (rc < size) @memset(@ptrCast([*]u8, set) + rc, 0, size - rc);
return 0;
@@ -974,7 +974,7 @@ pub fn epoll_create1(flags: usize) usize {
}
pub fn epoll_ctl(epoll_fd: i32, op: u32, fd: i32, ev: ?*epoll_event) usize {
- return syscall4(SYS_epoll_ctl, @bitCast(usize, isize(epoll_fd)), @intCast(usize, op), @bitCast(usize, isize(fd)), @ptrToInt(ev));
+ return syscall4(SYS_epoll_ctl, @bitCast(usize, @as(isize, epoll_fd)), @intCast(usize, op), @bitCast(usize, @as(isize, fd)), @ptrToInt(ev));
}
pub fn epoll_wait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32) usize {
@@ -984,10 +984,10 @@ pub fn epoll_wait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout
pub fn epoll_pwait(epoll_fd: i32, events: [*]epoll_event, maxevents: u32, timeout: i32, sigmask: ?*sigset_t) usize {
return syscall6(
SYS_epoll_pwait,
- @bitCast(usize, isize(epoll_fd)),
+ @bitCast(usize, @as(isize, epoll_fd)),
@ptrToInt(events),
@intCast(usize, maxevents),
- @bitCast(usize, isize(timeout)),
+ @bitCast(usize, @as(isize, timeout)),
@ptrToInt(sigmask),
@sizeOf(sigset_t),
);
@@ -998,7 +998,7 @@ pub fn eventfd(count: u32, flags: u32) usize {
}
pub fn timerfd_create(clockid: i32, flags: u32) usize {
- return syscall2(SYS_timerfd_create, @bitCast(usize, isize(clockid)), flags);
+ return syscall2(SYS_timerfd_create, @bitCast(usize, @as(isize, clockid)), flags);
}
pub const itimerspec = extern struct {
@@ -1007,11 +1007,11 @@ pub const itimerspec = extern struct {
};
pub fn timerfd_gettime(fd: i32, curr_value: *itimerspec) usize {
- return syscall2(SYS_timerfd_gettime, @bitCast(usize, isize(fd)), @ptrToInt(curr_value));
+ return syscall2(SYS_timerfd_gettime, @bitCast(usize, @as(isize, fd)), @ptrToInt(curr_value));
}
pub fn timerfd_settime(fd: i32, flags: u32, new_value: *const itimerspec, old_value: ?*itimerspec) usize {
- return syscall4(SYS_timerfd_settime, @bitCast(usize, isize(fd)), flags, @ptrToInt(new_value), @ptrToInt(old_value));
+ return syscall4(SYS_timerfd_settime, @bitCast(usize, @as(isize, fd)), flags, @ptrToInt(new_value), @ptrToInt(old_value));
}
pub fn unshare(flags: usize) usize {
@@ -1096,11 +1096,11 @@ pub fn io_uring_setup(entries: u32, p: *io_uring_params) usize {
}
pub fn io_uring_enter(fd: i32, to_submit: u32, min_complete: u32, flags: u32, sig: ?*sigset_t) usize {
- return syscall6(SYS_io_uring_enter, @bitCast(usize, isize(fd)), to_submit, min_complete, flags, @ptrToInt(sig), NSIG / 8);
+ return syscall6(SYS_io_uring_enter, @bitCast(usize, @as(isize, fd)), to_submit, min_complete, flags, @ptrToInt(sig), NSIG / 8);
}
pub fn io_uring_register(fd: i32, opcode: u32, arg: ?*const c_void, nr_args: u32) usize {
- return syscall4(SYS_io_uring_register, @bitCast(usize, isize(fd)), opcode, @ptrToInt(arg), nr_args);
+ return syscall4(SYS_io_uring_register, @bitCast(usize, @as(isize, fd)), opcode, @ptrToInt(arg), nr_args);
}
test "" {
lib/std/os/test.zig
@@ -172,7 +172,7 @@ export fn iter_fn(info: *dl_phdr_info, size: usize, data: ?*usize) i32 {
var counter = data.?;
// Count how many libraries are loaded
- counter.* += usize(1);
+ counter.* += @as(usize, 1);
// The image should contain at least a PT_LOAD segment
if (info.dlpi_phnum < 1) return -1;
lib/std/os/windows.zig
@@ -801,7 +801,7 @@ pub fn toSysTime(ns: i64) i64 {
}
pub fn fileTimeToNanoSeconds(ft: FILETIME) i64 {
- const hns = @bitCast(i64, (u64(ft.dwHighDateTime) << 32) | ft.dwLowDateTime);
+ const hns = @bitCast(i64, (@as(u64, ft.dwHighDateTime) << 32) | ft.dwLowDateTime);
return fromSysTime(hns);
}
lib/std/os/zen.zig
@@ -138,7 +138,7 @@ pub const Syscall = enum(usize) {
////////////////////
pub fn exit(status: i32) noreturn {
- _ = syscall1(Syscall.exit, @bitCast(usize, isize(status)));
+ _ = syscall1(Syscall.exit, @bitCast(usize, @as(isize, status)));
unreachable;
}
@@ -167,7 +167,7 @@ pub fn map(v_addr: usize, p_addr: usize, size: usize, writable: bool) bool {
}
pub fn createThread(function: fn () void) u16 {
- return u16(syscall1(Syscall.createThread, @ptrToInt(function)));
+ return @as(u16, syscall1(Syscall.createThread, @ptrToInt(function)));
}
/////////////////////////
lib/std/rand/ziggurat.zig
@@ -17,7 +17,7 @@ pub fn next_f64(random: *Random, comptime tables: ZigTable) f64 {
// We manually construct a float from parts as we can avoid an extra random lookup here by
// using the unused exponent for the lookup table entry.
const bits = random.scalar(u64);
- const i = usize(bits & 0xff);
+ const i = @as(usize, bits & 0xff);
const u = blk: {
if (tables.is_symmetric) {
lib/std/special/compiler_rt/addXf3.zig
@@ -19,26 +19,26 @@ pub extern fn __addtf3(a: f128, b: f128) f128 {
}
pub extern fn __subsf3(a: f32, b: f32) f32 {
- const neg_b = @bitCast(f32, @bitCast(u32, b) ^ (u32(1) << 31));
+ const neg_b = @bitCast(f32, @bitCast(u32, b) ^ (@as(u32, 1) << 31));
return addXf3(f32, a, neg_b);
}
pub extern fn __subdf3(a: f64, b: f64) f64 {
- const neg_b = @bitCast(f64, @bitCast(u64, b) ^ (u64(1) << 63));
+ const neg_b = @bitCast(f64, @bitCast(u64, b) ^ (@as(u64, 1) << 63));
return addXf3(f64, a, neg_b);
}
pub extern fn __subtf3(a: f128, b: f128) f128 {
- const neg_b = @bitCast(f128, @bitCast(u128, b) ^ (u128(1) << 127));
+ const neg_b = @bitCast(f128, @bitCast(u128, b) ^ (@as(u128, 1) << 127));
return addXf3(f128, a, neg_b);
}
// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
fn normalize(comptime T: type, significand: *@IntType(false, T.bit_count)) i32 {
const Z = @IntType(false, T.bit_count);
- const S = @IntType(false, T.bit_count - @clz(Z, Z(T.bit_count) - 1));
+ const S = @IntType(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
const significandBits = std.math.floatMantissaBits(T);
- const implicitBit = Z(1) << significandBits;
+ const implicitBit = @as(Z, 1) << significandBits;
const shift = @clz(@IntType(false, T.bit_count), significand.*) - @clz(Z, implicitBit);
significand.* <<= @intCast(S, shift);
@@ -48,17 +48,17 @@ fn normalize(comptime T: type, significand: *@IntType(false, T.bit_count)) i32 {
// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
fn addXf3(comptime T: type, a: T, b: T) T {
const Z = @IntType(false, T.bit_count);
- const S = @IntType(false, T.bit_count - @clz(Z, Z(T.bit_count) - 1));
+ const S = @IntType(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
const typeWidth = T.bit_count;
const significandBits = std.math.floatMantissaBits(T);
const exponentBits = std.math.floatExponentBits(T);
- const signBit = (Z(1) << (significandBits + exponentBits));
+ const signBit = (@as(Z, 1) << (significandBits + exponentBits));
const maxExponent = ((1 << exponentBits) - 1);
const exponentBias = (maxExponent >> 1);
- const implicitBit = (Z(1) << significandBits);
+ const implicitBit = (@as(Z, 1) << significandBits);
const quietBit = implicitBit >> 1;
const significandMask = implicitBit - 1;
@@ -78,8 +78,8 @@ fn addXf3(comptime T: type, a: T, b: T) T {
const infRep = @bitCast(Z, std.math.inf(T));
// Detect if a or b is zero, infinity, or NaN.
- if (aAbs -% Z(1) >= infRep - Z(1) or
- bAbs -% Z(1) >= infRep - Z(1))
+ if (aAbs -% @as(Z, 1) >= infRep - @as(Z, 1) or
+ bAbs -% @as(Z, 1) >= infRep - @as(Z, 1))
{
// NaN + anything = qNaN
if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
@@ -148,7 +148,7 @@ fn addXf3(comptime T: type, a: T, b: T) T {
const @"align" = @intCast(Z, aExponent - bExponent);
if (@"align" != 0) {
if (@"align" < typeWidth) {
- const sticky = if (bSignificand << @intCast(S, typeWidth - @"align") != 0) Z(1) else 0;
+ const sticky = if (bSignificand << @intCast(S, typeWidth - @"align") != 0) @as(Z, 1) else 0;
bSignificand = (bSignificand >> @truncate(S, @"align")) | sticky;
} else {
bSignificand = 1; // sticky; b is known to be non-zero.
@@ -157,7 +157,7 @@ fn addXf3(comptime T: type, a: T, b: T) T {
if (subtraction) {
aSignificand -= bSignificand;
// If a == -b, return +zero.
- if (aSignificand == 0) return @bitCast(T, Z(0));
+ if (aSignificand == 0) return @bitCast(T, @as(Z, 0));
// If partial cancellation occured, we need to left-shift the result
// and adjust the exponent:
@@ -185,7 +185,7 @@ fn addXf3(comptime T: type, a: T, b: T) T {
// Result is denormal before rounding; the exponent is zero and we
// need to shift the significand.
const shift = @intCast(Z, 1 - aExponent);
- const sticky = if (aSignificand << @intCast(S, typeWidth - shift) != 0) Z(1) else 0;
+ const sticky = if (aSignificand << @intCast(S, typeWidth - shift) != 0) @as(Z, 1) else 0;
aSignificand = aSignificand >> @intCast(S, shift | sticky);
aExponent = 0;
}
lib/std/special/compiler_rt/addXf3_test.zig
@@ -3,8 +3,8 @@
// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/addtf3_test.c
// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/subtf3_test.c
-const qnan128 = @bitCast(f128, u128(0x7fff800000000000) << 64);
-const inf128 = @bitCast(f128, u128(0x7fff000000000000) << 64);
+const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
+const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
const __addtf3 = @import("addXf3.zig").__addtf3;
@@ -34,7 +34,7 @@ test "addtf3" {
test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
// NaN + any = NaN
- test__addtf3(@bitCast(f128, (u128(0x7fff000000000000) << 64) | u128(0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+ test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
// inf + inf = inf
test__addtf3(inf128, inf128, 0x7fff000000000000, 0x0);
@@ -75,7 +75,7 @@ test "subtf3" {
test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
// NaN + any = NaN
- test__subtf3(@bitCast(f128, (u128(0x7fff000000000000) << 64) | u128(0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+ test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
// inf - any = inf
test__subtf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
lib/std/special/compiler_rt/comparedf2.zig
@@ -13,19 +13,19 @@ const srep_t = i64;
const typeWidth = rep_t.bit_count;
const significandBits = std.math.floatMantissaBits(fp_t);
const exponentBits = std.math.floatExponentBits(fp_t);
-const signBit = (rep_t(1) << (significandBits + exponentBits));
+const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
const absMask = signBit - 1;
-const implicitBit = rep_t(1) << significandBits;
+const implicitBit = @as(rep_t, 1) << significandBits;
const significandMask = implicitBit - 1;
const exponentMask = absMask ^ significandMask;
const infRep = @bitCast(rep_t, std.math.inf(fp_t));
// TODO https://github.com/ziglang/zig/issues/641
// and then make the return types of some of these functions the enum instead of c_int
-const LE_LESS = c_int(-1);
-const LE_EQUAL = c_int(0);
-const LE_GREATER = c_int(1);
-const LE_UNORDERED = c_int(1);
+const LE_LESS = @as(c_int, -1);
+const LE_EQUAL = @as(c_int, 0);
+const LE_GREATER = @as(c_int, 1);
+const LE_UNORDERED = @as(c_int, 1);
pub extern fn __ledf2(a: fp_t, b: fp_t) c_int {
@setRuntimeSafety(is_test);
@@ -65,10 +65,10 @@ pub extern fn __ledf2(a: fp_t, b: fp_t) c_int {
// TODO https://github.com/ziglang/zig/issues/641
// and then make the return types of some of these functions the enum instead of c_int
-const GE_LESS = c_int(-1);
-const GE_EQUAL = c_int(0);
-const GE_GREATER = c_int(1);
-const GE_UNORDERED = c_int(-1); // Note: different from LE_UNORDERED
+const GE_LESS = @as(c_int, -1);
+const GE_EQUAL = @as(c_int, 0);
+const GE_GREATER = @as(c_int, 1);
+const GE_UNORDERED = @as(c_int, -1); // Note: different from LE_UNORDERED
pub extern fn __gedf2(a: fp_t, b: fp_t) c_int {
@setRuntimeSafety(is_test);
lib/std/special/compiler_rt/comparesf2.zig
@@ -13,19 +13,19 @@ const srep_t = i32;
const typeWidth = rep_t.bit_count;
const significandBits = std.math.floatMantissaBits(fp_t);
const exponentBits = std.math.floatExponentBits(fp_t);
-const signBit = (rep_t(1) << (significandBits + exponentBits));
+const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
const absMask = signBit - 1;
-const implicitBit = rep_t(1) << significandBits;
+const implicitBit = @as(rep_t, 1) << significandBits;
const significandMask = implicitBit - 1;
const exponentMask = absMask ^ significandMask;
const infRep = @bitCast(rep_t, std.math.inf(fp_t));
// TODO https://github.com/ziglang/zig/issues/641
// and then make the return types of some of these functions the enum instead of c_int
-const LE_LESS = c_int(-1);
-const LE_EQUAL = c_int(0);
-const LE_GREATER = c_int(1);
-const LE_UNORDERED = c_int(1);
+const LE_LESS = @as(c_int, -1);
+const LE_EQUAL = @as(c_int, 0);
+const LE_GREATER = @as(c_int, 1);
+const LE_UNORDERED = @as(c_int, 1);
pub extern fn __lesf2(a: fp_t, b: fp_t) c_int {
@setRuntimeSafety(is_test);
@@ -65,10 +65,10 @@ pub extern fn __lesf2(a: fp_t, b: fp_t) c_int {
// TODO https://github.com/ziglang/zig/issues/641
// and then make the return types of some of these functions the enum instead of c_int
-const GE_LESS = c_int(-1);
-const GE_EQUAL = c_int(0);
-const GE_GREATER = c_int(1);
-const GE_UNORDERED = c_int(-1); // Note: different from LE_UNORDERED
+const GE_LESS = @as(c_int, -1);
+const GE_EQUAL = @as(c_int, 0);
+const GE_GREATER = @as(c_int, 1);
+const GE_UNORDERED = @as(c_int, -1); // Note: different from LE_UNORDERED
pub extern fn __gesf2(a: fp_t, b: fp_t) c_int {
@setRuntimeSafety(is_test);
lib/std/special/compiler_rt/comparetf2.zig
@@ -1,9 +1,9 @@
// TODO https://github.com/ziglang/zig/issues/641
// and then make the return types of some of these functions the enum instead of c_int
-const LE_LESS = c_int(-1);
-const LE_EQUAL = c_int(0);
-const LE_GREATER = c_int(1);
-const LE_UNORDERED = c_int(1);
+const LE_LESS = @as(c_int, -1);
+const LE_EQUAL = @as(c_int, 0);
+const LE_GREATER = @as(c_int, 1);
+const LE_UNORDERED = @as(c_int, 1);
const rep_t = u128;
const srep_t = i128;
@@ -11,9 +11,9 @@ const srep_t = i128;
const typeWidth = rep_t.bit_count;
const significandBits = 112;
const exponentBits = (typeWidth - significandBits - 1);
-const signBit = (rep_t(1) << (significandBits + exponentBits));
+const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
const absMask = signBit - 1;
-const implicitBit = rep_t(1) << significandBits;
+const implicitBit = @as(rep_t, 1) << significandBits;
const significandMask = implicitBit - 1;
const exponentMask = absMask ^ significandMask;
const infRep = exponentMask;
@@ -60,10 +60,10 @@ pub extern fn __letf2(a: f128, b: f128) c_int {
// TODO https://github.com/ziglang/zig/issues/641
// and then make the return types of some of these functions the enum instead of c_int
-const GE_LESS = c_int(-1);
-const GE_EQUAL = c_int(0);
-const GE_GREATER = c_int(1);
-const GE_UNORDERED = c_int(-1); // Note: different from LE_UNORDERED
+const GE_LESS = @as(c_int, -1);
+const GE_EQUAL = @as(c_int, 0);
+const GE_GREATER = @as(c_int, 1);
+const GE_UNORDERED = @as(c_int, -1); // Note: different from LE_UNORDERED
pub extern fn __getf2(a: f128, b: f128) c_int {
@setRuntimeSafety(is_test);
lib/std/special/compiler_rt/divdf3.zig
@@ -14,11 +14,11 @@ pub extern fn __divdf3(a: f64, b: f64) f64 {
const significandBits = std.math.floatMantissaBits(f64);
const exponentBits = std.math.floatExponentBits(f64);
- const signBit = (Z(1) << (significandBits + exponentBits));
+ const signBit = (@as(Z, 1) << (significandBits + exponentBits));
const maxExponent = ((1 << exponentBits) - 1);
const exponentBias = (maxExponent >> 1);
- const implicitBit = (Z(1) << significandBits);
+ const implicitBit = (@as(Z, 1) << significandBits);
const quietBit = implicitBit >> 1;
const significandMask = implicitBit - 1;
@@ -91,7 +91,7 @@ pub extern fn __divdf3(a: f64, b: f64) f64 {
// polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This
// is accurate to about 3.5 binary digits.
const q31b: u32 = @truncate(u32, bSignificand >> 21);
- var recip32 = u32(0x7504f333) -% q31b;
+ var recip32 = @as(u32, 0x7504f333) -% q31b;
// Now refine the reciprocal estimate using a Newton-Raphson iteration:
//
@@ -101,12 +101,12 @@ pub extern fn __divdf3(a: f64, b: f64) f64 {
// with each iteration, so after three iterations, we have about 28 binary
// digits of accuracy.
var correction32: u32 = undefined;
- correction32 = @truncate(u32, ~(u64(recip32) *% q31b >> 32) +% 1);
- recip32 = @truncate(u32, u64(recip32) *% correction32 >> 31);
- correction32 = @truncate(u32, ~(u64(recip32) *% q31b >> 32) +% 1);
- recip32 = @truncate(u32, u64(recip32) *% correction32 >> 31);
- correction32 = @truncate(u32, ~(u64(recip32) *% q31b >> 32) +% 1);
- recip32 = @truncate(u32, u64(recip32) *% correction32 >> 31);
+ correction32 = @truncate(u32, ~(@as(u64, recip32) *% q31b >> 32) +% 1);
+ recip32 = @truncate(u32, @as(u64, recip32) *% correction32 >> 31);
+ correction32 = @truncate(u32, ~(@as(u64, recip32) *% q31b >> 32) +% 1);
+ recip32 = @truncate(u32, @as(u64, recip32) *% correction32 >> 31);
+ correction32 = @truncate(u32, ~(@as(u64, recip32) *% q31b >> 32) +% 1);
+ recip32 = @truncate(u32, @as(u64, recip32) *% correction32 >> 31);
// recip32 might have overflowed to exactly zero in the preceding
// computation if the high word of b is exactly 1.0. This would sabotage
@@ -119,10 +119,10 @@ pub extern fn __divdf3(a: f64, b: f64) f64 {
const q63blo: u32 = @truncate(u32, bSignificand << 11);
var correction: u64 = undefined;
var reciprocal: u64 = undefined;
- correction = ~(u64(recip32) *% q31b +% (u64(recip32) *% q63blo >> 32)) +% 1;
+ correction = ~(@as(u64, recip32) *% q31b +% (@as(u64, recip32) *% q63blo >> 32)) +% 1;
const cHi = @truncate(u32, correction >> 32);
const cLo = @truncate(u32, correction);
- reciprocal = u64(recip32) *% cHi +% (u64(recip32) *% cLo >> 32);
+ reciprocal = @as(u64, recip32) *% cHi +% (@as(u64, recip32) *% cLo >> 32);
// We already adjusted the 32-bit estimate, now we need to adjust the final
// 64-bit reciprocal estimate downward to ensure that it is strictly smaller
@@ -195,7 +195,7 @@ pub extern fn __divdf3(a: f64, b: f64) f64 {
// Clear the implicit bit
var absResult = quotient & significandMask;
// Insert the exponent
- absResult |= @bitCast(Z, SignedZ(writtenExponent)) << significandBits;
+ absResult |= @bitCast(Z, @as(SignedZ, writtenExponent)) << significandBits;
// Round
absResult +%= round;
// Insert the sign and return
@@ -208,7 +208,7 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
switch (Z) {
u32 => {
// 32x32 --> 64 bit multiply
- const product = u64(a) * u64(b);
+ const product = @as(u64, a) * @as(u64, b);
hi.* = @truncate(u32, product >> 32);
lo.* = @truncate(u32, product);
},
@@ -237,9 +237,9 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi;
},
u128 => {
- const Word_LoMask = u64(0x00000000ffffffff);
- const Word_HiMask = u64(0xffffffff00000000);
- const Word_FullMask = u64(0xffffffffffffffff);
+ const Word_LoMask = @as(u64, 0x00000000ffffffff);
+ const Word_HiMask = @as(u64, 0xffffffff00000000);
+ const Word_FullMask = @as(u64, 0xffffffffffffffff);
const S = struct {
fn Word_1(x: u128) u64 {
return @truncate(u32, x >> 96);
@@ -275,22 +275,22 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
const product43: u64 = S.Word_4(a) * S.Word_3(b);
const product44: u64 = S.Word_4(a) * S.Word_4(b);
- const sum0: u128 = u128(product44);
- const sum1: u128 = u128(product34) +%
- u128(product43);
- const sum2: u128 = u128(product24) +%
- u128(product33) +%
- u128(product42);
- const sum3: u128 = u128(product14) +%
- u128(product23) +%
- u128(product32) +%
- u128(product41);
- const sum4: u128 = u128(product13) +%
- u128(product22) +%
- u128(product31);
- const sum5: u128 = u128(product12) +%
- u128(product21);
- const sum6: u128 = u128(product11);
+ const sum0: u128 = @as(u128, product44);
+ const sum1: u128 = @as(u128, product34) +%
+ @as(u128, product43);
+ const sum2: u128 = @as(u128, product24) +%
+ @as(u128, product33) +%
+ @as(u128, product42);
+ const sum3: u128 = @as(u128, product14) +%
+ @as(u128, product23) +%
+ @as(u128, product32) +%
+ @as(u128, product41);
+ const sum4: u128 = @as(u128, product13) +%
+ @as(u128, product22) +%
+ @as(u128, product31);
+ const sum5: u128 = @as(u128, product12) +%
+ @as(u128, product21);
+ const sum6: u128 = @as(u128, product11);
const r0: u128 = (sum0 & Word_FullMask) +%
((sum1 & Word_LoMask) << 32);
@@ -316,7 +316,7 @@ fn normalize(comptime T: type, significand: *@IntType(false, T.bit_count)) i32 {
@setRuntimeSafety(builtin.is_test);
const Z = @IntType(false, T.bit_count);
const significandBits = std.math.floatMantissaBits(T);
- const implicitBit = Z(1) << significandBits;
+ const implicitBit = @as(Z, 1) << significandBits;
const shift = @clz(Z, significand.*) - @clz(Z, implicitBit);
significand.* <<= @intCast(std.math.Log2Int(Z), shift);
lib/std/special/compiler_rt/divsf3.zig
@@ -13,11 +13,11 @@ pub extern fn __divsf3(a: f32, b: f32) f32 {
const significandBits = std.math.floatMantissaBits(f32);
const exponentBits = std.math.floatExponentBits(f32);
- const signBit = (Z(1) << (significandBits + exponentBits));
+ const signBit = (@as(Z, 1) << (significandBits + exponentBits));
const maxExponent = ((1 << exponentBits) - 1);
const exponentBias = (maxExponent >> 1);
- const implicitBit = (Z(1) << significandBits);
+ const implicitBit = (@as(Z, 1) << significandBits);
const quietBit = implicitBit >> 1;
const significandMask = implicitBit - 1;
@@ -90,7 +90,7 @@ pub extern fn __divsf3(a: f32, b: f32) f32 {
// polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2. This
// is accurate to about 3.5 binary digits.
const q31b = bSignificand << 8;
- var reciprocal = u32(0x7504f333) -% q31b;
+ var reciprocal = @as(u32, 0x7504f333) -% q31b;
// Now refine the reciprocal estimate using a Newton-Raphson iteration:
//
@@ -100,12 +100,12 @@ pub extern fn __divsf3(a: f32, b: f32) f32 {
// with each iteration, so after three iterations, we have about 28 binary
// digits of accuracy.
var correction: u32 = undefined;
- correction = @truncate(u32, ~(u64(reciprocal) *% q31b >> 32) +% 1);
- reciprocal = @truncate(u32, u64(reciprocal) *% correction >> 31);
- correction = @truncate(u32, ~(u64(reciprocal) *% q31b >> 32) +% 1);
- reciprocal = @truncate(u32, u64(reciprocal) *% correction >> 31);
- correction = @truncate(u32, ~(u64(reciprocal) *% q31b >> 32) +% 1);
- reciprocal = @truncate(u32, u64(reciprocal) *% correction >> 31);
+ correction = @truncate(u32, ~(@as(u64, reciprocal) *% q31b >> 32) +% 1);
+ reciprocal = @truncate(u32, @as(u64, reciprocal) *% correction >> 31);
+ correction = @truncate(u32, ~(@as(u64, reciprocal) *% q31b >> 32) +% 1);
+ reciprocal = @truncate(u32, @as(u64, reciprocal) *% correction >> 31);
+ correction = @truncate(u32, ~(@as(u64, reciprocal) *% q31b >> 32) +% 1);
+ reciprocal = @truncate(u32, @as(u64, reciprocal) *% correction >> 31);
// Exhaustive testing shows that the error in reciprocal after three steps
// is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our
@@ -127,7 +127,7 @@ pub extern fn __divsf3(a: f32, b: f32) f32 {
// is the error in the reciprocal of b scaled by the maximum
// possible value of a. As a consequence of this error bound,
// either q or nextafter(q) is the correctly rounded
- var quotient: Z = @truncate(u32, u64(reciprocal) *% (aSignificand << 1) >> 32);
+ var quotient: Z = @truncate(u32, @as(u64, reciprocal) *% (aSignificand << 1) >> 32);
// Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).
// In either case, we are going to compute a residual of the form
@@ -189,7 +189,7 @@ fn normalize(comptime T: type, significand: *@IntType(false, T.bit_count)) i32 {
@setRuntimeSafety(builtin.is_test);
const Z = @IntType(false, T.bit_count);
const significandBits = std.math.floatMantissaBits(T);
- const implicitBit = Z(1) << significandBits;
+ const implicitBit = @as(Z, 1) << significandBits;
const shift = @clz(Z, significand.*) - @clz(Z, implicitBit);
significand.* <<= @intCast(std.math.Log2Int(Z), shift);
lib/std/special/compiler_rt/divti3_test.zig
@@ -14,8 +14,8 @@ test "divti3" {
test__divti3(-2, 1, -2);
test__divti3(-2, -1, 2);
- test__divti3(@bitCast(i128, u128(0x8 << 124)), 1, @bitCast(i128, u128(0x8 << 124)));
- test__divti3(@bitCast(i128, u128(0x8 << 124)), -1, @bitCast(i128, u128(0x8 << 124)));
- test__divti3(@bitCast(i128, u128(0x8 << 124)), -2, @bitCast(i128, u128(0x4 << 124)));
- test__divti3(@bitCast(i128, u128(0x8 << 124)), 2, @bitCast(i128, u128(0xc << 124)));
+ test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 1, @bitCast(i128, @as(u128, 0x8 << 124)));
+ test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -1, @bitCast(i128, @as(u128, 0x8 << 124)));
+ test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), -2, @bitCast(i128, @as(u128, 0x4 << 124)));
+ test__divti3(@bitCast(i128, @as(u128, 0x8 << 124)), 2, @bitCast(i128, @as(u128, 0xc << 124)));
}
lib/std/special/compiler_rt/extendXfYf2.zig
@@ -49,7 +49,7 @@ fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: @IntType(false, @t
const dstInfExp = (1 << dstExpBits) - 1;
const dstExpBias = dstInfExp >> 1;
- const dstMinNormal: dst_rep_t = dst_rep_t(1) << dstSigBits;
+ const dstMinNormal: dst_rep_t = @as(dst_rep_t, 1) << dstSigBits;
// Break a into a sign and representation of the absolute value
const aRep: src_rep_t = @bitCast(src_rep_t, a);
@@ -61,7 +61,7 @@ fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: @IntType(false, @t
// a is a normal number.
// Extend to the destination type by shifting the significand and
// exponent into the proper position and rebiasing the exponent.
- absResult = dst_rep_t(aAbs) << (dstSigBits - srcSigBits);
+ absResult = @as(dst_rep_t, aAbs) << (dstSigBits - srcSigBits);
absResult += (dstExpBias - srcExpBias) << dstSigBits;
} else if (aAbs >= srcInfinity) {
// a is NaN or infinity.
@@ -69,15 +69,15 @@ fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: @IntType(false, @t
// bit (if needed) and right-aligning the rest of the trailing NaN
// payload field.
absResult = dstInfExp << dstSigBits;
- absResult |= dst_rep_t(aAbs & srcQNaN) << (dstSigBits - srcSigBits);
- absResult |= dst_rep_t(aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
+ absResult |= @as(dst_rep_t, aAbs & srcQNaN) << (dstSigBits - srcSigBits);
+ absResult |= @as(dst_rep_t, aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
} else if (aAbs != 0) {
// a is denormal.
// renormalize the significand and clear the leading bit, then insert
// the correct adjusted exponent in the destination type.
const scale: u32 = @clz(src_rep_t, aAbs) -
- @clz(src_rep_t, src_rep_t(srcMinNormal));
- absResult = dst_rep_t(aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
+ @clz(src_rep_t, @as(src_rep_t, srcMinNormal));
+ absResult = @as(dst_rep_t, aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
absResult ^= dstMinNormal;
const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;
absResult |= @intCast(dst_rep_t, resultExponent) << dstSigBits;
@@ -87,7 +87,7 @@ fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: @IntType(false, @t
}
// Apply the signbit to (dst_t)abs(a).
- const result: dst_rep_t align(@alignOf(dst_t)) = absResult | dst_rep_t(sign) << (dstBits - srcBits);
+ const result: dst_rep_t align(@alignOf(dst_t)) = absResult | @as(dst_rep_t, sign) << (dstBits - srcBits);
return @bitCast(dst_t, result);
}
lib/std/special/compiler_rt/extendXfYf2_test.zig
@@ -134,11 +134,11 @@ test "extendsftf2" {
}
fn makeQNaN64() f64 {
- return @bitCast(f64, u64(0x7ff8000000000000));
+ return @bitCast(f64, @as(u64, 0x7ff8000000000000));
}
fn makeInf64() f64 {
- return @bitCast(f64, u64(0x7ff0000000000000));
+ return @bitCast(f64, @as(u64, 0x7ff0000000000000));
}
fn makeNaN64(rand: u64) f64 {
@@ -146,7 +146,7 @@ fn makeNaN64(rand: u64) f64 {
}
fn makeQNaN32() f32 {
- return @bitCast(f32, u32(0x7fc00000));
+ return @bitCast(f32, @as(u32, 0x7fc00000));
}
fn makeNaN32(rand: u32) f32 {
@@ -154,5 +154,5 @@ fn makeNaN32(rand: u32) f32 {
}
fn makeInf32() f32 {
- return @bitCast(f32, u32(0x7f800000));
+ return @bitCast(f32, @as(u32, 0x7f800000));
}
lib/std/special/compiler_rt/fixdfdi_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixdfdi(a: f64, expected: i64) void {
const x = __fixdfdi(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u64({x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u64, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixdfsi_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixdfsi(a: f64, expected: i32) void {
const x = __fixdfsi(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u64({x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u32, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixdfti_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixdfti(a: f64, expected: i128) void {
const x = __fixdfti(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u64({x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u64, a), x, x, expected, expected, @bitCast(u128, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixint.zig
@@ -25,11 +25,11 @@ pub fn fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t) fixint_t {
const typeWidth = rep_t.bit_count;
const exponentBits = (typeWidth - significandBits - 1);
- const signBit = (rep_t(1) << (significandBits + exponentBits));
+ const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
const maxExponent = ((1 << exponentBits) - 1);
const exponentBias = (maxExponent >> 1);
- const implicitBit = (rep_t(1) << significandBits);
+ const implicitBit = (@as(rep_t, 1) << significandBits);
const significandMask = (implicitBit - 1);
// Break a into sign, exponent, significand
@@ -51,7 +51,7 @@ pub fn fixint(comptime fp_t: type, comptime fixint_t: type, a: fp_t) fixint_t {
// If the value is too large for the integer type, saturate.
if (@intCast(usize, exponent) >= fixint_t.bit_count) {
- return if (negative) fixint_t(minInt(fixint_t)) else fixint_t(maxInt(fixint_t));
+ return if (negative) @as(fixint_t, minInt(fixint_t)) else @as(fixint_t, maxInt(fixint_t));
}
// If 0 <= exponent < significandBits, right shift else left shift
lib/std/special/compiler_rt/fixint_test.zig
@@ -81,8 +81,8 @@ test "fixint.i3" {
test "fixint.i32" {
test__fixint(f64, i32, -math.inf_f64, math.minInt(i32));
test__fixint(f64, i32, -math.f64_max, math.minInt(i32));
- test__fixint(f64, i32, f64(math.minInt(i32)), math.minInt(i32));
- test__fixint(f64, i32, f64(math.minInt(i32)) + 1, math.minInt(i32) + 1);
+ test__fixint(f64, i32, @as(f64, math.minInt(i32)), math.minInt(i32));
+ test__fixint(f64, i32, @as(f64, math.minInt(i32)) + 1, math.minInt(i32) + 1);
test__fixint(f64, i32, -2.0, -2);
test__fixint(f64, i32, -1.9, -1);
test__fixint(f64, i32, -1.1, -1);
@@ -96,8 +96,8 @@ test "fixint.i32" {
test__fixint(f64, i32, 0.1, 0);
test__fixint(f64, i32, 0.9, 0);
test__fixint(f64, i32, 1.0, 1);
- test__fixint(f64, i32, f64(math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
- test__fixint(f64, i32, f64(math.maxInt(i32)), math.maxInt(i32));
+ test__fixint(f64, i32, @as(f64, math.maxInt(i32)) - 1, math.maxInt(i32) - 1);
+ test__fixint(f64, i32, @as(f64, math.maxInt(i32)), math.maxInt(i32));
test__fixint(f64, i32, math.f64_max, math.maxInt(i32));
test__fixint(f64, i32, math.inf_f64, math.maxInt(i32));
}
@@ -105,9 +105,9 @@ test "fixint.i32" {
test "fixint.i64" {
test__fixint(f64, i64, -math.inf_f64, math.minInt(i64));
test__fixint(f64, i64, -math.f64_max, math.minInt(i64));
- test__fixint(f64, i64, f64(math.minInt(i64)), math.minInt(i64));
- test__fixint(f64, i64, f64(math.minInt(i64)) + 1, math.minInt(i64));
- test__fixint(f64, i64, f64(math.minInt(i64) / 2), math.minInt(i64) / 2);
+ test__fixint(f64, i64, @as(f64, math.minInt(i64)), math.minInt(i64));
+ test__fixint(f64, i64, @as(f64, math.minInt(i64)) + 1, math.minInt(i64));
+ test__fixint(f64, i64, @as(f64, math.minInt(i64) / 2), math.minInt(i64) / 2);
test__fixint(f64, i64, -2.0, -2);
test__fixint(f64, i64, -1.9, -1);
test__fixint(f64, i64, -1.1, -1);
@@ -121,8 +121,8 @@ test "fixint.i64" {
test__fixint(f64, i64, 0.1, 0);
test__fixint(f64, i64, 0.9, 0);
test__fixint(f64, i64, 1.0, 1);
- test__fixint(f64, i64, f64(math.maxInt(i64)) - 1, math.maxInt(i64));
- test__fixint(f64, i64, f64(math.maxInt(i64)), math.maxInt(i64));
+ test__fixint(f64, i64, @as(f64, math.maxInt(i64)) - 1, math.maxInt(i64));
+ test__fixint(f64, i64, @as(f64, math.maxInt(i64)), math.maxInt(i64));
test__fixint(f64, i64, math.f64_max, math.maxInt(i64));
test__fixint(f64, i64, math.inf_f64, math.maxInt(i64));
}
@@ -130,8 +130,8 @@ test "fixint.i64" {
test "fixint.i128" {
test__fixint(f64, i128, -math.inf_f64, math.minInt(i128));
test__fixint(f64, i128, -math.f64_max, math.minInt(i128));
- test__fixint(f64, i128, f64(math.minInt(i128)), math.minInt(i128));
- test__fixint(f64, i128, f64(math.minInt(i128)) + 1, math.minInt(i128));
+ test__fixint(f64, i128, @as(f64, math.minInt(i128)), math.minInt(i128));
+ test__fixint(f64, i128, @as(f64, math.minInt(i128)) + 1, math.minInt(i128));
test__fixint(f64, i128, -2.0, -2);
test__fixint(f64, i128, -1.9, -1);
test__fixint(f64, i128, -1.1, -1);
@@ -145,8 +145,8 @@ test "fixint.i128" {
test__fixint(f64, i128, 0.1, 0);
test__fixint(f64, i128, 0.9, 0);
test__fixint(f64, i128, 1.0, 1);
- test__fixint(f64, i128, f64(math.maxInt(i128)) - 1, math.maxInt(i128));
- test__fixint(f64, i128, f64(math.maxInt(i128)), math.maxInt(i128));
+ test__fixint(f64, i128, @as(f64, math.maxInt(i128)) - 1, math.maxInt(i128));
+ test__fixint(f64, i128, @as(f64, math.maxInt(i128)), math.maxInt(i128));
test__fixint(f64, i128, math.f64_max, math.maxInt(i128));
test__fixint(f64, i128, math.inf_f64, math.maxInt(i128));
}
lib/std/special/compiler_rt/fixsfdi_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixsfdi(a: f32, expected: i64) void {
const x = __fixsfdi(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u32({x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u64, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixsfsi_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixsfsi(a: f32, expected: i32) void {
const x = __fixsfsi(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u32({x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u32, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixsfti_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixsfti(a: f32, expected: i128) void {
const x = __fixsfti(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u128({x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", a, @bitCast(u32, a), x, x, expected, expected, @bitCast(u128, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixtfdi_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixtfdi(a: f128, expected: i64) void {
const x = __fixtfdi(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u64({x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u64, {x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u64, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixtfsi_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixtfsi(a: f128, expected: i32) void {
const x = __fixtfsi(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u32({x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u32, {x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u32, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixtfti_test.zig
@@ -6,7 +6,7 @@ const warn = std.debug.warn;
fn test__fixtfti(a: f128, expected: i128) void {
const x = __fixtfti(a);
- //warn("a={}:{x} x={}:{x} expected={}:{x}:u128({x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected));
+ //warn("a={}:{x} x={}:{x} expected={}:{x}:@as(u128, {x})\n", a, @bitCast(u128, a), x, x, expected, expected, @bitCast(u128, expected));
testing.expect(x == expected);
}
lib/std/special/compiler_rt/fixuint.zig
@@ -19,11 +19,11 @@ pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t
};
const typeWidth = rep_t.bit_count;
const exponentBits = (typeWidth - significandBits - 1);
- const signBit = (rep_t(1) << (significandBits + exponentBits));
+ const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
const maxExponent = ((1 << exponentBits) - 1);
const exponentBias = (maxExponent >> 1);
- const implicitBit = (rep_t(1) << significandBits);
+ const implicitBit = (@as(rep_t, 1) << significandBits);
const significandMask = (implicitBit - 1);
// Break a into sign, exponent, significand
@@ -31,7 +31,7 @@ pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t
const absMask = signBit - 1;
const aAbs: rep_t = aRep & absMask;
- const sign = if ((aRep & signBit) != 0) i32(-1) else i32(1);
+ const sign = if ((aRep & signBit) != 0) @as(i32, -1) else @as(i32, 1);
const exponent = @intCast(i32, aAbs >> significandBits) - exponentBias;
const significand: rep_t = (aAbs & significandMask) | implicitBit;
@@ -39,7 +39,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 ~fixuint_t(0);
+ if (@intCast(c_uint, exponent) >= fixuint_t.bit_count) return ~@as(fixuint_t, 0);
// If 0 <= exponent < significandBits, right shift to get the result.
// Otherwise, shift left.
lib/std/special/compiler_rt/fixunstfsi_test.zig
@@ -6,7 +6,7 @@ fn test__fixunstfsi(a: f128, expected: u32) void {
testing.expect(x == expected);
}
-const inf128 = @bitCast(f128, u128(0x7fff0000000000000000000000000000));
+const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
test "fixunstfsi" {
test__fixunstfsi(inf128, 0xffffffff);
lib/std/special/compiler_rt/fixunstfti_test.zig
@@ -6,7 +6,7 @@ fn test__fixunstfti(a: f128, expected: u128) void {
testing.expect(x == expected);
}
-const inf128 = @bitCast(f128, u128(0x7fff0000000000000000000000000000));
+const inf128 = @bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000));
test "fixunstfti" {
test__fixunstfti(inf128, 0xffffffffffffffffffffffffffffffff);
lib/std/special/compiler_rt/floatsiXf.zig
@@ -6,24 +6,24 @@ fn floatsiXf(comptime T: type, a: i32) T {
@setRuntimeSafety(builtin.is_test);
const Z = @IntType(false, T.bit_count);
- const S = @IntType(false, T.bit_count - @clz(Z, Z(T.bit_count) - 1));
+ const S = @IntType(false, T.bit_count - @clz(Z, @as(Z, T.bit_count) - 1));
if (a == 0) {
- return T(0.0);
+ return @as(T, 0.0);
}
const significandBits = std.math.floatMantissaBits(T);
const exponentBits = std.math.floatExponentBits(T);
const exponentBias = ((1 << exponentBits - 1) - 1);
- const implicitBit = Z(1) << significandBits;
- const signBit = Z(1 << Z.bit_count - 1);
+ const implicitBit = @as(Z, 1) << significandBits;
+ const signBit = @as(Z, 1 << Z.bit_count - 1);
const sign = a >> 31;
// Take absolute value of a via abs(x) = (x^(x >> 31)) - (x >> 31).
const abs_a = (a ^ sign) -% sign;
// The exponent is the width of abs(a)
- const exp = Z(31 - @clz(i32, abs_a));
+ const exp = @as(Z, 31 - @clz(i32, abs_a));
const sign_bit = if (sign < 0) signBit else 0;
lib/std/special/compiler_rt/floattidf.zig
@@ -47,7 +47,7 @@ pub extern fn __floattidf(arg: i128) f64 {
a += 1; // round - this step may add a significant bit
a >>= 2; // dump Q and R
// a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits
- if ((a & (u128(1) << DBL_MANT_DIG)) != 0) {
+ if ((a & (@as(u128, 1) << DBL_MANT_DIG)) != 0) {
a >>= 1;
e += 1;
}
lib/std/special/compiler_rt/floattisf.zig
@@ -48,7 +48,7 @@ pub extern fn __floattisf(arg: i128) f32 {
a += 1; // round - this step may add a significant bit
a >>= 2; // dump Q and R
// a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits
- if ((a & (u128(1) << FLT_MANT_DIG)) != 0) {
+ if ((a & (@as(u128, 1) << FLT_MANT_DIG)) != 0) {
a >>= 1;
e += 1;
}
lib/std/special/compiler_rt/floattitf.zig
@@ -47,7 +47,7 @@ pub extern fn __floattitf(arg: i128) f128 {
a += 1; // round - this step may add a significant bit
a >>= 2; // dump Q and R
// a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits
- if ((a & (u128(1) << LDBL_MANT_DIG)) != 0) {
+ if ((a & (@as(u128, 1) << LDBL_MANT_DIG)) != 0) {
a >>= 1;
e += 1;
}
lib/std/special/compiler_rt/floatunsidf.zig
@@ -2,7 +2,7 @@ const builtin = @import("builtin");
const std = @import("std");
const maxInt = std.math.maxInt;
-const implicitBit = u64(1) << 52;
+const implicitBit = @as(u64, 1) << 52;
pub extern fn __floatunsidf(arg: u32) f64 {
@setRuntimeSafety(builtin.is_test);
@@ -10,10 +10,10 @@ pub extern fn __floatunsidf(arg: u32) f64 {
if (arg == 0) return 0.0;
// The exponent is the width of abs(a)
- const exp = u64(31) - @clz(u32, arg);
+ const exp = @as(u64, 31) - @clz(u32, arg);
// Shift a into the significand field and clear the implicit bit
const shift = @intCast(u6, 52 - exp);
- const mant = u64(arg) << shift ^ implicitBit;
+ const mant = @as(u64, arg) << shift ^ implicitBit;
return @bitCast(f64, mant | (exp + 1023) << 52);
}
lib/std/special/compiler_rt/floatuntidf.zig
@@ -32,7 +32,7 @@ pub extern fn __floatuntidf(arg: u128) f64 {
const shift_amt = @bitCast(i32, N + (DBL_MANT_DIG + 2)) - sd;
const shift_amt_u7 = @intCast(u7, shift_amt);
a = (a >> @intCast(u7, sd - (DBL_MANT_DIG + 2))) |
- @boolToInt((a & (u128(maxInt(u128)) >> shift_amt_u7)) != 0);
+ @boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0);
},
}
// finish
@@ -40,7 +40,7 @@ pub extern fn __floatuntidf(arg: u128) f64 {
a += 1; // round - this step may add a significant bit
a >>= 2; // dump Q and R
// a is now rounded to DBL_MANT_DIG or DBL_MANT_DIG+1 bits
- if ((a & (u128(1) << DBL_MANT_DIG)) != 0) {
+ if ((a & (@as(u128, 1) << DBL_MANT_DIG)) != 0) {
a >>= 1;
e += 1;
}
lib/std/special/compiler_rt/floatuntisf.zig
@@ -32,7 +32,7 @@ pub extern fn __floatuntisf(arg: u128) f32 {
const shift_amt = @bitCast(i32, N + (FLT_MANT_DIG + 2)) - sd;
const shift_amt_u7 = @intCast(u7, shift_amt);
a = (a >> @intCast(u7, sd - (FLT_MANT_DIG + 2))) |
- @boolToInt((a & (u128(maxInt(u128)) >> shift_amt_u7)) != 0);
+ @boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0);
},
}
// finish
@@ -40,7 +40,7 @@ pub extern fn __floatuntisf(arg: u128) f32 {
a += 1; // round - this step may add a significant bit
a >>= 2; // dump Q and R
// a is now rounded to FLT_MANT_DIG or FLT_MANT_DIG+1 bits
- if ((a & (u128(1) << FLT_MANT_DIG)) != 0) {
+ if ((a & (@as(u128, 1) << FLT_MANT_DIG)) != 0) {
a >>= 1;
e += 1;
}
lib/std/special/compiler_rt/floatuntitf.zig
@@ -32,7 +32,7 @@ pub extern fn __floatuntitf(arg: u128) f128 {
const shift_amt = @bitCast(i32, N + (LDBL_MANT_DIG + 2)) - sd;
const shift_amt_u7 = @intCast(u7, shift_amt);
a = (a >> @intCast(u7, sd - (LDBL_MANT_DIG + 2))) |
- @boolToInt((a & (u128(maxInt(u128)) >> shift_amt_u7)) != 0);
+ @boolToInt((a & (@as(u128, maxInt(u128)) >> shift_amt_u7)) != 0);
},
}
// finish
@@ -40,7 +40,7 @@ pub extern fn __floatuntitf(arg: u128) f128 {
a += 1; // round - this step may add a significant bit
a >>= 2; // dump Q and R
// a is now rounded to LDBL_MANT_DIG or LDBL_MANT_DIG+1 bits
- if ((a & (u128(1) << LDBL_MANT_DIG)) != 0) {
+ if ((a & (@as(u128, 1) << LDBL_MANT_DIG)) != 0) {
a >>= 1;
e += 1;
}
lib/std/special/compiler_rt/muldi3.zig
@@ -21,7 +21,7 @@ fn __muldsi3(a: u32, b: u32) i64 {
@setRuntimeSafety(builtin.is_test);
const bits_in_word_2 = @sizeOf(i32) * 8 / 2;
- const lower_mask = (~u32(0)) >> bits_in_word_2;
+ const lower_mask = (~@as(u32, 0)) >> bits_in_word_2;
var r: dwords = undefined;
r.s.low = (a & lower_mask) *% (b & lower_mask);
lib/std/special/compiler_rt/mulodi4.zig
@@ -6,7 +6,7 @@ const minInt = std.math.minInt;
pub extern fn __mulodi4(a: i64, b: i64, overflow: *c_int) i64 {
@setRuntimeSafety(builtin.is_test);
- const min = @bitCast(i64, u64(1 << (i64.bit_count - 1)));
+ const min = @bitCast(i64, @as(u64, 1 << (i64.bit_count - 1)));
const max = ~min;
overflow.* = 0;
lib/std/special/compiler_rt/mulodi4_test.zig
@@ -52,34 +52,34 @@ test "mulodi4" {
test__mulodi4(0x7FFFFFFFFFFFFFFF, -2, 2, 1);
test__mulodi4(-2, 0x7FFFFFFFFFFFFFFF, 2, 1);
- test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, u64(0x8000000000000001)), 0);
- test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, u64(0x8000000000000001)), 0);
+ test__mulodi4(0x7FFFFFFFFFFFFFFF, -1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
+ test__mulodi4(-1, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
test__mulodi4(0x7FFFFFFFFFFFFFFF, 0, 0, 0);
test__mulodi4(0, 0x7FFFFFFFFFFFFFFF, 0, 0);
test__mulodi4(0x7FFFFFFFFFFFFFFF, 1, 0x7FFFFFFFFFFFFFFF, 0);
test__mulodi4(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFF, 0);
- test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, u64(0x8000000000000001)), 1);
- test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, u64(0x8000000000000001)), 1);
+ test__mulodi4(0x7FFFFFFFFFFFFFFF, 2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
+ test__mulodi4(2, 0x7FFFFFFFFFFFFFFF, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000000)), -2, @bitCast(i64, u64(0x8000000000000000)), 1);
- test__mulodi4(-2, @bitCast(i64, u64(0x8000000000000000)), @bitCast(i64, u64(0x8000000000000000)), 1);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000000)), -1, @bitCast(i64, u64(0x8000000000000000)), 1);
- test__mulodi4(-1, @bitCast(i64, u64(0x8000000000000000)), @bitCast(i64, u64(0x8000000000000000)), 1);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000000)), 0, 0, 0);
- test__mulodi4(0, @bitCast(i64, u64(0x8000000000000000)), 0, 0);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000000)), 1, @bitCast(i64, u64(0x8000000000000000)), 0);
- test__mulodi4(1, @bitCast(i64, u64(0x8000000000000000)), @bitCast(i64, u64(0x8000000000000000)), 0);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000000)), 2, @bitCast(i64, u64(0x8000000000000000)), 1);
- test__mulodi4(2, @bitCast(i64, u64(0x8000000000000000)), @bitCast(i64, u64(0x8000000000000000)), 1);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
+ test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
+ test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0, 0);
+ test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000000)), 0, 0);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
+ test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 0);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
+ test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000000)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000001)), -2, @bitCast(i64, u64(0x8000000000000001)), 1);
- test__mulodi4(-2, @bitCast(i64, u64(0x8000000000000001)), @bitCast(i64, u64(0x8000000000000001)), 1);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0);
- test__mulodi4(-1, @bitCast(i64, u64(0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000001)), 0, 0, 0);
- test__mulodi4(0, @bitCast(i64, u64(0x8000000000000001)), 0, 0);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000001)), 1, @bitCast(i64, u64(0x8000000000000001)), 0);
- test__mulodi4(1, @bitCast(i64, u64(0x8000000000000001)), @bitCast(i64, u64(0x8000000000000001)), 0);
- test__mulodi4(@bitCast(i64, u64(0x8000000000000001)), 2, @bitCast(i64, u64(0x8000000000000000)), 1);
- test__mulodi4(2, @bitCast(i64, u64(0x8000000000000001)), @bitCast(i64, u64(0x8000000000000000)), 1);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -2, @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
+ test__mulodi4(-2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 1);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), -1, 0x7FFFFFFFFFFFFFFF, 0);
+ test__mulodi4(-1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0x7FFFFFFFFFFFFFFF, 0);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0, 0);
+ test__mulodi4(0, @bitCast(i64, @as(u64, 0x8000000000000001)), 0, 0);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 1, @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
+ test__mulodi4(1, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000001)), 0);
+ test__mulodi4(@bitCast(i64, @as(u64, 0x8000000000000001)), 2, @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
+ test__mulodi4(2, @bitCast(i64, @as(u64, 0x8000000000000001)), @bitCast(i64, @as(u64, 0x8000000000000000)), 1);
}
lib/std/special/compiler_rt/muloti4.zig
@@ -4,7 +4,7 @@ const compiler_rt = @import("../compiler_rt.zig");
pub extern fn __muloti4(a: i128, b: i128, overflow: *c_int) i128 {
@setRuntimeSafety(builtin.is_test);
- const min = @bitCast(i128, u128(1 << (i128.bit_count - 1)));
+ const min = @bitCast(i128, @as(u128, 1 << (i128.bit_count - 1)));
const max = ~min;
overflow.* = 0;
lib/std/special/compiler_rt/muloti4_test.zig
@@ -39,38 +39,38 @@ test "muloti4" {
test__muloti4(2097152, -4398046511103, -9223372036852678656, 0);
test__muloti4(-2097152, -4398046511103, 9223372036852678656, 0);
- test__muloti4(@bitCast(i128, u128(0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, u128(0x000000000000000000B504F333F9DE5B)), @bitCast(i128, u128(0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);
- test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
- test__muloti4(-2, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x00000000000000B504F333F9DE5BE000)), @bitCast(i128, @as(u128, 0x000000000000000000B504F333F9DE5B)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFF328DF915DA296E8A000)), 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
+ test__muloti4(-2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
- test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
- test__muloti4(-1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
- test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);
- test__muloti4(0, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);
- test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
- test__muloti4(1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
- test__muloti4(@bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
- test__muloti4(2, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
+ test__muloti4(-1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0, 0);
+ test__muloti4(0, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0, 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
+ test__muloti4(1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
+ test__muloti4(2, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), -2, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
- test__muloti4(-2, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), -1, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
- test__muloti4(-1, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), 0, 0, 0);
- test__muloti4(0, @bitCast(i128, u128(0x80000000000000000000000000000000)), 0, 0);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), 1, @bitCast(i128, u128(0x80000000000000000000000000000000)), 0);
- test__muloti4(1, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 0);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000000)), 2, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
- test__muloti4(2, @bitCast(i128, u128(0x80000000000000000000000000000000)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
+ test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), -1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
+ test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0, 0);
+ test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0, 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
+ test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
+ test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), -2, @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
- test__muloti4(-2, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 1);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), -1, @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
- test__muloti4(-1, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), 0, 0, 0);
- test__muloti4(0, @bitCast(i128, u128(0x80000000000000000000000000000001)), 0, 0);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), 1, @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
- test__muloti4(1, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x80000000000000000000000000000001)), 0);
- test__muloti4(@bitCast(i128, u128(0x80000000000000000000000000000001)), 2, @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
- test__muloti4(2, @bitCast(i128, u128(0x80000000000000000000000000000001)), @bitCast(i128, u128(0x80000000000000000000000000000000)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
+ test__muloti4(-2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), -1, @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
+ test__muloti4(-1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)), 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0, 0);
+ test__muloti4(0, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0, 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
+ test__muloti4(1, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 0);
+ test__muloti4(@bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), 2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
+ test__muloti4(2, @bitCast(i128, @as(u128, 0x80000000000000000000000000000001)), @bitCast(i128, @as(u128, 0x80000000000000000000000000000000)), 1);
}
lib/std/special/compiler_rt/multi3.zig
@@ -21,7 +21,7 @@ pub extern fn __multi3_windows_x86_64(a: v128, b: v128) v128 {
fn __mulddi3(a: u64, b: u64) i128 {
const bits_in_dword_2 = (@sizeOf(i64) * 8) / 2;
- const lower_mask = ~u64(0) >> bits_in_dword_2;
+ const lower_mask = ~@as(u64, 0) >> bits_in_dword_2;
var r: twords = undefined;
r.s.low = (a & lower_mask) *% (b & lower_mask);
var t: u64 = r.s.low >> bits_in_dword_2;
lib/std/special/compiler_rt/mulXf3.zig
@@ -24,11 +24,11 @@ fn mulXf3(comptime T: type, a: T, b: T) T {
const significandBits = std.math.floatMantissaBits(T);
const exponentBits = std.math.floatExponentBits(T);
- const signBit = (Z(1) << (significandBits + exponentBits));
+ const signBit = (@as(Z, 1) << (significandBits + exponentBits));
const maxExponent = ((1 << exponentBits) - 1);
const exponentBias = (maxExponent >> 1);
- const implicitBit = (Z(1) << significandBits);
+ const implicitBit = (@as(Z, 1) << significandBits);
const quietBit = implicitBit >> 1;
const significandMask = implicitBit - 1;
@@ -122,7 +122,7 @@ fn mulXf3(comptime T: type, a: T, b: T) T {
// a zero of the appropriate sign. Mathematically there is no need to
// handle this case separately, but we make it a special case to
// simplify the shift logic.
- const shift: u32 = @truncate(u32, Z(1) -% @bitCast(u32, productExponent));
+ const shift: u32 = @truncate(u32, @as(Z, 1) -% @bitCast(u32, productExponent));
if (shift >= typeWidth) return @bitCast(T, productSign);
// Otherwise, shift the significand of the result so that the round
@@ -131,7 +131,7 @@ fn mulXf3(comptime T: type, a: T, b: T) T {
} else {
// Result is normal before rounding; insert the exponent.
productHi &= significandMask;
- productHi |= Z(@bitCast(u32, productExponent)) << significandBits;
+ productHi |= @as(Z, @bitCast(u32, productExponent)) << significandBits;
}
// Insert the sign of the result:
@@ -150,7 +150,7 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
switch (Z) {
u32 => {
// 32x32 --> 64 bit multiply
- const product = u64(a) * u64(b);
+ const product = @as(u64, a) * @as(u64, b);
hi.* = @truncate(u32, product >> 32);
lo.* = @truncate(u32, product);
},
@@ -179,9 +179,9 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi;
},
u128 => {
- const Word_LoMask = u64(0x00000000ffffffff);
- const Word_HiMask = u64(0xffffffff00000000);
- const Word_FullMask = u64(0xffffffffffffffff);
+ const Word_LoMask = @as(u64, 0x00000000ffffffff);
+ const Word_HiMask = @as(u64, 0xffffffff00000000);
+ const Word_FullMask = @as(u64, 0xffffffffffffffff);
const S = struct {
fn Word_1(x: u128) u64 {
return @truncate(u32, x >> 96);
@@ -217,22 +217,22 @@ fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
const product43: u64 = S.Word_4(a) * S.Word_3(b);
const product44: u64 = S.Word_4(a) * S.Word_4(b);
- const sum0: u128 = u128(product44);
- const sum1: u128 = u128(product34) +%
- u128(product43);
- const sum2: u128 = u128(product24) +%
- u128(product33) +%
- u128(product42);
- const sum3: u128 = u128(product14) +%
- u128(product23) +%
- u128(product32) +%
- u128(product41);
- const sum4: u128 = u128(product13) +%
- u128(product22) +%
- u128(product31);
- const sum5: u128 = u128(product12) +%
- u128(product21);
- const sum6: u128 = u128(product11);
+ const sum0: u128 = @as(u128, product44);
+ const sum1: u128 = @as(u128, product34) +%
+ @as(u128, product43);
+ const sum2: u128 = @as(u128, product24) +%
+ @as(u128, product33) +%
+ @as(u128, product42);
+ const sum3: u128 = @as(u128, product14) +%
+ @as(u128, product23) +%
+ @as(u128, product32) +%
+ @as(u128, product41);
+ const sum4: u128 = @as(u128, product13) +%
+ @as(u128, product22) +%
+ @as(u128, product31);
+ const sum5: u128 = @as(u128, product12) +%
+ @as(u128, product21);
+ const sum6: u128 = @as(u128, product11);
const r0: u128 = (sum0 & Word_FullMask) +%
((sum1 & Word_LoMask) << 32);
@@ -258,7 +258,7 @@ fn normalize(comptime T: type, significand: *@IntType(false, T.bit_count)) i32 {
@setRuntimeSafety(builtin.is_test);
const Z = @IntType(false, T.bit_count);
const significandBits = std.math.floatMantissaBits(T);
- const implicitBit = Z(1) << significandBits;
+ const implicitBit = @as(Z, 1) << significandBits;
const shift = @clz(Z, significand.*) - @clz(Z, implicitBit);
significand.* <<= @intCast(std.math.Log2Int(Z), shift);
lib/std/special/compiler_rt/mulXf3_test.zig
@@ -2,8 +2,8 @@
//
// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/test/builtins/Unit/multf3_test.c
-const qnan128 = @bitCast(f128, u128(0x7fff800000000000) << 64);
-const inf128 = @bitCast(f128, u128(0x7fff000000000000) << 64);
+const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
+const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
const __multf3 = @import("mulXf3.zig").__multf3;
@@ -39,7 +39,7 @@ fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) void {
}
fn makeNaN128(rand: u64) f128 {
- const int_result = u128(0x7fff000000000000 | (rand & 0xffffffffffff)) << 64;
+ const int_result = @as(u128, 0x7fff000000000000 | (rand & 0xffffffffffff)) << 64;
const float_result = @bitCast(f128, int_result);
return float_result;
}
@@ -55,15 +55,15 @@ test "multf3" {
// any * any
test__multf3(
- @bitCast(f128, u128(0x40042eab345678439abcdefea5678234)),
- @bitCast(f128, u128(0x3ffeedcb34a235253948765432134675)),
+ @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
+ @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
0x400423e7f9e3c9fc,
0xd906c2c2a85777c4,
);
test__multf3(
- @bitCast(f128, u128(0x3fcd353e45674d89abacc3a2ebf3ff50)),
- @bitCast(f128, u128(0x3ff6ed8764648369535adf4be3214568)),
+ @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
+ @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
0x3fc52a163c6223fc,
0xc94c4bf0430768b4,
);
@@ -76,8 +76,8 @@ test "multf3" {
);
test__multf3(
- @bitCast(f128, u128(0x3f154356473c82a9fabf2d22ace345df)),
- @bitCast(f128, u128(0x3e38eda98765476743ab21da23d45679)),
+ @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
+ @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
0x3d4f37c1a3137cae,
0xfc6807048bc2836a,
);
lib/std/special/compiler_rt/negXf2.zig
@@ -15,7 +15,7 @@ fn negXf2(comptime T: type, a: T) T {
const significandBits = std.math.floatMantissaBits(T);
const exponentBits = std.math.floatExponentBits(T);
- const signBit = (Z(1) << (significandBits + exponentBits));
+ const signBit = (@as(Z, 1) << (significandBits + exponentBits));
return @bitCast(T, @bitCast(Z, a) ^ signBit);
}
lib/std/special/compiler_rt/popcountdi2_test.zig
@@ -20,8 +20,8 @@ test "popcountdi2" {
test__popcountdi2(0);
test__popcountdi2(1);
test__popcountdi2(2);
- test__popcountdi2(@bitCast(i64, u64(0xFFFFFFFFFFFFFFFD)));
- test__popcountdi2(@bitCast(i64, u64(0xFFFFFFFFFFFFFFFE)));
- test__popcountdi2(@bitCast(i64, u64(0xFFFFFFFFFFFFFFFF)));
+ test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFD)));
+ test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFE)));
+ test__popcountdi2(@bitCast(i64, @as(u64, 0xFFFFFFFFFFFFFFFF)));
// TODO some fuzz testing
}
lib/std/special/compiler_rt/truncXfYf2.zig
@@ -69,7 +69,7 @@ inline fn truncXfYf2(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t
// destination format. We can convert by simply right-shifting with
// rounding and adjusting the exponent.
absResult = @truncate(dst_rep_t, aAbs >> (srcSigBits - dstSigBits));
- absResult -%= dst_rep_t(srcExpBias - dstExpBias) << dstSigBits;
+ absResult -%= @as(dst_rep_t, srcExpBias - dstExpBias) << dstSigBits;
const roundBits: src_rep_t = aAbs & roundMask;
if (roundBits > halfway) {
lib/std/special/compiler_rt/truncXfYf2_test.zig
@@ -152,11 +152,11 @@ fn test__trunctfsf2(a: f128, expected: u32) void {
test "trunctfsf2" {
// qnan
- test__trunctfsf2(@bitCast(f128, u128(0x7fff800000000000 << 64)), 0x7fc00000);
+ test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7fc00000);
// nan
- test__trunctfsf2(@bitCast(f128, u128((0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7fc08000);
+ test__trunctfsf2(@bitCast(f128, @as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7fc08000);
// inf
- test__trunctfsf2(@bitCast(f128, u128(0x7fff000000000000 << 64)), 0x7f800000);
+ test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff000000000000 << 64)), 0x7f800000);
// zero
test__trunctfsf2(0.0, 0x0);
@@ -187,11 +187,11 @@ fn test__trunctfdf2(a: f128, expected: u64) void {
test "trunctfdf2" {
// qnan
- test__trunctfdf2(@bitCast(f128, u128(0x7fff800000000000 << 64)), 0x7ff8000000000000);
+ test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7ff8000000000000);
// nan
- test__trunctfdf2(@bitCast(f128, u128((0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7ff8100000000000);
+ test__trunctfdf2(@bitCast(f128, @as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7ff8100000000000);
// inf
- test__trunctfdf2(@bitCast(f128, u128(0x7fff000000000000 << 64)), 0x7ff0000000000000);
+ test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff000000000000 << 64)), 0x7ff0000000000000);
// zero
test__trunctfdf2(0.0, 0x0);
@@ -224,11 +224,11 @@ fn test__truncdfsf2(a: f64, expected: u32) void {
test "truncdfsf2" {
// nan & qnan
- test__truncdfsf2(@bitCast(f64, u64(0x7ff8000000000000)), 0x7fc00000);
- test__truncdfsf2(@bitCast(f64, u64(0x7ff0000000000001)), 0x7fc00000);
+ test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff8000000000000)), 0x7fc00000);
+ test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff0000000000001)), 0x7fc00000);
// inf
- test__truncdfsf2(@bitCast(f64, u64(0x7ff0000000000000)), 0x7f800000);
- test__truncdfsf2(@bitCast(f64, u64(0xfff0000000000000)), 0xff800000);
+ test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff0000000000000)), 0x7f800000);
+ test__truncdfsf2(@bitCast(f64, @as(u64, 0xfff0000000000000)), 0xff800000);
test__truncdfsf2(0.0, 0x0);
test__truncdfsf2(1.0, 0x3f800000);
lib/std/special/compiler_rt/udivmod.zig
@@ -76,7 +76,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
// K K
// ---
// K 0
- sr = @bitCast(c_uint, c_int(@clz(SingleInt, d[high])) - c_int(@clz(SingleInt, n[high])));
+ 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
if (sr > SingleInt.bit_count - 2) {
if (maybe_rem) |rem| {
@@ -114,7 +114,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
// K X
// ---
// 0 K
- sr = 1 + SingleInt.bit_count + c_uint(@clz(SingleInt, d[low])) - c_uint(@clz(SingleInt, n[high]));
+ sr = 1 + SingleInt.bit_count + @as(c_uint, @clz(SingleInt, d[low])) - @as(c_uint, @clz(SingleInt, n[high]));
// 2 <= sr <= DoubleInt.bit_count - 1
// q.all = a << (DoubleInt.bit_count - sr);
// r.all = a >> sr;
@@ -140,7 +140,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
// K X
// ---
// K K
- sr = @bitCast(c_uint, c_int(@clz(SingleInt, d[high])) - c_int(@clz(SingleInt, n[high])));
+ 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
if (sr > SingleInt.bit_count - 1) {
if (maybe_rem) |rem| {
lib/std/special/c.zig
@@ -62,7 +62,7 @@ extern fn strncmp(_l: [*]const u8, _r: [*]const u8, _n: usize) c_int {
r += 1;
n -= 1;
}
- return c_int(l[0]) - c_int(r[0]);
+ return @as(c_int, l[0]) - @as(c_int, r[0]);
}
extern fn strerror(errnum: c_int) [*]const u8 {
@@ -540,7 +540,7 @@ fn generic_fmod(comptime T: type, x: T, y: T) T {
// scale result up
if (ex > 0) {
ux -%= 1 << digits;
- ux |= uint(@bitCast(u32, ex)) << digits;
+ ux |= @as(uint, @bitCast(u32, ex)) << digits;
} else {
ux >>= @intCast(log2uint, @bitCast(u32, -ex + 1));
}
@@ -687,7 +687,7 @@ export fn sqrt(x: f64) f64 {
export fn sqrtf(x: f32) f32 {
const tiny: f32 = 1.0e-30;
- const sign: i32 = @bitCast(i32, u32(0x80000000));
+ const sign: i32 = @bitCast(i32, @as(u32, 0x80000000));
var ix: i32 = @bitCast(i32, x);
if ((ix & 0x7F800000) == 0x7F800000) {
lib/std/special/compiler_rt.zig
@@ -672,7 +672,7 @@ extern fn __udivsi3(n: u32, d: u32) u32 {
// special cases
if (d == 0) return 0; // ?!
if (n == 0) return 0;
- var sr = @bitCast(c_uint, c_int(@clz(u32, d)) - c_int(@clz(u32, n)));
+ var sr = @bitCast(c_uint, @as(c_int, @clz(u32, d)) - @as(c_int, @clz(u32, n)));
// 0 <= sr <= n_uword_bits - 1 or sr large
if (sr > n_uword_bits - 1) {
// d > r
@@ -1414,10 +1414,10 @@ test "test_divsi3" {
[_]i32{ -2, 1, -2 },
[_]i32{ -2, -1, 2 },
- [_]i32{ @bitCast(i32, u32(0x80000000)), 1, @bitCast(i32, u32(0x80000000)) },
- [_]i32{ @bitCast(i32, u32(0x80000000)), -1, @bitCast(i32, u32(0x80000000)) },
- [_]i32{ @bitCast(i32, u32(0x80000000)), -2, 0x40000000 },
- [_]i32{ @bitCast(i32, u32(0x80000000)), 2, @bitCast(i32, u32(0xC0000000)) },
+ [_]i32{ @bitCast(i32, @as(u32, 0x80000000)), 1, @bitCast(i32, @as(u32, 0x80000000)) },
+ [_]i32{ @bitCast(i32, @as(u32, 0x80000000)), -1, @bitCast(i32, @as(u32, 0x80000000)) },
+ [_]i32{ @bitCast(i32, @as(u32, 0x80000000)), -2, 0x40000000 },
+ [_]i32{ @bitCast(i32, @as(u32, 0x80000000)), 2, @bitCast(i32, @as(u32, 0xC0000000)) },
};
for (cases) |case| {
@@ -1443,8 +1443,8 @@ test "test_divmodsi4" {
[_]i32{ 19, 5, 3, 4 },
[_]i32{ 19, -5, -3, 4 },
- [_]i32{ @bitCast(i32, u32(0x80000000)), 8, @bitCast(i32, u32(0xf0000000)), 0 },
- [_]i32{ @bitCast(i32, u32(0x80000007)), 8, @bitCast(i32, u32(0xf0000001)), -1 },
+ [_]i32{ @bitCast(i32, @as(u32, 0x80000000)), 8, @bitCast(i32, @as(u32, 0xf0000000)), 0 },
+ [_]i32{ @bitCast(i32, @as(u32, 0x80000007)), 8, @bitCast(i32, @as(u32, 0xf0000001)), -1 },
};
for (cases) |case| {
@@ -1467,10 +1467,10 @@ test "test_divdi3" {
[_]i64{ -2, 1, -2 },
[_]i64{ -2, -1, 2 },
- [_]i64{ @bitCast(i64, u64(0x8000000000000000)), 1, @bitCast(i64, u64(0x8000000000000000)) },
- [_]i64{ @bitCast(i64, u64(0x8000000000000000)), -1, @bitCast(i64, u64(0x8000000000000000)) },
- [_]i64{ @bitCast(i64, u64(0x8000000000000000)), -2, 0x4000000000000000 },
- [_]i64{ @bitCast(i64, u64(0x8000000000000000)), 2, @bitCast(i64, u64(0xC000000000000000)) },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), 1, @bitCast(i64, @as(u64, 0x8000000000000000)) },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), -1, @bitCast(i64, @as(u64, 0x8000000000000000)) },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), -2, 0x4000000000000000 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), 2, @bitCast(i64, @as(u64, 0xC000000000000000)) },
};
for (cases) |case| {
@@ -1492,12 +1492,12 @@ test "test_moddi3" {
[_]i64{ -5, 3, -2 },
[_]i64{ -5, -3, -2 },
- [_]i64{ @bitCast(i64, @intCast(u64, 0x8000000000000000)), 1, 0 },
- [_]i64{ @bitCast(i64, @intCast(u64, 0x8000000000000000)), -1, 0 },
- [_]i64{ @bitCast(i64, @intCast(u64, 0x8000000000000000)), 2, 0 },
- [_]i64{ @bitCast(i64, @intCast(u64, 0x8000000000000000)), -2, 0 },
- [_]i64{ @bitCast(i64, @intCast(u64, 0x8000000000000000)), 3, -2 },
- [_]i64{ @bitCast(i64, @intCast(u64, 0x8000000000000000)), -3, -2 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), 1, 0 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), -1, 0 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), 2, 0 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), -2, 0 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), 3, -2 },
+ [_]i64{ @bitCast(i64, @as(u64, 0x8000000000000000)), -3, -2 },
};
for (cases) |case| {
lib/std/zig/parse_string_literal.zig
@@ -19,7 +19,7 @@ pub fn parseStringLiteral(
bytes: []const u8,
bad_index: *usize, // populated if error.InvalidCharacter is returned
) ParseStringLiteralError![]u8 {
- const first_index = if (bytes[0] == 'c') usize(2) else usize(1);
+ const first_index = if (bytes[0] == 'c') @as(usize, 2) else @as(usize, 1);
assert(bytes[bytes.len - 1] == '"');
var list = std.ArrayList(u8).init(allocator);
lib/std/zig/parser_test.zig
@@ -37,7 +37,7 @@ test "zig fmt: while else err prong with no block" {
\\test "" {
\\ const result = while (returnError()) |value| {
\\ break value;
- \\ } else |err| i32(2);
+ \\ } else |err| @as(i32, 2);
\\ expect(result == 2);
\\}
\\
lib/std/zig/render.zig
@@ -410,8 +410,8 @@ fn renderExpression(
switch (prefix_op_node.op) {
ast.Node.PrefixOp.Op.PtrType => |ptr_info| {
const star_offset = switch (tree.tokens.at(prefix_op_node.op_token).id) {
- Token.Id.AsteriskAsterisk => usize(1),
- else => usize(0),
+ Token.Id.AsteriskAsterisk => @as(usize, 1),
+ else => @as(usize, 0),
};
try renderTokenOffset(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None, star_offset); // *
if (ptr_info.allowzero_token) |allowzero_token| {
@@ -2097,7 +2097,7 @@ fn renderTokenOffset(
while (true) {
assert(loc.line != 0);
- const newline_count = if (loc.line == 1) u8(1) else u8(2);
+ const newline_count = if (loc.line == 1) @as(u8, 1) else @as(u8, 2);
try stream.writeByteNTimes('\n', newline_count);
try stream.writeByteNTimes(' ', indent);
try stream.write(mem.trimRight(u8, tree.tokenSlicePtr(next_token), " "));
lib/std/zig/tokenizer.zig
@@ -350,7 +350,7 @@ pub const Tokenizer = struct {
};
} else {
// Skip the UTF-8 BOM if present
- const src_start = if (mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else usize(0);
+ const src_start = if (mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else @as(usize, 0);
return Tokenizer{
.buffer = buffer,
.index = src_start,
lib/std/array_list.zig
@@ -344,18 +344,18 @@ test "std.ArrayList.orderedRemove" {
try list.append(7);
//remove from middle
- testing.expectEqual(i32(4), list.orderedRemove(3));
- testing.expectEqual(i32(5), list.at(3));
- testing.expectEqual(usize(6), list.len);
+ testing.expectEqual(@as(i32, 4), list.orderedRemove(3));
+ testing.expectEqual(@as(i32, 5), list.at(3));
+ testing.expectEqual(@as(usize, 6), list.len);
//remove from end
- testing.expectEqual(i32(7), list.orderedRemove(5));
- testing.expectEqual(usize(5), list.len);
+ testing.expectEqual(@as(i32, 7), list.orderedRemove(5));
+ testing.expectEqual(@as(usize, 5), list.len);
//remove from front
- testing.expectEqual(i32(1), list.orderedRemove(0));
- testing.expectEqual(i32(2), list.at(0));
- testing.expectEqual(usize(4), list.len);
+ testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
+ testing.expectEqual(@as(i32, 2), list.at(0));
+ testing.expectEqual(@as(usize, 4), list.len);
}
test "std.ArrayList.swapRemove" {
lib/std/ascii.zig
@@ -129,26 +129,26 @@ const combinedTable = init: {
comptime var i = 0;
inline while (i < 128) : (i += 1) {
table[i] =
- u8(alpha[i]) << @enumToInt(tIndex.Alpha) |
- u8(hex[i]) << @enumToInt(tIndex.Hex) |
- u8(space[i]) << @enumToInt(tIndex.Space) |
- u8(digit[i]) << @enumToInt(tIndex.Digit) |
- u8(lower[i]) << @enumToInt(tIndex.Lower) |
- u8(upper[i]) << @enumToInt(tIndex.Upper) |
- u8(punct[i]) << @enumToInt(tIndex.Punct) |
- u8(graph[i]) << @enumToInt(tIndex.Graph);
+ @as(u8, alpha[i]) << @enumToInt(tIndex.Alpha) |
+ @as(u8, hex[i]) << @enumToInt(tIndex.Hex) |
+ @as(u8, space[i]) << @enumToInt(tIndex.Space) |
+ @as(u8, digit[i]) << @enumToInt(tIndex.Digit) |
+ @as(u8, lower[i]) << @enumToInt(tIndex.Lower) |
+ @as(u8, upper[i]) << @enumToInt(tIndex.Upper) |
+ @as(u8, punct[i]) << @enumToInt(tIndex.Punct) |
+ @as(u8, graph[i]) << @enumToInt(tIndex.Graph);
}
mem.set(u8, table[128..256], 0);
break :init table;
};
fn inTable(c: u8, t: tIndex) bool {
- return (combinedTable[c] & (u8(1) << @enumToInt(t))) != 0;
+ return (combinedTable[c] & (@as(u8, 1) << @enumToInt(t))) != 0;
}
pub fn isAlNum(c: u8) bool {
- return (combinedTable[c] & ((u8(1) << @enumToInt(tIndex.Alpha)) |
- u8(1) << @enumToInt(tIndex.Digit))) != 0;
+ return (combinedTable[c] & ((@as(u8, 1) << @enumToInt(tIndex.Alpha)) |
+ @as(u8, 1) << @enumToInt(tIndex.Digit))) != 0;
}
pub fn isAlpha(c: u8) bool {
lib/std/bloom_filter.zig
@@ -171,7 +171,7 @@ test "std.BloomFilter" {
testing.expectEqual(emptyCell, bf.getCell(@intCast(BF.Index, i)));
}
testing.expectEqual(BF.Index(0), bf.popCount());
- testing.expectEqual(f64(0), bf.estimateItems());
+ testing.expectEqual(@as(f64, 0), bf.estimateItems());
// fill in a few items
bf.incrementCell(42);
bf.incrementCell(255);
@@ -197,7 +197,7 @@ test "std.BloomFilter" {
testing.expectEqual(emptyCell, bf.getCell(@intCast(BF.Index, i)));
}
testing.expectEqual(BF.Index(0), bf.popCount());
- testing.expectEqual(f64(0), bf.estimateItems());
+ testing.expectEqual(@as(f64, 0), bf.estimateItems());
// Lets add a string
bf.add("foo");
@@ -219,7 +219,7 @@ test "std.BloomFilter" {
testing.expectEqual(emptyCell, bf.getCell(@intCast(BF.Index, i)));
}
testing.expectEqual(BF.Index(0), bf.popCount());
- testing.expectEqual(f64(0), bf.estimateItems());
+ testing.expectEqual(@as(f64, 0), bf.estimateItems());
comptime var teststrings = [_][]const u8{
"foo",
lib/std/child_process.zig
@@ -717,7 +717,7 @@ fn destroyPipe(pipe: [2]os.fd_t) void {
// Child of fork calls this to report an error to the fork parent.
// Then the child exits.
fn forkChildErrReport(fd: i32, err: ChildProcess.SpawnError) noreturn {
- writeIntFd(fd, ErrInt(@errorToInt(err))) catch {};
+ writeIntFd(fd, @as(ErrInt,@errorToInt(err))) catch {};
os.exit(1);
}
lib/std/debug.zig
@@ -1008,7 +1008,7 @@ fn readSparseBitVector(stream: var, allocator: *mem.Allocator) ![]usize {
const word = try stream.readIntLittle(u32);
var bit_i: u5 = 0;
while (true) : (bit_i += 1) {
- if (word & (u32(1) << bit_i) != 0) {
+ if (word & (@as(u32, 1) << bit_i) != 0) {
try list.append(word_i * 32 + bit_i);
}
if (bit_i == maxInt(u5)) break;
@@ -1556,13 +1556,14 @@ fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: var, signed: boo
// TODO the noasyncs here are workarounds
fn parseFormValueDwarfOffsetSize(in_stream: var, is_64: bool) !u64 {
- return if (is_64) try noasync in_stream.readIntLittle(u64) else u64(try noasync in_stream.readIntLittle(u32));
+ return if (is_64) try noasync in_stream.readIntLittle(u64) else @as(u64, try noasync in_stream.readIntLittle(u32));
}
// TODO the noasyncs here are workarounds
fn parseFormValueTargetAddrSize(in_stream: var) !u64 {
if (@sizeOf(usize) == 4) {
- return u64(try noasync in_stream.readIntLittle(u32));
+ // TODO this cast should not be needed
+ return @as(u64, try noasync in_stream.readIntLittle(u32));
} else if (@sizeOf(usize) == 8) {
return noasync in_stream.readIntLittle(u64);
} else {
@@ -1846,7 +1847,7 @@ fn getLineNumberInfoMacOs(di: *DebugInfo, symbol: MachoSymbol, target_address: u
// special opcodes
const adjusted_opcode = opcode - opcode_base;
const inc_addr = minimum_instruction_length * (adjusted_opcode / line_range);
- const inc_line = i32(line_base) + i32(adjusted_opcode % line_range);
+ const inc_line = @as(i32, line_base) + @as(i32, adjusted_opcode % line_range);
prog.line += inc_line;
prog.address += inc_addr;
if (try prog.checkLineMatch()) |info| return info;
@@ -1913,7 +1914,7 @@ fn getLineNumberInfoDwarf(di: *DwarfInfo, compile_unit: CompileUnit, target_addr
if (unit_length == 0) {
return error.MissingDebugInfo;
}
- const next_offset = unit_length + (if (is_64) usize(12) else usize(4));
+ const next_offset = unit_length + (if (is_64) @as(usize, 12) else @as(usize, 4));
const version = try di.dwarf_in_stream.readInt(u16, di.endian);
// TODO support 3 and 5
@@ -2012,7 +2013,7 @@ fn getLineNumberInfoDwarf(di: *DwarfInfo, compile_unit: CompileUnit, target_addr
// special opcodes
const adjusted_opcode = opcode - opcode_base;
const inc_addr = minimum_instruction_length * (adjusted_opcode / line_range);
- const inc_line = i32(line_base) + i32(adjusted_opcode % line_range);
+ const inc_line = @as(i32, line_base) + @as(i32, adjusted_opcode % line_range);
prog.line += inc_line;
prog.address += inc_addr;
if (try prog.checkLineMatch()) |info| return info;
@@ -2093,7 +2094,7 @@ fn scanAllFunctions(di: *DwarfInfo) !void {
var is_64: bool = undefined;
const unit_length = try readInitialLength(@typeOf(di.dwarf_in_stream.readFn).ReturnType.ErrorSet, di.dwarf_in_stream, &is_64);
if (unit_length == 0) return;
- const next_offset = unit_length + (if (is_64) usize(12) else usize(4));
+ const next_offset = unit_length + (if (is_64) @as(usize, 12) else @as(usize, 4));
const version = try di.dwarf_in_stream.readInt(u16, di.endian);
if (version < 2 or version > 5) return error.InvalidDebugInfo;
@@ -2195,7 +2196,7 @@ fn scanAllCompileUnits(di: *DwarfInfo) !void {
var is_64: bool = undefined;
const unit_length = try readInitialLength(@typeOf(di.dwarf_in_stream.readFn).ReturnType.ErrorSet, di.dwarf_in_stream, &is_64);
if (unit_length == 0) return;
- const next_offset = unit_length + (if (is_64) usize(12) else usize(4));
+ const next_offset = unit_length + (if (is_64) @as(usize, 12) else @as(usize, 4));
const version = try di.dwarf_in_stream.readInt(u16, di.endian);
if (version < 2 or version > 5) return error.InvalidDebugInfo;
@@ -2312,7 +2313,8 @@ fn readInitialLengthMem(ptr: *[*]const u8, is_64: *bool) !u64 {
} else {
if (first_32_bits >= 0xfffffff0) return error.InvalidDebugInfo;
ptr.* += 4;
- return u64(first_32_bits);
+ // TODO this cast should not be needed
+ return @as(u64, first_32_bits);
}
}
@@ -2329,7 +2331,8 @@ fn readInitialLength(comptime E: type, in_stream: *io.InStream(E), is_64: *bool)
return in_stream.readIntLittle(u64);
} else {
if (first_32_bits >= 0xfffffff0) return error.InvalidDebugInfo;
- return u64(first_32_bits);
+ // TODO this cast should not be needed
+ return @as(u64, first_32_bits);
}
}
lib/std/dynamic_library.zig
@@ -215,8 +215,8 @@ pub const ElfLib = struct {
var i: usize = 0;
while (i < self.hashtab[1]) : (i += 1) {
- if (0 == (u32(1) << @intCast(u5, self.syms[i].st_info & 0xf) & OK_TYPES)) continue;
- if (0 == (u32(1) << @intCast(u5, self.syms[i].st_info >> 4) & OK_BINDS)) continue;
+ if (0 == (@as(u32, 1) << @intCast(u5, self.syms[i].st_info & 0xf) & OK_TYPES)) continue;
+ if (0 == (@as(u32, 1) << @intCast(u5, self.syms[i].st_info >> 4) & OK_BINDS)) continue;
if (0 == self.syms[i].st_shndx) continue;
if (!mem.eql(u8, name, mem.toSliceConst(u8, self.strings + self.syms[i].st_name))) continue;
if (maybe_versym) |versym| {
lib/std/elf.zig
@@ -441,9 +441,9 @@ pub const Elf = struct {
elf.program_header_offset = try in.readInt(u64, elf.endian);
elf.section_header_offset = try in.readInt(u64, elf.endian);
} else {
- elf.entry_addr = u64(try in.readInt(u32, elf.endian));
- elf.program_header_offset = u64(try in.readInt(u32, elf.endian));
- elf.section_header_offset = u64(try in.readInt(u32, elf.endian));
+ elf.entry_addr = @as(u64, try in.readInt(u32, elf.endian));
+ elf.program_header_offset = @as(u64, try in.readInt(u32, elf.endian));
+ elf.section_header_offset = @as(u64, try in.readInt(u32, elf.endian));
}
// skip over flags
@@ -458,13 +458,13 @@ pub const Elf = struct {
const ph_entry_count = try in.readInt(u16, elf.endian);
const sh_entry_size = try in.readInt(u16, elf.endian);
const sh_entry_count = try in.readInt(u16, elf.endian);
- elf.string_section_index = usize(try in.readInt(u16, elf.endian));
+ elf.string_section_index = @as(usize, try in.readInt(u16, elf.endian));
if (elf.string_section_index >= sh_entry_count) return error.InvalidFormat;
- const sh_byte_count = u64(sh_entry_size) * u64(sh_entry_count);
+ const sh_byte_count = @as(u64, sh_entry_size) * @as(u64, sh_entry_count);
const end_sh = try math.add(u64, elf.section_header_offset, sh_byte_count);
- const ph_byte_count = u64(ph_entry_size) * u64(ph_entry_count);
+ const ph_byte_count = @as(u64, ph_entry_size) * @as(u64, ph_entry_count);
const end_ph = try math.add(u64, elf.program_header_offset, ph_byte_count);
const stream_end = try seekable_stream.getEndPos();
@@ -499,14 +499,14 @@ pub const Elf = struct {
// TODO (multiple occurrences) allow implicit cast from %u32 -> %u64 ?
elf_section.name = try in.readInt(u32, elf.endian);
elf_section.sh_type = try in.readInt(u32, elf.endian);
- elf_section.flags = u64(try in.readInt(u32, elf.endian));
- elf_section.addr = u64(try in.readInt(u32, elf.endian));
- elf_section.offset = u64(try in.readInt(u32, elf.endian));
- elf_section.size = u64(try in.readInt(u32, elf.endian));
+ elf_section.flags = @as(u64, try in.readInt(u32, elf.endian));
+ elf_section.addr = @as(u64, try in.readInt(u32, elf.endian));
+ elf_section.offset = @as(u64, try in.readInt(u32, elf.endian));
+ elf_section.size = @as(u64, try in.readInt(u32, elf.endian));
elf_section.link = try in.readInt(u32, elf.endian);
elf_section.info = try in.readInt(u32, elf.endian);
- elf_section.addr_align = u64(try in.readInt(u32, elf.endian));
- elf_section.ent_size = u64(try in.readInt(u32, elf.endian));
+ elf_section.addr_align = @as(u64, try in.readInt(u32, elf.endian));
+ elf_section.ent_size = @as(u64, try in.readInt(u32, elf.endian));
}
}
lib/std/fifo.zig
@@ -257,7 +257,7 @@ test "ByteFifo" {
defer fifo.deinit();
try fifo.write("HELLO");
- testing.expectEqual(usize(5), fifo.readableLength());
+ testing.expectEqual(@as(usize, 5), fifo.readableLength());
testing.expectEqualSlices(u8, "HELLO", fifo.readableSlice(0));
{
@@ -265,34 +265,34 @@ test "ByteFifo" {
while (i < 5) : (i += 1) {
try fifo.write([_]u8{try fifo.peekItem(i)});
}
- testing.expectEqual(usize(10), fifo.readableLength());
+ testing.expectEqual(@as(usize, 10), fifo.readableLength());
testing.expectEqualSlices(u8, "HELLOHELLO", fifo.readableSlice(0));
}
{
- testing.expectEqual(u8('H'), try fifo.readItem());
- testing.expectEqual(u8('E'), try fifo.readItem());
- testing.expectEqual(u8('L'), try fifo.readItem());
- testing.expectEqual(u8('L'), try fifo.readItem());
- testing.expectEqual(u8('O'), try fifo.readItem());
+ testing.expectEqual(@as(u8, 'H'), try fifo.readItem());
+ testing.expectEqual(@as(u8, 'E'), try fifo.readItem());
+ testing.expectEqual(@as(u8, 'L'), try fifo.readItem());
+ testing.expectEqual(@as(u8, 'L'), try fifo.readItem());
+ testing.expectEqual(@as(u8, 'O'), try fifo.readItem());
}
- testing.expectEqual(usize(5), fifo.readableLength());
+ testing.expectEqual(@as(usize, 5), fifo.readableLength());
{ // Writes that wrap around
- testing.expectEqual(usize(11), fifo.writableLength());
- testing.expectEqual(usize(6), fifo.writableSlice(0).len);
+ testing.expectEqual(@as(usize, 11), fifo.writableLength());
+ testing.expectEqual(@as(usize, 6), fifo.writableSlice(0).len);
fifo.writeAssumeCapacity("6<chars<11");
testing.expectEqualSlices(u8, "HELLO6<char", fifo.readableSlice(0));
testing.expectEqualSlices(u8, "s<11", fifo.readableSlice(11));
fifo.discard(11);
testing.expectEqualSlices(u8, "s<11", fifo.readableSlice(0));
fifo.discard(4);
- testing.expectEqual(usize(0), fifo.readableLength());
+ testing.expectEqual(@as(usize, 0), fifo.readableLength());
}
{
const buf = try fifo.writeableWithSize(12);
- testing.expectEqual(usize(12), buf.len);
+ testing.expectEqual(@as(usize, 12), buf.len);
var i: u8 = 0;
while (i < 10) : (i += 1) {
buf[i] = i + 'a';
@@ -313,6 +313,6 @@ test "ByteFifo" {
try fifo.print("{}, {}!", "Hello", "World");
var result: [30]u8 = undefined;
testing.expectEqualSlices(u8, "Hello, World!", fifo.read(&result));
- testing.expectEqual(usize(0), fifo.readableLength());
+ testing.expectEqual(@as(usize, 0), fifo.readableLength());
}
}
lib/std/fmt.zig
@@ -512,7 +512,7 @@ pub fn formatIntValue(
uppercase = false;
} else if (comptime std.mem.eql(u8, fmt, "c")) {
if (@typeOf(int_value).bit_count <= 8) {
- return formatAsciiChar(u8(int_value), options, context, Errors, output);
+ return formatAsciiChar(@as(u8, int_value), options, context, Errors, output);
} else {
@compileError("Cannot print integer that is larger than 8 bits as a ascii");
}
@@ -594,7 +594,7 @@ pub fn formatBuf(
var leftover_padding = if (width > buf.len) (width - buf.len) else return;
const pad_byte: u8 = options.fill;
while (leftover_padding > 0) : (leftover_padding -= 1) {
- try output(context, (*const [1]u8)(&pad_byte)[0..1]);
+ try output(context, @as(*const [1]u8, &pad_byte)[0..1]);
}
}
@@ -668,7 +668,7 @@ pub fn formatFloatScientific(
try output(context, float_decimal.digits[0..1]);
try output(context, ".");
if (float_decimal.digits.len > 1) {
- const num_digits = if (@typeOf(value) == f32) math.min(usize(9), float_decimal.digits.len) else float_decimal.digits.len;
+ const num_digits = if (@typeOf(value) == f32) math.min(@as(usize, 9), float_decimal.digits.len) else float_decimal.digits.len;
try output(context, float_decimal.digits[1..num_digits]);
} else {
@@ -703,7 +703,7 @@ pub fn formatFloatDecimal(
comptime Errors: type,
output: fn (@typeOf(context), []const u8) Errors!void,
) Errors!void {
- var x = f64(value);
+ var x = @as(f64, value);
// Errol doesn't handle these special cases.
if (math.signbit(x)) {
@@ -921,14 +921,14 @@ fn formatIntSigned(
const uint = @IntType(false, @typeOf(value).bit_count);
if (value < 0) {
const minus_sign: u8 = '-';
- try output(context, (*const [1]u8)(&minus_sign)[0..]);
+ try output(context, @as(*const [1]u8, &minus_sign)[0..]);
const new_value = @intCast(uint, -(value + 1)) + 1;
return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
} else if (options.width == null or options.width.? == 0) {
return formatIntUnsigned(@intCast(uint, value), base, uppercase, options, context, Errors, output);
} else {
const plus_sign: u8 = '+';
- try output(context, (*const [1]u8)(&plus_sign)[0..]);
+ try output(context, @as(*const [1]u8, &plus_sign)[0..]);
const new_value = @intCast(uint, value);
return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
}
@@ -966,7 +966,7 @@ fn formatIntUnsigned(
const zero_byte: u8 = options.fill;
var leftover_padding = padding - index;
while (true) {
- try output(context, (*const [1]u8)(&zero_byte)[0..]);
+ try output(context, @as(*const [1]u8, &zero_byte)[0..]);
leftover_padding -= 1;
if (leftover_padding == 0) break;
}
@@ -1088,7 +1088,7 @@ pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
fn digitToChar(digit: u8, uppercase: bool) u8 {
return switch (digit) {
0...9 => digit + '0',
- 10...35 => digit + ((if (uppercase) u8('A') else u8('a')) - 10),
+ 10...35 => digit + ((if (uppercase) @as(u8, 'A') else @as(u8, 'a')) - 10),
else => unreachable,
};
}
@@ -1134,19 +1134,19 @@ fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
test "bufPrintInt" {
var buffer: [100]u8 = undefined;
const buf = buffer[0..];
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 2, false, FormatOptions{}), "-101111000110000101001110"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 10, false, FormatOptions{}), "-12345678"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, false, FormatOptions{}), "-bc614e"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, true, FormatOptions{}), "-BC614E"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 2, false, FormatOptions{}), "-101111000110000101001110"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 10, false, FormatOptions{}), "-12345678"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, false, FormatOptions{}), "-bc614e"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -12345678), 16, true, FormatOptions{}), "-BC614E"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(12345678), 10, true, FormatOptions{}), "12345678"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 12345678), 10, true, FormatOptions{}), "12345678"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(666), 10, false, FormatOptions{ .width = 6 }), " 666"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, FormatOptions{ .width = 6 }), " 1234"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, FormatOptions{ .width = 1 }), "1234"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 666), 10, false, FormatOptions{ .width = 6 }), " 666"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 6 }), " 1234"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(u32, 0x1234), 16, false, FormatOptions{ .width = 1 }), "1234"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(42), 10, false, FormatOptions{ .width = 3 }), "+42"));
- testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-42), 10, false, FormatOptions{ .width = 3 }), "-42"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, 42), 10, false, FormatOptions{ .width = 3 }), "+42"));
+ testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, @as(i32, -42), 10, false, FormatOptions{ .width = 3 }), "-42"));
}
fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) []u8 {
@@ -1208,8 +1208,8 @@ test "int.specifier" {
}
test "int.padded" {
- try testFmt("u8: ' 1'", "u8: '{:4}'", u8(1));
- try testFmt("u8: 'xxx1'", "u8: '{:x<4}'", u8(1));
+ try testFmt("u8: ' 1'", "u8: '{:4}'", @as(u8, 1));
+ try testFmt("u8: 'xxx1'", "u8: '{:x<4}'", @as(u8, 1));
}
test "buffer" {
@@ -1287,8 +1287,8 @@ test "filesize" {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
- try testFmt("file size: 63MiB\n", "file size: {Bi}\n", usize(63 * 1024 * 1024));
- try testFmt("file size: 66.06MB\n", "file size: {B:.2}\n", usize(63 * 1024 * 1024));
+ try testFmt("file size: 63MiB\n", "file size: {Bi}\n", @as(usize, 63 * 1024 * 1024));
+ try testFmt("file size: 66.06MB\n", "file size: {B:.2}\n", @as(usize, 63 * 1024 * 1024));
}
test "struct" {
@@ -1327,8 +1327,8 @@ test "float.scientific" {
}
try testFmt("f32: 1.34000003e+00", "f32: {e}", f32(1.34));
try testFmt("f32: 1.23400001e+01", "f32: {e}", f32(12.34));
- try testFmt("f64: -1.234e+11", "f64: {e}", f64(-12.34e10));
- try testFmt("f64: 9.99996e-40", "f64: {e}", f64(9.999960e-40));
+ try testFmt("f64: -1.234e+11", "f64: {e}", @as(f64, -12.34e10));
+ try testFmt("f64: 9.99996e-40", "f64: {e}", @as(f64, 9.999960e-40));
}
test "float.scientific.precision" {
@@ -1336,12 +1336,12 @@ test "float.scientific.precision" {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
- try testFmt("f64: 1.40971e-42", "f64: {e:.5}", f64(1.409706e-42));
- try testFmt("f64: 1.00000e-09", "f64: {e:.5}", f64(@bitCast(f32, u32(814313563))));
- try testFmt("f64: 7.81250e-03", "f64: {e:.5}", f64(@bitCast(f32, u32(1006632960))));
+ try testFmt("f64: 1.40971e-42", "f64: {e:.5}", @as(f64, 1.409706e-42));
+ try testFmt("f64: 1.00000e-09", "f64: {e:.5}", @as(f64, @bitCast(f32, @as(u32, 814313563))));
+ try testFmt("f64: 7.81250e-03", "f64: {e:.5}", @as(f64, @bitCast(f32, @as(u32, 1006632960))));
// libc rounds 1.000005e+05 to 1.00000e+05 but zig does 1.00001e+05.
// In fact, libc doesn't round a lot of 5 cases up when one past the precision point.
- try testFmt("f64: 1.00001e+05", "f64: {e:.5}", f64(@bitCast(f32, u32(1203982400))));
+ try testFmt("f64: 1.00001e+05", "f64: {e:.5}", @as(f64, @bitCast(f32, @as(u32, 1203982400))));
}
test "float.special" {
@@ -1364,21 +1364,21 @@ test "float.decimal" {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
- try testFmt("f64: 152314000000000000000000000000", "f64: {d}", f64(1.52314e+29));
+ try testFmt("f64: 152314000000000000000000000000", "f64: {d}", @as(f64, 1.52314e+29));
try testFmt("f32: 1.1", "f32: {d:.1}", f32(1.1234));
try testFmt("f32: 1234.57", "f32: {d:.2}", f32(1234.567));
// -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
// -11.12339... is rounded back up to -11.1234
try testFmt("f32: -11.1234", "f32: {d:.4}", f32(-11.1234));
try testFmt("f32: 91.12345", "f32: {d:.5}", f32(91.12345));
- try testFmt("f64: 91.1234567890", "f64: {d:.10}", f64(91.12345678901235));
- try testFmt("f64: 0.00000", "f64: {d:.5}", f64(0.0));
- try testFmt("f64: 6", "f64: {d:.0}", f64(5.700));
- try testFmt("f64: 10.0", "f64: {d:.1}", f64(9.999));
- try testFmt("f64: 1.000", "f64: {d:.3}", f64(1.0));
- try testFmt("f64: 0.00030000", "f64: {d:.8}", f64(0.0003));
- try testFmt("f64: 0.00000", "f64: {d:.5}", f64(1.40130e-45));
- try testFmt("f64: 0.00000", "f64: {d:.5}", f64(9.999960e-40));
+ try testFmt("f64: 91.1234567890", "f64: {d:.10}", @as(f64, 91.12345678901235));
+ try testFmt("f64: 0.00000", "f64: {d:.5}", @as(f64, 0.0));
+ try testFmt("f64: 6", "f64: {d:.0}", @as(f64, 5.700));
+ try testFmt("f64: 10.0", "f64: {d:.1}", @as(f64, 9.999));
+ try testFmt("f64: 1.000", "f64: {d:.3}", @as(f64, 1.0));
+ try testFmt("f64: 0.00030000", "f64: {d:.8}", @as(f64, 0.0003));
+ try testFmt("f64: 0.00000", "f64: {d:.5}", @as(f64, 1.40130e-45));
+ try testFmt("f64: 0.00000", "f64: {d:.5}", @as(f64, 9.999960e-40));
}
test "float.libc.sanity" {
@@ -1386,22 +1386,22 @@ test "float.libc.sanity" {
// TODO https://github.com/ziglang/zig/issues/3289
return error.SkipZigTest;
}
- try testFmt("f64: 0.00001", "f64: {d:.5}", f64(@bitCast(f32, u32(916964781))));
- try testFmt("f64: 0.00001", "f64: {d:.5}", f64(@bitCast(f32, u32(925353389))));
- try testFmt("f64: 0.10000", "f64: {d:.5}", f64(@bitCast(f32, u32(1036831278))));
- try testFmt("f64: 1.00000", "f64: {d:.5}", f64(@bitCast(f32, u32(1065353133))));
- try testFmt("f64: 10.00000", "f64: {d:.5}", f64(@bitCast(f32, u32(1092616192))));
+ try testFmt("f64: 0.00001", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 916964781))));
+ try testFmt("f64: 0.00001", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 925353389))));
+ try testFmt("f64: 0.10000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1036831278))));
+ try testFmt("f64: 1.00000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1065353133))));
+ try testFmt("f64: 10.00000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1092616192))));
// libc differences
//
// This is 0.015625 exactly according to gdb. We thus round down,
// however glibc rounds up for some reason. This occurs for all
// floats of the form x.yyyy25 on a precision point.
- try testFmt("f64: 0.01563", "f64: {d:.5}", f64(@bitCast(f32, u32(1015021568))));
+ try testFmt("f64: 0.01563", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1015021568))));
// errol3 rounds to ... 630 but libc rounds to ...632. Grisu3
// also rounds to 630 so I'm inclined to believe libc is not
// optimal here.
- try testFmt("f64: 18014400656965630.00000", "f64: {d:.5}", f64(@bitCast(f32, u32(1518338049))));
+ try testFmt("f64: 18014400656965630.00000", "f64: {d:.5}", @as(f64, @bitCast(f32, @as(u32, 1518338049))));
}
test "custom" {
@@ -1677,17 +1677,17 @@ test "formatType max_depth" {
}
test "positional" {
- try testFmt("2 1 0", "{2} {1} {0}", usize(0), usize(1), usize(2));
- try testFmt("2 1 0", "{2} {1} {}", usize(0), usize(1), usize(2));
- try testFmt("0 0", "{0} {0}", usize(0));
- try testFmt("0 1", "{} {1}", usize(0), usize(1));
- try testFmt("1 0 0 1", "{1} {} {0} {}", usize(0), usize(1));
+ try testFmt("2 1 0", "{2} {1} {0}", @as(usize, 0), @as(usize, 1), @as(usize, 2));
+ try testFmt("2 1 0", "{2} {1} {}", @as(usize, 0), @as(usize, 1), @as(usize, 2));
+ try testFmt("0 0", "{0} {0}", @as(usize, 0));
+ try testFmt("0 1", "{} {1}", @as(usize, 0), @as(usize, 1));
+ try testFmt("1 0 0 1", "{1} {} {0} {}", @as(usize, 0), @as(usize, 1));
}
test "positional with specifier" {
- try testFmt("10.0", "{0d:.1}", f64(9.999));
+ try testFmt("10.0", "{0d:.1}", @as(f64, 9.999));
}
test "positional/alignment/width/precision" {
- try testFmt("10.0", "{0d: >3.1}", f64(9.999));
+ try testFmt("10.0", "{0d: >3.1}", @as(f64, 9.999));
}
lib/std/hash_map.zig
@@ -402,7 +402,7 @@ pub fn HashMap(comptime K: type, comptime V: type, comptime hash: fn (key: K) u3
}
fn keyToIndex(hm: Self, key: K) usize {
- return hm.constrainIndex(usize(hash(key)));
+ return hm.constrainIndex(@as(usize, hash(key)));
}
fn constrainIndex(hm: Self, i: usize) usize {
lib/std/heap.zig
@@ -896,7 +896,7 @@ fn testAllocatorLargeAlignment(allocator: *mem.Allocator) mem.Allocator.Error!vo
const large_align = u29(mem.page_size << 2);
var align_mask: usize = undefined;
- _ = @shlWithOverflow(usize, ~usize(0), USizeShift(@ctz(u29, large_align)), &align_mask);
+ _ = @shlWithOverflow(usize, ~@as(usize, 0), USizeShift(@ctz(u29, large_align)), &align_mask);
var slice = try allocator.alignedAlloc(u8, large_align, 500);
testing.expect(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
lib/std/io.zig
@@ -353,7 +353,7 @@ pub fn BitInStream(endian: builtin.Endian, comptime Error: type) type {
const Buf = @IntType(false, buf_bit_count);
const BufShift = math.Log2Int(Buf);
- out_bits.* = usize(0);
+ out_bits.* = @as(usize, 0);
if (U == u0 or bits == 0) return 0;
var out_buffer = Buf(0);
@@ -434,7 +434,7 @@ pub fn BitInStream(endian: builtin.Endian, comptime Error: type) type {
var self = @fieldParentPtr(Self, "stream", self_stream);
var out_bits: usize = undefined;
- var out_bits_total = usize(0);
+ var out_bits_total = @as(usize, 0);
//@NOTE: I'm not sure this is a good idea, maybe alignToByte should be forced
if (self.bit_count > 0) {
for (buffer) |*b, i| {
lib/std/json.zig
@@ -1343,7 +1343,7 @@ test "write json then parse it" {
try jw.emitBool(true);
try jw.objectField("int");
- try jw.emitNumber(i32(1234));
+ try jw.emitNumber(@as(i32, 1234));
try jw.objectField("array");
try jw.beginArray();
@@ -1352,7 +1352,7 @@ test "write json then parse it" {
try jw.emitNull();
try jw.arrayElem();
- try jw.emitNumber(f64(12.34));
+ try jw.emitNumber(@as(f64, 12.34));
try jw.endArray();
lib/std/math.zig
@@ -44,10 +44,10 @@ pub const sqrt2 = 1.414213562373095048801688724209698079;
pub const sqrt1_2 = 0.707106781186547524400844362104849039;
// From a small c++ [program using boost float128](https://github.com/winksaville/cpp_boost_float128)
-pub const f128_true_min = @bitCast(f128, u128(0x00000000000000000000000000000001));
-pub const f128_min = @bitCast(f128, u128(0x00010000000000000000000000000000));
-pub const f128_max = @bitCast(f128, u128(0x7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF));
-pub const f128_epsilon = @bitCast(f128, u128(0x3F8F0000000000000000000000000000));
+pub const f128_true_min = @bitCast(f128, @as(u128, 0x00000000000000000000000000000001));
+pub const f128_min = @bitCast(f128, @as(u128, 0x00010000000000000000000000000000));
+pub const f128_max = @bitCast(f128, @as(u128, 0x7FFEFFFFFFFFFFFFFFFFFFFFFFFFFFFF));
+pub const f128_epsilon = @bitCast(f128, @as(u128, 0x3F8F0000000000000000000000000000));
pub const f128_toint = 1.0 / f128_epsilon;
// float.h details
@@ -69,28 +69,28 @@ pub const f16_max = 65504;
pub const f16_epsilon = 0.0009765625; // 2**-10
pub const f16_toint = 1.0 / f16_epsilon;
-pub const nan_u16 = u16(0x7C01);
+pub const nan_u16 = @as(u16, 0x7C01);
pub const nan_f16 = @bitCast(f16, nan_u16);
-pub const inf_u16 = u16(0x7C00);
+pub const inf_u16 = @as(u16, 0x7C00);
pub const inf_f16 = @bitCast(f16, inf_u16);
-pub const nan_u32 = u32(0x7F800001);
+pub const nan_u32 = @as(u32, 0x7F800001);
pub const nan_f32 = @bitCast(f32, nan_u32);
-pub const inf_u32 = u32(0x7F800000);
+pub const inf_u32 = @as(u32, 0x7F800000);
pub const inf_f32 = @bitCast(f32, inf_u32);
-pub const nan_u64 = u64(0x7FF << 52) | 1;
+pub const nan_u64 = @as(u64, 0x7FF << 52) | 1;
pub const nan_f64 = @bitCast(f64, nan_u64);
-pub const inf_u64 = u64(0x7FF << 52);
+pub const inf_u64 = @as(u64, 0x7FF << 52);
pub const inf_f64 = @bitCast(f64, inf_u64);
-pub const nan_u128 = u128(0x7fff0000000000000000000000000001);
+pub const nan_u128 = @as(u128, 0x7fff0000000000000000000000000001);
pub const nan_f128 = @bitCast(f128, nan_u128);
-pub const inf_u128 = u128(0x7fff0000000000000000000000000000);
+pub const inf_u128 = @as(u128, 0x7fff0000000000000000000000000000);
pub const inf_f128 = @bitCast(f128, inf_u128);
pub const nan = @import("math/nan.zig").nan;
@@ -248,7 +248,7 @@ pub fn Min(comptime A: type, comptime B: type) type {
},
else => {},
}
- return @typeOf(A(0) + B(0));
+ return @typeOf(@as(A, 0) + @as(B, 0));
}
/// Returns the smaller number. When one of the parameter's type's full range fits in the other,
@@ -273,7 +273,7 @@ pub fn min(x: var, y: var) Min(@typeOf(x), @typeOf(y)) {
}
test "math.min" {
- testing.expect(min(i32(-1), i32(2)) == -1);
+ testing.expect(min(@as(i32, -1), @as(i32, 2)) == -1);
{
var a: u16 = 999;
var b: u32 = 10;
@@ -309,7 +309,7 @@ pub fn max(x: var, y: var) @typeOf(x + y) {
}
test "math.max" {
- testing.expect(max(i32(-1), i32(2)) == 2);
+ testing.expect(max(@as(i32, -1), @as(i32, 2)) == 2);
}
pub fn mul(comptime T: type, a: T, b: T) (error{Overflow}!T) {
@@ -352,10 +352,10 @@ pub fn shl(comptime T: type, a: T, shift_amt: var) T {
}
test "math.shl" {
- testing.expect(shl(u8, 0b11111111, usize(3)) == 0b11111000);
- testing.expect(shl(u8, 0b11111111, usize(8)) == 0);
- testing.expect(shl(u8, 0b11111111, usize(9)) == 0);
- testing.expect(shl(u8, 0b11111111, isize(-2)) == 0b00111111);
+ testing.expect(shl(u8, 0b11111111, @as(usize, 3)) == 0b11111000);
+ testing.expect(shl(u8, 0b11111111, @as(usize, 8)) == 0);
+ testing.expect(shl(u8, 0b11111111, @as(usize, 9)) == 0);
+ testing.expect(shl(u8, 0b11111111, @as(isize, -2)) == 0b00111111);
testing.expect(shl(u8, 0b11111111, 3) == 0b11111000);
testing.expect(shl(u8, 0b11111111, 8) == 0);
testing.expect(shl(u8, 0b11111111, 9) == 0);
@@ -380,10 +380,10 @@ pub fn shr(comptime T: type, a: T, shift_amt: var) T {
}
test "math.shr" {
- testing.expect(shr(u8, 0b11111111, usize(3)) == 0b00011111);
- testing.expect(shr(u8, 0b11111111, usize(8)) == 0);
- testing.expect(shr(u8, 0b11111111, usize(9)) == 0);
- testing.expect(shr(u8, 0b11111111, isize(-2)) == 0b11111100);
+ testing.expect(shr(u8, 0b11111111, @as(usize, 3)) == 0b00011111);
+ testing.expect(shr(u8, 0b11111111, @as(usize, 8)) == 0);
+ testing.expect(shr(u8, 0b11111111, @as(usize, 9)) == 0);
+ testing.expect(shr(u8, 0b11111111, @as(isize, -2)) == 0b11111100);
testing.expect(shr(u8, 0b11111111, 3) == 0b00011111);
testing.expect(shr(u8, 0b11111111, 8) == 0);
testing.expect(shr(u8, 0b11111111, 9) == 0);
@@ -402,11 +402,11 @@ pub fn rotr(comptime T: type, x: T, r: var) T {
}
test "math.rotr" {
- testing.expect(rotr(u8, 0b00000001, usize(0)) == 0b00000001);
- testing.expect(rotr(u8, 0b00000001, usize(9)) == 0b10000000);
- testing.expect(rotr(u8, 0b00000001, usize(8)) == 0b00000001);
- testing.expect(rotr(u8, 0b00000001, usize(4)) == 0b00010000);
- testing.expect(rotr(u8, 0b00000001, isize(-1)) == 0b00000010);
+ testing.expect(rotr(u8, 0b00000001, @as(usize, 0)) == 0b00000001);
+ testing.expect(rotr(u8, 0b00000001, @as(usize, 9)) == 0b10000000);
+ testing.expect(rotr(u8, 0b00000001, @as(usize, 8)) == 0b00000001);
+ testing.expect(rotr(u8, 0b00000001, @as(usize, 4)) == 0b00010000);
+ testing.expect(rotr(u8, 0b00000001, @as(isize, -1)) == 0b00000010);
}
/// Rotates left. Only unsigned values can be rotated.
@@ -421,11 +421,11 @@ pub fn rotl(comptime T: type, x: T, r: var) T {
}
test "math.rotl" {
- testing.expect(rotl(u8, 0b00000001, usize(0)) == 0b00000001);
- testing.expect(rotl(u8, 0b00000001, usize(9)) == 0b00000010);
- testing.expect(rotl(u8, 0b00000001, usize(8)) == 0b00000001);
- testing.expect(rotl(u8, 0b00000001, usize(4)) == 0b00010000);
- testing.expect(rotl(u8, 0b00000001, isize(-1)) == 0b10000000);
+ testing.expect(rotl(u8, 0b00000001, @as(usize, 0)) == 0b00000001);
+ testing.expect(rotl(u8, 0b00000001, @as(usize, 9)) == 0b00000010);
+ testing.expect(rotl(u8, 0b00000001, @as(usize, 8)) == 0b00000001);
+ testing.expect(rotl(u8, 0b00000001, @as(usize, 4)) == 0b00010000);
+ testing.expect(rotl(u8, 0b00000001, @as(isize, -1)) == 0b10000000);
}
pub fn Log2Int(comptime T: type) type {
@@ -532,8 +532,8 @@ test "math.absInt" {
comptime testAbsInt();
}
fn testAbsInt() void {
- testing.expect((absInt(i32(-10)) catch unreachable) == 10);
- testing.expect((absInt(i32(10)) catch unreachable) == 10);
+ testing.expect((absInt(@as(i32, -10)) catch unreachable) == 10);
+ testing.expect((absInt(@as(i32, 10)) catch unreachable) == 10);
}
pub const absFloat = fabs;
@@ -679,14 +679,14 @@ pub fn absCast(x: var) t: {
}
test "math.absCast" {
- testing.expect(absCast(i32(-999)) == 999);
- testing.expect(@typeOf(absCast(i32(-999))) == u32);
+ testing.expect(absCast(@as(i32, -999)) == 999);
+ testing.expect(@typeOf(absCast(@as(i32, -999))) == u32);
- testing.expect(absCast(i32(999)) == 999);
- testing.expect(@typeOf(absCast(i32(999))) == u32);
+ testing.expect(absCast(@as(i32, 999)) == 999);
+ testing.expect(@typeOf(absCast(@as(i32, 999))) == u32);
- testing.expect(absCast(i32(minInt(i32))) == -minInt(i32));
- testing.expect(@typeOf(absCast(i32(minInt(i32)))) == u32);
+ testing.expect(absCast(@as(i32, minInt(i32))) == -minInt(i32));
+ testing.expect(@typeOf(absCast(@as(i32, minInt(i32)))) == u32);
testing.expect(absCast(-999) == 999);
}
@@ -705,13 +705,13 @@ pub fn negateCast(x: var) !@IntType(true, @typeOf(x).bit_count) {
}
test "math.negateCast" {
- testing.expect((negateCast(u32(999)) catch unreachable) == -999);
- testing.expect(@typeOf(negateCast(u32(999)) catch unreachable) == i32);
+ testing.expect((negateCast(@as(u32, 999)) catch unreachable) == -999);
+ testing.expect(@typeOf(negateCast(@as(u32, 999)) catch unreachable) == i32);
- testing.expect((negateCast(u32(-minInt(i32))) catch unreachable) == minInt(i32));
- testing.expect(@typeOf(negateCast(u32(-minInt(i32))) catch unreachable) == i32);
+ testing.expect((negateCast(@as(u32, -minInt(i32))) catch unreachable) == minInt(i32));
+ testing.expect(@typeOf(negateCast(@as(u32, -minInt(i32))) catch unreachable) == i32);
- testing.expectError(error.Overflow, negateCast(u32(maxInt(i32) + 10)));
+ testing.expectError(error.Overflow, negateCast(@as(u32, maxInt(i32) + 10)));
}
/// Cast an integer to a different integer type. If the value doesn't fit,
@@ -729,13 +729,13 @@ pub fn cast(comptime T: type, x: var) (error{Overflow}!T) {
}
test "math.cast" {
- testing.expectError(error.Overflow, cast(u8, u32(300)));
- testing.expectError(error.Overflow, cast(i8, i32(-200)));
+ testing.expectError(error.Overflow, cast(u8, @as(u32, 300)));
+ testing.expectError(error.Overflow, cast(i8, @as(i32, -200)));
testing.expectError(error.Overflow, cast(u8, i8(-1)));
testing.expectError(error.Overflow, cast(u64, i8(-1)));
- testing.expect((try cast(u8, u32(255))) == u8(255));
- testing.expect(@typeOf(try cast(u8, u32(255))) == u8);
+ testing.expect((try cast(u8, @as(u32, 255))) == @as(u8, 255));
+ testing.expect(@typeOf(try cast(u8, @as(u32, 255))) == u8);
}
pub const AlignCastError = error{UnalignedMemory};
@@ -812,15 +812,15 @@ test "math.ceilPowerOfTwoPromote" {
}
fn testCeilPowerOfTwoPromote() void {
- testing.expectEqual(u33(1), ceilPowerOfTwoPromote(u32, 1));
- testing.expectEqual(u33(2), ceilPowerOfTwoPromote(u32, 2));
- testing.expectEqual(u33(64), ceilPowerOfTwoPromote(u32, 63));
- testing.expectEqual(u33(64), ceilPowerOfTwoPromote(u32, 64));
- testing.expectEqual(u33(128), ceilPowerOfTwoPromote(u32, 65));
- testing.expectEqual(u6(8), ceilPowerOfTwoPromote(u5, 7));
- testing.expectEqual(u6(8), ceilPowerOfTwoPromote(u5, 8));
- testing.expectEqual(u6(16), ceilPowerOfTwoPromote(u5, 9));
- testing.expectEqual(u5(16), ceilPowerOfTwoPromote(u4, 9));
+ testing.expectEqual(@as(u33, 1), ceilPowerOfTwoPromote(u32, 1));
+ testing.expectEqual(@as(u33, 2), ceilPowerOfTwoPromote(u32, 2));
+ testing.expectEqual(@as(u33, 64), ceilPowerOfTwoPromote(u32, 63));
+ testing.expectEqual(@as(u33, 64), ceilPowerOfTwoPromote(u32, 64));
+ testing.expectEqual(@as(u33, 128), ceilPowerOfTwoPromote(u32, 65));
+ testing.expectEqual(@as(u6, 8), ceilPowerOfTwoPromote(u5, 7));
+ testing.expectEqual(@as(u6, 8), ceilPowerOfTwoPromote(u5, 8));
+ testing.expectEqual(@as(u6, 16), ceilPowerOfTwoPromote(u5, 9));
+ testing.expectEqual(@as(u5, 16), ceilPowerOfTwoPromote(u4, 9));
}
test "math.ceilPowerOfTwo" {
@@ -829,14 +829,14 @@ test "math.ceilPowerOfTwo" {
}
fn testCeilPowerOfTwo() !void {
- testing.expectEqual(u32(1), try ceilPowerOfTwo(u32, 1));
- testing.expectEqual(u32(2), try ceilPowerOfTwo(u32, 2));
- testing.expectEqual(u32(64), try ceilPowerOfTwo(u32, 63));
- testing.expectEqual(u32(64), try ceilPowerOfTwo(u32, 64));
- testing.expectEqual(u32(128), try ceilPowerOfTwo(u32, 65));
- testing.expectEqual(u5(8), try ceilPowerOfTwo(u5, 7));
- testing.expectEqual(u5(8), try ceilPowerOfTwo(u5, 8));
- testing.expectEqual(u5(16), try ceilPowerOfTwo(u5, 9));
+ testing.expectEqual(@as(u32, 1), try ceilPowerOfTwo(u32, 1));
+ testing.expectEqual(@as(u32, 2), try ceilPowerOfTwo(u32, 2));
+ testing.expectEqual(@as(u32, 64), try ceilPowerOfTwo(u32, 63));
+ testing.expectEqual(@as(u32, 64), try ceilPowerOfTwo(u32, 64));
+ testing.expectEqual(@as(u32, 128), try ceilPowerOfTwo(u32, 65));
+ testing.expectEqual(@as(u5, 8), try ceilPowerOfTwo(u5, 7));
+ testing.expectEqual(@as(u5, 8), try ceilPowerOfTwo(u5, 8));
+ testing.expectEqual(@as(u5, 16), try ceilPowerOfTwo(u5, 9));
testing.expectError(error.Overflow, ceilPowerOfTwo(u4, 9));
}
@@ -944,7 +944,7 @@ test "max value type" {
pub fn mulWide(comptime T: type, a: T, b: T) @IntType(T.is_signed, T.bit_count * 2) {
const ResultInt = @IntType(T.is_signed, T.bit_count * 2);
- return ResultInt(a) * ResultInt(b);
+ return @as(ResultInt, a) * @as(ResultInt, b);
}
test "math.mulWide" {
lib/std/mem.zig
@@ -118,7 +118,7 @@ pub const Allocator = struct {
} else @alignOf(T);
if (n == 0) {
- return ([*]align(a) T)(undefined)[0..0];
+ return @as([*]align(a) T, undefined)[0..0];
}
const byte_count = math.mul(usize, @sizeOf(T), n) catch return Error.OutOfMemory;
@@ -170,7 +170,7 @@ pub const Allocator = struct {
}
if (new_n == 0) {
self.free(old_mem);
- return ([*]align(new_alignment) T)(undefined)[0..0];
+ return @as([*]align(new_alignment) T, undefined)[0..0];
}
const old_byte_slice = @sliceToBytes(old_mem);
@@ -523,7 +523,7 @@ pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: builtin.
builtin.Endian.Little => {
const ShiftType = math.Log2Int(ReturnType);
for (bytes) |b, index| {
- result = result | (ReturnType(b) << @intCast(ShiftType, index * 8));
+ result = result | (@as(ReturnType, b) << @intCast(ShiftType, index * 8));
}
},
}
@@ -1332,7 +1332,7 @@ fn AsBytesReturnType(comptime P: type) type {
if (comptime !trait.isSingleItemPtr(P))
@compileError("expected single item " ++ "pointer, passed " ++ @typeName(P));
- const size = usize(@sizeOf(meta.Child(P)));
+ const size = @as(usize, @sizeOf(meta.Child(P)));
const alignment = comptime meta.alignment(P);
if (alignment == 0) {
@@ -1353,7 +1353,7 @@ pub fn asBytes(ptr: var) AsBytesReturnType(@typeOf(ptr)) {
}
test "asBytes" {
- const deadbeef = u32(0xDEADBEEF);
+ const deadbeef = @as(u32, 0xDEADBEEF);
const deadbeef_bytes = switch (builtin.endian) {
builtin.Endian.Big => "\xDE\xAD\xBE\xEF",
builtin.Endian.Little => "\xEF\xBE\xAD\xDE",
@@ -1361,7 +1361,7 @@ test "asBytes" {
testing.expect(eql(u8, asBytes(&deadbeef), deadbeef_bytes));
- var codeface = u32(0xC0DEFACE);
+ var codeface = @as(u32, 0xC0DEFACE);
for (asBytes(&codeface).*) |*b|
b.* = 0;
testing.expect(codeface == 0);
@@ -1392,7 +1392,7 @@ pub fn toBytes(value: var) [@sizeOf(@typeOf(value))]u8 {
}
test "toBytes" {
- var my_bytes = toBytes(u32(0x12345678));
+ var my_bytes = toBytes(@as(u32, 0x12345678));
switch (builtin.endian) {
builtin.Endian.Big => testing.expect(eql(u8, my_bytes, "\x12\x34\x56\x78")),
builtin.Endian.Little => testing.expect(eql(u8, my_bytes, "\x78\x56\x34\x12")),
@@ -1406,7 +1406,7 @@ test "toBytes" {
}
fn BytesAsValueReturnType(comptime T: type, comptime B: type) type {
- const size = usize(@sizeOf(T));
+ const size = @as(usize, @sizeOf(T));
if (comptime !trait.is(builtin.TypeId.Pointer)(B) or meta.Child(B) != [size]u8) {
@compileError("expected *[N]u8 " ++ ", passed " ++ @typeName(B));
@@ -1424,7 +1424,7 @@ pub fn bytesAsValue(comptime T: type, bytes: var) BytesAsValueReturnType(T, @typ
}
test "bytesAsValue" {
- const deadbeef = u32(0xDEADBEEF);
+ const deadbeef = @as(u32, 0xDEADBEEF);
const deadbeef_bytes = switch (builtin.endian) {
builtin.Endian.Big => "\xDE\xAD\xBE\xEF",
builtin.Endian.Little => "\xEF\xBE\xAD\xDE",
@@ -1472,7 +1472,7 @@ test "bytesToValue" {
};
const deadbeef = bytesToValue(u32, deadbeef_bytes);
- testing.expect(deadbeef == u32(0xDEADBEEF));
+ testing.expect(deadbeef == @as(u32, 0xDEADBEEF));
}
fn SubArrayPtrReturnType(comptime T: type, comptime length: usize) type {
lib/std/meta.zig
@@ -505,7 +505,7 @@ test "std.meta.eql" {
const EU = struct {
fn tst(err: bool) !u8 {
if (err) return error.Error;
- return u8(5);
+ return @as(u8, 5);
}
};
lib/std/net.zig
@@ -611,7 +611,7 @@ fn linuxLookupName(
// TODO sa6.addr[12..16] should return *[4]u8, making this cast unnecessary.
mem.writeIntNative(u32, @ptrCast(*[4]u8, &sa6.addr[12]), sa4.addr);
}
- if (dscope == i32(scopeOf(sa6.addr))) key |= DAS_MATCHINGSCOPE;
+ if (dscope == @as(i32, scopeOf(sa6.addr))) key |= DAS_MATCHINGSCOPE;
if (dlabel == labelOf(sa6.addr)) key |= DAS_MATCHINGLABEL;
prefixlen = prefixMatch(sa6.addr, da6.addr);
} else |_| {}
@@ -710,7 +710,7 @@ fn prefixMatch(s: [16]u8, d: [16]u8) u8 {
// address. However the definition of the source prefix length is
// not clear and thus this limiting is not yet implemented.
var i: u8 = 0;
- while (i < 128 and ((s[i / 8] ^ d[i / 8]) & (u8(128) >> @intCast(u3, i % 8))) == 0) : (i += 1) {}
+ while (i < 128 and ((s[i / 8] ^ d[i / 8]) & (@as(u8, 128) >> @intCast(u3, i % 8))) == 0) : (i += 1) {}
return i;
}
@@ -1194,23 +1194,23 @@ fn dnsParse(
if (r.len < 12) return error.InvalidDnsPacket;
if ((r[3] & 15) != 0) return;
var p = r.ptr + 12;
- var qdcount = r[4] * usize(256) + r[5];
- var ancount = r[6] * usize(256) + r[7];
+ var qdcount = r[4] * @as(usize, 256) + r[5];
+ var ancount = r[6] * @as(usize, 256) + r[7];
if (qdcount + ancount > 64) return error.InvalidDnsPacket;
while (qdcount != 0) {
qdcount -= 1;
while (@ptrToInt(p) - @ptrToInt(r.ptr) < r.len and p[0] -% 1 < 127) p += 1;
if (p[0] > 193 or (p[0] == 193 and p[1] > 254) or @ptrToInt(p) > @ptrToInt(r.ptr) + r.len - 6)
return error.InvalidDnsPacket;
- p += usize(5) + @boolToInt(p[0] != 0);
+ p += @as(usize, 5) + @boolToInt(p[0] != 0);
}
while (ancount != 0) {
ancount -= 1;
while (@ptrToInt(p) - @ptrToInt(r.ptr) < r.len and p[0] -% 1 < 127) p += 1;
if (p[0] > 193 or (p[0] == 193 and p[1] > 254) or @ptrToInt(p) > @ptrToInt(r.ptr) + r.len - 6)
return error.InvalidDnsPacket;
- p += usize(1) + @boolToInt(p[0] != 0);
- const len = p[8] * usize(256) + p[9];
+ p += @as(usize, 1) + @boolToInt(p[0] != 0);
+ const len = p[8] * @as(usize, 256) + p[9];
if (@ptrToInt(p) + len > @ptrToInt(r.ptr) + r.len) return error.InvalidDnsPacket;
try callback(ctx, p[1], p[10 .. 10 + len], r);
p += 10 + len;
lib/std/os.zig
@@ -472,7 +472,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!void {
var index: usize = 0;
while (index < bytes.len) {
- const amt_to_write = math.min(bytes.len - index, usize(max_bytes_len));
+ const amt_to_write = math.min(bytes.len - index, @as(usize, max_bytes_len));
const rc = system.write(fd, bytes.ptr + index, amt_to_write);
switch (errno(rc)) {
0 => {
@@ -1526,7 +1526,7 @@ pub fn isatty(handle: fd_t) bool {
}
if (builtin.os == .linux) {
var wsz: linux.winsize = undefined;
- return linux.syscall3(linux.SYS_ioctl, @bitCast(usize, isize(handle)), linux.TIOCGWINSZ, @ptrToInt(&wsz)) == 0;
+ return linux.syscall3(linux.SYS_ioctl, @bitCast(usize, @as(isize, handle)), linux.TIOCGWINSZ, @ptrToInt(&wsz)) == 0;
}
unreachable;
}
@@ -1547,7 +1547,7 @@ pub fn isCygwinPty(handle: fd_t) bool {
}
const name_info = @ptrCast(*const windows.FILE_NAME_INFO, &name_info_bytes[0]);
- const name_bytes = name_info_bytes[size .. size + usize(name_info.FileNameLength)];
+ const name_bytes = name_info_bytes[size .. size + @as(usize, name_info.FileNameLength)];
const name_wide = @bytesToSlice(u16, name_bytes);
return mem.indexOf(u16, name_wide, [_]u16{ 'm', 's', 'y', 's', '-' }) != null or
mem.indexOf(u16, name_wide, [_]u16{ '-', 'p', 't', 'y' }) != null;
@@ -2897,7 +2897,7 @@ pub fn res_mkquery(
// Construct query template - ID will be filled later
var q: [280]u8 = undefined;
@memset(&q, 0, n);
- q[2] = u8(op) * 8 + 1;
+ q[2] = @as(u8, op) * 8 + 1;
q[5] = 1;
mem.copy(u8, q[13..], name);
var i: usize = 13;
@@ -3143,7 +3143,7 @@ pub fn dn_expand(
// loop invariants: p<end, dest<dend
if ((p[0] & 0xc0) != 0) {
if (p + 1 == end) return error.InvalidDnsPacket;
- var j = ((p[0] & usize(0x3f)) << 8) | p[1];
+ var j = ((p[0] & @as(usize, 0x3f)) << 8) | p[1];
if (len == std.math.maxInt(usize)) len = @ptrToInt(p) + 2 - @ptrToInt(comp_dn.ptr);
if (j >= msg.len) return error.InvalidDnsPacket;
p = msg.ptr + j;
lib/std/packed_int_array.zig
@@ -331,7 +331,7 @@ test "PackedIntArray" {
var data = PackedArray(undefined);
//write values, counting up
- var i = usize(0);
+ var i = @as(usize, 0);
var count = I(0);
while (i < data.len()) : (i += 1) {
data.set(i, count);
@@ -352,7 +352,7 @@ test "PackedIntArray" {
test "PackedIntArray init" {
const PackedArray = PackedIntArray(u3, 8);
var packed_array = PackedArray.init([_]u3{ 0, 1, 2, 3, 4, 5, 6, 7 });
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_array.len()) : (i += 1) testing.expect(packed_array.get(i) == i);
}
@@ -375,7 +375,7 @@ test "PackedIntSlice" {
var data = P.init(&buffer, int_count);
//write values, counting up
- var i = usize(0);
+ var i = @as(usize, 0);
var count = I(0);
while (i < data.len()) : (i += 1) {
data.set(i, count);
@@ -406,7 +406,7 @@ test "PackedIntSlice of PackedInt(Array/Slice)" {
const limit = (1 << bits);
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_array.len()) : (i += 1) {
packed_array.set(i, @intCast(Int, i % limit));
}
@@ -466,7 +466,7 @@ test "PackedIntSlice accumulating bit offsets" {
var packed_array = PackedArray(undefined);
var packed_slice = packed_array.slice(0, packed_array.len());
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_array.len() - 1) : (i += 1) {
packed_slice = packed_slice.slice(1, packed_slice.len());
}
@@ -476,7 +476,7 @@ test "PackedIntSlice accumulating bit offsets" {
var packed_array = PackedArray(undefined);
var packed_slice = packed_array.slice(0, packed_array.len());
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_array.len() - 1) : (i += 1) {
packed_slice = packed_slice.slice(1, packed_slice.len());
}
@@ -493,7 +493,7 @@ test "PackedInt(Array/Slice) sliceCast" {
var packed_slice_cast_9 = packed_array.slice(0, (packed_array.len() / 9) * 9).sliceCast(u9);
const packed_slice_cast_3 = packed_slice_cast_9.sliceCast(u3);
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_slice_cast_2.len()) : (i += 1) {
const val = switch (builtin.endian) {
.Big => 0b01,
@@ -541,7 +541,7 @@ test "PackedInt(Array/Slice)Endian" {
testing.expect(packed_array_be.bytes[0] == 0b00000001);
testing.expect(packed_array_be.bytes[1] == 0b00100011);
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_array_be.len()) : (i += 1) {
testing.expect(packed_array_be.get(i) == i);
}
@@ -579,7 +579,7 @@ test "PackedInt(Array/Slice)Endian" {
testing.expect(packed_array_be.bytes[3] == 0b00000001);
testing.expect(packed_array_be.bytes[4] == 0b00000000);
- var i = usize(0);
+ var i = @as(usize, 0);
while (i < packed_array_be.len()) : (i += 1) {
testing.expect(packed_array_be.get(i) == i);
}
lib/std/pdb.zig
@@ -532,7 +532,7 @@ const Msf = struct {
const stream_sizes = try allocator.alloc(u32, stream_count);
defer allocator.free(stream_sizes);
- // Microsoft's implementation uses u32(-1) for inexistant streams.
+ // Microsoft's implementation uses @as(u32, -1) for inexistant streams.
// These streams are not used, but still participate in the file
// and must be taken into account when resolving stream indices.
const Nil = 0xFFFFFFFF;
lib/std/priority_queue.zig
@@ -236,12 +236,12 @@ test "std.PriorityQueue: add and remove min heap" {
try queue.add(23);
try queue.add(25);
try queue.add(13);
- expectEqual(u32(7), queue.remove());
- expectEqual(u32(12), queue.remove());
- expectEqual(u32(13), queue.remove());
- expectEqual(u32(23), queue.remove());
- expectEqual(u32(25), queue.remove());
- expectEqual(u32(54), queue.remove());
+ expectEqual(@as(u32, 7), queue.remove());
+ expectEqual(@as(u32, 12), queue.remove());
+ expectEqual(@as(u32, 13), queue.remove());
+ expectEqual(@as(u32, 23), queue.remove());
+ expectEqual(@as(u32, 25), queue.remove());
+ expectEqual(@as(u32, 54), queue.remove());
}
test "std.PriorityQueue: add and remove same min heap" {
@@ -254,12 +254,12 @@ test "std.PriorityQueue: add and remove same min heap" {
try queue.add(2);
try queue.add(1);
try queue.add(1);
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(2), queue.remove());
- expectEqual(u32(2), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 2), queue.remove());
+ expectEqual(@as(u32, 2), queue.remove());
}
test "std.PriorityQueue: removeOrNull on empty" {
@@ -276,9 +276,9 @@ test "std.PriorityQueue: edge case 3 elements" {
try queue.add(9);
try queue.add(3);
try queue.add(2);
- expectEqual(u32(2), queue.remove());
- expectEqual(u32(3), queue.remove());
- expectEqual(u32(9), queue.remove());
+ expectEqual(@as(u32, 2), queue.remove());
+ expectEqual(@as(u32, 3), queue.remove());
+ expectEqual(@as(u32, 9), queue.remove());
}
test "std.PriorityQueue: peek" {
@@ -289,8 +289,8 @@ test "std.PriorityQueue: peek" {
try queue.add(9);
try queue.add(3);
try queue.add(2);
- expectEqual(u32(2), queue.peek().?);
- expectEqual(u32(2), queue.peek().?);
+ expectEqual(@as(u32, 2), queue.peek().?);
+ expectEqual(@as(u32, 2), queue.peek().?);
}
test "std.PriorityQueue: sift up with odd indices" {
@@ -341,12 +341,12 @@ test "std.PriorityQueue: add and remove max heap" {
try queue.add(23);
try queue.add(25);
try queue.add(13);
- expectEqual(u32(54), queue.remove());
- expectEqual(u32(25), queue.remove());
- expectEqual(u32(23), queue.remove());
- expectEqual(u32(13), queue.remove());
- expectEqual(u32(12), queue.remove());
- expectEqual(u32(7), queue.remove());
+ expectEqual(@as(u32, 54), queue.remove());
+ expectEqual(@as(u32, 25), queue.remove());
+ expectEqual(@as(u32, 23), queue.remove());
+ expectEqual(@as(u32, 13), queue.remove());
+ expectEqual(@as(u32, 12), queue.remove());
+ expectEqual(@as(u32, 7), queue.remove());
}
test "std.PriorityQueue: add and remove same max heap" {
@@ -359,12 +359,12 @@ test "std.PriorityQueue: add and remove same max heap" {
try queue.add(2);
try queue.add(1);
try queue.add(1);
- expectEqual(u32(2), queue.remove());
- expectEqual(u32(2), queue.remove());
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(1), queue.remove());
- expectEqual(u32(1), queue.remove());
+ expectEqual(@as(u32, 2), queue.remove());
+ expectEqual(@as(u32, 2), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
+ expectEqual(@as(u32, 1), queue.remove());
}
test "std.PriorityQueue: iterator" {
@@ -386,5 +386,5 @@ test "std.PriorityQueue: iterator" {
_ = map.remove(e);
}
- expectEqual(usize(0), map.count());
+ expectEqual(@as(usize, 0), map.count());
}
lib/std/rand.zig
@@ -633,8 +633,8 @@ pub const Xoroshiro128 = struct {
const r = s0 +% s1;
s1 ^= s0;
- self.s[0] = math.rotl(u64, s0, u8(55)) ^ s1 ^ (s1 << 14);
- self.s[1] = math.rotl(u64, s1, u8(36));
+ self.s[0] = math.rotl(u64, s0, @as(u8, 55)) ^ s1 ^ (s1 << 14);
+ self.s[1] = math.rotl(u64, s1, @as(u8, 36));
return r;
}
@@ -652,7 +652,7 @@ pub const Xoroshiro128 = struct {
inline for (table) |entry| {
var b: usize = 0;
while (b < 64) : (b += 1) {
- if ((entry & (u64(1) << @intCast(u6, b))) != 0) {
+ if ((entry & (@as(u64, 1) << @intCast(u6, b))) != 0) {
s0 ^= self.s[0];
s1 ^= self.s[1];
}
@@ -1090,7 +1090,7 @@ fn testRange(r: *Random, start: i8, end: i8) void {
testRangeBias(r, start, end, false);
}
fn testRangeBias(r: *Random, start: i8, end: i8, biased: bool) void {
- const count = @intCast(usize, i32(end) - i32(start));
+ const count = @intCast(usize, @as(i32, end) - @as(i32, start));
var values_buffer = [_]bool{false} ** 0x100;
const values = values_buffer[0..count];
var i: usize = 0;
lib/std/segmented_list.zig
@@ -162,7 +162,7 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
/// Grows or shrinks capacity to match usage.
pub fn setCapacity(self: *Self, new_capacity: usize) !void {
if (prealloc_item_count != 0) {
- if (new_capacity <= usize(1) << (prealloc_exp + @intCast(ShelfIndex, self.dynamic_segments.len))) {
+ if (new_capacity <= @as(usize, 1) << (prealloc_exp + @intCast(ShelfIndex, self.dynamic_segments.len))) {
return self.shrinkCapacity(new_capacity);
}
}
@@ -231,9 +231,9 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
fn shelfSize(shelf_index: ShelfIndex) usize {
if (prealloc_item_count == 0) {
- return usize(1) << shelf_index;
+ return @as(usize, 1) << shelf_index;
}
- return usize(1) << (shelf_index + (prealloc_exp + 1));
+ return @as(usize, 1) << (shelf_index + (prealloc_exp + 1));
}
fn shelfIndex(list_index: usize) ShelfIndex {
@@ -245,9 +245,9 @@ pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type
fn boxIndex(list_index: usize, shelf_index: ShelfIndex) usize {
if (prealloc_item_count == 0) {
- return (list_index + 1) - (usize(1) << shelf_index);
+ return (list_index + 1) - (@as(usize, 1) << shelf_index);
}
- return list_index + prealloc_item_count - (usize(1) << ((prealloc_exp + 1) + shelf_index));
+ return list_index + prealloc_item_count - (@as(usize, 1) << ((prealloc_exp + 1) + shelf_index));
}
fn freeShelves(self: *Self, from_count: ShelfIndex, to_count: ShelfIndex) void {
lib/std/sort.zig
@@ -813,7 +813,7 @@ fn blockSwap(comptime T: type, items: []T, start1: usize, start2: usize, block_s
// where have some idea as to how many unique values there are and where the next value might be
fn findFirstForward(comptime T: type, items: []T, value: T, range: Range, lessThan: fn (T, T) bool, unique: usize) usize {
if (range.length() == 0) return range.start;
- const skip = math.max(range.length() / unique, usize(1));
+ const skip = math.max(range.length() / unique, @as(usize, 1));
var index = range.start + skip;
while (lessThan(items[index - 1], value)) : (index += skip) {
@@ -827,7 +827,7 @@ fn findFirstForward(comptime T: type, items: []T, value: T, range: Range, lessTh
fn findFirstBackward(comptime T: type, items: []T, value: T, range: Range, lessThan: fn (T, T) bool, unique: usize) usize {
if (range.length() == 0) return range.start;
- const skip = math.max(range.length() / unique, usize(1));
+ const skip = math.max(range.length() / unique, @as(usize, 1));
var index = range.end - skip;
while (index > range.start and !lessThan(items[index - 1], value)) : (index -= skip) {
@@ -841,7 +841,7 @@ fn findFirstBackward(comptime T: type, items: []T, value: T, range: Range, lessT
fn findLastForward(comptime T: type, items: []T, value: T, range: Range, lessThan: fn (T, T) bool, unique: usize) usize {
if (range.length() == 0) return range.start;
- const skip = math.max(range.length() / unique, usize(1));
+ const skip = math.max(range.length() / unique, @as(usize, 1));
var index = range.start + skip;
while (!lessThan(value, items[index - 1])) : (index += skip) {
@@ -855,7 +855,7 @@ fn findLastForward(comptime T: type, items: []T, value: T, range: Range, lessTha
fn findLastBackward(comptime T: type, items: []T, value: T, range: Range, lessThan: fn (T, T) bool, unique: usize) usize {
if (range.length() == 0) return range.start;
- const skip = math.max(range.length() / unique, usize(1));
+ const skip = math.max(range.length() / unique, @as(usize, 1));
var index = range.end - skip;
while (index > range.start and lessThan(value, items[index - 1])) : (index -= skip) {
lib/std/target.zig
@@ -581,7 +581,7 @@ pub const Target = union(enum) {
};
pub fn getExternalExecutor(self: Target) Executor {
- if (@TagType(Target)(self) == .Native) return .native;
+ if (@as(@TagType(Target),self) == .Native) return .native;
// If the target OS matches the host OS, we can use QEMU to emulate a foreign architecture.
if (self.getOs() == builtin.os) {
lib/std/thread.zig
@@ -344,7 +344,7 @@ pub const Thread = struct {
pub fn cpuCount() CpuCountError!usize {
if (builtin.os == .linux) {
const cpu_set = try os.sched_getaffinity(0);
- return usize(os.CPU_COUNT(cpu_set)); // TODO should not need this usize cast
+ return @as(usize, os.CPU_COUNT(cpu_set)); // TODO should not need this usize cast
}
if (builtin.os == .windows) {
var system_info: windows.SYSTEM_INFO = undefined;
lib/std/time.zig
@@ -38,7 +38,7 @@ pub fn milliTimestamp() u64 {
const hns_per_ms = (ns_per_s / 100) / ms_per_s;
const epoch_adj = epoch.windows * ms_per_s;
- const ft64 = (u64(ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ const ft64 = (@as(u64, ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
return @divFloor(ft64, hns_per_ms) - -epoch_adj;
}
if (builtin.os == .wasi and !builtin.link_libc) {
@@ -142,10 +142,10 @@ pub const Timer = struct {
// seccomp is going to block us it will at least do so consistently
var ts: os.timespec = undefined;
os.clock_getres(monotonic_clock_id, &ts) catch return error.TimerUnsupported;
- self.resolution = @intCast(u64, ts.tv_sec) * u64(ns_per_s) + @intCast(u64, ts.tv_nsec);
+ self.resolution = @intCast(u64, ts.tv_sec) * @as(u64, ns_per_s) + @intCast(u64, ts.tv_nsec);
os.clock_gettime(monotonic_clock_id, &ts) catch return error.TimerUnsupported;
- self.start_time = @intCast(u64, ts.tv_sec) * u64(ns_per_s) + @intCast(u64, ts.tv_nsec);
+ self.start_time = @intCast(u64, ts.tv_sec) * @as(u64, ns_per_s) + @intCast(u64, ts.tv_nsec);
}
return self;
@@ -185,7 +185,7 @@ pub const Timer = struct {
}
var ts: os.timespec = undefined;
os.clock_gettime(monotonic_clock_id, &ts) catch unreachable;
- return @intCast(u64, ts.tv_sec) * u64(ns_per_s) + @intCast(u64, ts.tv_nsec);
+ return @intCast(u64, ts.tv_sec) * @as(u64, ns_per_s) + @intCast(u64, ts.tv_nsec);
}
};
lib/std/unicode.zig
@@ -68,7 +68,7 @@ const Utf8DecodeError = Utf8Decode2Error || Utf8Decode3Error || Utf8Decode4Error
/// utf8Decode2,utf8Decode3,utf8Decode4 directly instead of this function.
pub fn utf8Decode(bytes: []const u8) Utf8DecodeError!u32 {
return switch (bytes.len) {
- 1 => u32(bytes[0]),
+ 1 => @as(u32, bytes[0]),
2 => utf8Decode2(bytes),
3 => utf8Decode3(bytes),
4 => utf8Decode4(bytes),
@@ -226,7 +226,7 @@ pub const Utf8Iterator = struct {
const slice = it.nextCodepointSlice() orelse return null;
switch (slice.len) {
- 1 => return u32(slice[0]),
+ 1 => return @as(u32, slice[0]),
2 => return utf8Decode2(slice) catch unreachable,
3 => return utf8Decode3(slice) catch unreachable,
4 => return utf8Decode4(slice) catch unreachable,
@@ -250,15 +250,15 @@ pub const Utf16LeIterator = struct {
assert(it.i <= it.bytes.len);
if (it.i == it.bytes.len) return null;
const c0: u32 = mem.readIntSliceLittle(u16, it.bytes[it.i .. it.i + 2]);
- if (c0 & ~u32(0x03ff) == 0xd800) {
+ if (c0 & ~@as(u32, 0x03ff) == 0xd800) {
// surrogate pair
it.i += 2;
if (it.i >= it.bytes.len) return error.DanglingSurrogateHalf;
const c1: u32 = mem.readIntSliceLittle(u16, it.bytes[it.i .. it.i + 2]);
- if (c1 & ~u32(0x03ff) != 0xdc00) return error.ExpectedSecondSurrogateHalf;
+ if (c1 & ~@as(u32, 0x03ff) != 0xdc00) return error.ExpectedSecondSurrogateHalf;
it.i += 2;
return 0x10000 + (((c0 & 0x03ff) << 10) | (c1 & 0x03ff));
- } else if (c0 & ~u32(0x03ff) == 0xdc00) {
+ } else if (c0 & ~@as(u32, 0x03ff) == 0xdc00) {
return error.UnexpectedSecondSurrogateHalf;
} else {
it.i += 2;
lib/std/valgrind.zig
@@ -76,7 +76,7 @@ pub const ClientRequest = extern enum {
InnerThreads = 6402,
};
pub fn ToolBase(base: [2]u8) u32 {
- return (u32(base[0] & 0xff) << 24) | (u32(base[1] & 0xff) << 16);
+ return (@as(u32, base[0] & 0xff) << 24) | (@as(u32, base[1] & 0xff) << 16);
}
pub fn IsTool(base: [2]u8, code: usize) bool {
return ToolBase(base) == (code & 0xffff0000);
test/stage1/behavior/bugs/1322.zig
@@ -13,7 +13,7 @@ const C = struct {};
test "tagged union with all void fields but a meaningful tag" {
var a: A = A{ .b = B{ .c = C{} } };
- std.testing.expect(@TagType(B)(a.b) == @TagType(B).c);
+ std.testing.expect(@as(@TagType(B), a.b) == @TagType(B).c);
a = A{ .b = B.None };
- std.testing.expect(@TagType(B)(a.b) == @TagType(B).None);
+ std.testing.expect(@as(@TagType(B), a.b) == @TagType(B).None);
}
test/stage1/behavior/bugs/1421.zig
@@ -10,5 +10,5 @@ const S = struct {
test "functions with return type required to be comptime are generic" {
const ti = S.method();
- expect(builtin.TypeId(ti) == builtin.TypeId.Struct);
+ expect(@as(builtin.TypeId, ti) == builtin.TypeId.Struct);
}
test/stage1/behavior/bugs/2114.zig
@@ -12,8 +12,8 @@ test "fixed" {
}
fn testClz() void {
- expect(ctz(u128(0x40000000000000000000000000000000)) == 126);
- expect(math.rotl(u128, u128(0x40000000000000000000000000000000), u8(1)) == u128(0x80000000000000000000000000000000));
- expect(ctz(u128(0x80000000000000000000000000000000)) == 127);
- expect(ctz(math.rotl(u128, u128(0x40000000000000000000000000000000), u8(1))) == 127);
+ expect(ctz(@as(u128, 0x40000000000000000000000000000000)) == 126);
+ expect(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1)) == @as(u128, 0x80000000000000000000000000000000));
+ expect(ctz(@as(u128, 0x80000000000000000000000000000000)) == 127);
+ expect(ctz(math.rotl(u128, @as(u128, 0x40000000000000000000000000000000), @as(u8, 1))) == 127);
}
test/stage1/behavior/bugs/3046.zig
@@ -13,7 +13,7 @@ var some_struct: SomeStruct = undefined;
test "fixed" {
some_struct = SomeStruct{
- .field = couldFail() catch |_| i32(0),
+ .field = couldFail() catch |_| @as(i32, 0),
};
expect(some_struct.field == 1);
}
test/stage1/behavior/align.zig
@@ -7,7 +7,7 @@ var foo: u8 align(4) = 100;
test "global variable alignment" {
expect(@typeOf(&foo).alignment == 4);
expect(@typeOf(&foo) == *align(4) u8);
- const slice = (*[1]u8)(&foo)[0..];
+ const slice = @as(*[1]u8, &foo)[0..];
expect(@typeOf(slice) == []align(4) u8);
}
@@ -61,7 +61,7 @@ fn addUnaligned(a: *align(1) const u32, b: *align(1) const u32) u32 {
test "implicitly decreasing slice alignment" {
const a: u32 align(4) = 3;
const b: u32 align(8) = 4;
- expect(addUnalignedSlice((*const [1]u32)(&a)[0..], (*const [1]u32)(&b)[0..]) == 7);
+ expect(addUnalignedSlice(@as(*const [1]u32, &a)[0..], @as(*const [1]u32, &b)[0..]) == 7);
}
fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
return a[0] + b[0];
test/stage1/behavior/array.zig
@@ -12,7 +12,7 @@ test "arrays" {
}
i = 0;
- var accumulator = u32(0);
+ var accumulator = @as(u32, 0);
while (i < 5) {
accumulator += array[i];
@@ -149,7 +149,7 @@ test "implicit cast single-item pointer" {
fn testImplicitCastSingleItemPtr() void {
var byte: u8 = 100;
- const slice = (*[1]u8)(&byte)[0..];
+ const slice = @as(*[1]u8, &byte)[0..];
slice[0] += 1;
expect(byte == 101);
}
test/stage1/behavior/asm.zig
@@ -45,42 +45,42 @@ test "alternative constraints" {
test "sized integer/float in asm input" {
asm volatile (""
:
- : [_] "m" (usize(3))
+ : [_] "m" (@as(usize, 3))
: ""
);
asm volatile (""
:
- : [_] "m" (i15(-3))
+ : [_] "m" (@as(i15, -3))
: ""
);
asm volatile (""
:
- : [_] "m" (u3(3))
+ : [_] "m" (@as(u3, 3))
: ""
);
asm volatile (""
:
- : [_] "m" (i3(3))
+ : [_] "m" (@as(i3, 3))
: ""
);
asm volatile (""
:
- : [_] "m" (u121(3))
+ : [_] "m" (@as(u121, 3))
: ""
);
asm volatile (""
:
- : [_] "m" (i121(3))
+ : [_] "m" (@as(i121, 3))
: ""
);
asm volatile (""
:
- : [_] "m" (f32(3.17))
+ : [_] "m" (@as(f32, 3.17))
: ""
);
asm volatile (""
:
- : [_] "m" (f64(3.17))
+ : [_] "m" (@as(f64, 3.17))
: ""
);
}
test/stage1/behavior/async_fn.zig
@@ -191,7 +191,7 @@ async fn testSuspendBlock() void {
// Test to make sure that @frame() works as advertised (issue #1296)
// var our_handle: anyframe = @frame();
- expect(a_promise == anyframe(@frame()));
+ expect(a_promise == @as(anyframe, @frame()));
global_result = true;
}
@@ -543,7 +543,7 @@ test "pass string literal to async function" {
fn hello(msg: []const u8) void {
frame = @frame();
suspend;
- expectEqual(([]const u8)("hello"), msg);
+ expectEqual(@as([]const u8, "hello"), msg);
ok = true;
}
};
@@ -1048,7 +1048,7 @@ test "using @typeOf on a generic function call" {
return await @asyncCall(frame, {}, amain, x - 1);
}
};
- _ = async S.amain(u32(1));
+ _ = async S.amain(@as(u32, 1));
resume S.global_frame;
expect(S.global_ok);
}
@@ -1080,8 +1080,8 @@ test "recursive call of await @asyncCall with struct return type" {
};
};
var res: S.Foo = undefined;
- var frame: @typeOf(async S.amain(u32(1))) = undefined;
- _ = @asyncCall(&frame, &res, S.amain, u32(1));
+ var frame: @typeOf(async S.amain(@as(u32, 1))) = undefined;
+ _ = @asyncCall(&frame, &res, S.amain, @as(u32, 1));
resume S.global_frame;
expect(S.global_ok);
expect(res.x == 1);
test/stage1/behavior/atomics.zig
@@ -98,12 +98,12 @@ test "cmpxchg with ignored result" {
_ = @cmpxchgStrong(i32, &x, 1234, 5678, .Monotonic, .Monotonic);
- expectEqual(i32(5678), x);
+ expectEqual(@as(i32, 5678), x);
}
-var a_global_variable = u32(1234);
+var a_global_variable = @as(u32, 1234);
test "cmpxchg on a global variable" {
_ = @cmpxchgWeak(u32, &a_global_variable, 1234, 42, .Acquire, .Monotonic);
- expectEqual(u32(42), a_global_variable);
+ expectEqual(@as(u32, 42), a_global_variable);
}
test/stage1/behavior/bitreverse.zig
@@ -46,24 +46,24 @@ fn testBitReverse() void {
expect(@bitReverse(u128, num128) == 0x818e868a828c84888f7b3d591e6a2c48);
// using comptime_ints, signed, positive
- expect(@bitReverse(u8, u8(0)) == 0);
- expect(@bitReverse(i8, @bitCast(i8, u8(0x92))) == @bitCast(i8, u8(0x49)));
- expect(@bitReverse(i16, @bitCast(i16, u16(0x1234))) == @bitCast(i16, u16(0x2c48)));
- expect(@bitReverse(i24, @bitCast(i24, u24(0x123456))) == @bitCast(i24, u24(0x6a2c48)));
- expect(@bitReverse(i32, @bitCast(i32, u32(0x12345678))) == @bitCast(i32, u32(0x1e6a2c48)));
- expect(@bitReverse(i40, @bitCast(i40, u40(0x123456789a))) == @bitCast(i40, u40(0x591e6a2c48)));
- expect(@bitReverse(i48, @bitCast(i48, u48(0x123456789abc))) == @bitCast(i48, u48(0x3d591e6a2c48)));
- expect(@bitReverse(i56, @bitCast(i56, u56(0x123456789abcde))) == @bitCast(i56, u56(0x7b3d591e6a2c48)));
- expect(@bitReverse(i64, @bitCast(i64, u64(0x123456789abcdef1))) == @bitCast(i64, u64(0x8f7b3d591e6a2c48)));
- expect(@bitReverse(i128, @bitCast(i128, u128(0x123456789abcdef11121314151617181))) == @bitCast(i128, u128(0x818e868a828c84888f7b3d591e6a2c48)));
+ expect(@bitReverse(u8, @as(u8, 0)) == 0);
+ expect(@bitReverse(i8, @bitCast(i8, @as(u8, 0x92))) == @bitCast(i8, @as(u8, 0x49)));
+ expect(@bitReverse(i16, @bitCast(i16, @as(u16, 0x1234))) == @bitCast(i16, @as(u16, 0x2c48)));
+ expect(@bitReverse(i24, @bitCast(i24, @as(u24, 0x123456))) == @bitCast(i24, @as(u24, 0x6a2c48)));
+ expect(@bitReverse(i32, @bitCast(i32, @as(u32, 0x12345678))) == @bitCast(i32, @as(u32, 0x1e6a2c48)));
+ expect(@bitReverse(i40, @bitCast(i40, @as(u40, 0x123456789a))) == @bitCast(i40, @as(u40, 0x591e6a2c48)));
+ expect(@bitReverse(i48, @bitCast(i48, @as(u48, 0x123456789abc))) == @bitCast(i48, @as(u48, 0x3d591e6a2c48)));
+ expect(@bitReverse(i56, @bitCast(i56, @as(u56, 0x123456789abcde))) == @bitCast(i56, @as(u56, 0x7b3d591e6a2c48)));
+ expect(@bitReverse(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1))) == @bitCast(i64, @as(u64, 0x8f7b3d591e6a2c48)));
+ expect(@bitReverse(i128, @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181))) == @bitCast(i128, @as(u128, 0x818e868a828c84888f7b3d591e6a2c48)));
// using signed, negative. Compare to runtime ints returned from llvm.
var neg8: i8 = -18;
- expect(@bitReverse(i8, i8(-18)) == @bitReverse(i8, neg8));
+ expect(@bitReverse(i8, @as(i8, -18)) == @bitReverse(i8, neg8));
var neg16: i16 = -32694;
- expect(@bitReverse(i16, i16(-32694)) == @bitReverse(i16, neg16));
+ expect(@bitReverse(i16, @as(i16, -32694)) == @bitReverse(i16, neg16));
var neg24: i24 = -6773785;
- expect(@bitReverse(i24, i24(-6773785)) == @bitReverse(i24, neg24));
+ expect(@bitReverse(i24, @as(i24, -6773785)) == @bitReverse(i24, neg24));
var neg32: i32 = -16773785;
- expect(@bitReverse(i32, i32(-16773785)) == @bitReverse(i32, neg32));
+ expect(@bitReverse(i32, @as(i32, -16773785)) == @bitReverse(i32, neg32));
}
test/stage1/behavior/bool.zig
@@ -8,14 +8,14 @@ test "bool literals" {
test "cast bool to int" {
const t = true;
const f = false;
- expect(@boolToInt(t) == u32(1));
- expect(@boolToInt(f) == u32(0));
+ expect(@boolToInt(t) == @as(u32, 1));
+ expect(@boolToInt(f) == @as(u32, 0));
nonConstCastBoolToInt(t, f);
}
fn nonConstCastBoolToInt(t: bool, f: bool) void {
- expect(@boolToInt(t) == u32(1));
- expect(@boolToInt(f) == u32(0));
+ expect(@boolToInt(t) == @as(u32, 1));
+ expect(@boolToInt(f) == @as(u32, 0));
}
test "bool cmp" {
test/stage1/behavior/byteswap.zig
@@ -11,24 +11,24 @@ test "@byteSwap integers" {
t(u24, 0x123456, 0x563412);
t(u32, 0x12345678, 0x78563412);
t(u40, 0x123456789a, 0x9a78563412);
- t(i48, 0x123456789abc, @bitCast(i48, u48(0xbc9a78563412)));
+ t(i48, 0x123456789abc, @bitCast(i48, @as(u48, 0xbc9a78563412)));
t(u56, 0x123456789abcde, 0xdebc9a78563412);
t(u64, 0x123456789abcdef1, 0xf1debc9a78563412);
t(u128, 0x123456789abcdef11121314151617181, 0x8171615141312111f1debc9a78563412);
- t(u0, u0(0), 0);
- t(i8, i8(-50), -50);
- t(i16, @bitCast(i16, u16(0x1234)), @bitCast(i16, u16(0x3412)));
- t(i24, @bitCast(i24, u24(0x123456)), @bitCast(i24, u24(0x563412)));
- t(i32, @bitCast(i32, u32(0x12345678)), @bitCast(i32, u32(0x78563412)));
- t(u40, @bitCast(i40, u40(0x123456789a)), u40(0x9a78563412));
- t(i48, @bitCast(i48, u48(0x123456789abc)), @bitCast(i48, u48(0xbc9a78563412)));
- t(i56, @bitCast(i56, u56(0x123456789abcde)), @bitCast(i56, u56(0xdebc9a78563412)));
- t(i64, @bitCast(i64, u64(0x123456789abcdef1)), @bitCast(i64, u64(0xf1debc9a78563412)));
+ t(u0, @as(u0, 0), 0);
+ t(i8, @as(i8, -50), -50);
+ t(i16, @bitCast(i16, @as(u16, 0x1234)), @bitCast(i16, @as(u16, 0x3412)));
+ t(i24, @bitCast(i24, @as(u24, 0x123456)), @bitCast(i24, @as(u24, 0x563412)));
+ t(i32, @bitCast(i32, @as(u32, 0x12345678)), @bitCast(i32, @as(u32, 0x78563412)));
+ t(u40, @bitCast(i40, @as(u40, 0x123456789a)), @as(u40, 0x9a78563412));
+ t(i48, @bitCast(i48, @as(u48, 0x123456789abc)), @bitCast(i48, @as(u48, 0xbc9a78563412)));
+ t(i56, @bitCast(i56, @as(u56, 0x123456789abcde)), @bitCast(i56, @as(u56, 0xdebc9a78563412)));
+ t(i64, @bitCast(i64, @as(u64, 0x123456789abcdef1)), @bitCast(i64, @as(u64, 0xf1debc9a78563412)));
t(
i128,
- @bitCast(i128, u128(0x123456789abcdef11121314151617181)),
- @bitCast(i128, u128(0x8171615141312111f1debc9a78563412)),
+ @bitCast(i128, @as(u128, 0x123456789abcdef11121314151617181)),
+ @bitCast(i128, @as(u128, 0x8171615141312111f1debc9a78563412)),
);
}
fn t(comptime I: type, input: I, expected_output: I) void {
test/stage1/behavior/cast.zig
@@ -4,7 +4,7 @@ const mem = std.mem;
const maxInt = std.math.maxInt;
test "int to ptr cast" {
- const x = usize(13);
+ const x = @as(usize, 13);
const y = @intToPtr(*u8, x);
const z = @ptrToInt(y);
expect(z == 13);
@@ -90,7 +90,7 @@ const A = struct {
a: i32,
};
fn castToOptionalTypeError(z: i32) void {
- const x = i32(1);
+ const x = @as(i32, 1);
const y: anyerror!?i32 = x;
expect((try y).? == 1);
@@ -134,10 +134,10 @@ test "peer type resolution: ?T and T" {
}
fn peerTypeTAndOptionalT(c: bool, b: bool) ?usize {
if (c) {
- return if (b) null else usize(0);
+ return if (b) null else @as(usize, 0);
}
- return usize(3);
+ return @as(usize, 3);
}
test "peer type resolution: [0]u8 and []const u8" {
@@ -256,7 +256,7 @@ test "@floatToInt" {
}
fn testFloatToInts() void {
- const x = i32(1e4);
+ const x = @as(i32, 1e4);
expect(x == 10000);
const y = @floatToInt(i32, f32(1e4));
expect(y == 10000);
@@ -442,7 +442,7 @@ fn incrementVoidPtrArray(array: ?*c_void, len: usize) void {
}
test "*usize to *void" {
- var i = usize(0);
+ var i = @as(usize, 0);
var v = @ptrCast(*void, &i);
v.* = {};
}
test/stage1/behavior/defer.zig
@@ -52,7 +52,7 @@ fn testBreakContInDefer(x: usize) void {
}
test "defer and labeled break" {
- var i = usize(0);
+ var i = @as(usize, 0);
blk: {
defer i += 1;
test/stage1/behavior/enum.zig
@@ -788,7 +788,7 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) void {
expect(1234 == switch (x) {
MultipleChoice.A => 1,
MultipleChoice.B => 2,
- MultipleChoice.C => u32(1234),
+ MultipleChoice.C => @as(u32, 1234),
MultipleChoice.D => 4,
});
}
@@ -816,7 +816,7 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {
MultipleChoice2.A => 1,
MultipleChoice2.B => 2,
MultipleChoice2.C => 3,
- MultipleChoice2.D => u32(1234),
+ MultipleChoice2.D => @as(u32, 1234),
MultipleChoice2.Unspecified1 => 5,
MultipleChoice2.Unspecified2 => 6,
MultipleChoice2.Unspecified3 => 7,
test/stage1/behavior/error.zig
@@ -51,7 +51,7 @@ test "error binary operator" {
expect(b == 10);
}
fn errBinaryOperatorG(x: bool) anyerror!isize {
- return if (x) error.ItBroke else isize(10);
+ return if (x) error.ItBroke else @as(isize, 10);
}
test "unwrap simple value from error" {
@@ -295,7 +295,7 @@ test "nested error union function call in optional unwrap" {
test "widen cast integer payload of error union function call" {
const S = struct {
fn errorable() !u64 {
- var x = u64(try number());
+ var x = @as(u64, try number());
return x;
}
test/stage1/behavior/eval.zig
@@ -405,19 +405,19 @@ test "float literal at compile time not lossy" {
}
test "f32 at compile time is lossy" {
- expect(f32(1 << 24) + 1 == 1 << 24);
+ expect(@as(f32, 1 << 24) + 1 == 1 << 24);
}
test "f64 at compile time is lossy" {
- expect(f64(1 << 53) + 1 == 1 << 53);
+ expect(@as(f64, 1 << 53) + 1 == 1 << 53);
}
test "f128 at compile time is lossy" {
- expect(f128(10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0);
+ expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0);
}
comptime {
- expect(f128(1 << 113) == 10384593717069655257060992658440192);
+ expect(@as(f128, 1 << 113) == 10384593717069655257060992658440192);
}
pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {
@@ -434,9 +434,9 @@ test "string literal used as comptime slice is memoized" {
}
test "comptime slice of undefined pointer of length 0" {
- const slice1 = ([*]i32)(undefined)[0..0];
+ const slice1 = @as([*]i32, undefined)[0..0];
expect(slice1.len == 0);
- const slice2 = ([*]i32)(undefined)[100..100];
+ const slice2 = @as([*]i32, undefined)[100..100];
expect(slice2.len == 0);
}
@@ -444,10 +444,10 @@ fn copyWithPartialInline(s: []u32, b: []u8) void {
comptime var i: usize = 0;
inline while (i < 4) : (i += 1) {
s[i] = 0;
- s[i] |= u32(b[i * 4 + 0]) << 24;
- s[i] |= u32(b[i * 4 + 1]) << 16;
- s[i] |= u32(b[i * 4 + 2]) << 8;
- s[i] |= u32(b[i * 4 + 3]) << 0;
+ s[i] |= @as(u32, b[i * 4 + 0]) << 24;
+ s[i] |= @as(u32, b[i * 4 + 1]) << 16;
+ s[i] |= @as(u32, b[i * 4 + 2]) << 8;
+ s[i] |= @as(u32, b[i * 4 + 3]) << 0;
}
}
@@ -557,14 +557,14 @@ test "array concat of slices gives slice" {
test "comptime shlWithOverflow" {
const ct_shifted: u64 = comptime amt: {
- var amt = u64(0);
- _ = @shlWithOverflow(u64, ~u64(0), 16, &amt);
+ var amt = @as(u64, 0);
+ _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
break :amt amt;
};
const rt_shifted: u64 = amt: {
- var amt = u64(0);
- _ = @shlWithOverflow(u64, ~u64(0), 16, &amt);
+ var amt = @as(u64, 0);
+ _ = @shlWithOverflow(u64, ~@as(u64, 0), 16, &amt);
break :amt amt;
};
@@ -670,7 +670,7 @@ fn loopNTimes(comptime n: usize) void {
}
test "variable inside inline loop that has different types on different iterations" {
- testVarInsideInlineLoop(true, u32(42));
+ testVarInsideInlineLoop(true, @as(u32, 42));
}
fn testVarInsideInlineLoop(args: ...) void {
@@ -757,11 +757,11 @@ test "comptime bitwise operators" {
expect(-3 | -1 == -1);
expect(3 ^ -1 == -4);
expect(-3 ^ -1 == 2);
- expect(~i8(-1) == 0);
- expect(~i128(-1) == 0);
+ expect(~@as(i8, -1) == 0);
+ expect(~@as(i128, -1) == 0);
expect(18446744073709551615 & 18446744073709551611 == 18446744073709551611);
expect(-18446744073709551615 & -18446744073709551611 == -18446744073709551615);
- expect(~u128(0) == 0xffffffffffffffffffffffffffffffff);
+ expect(~@as(u128, 0) == 0xffffffffffffffffffffffffffffffff);
}
}
test/stage1/behavior/floatop.zig
@@ -117,11 +117,11 @@ test "@ln" {
fn testLn() void {
{
var a: f32 = e;
- expect(@ln(f32, a) == 1 or @ln(f32, a) == @bitCast(f32, u32(0x3f7fffff)));
+ expect(@ln(f32, a) == 1 or @ln(f32, a) == @bitCast(f32, @as(u32, 0x3f7fffff)));
}
{
var a: f64 = e;
- expect(@ln(f64, a) == 1 or @ln(f64, a) == @bitCast(f64, u64(0x3ff0000000000000)));
+ expect(@ln(f64, a) == 1 or @ln(f64, a) == @bitCast(f64, @as(u64, 0x3ff0000000000000)));
}
}
test/stage1/behavior/fn.zig
@@ -29,7 +29,7 @@ test "mutable local variables" {
var zero: i32 = 0;
expect(zero == 0);
- var i = i32(0);
+ var i = @as(i32, 0);
while (i != 3) {
i += 1;
}
@@ -43,7 +43,7 @@ test "separate block scopes" {
}
const c = x: {
- const no_conflict = i32(10);
+ const no_conflict = @as(i32, 10);
break :x no_conflict;
};
expect(c == 10);
test/stage1/behavior/if.zig
@@ -32,7 +32,7 @@ fn elseIfExpressionF(c: u8) u8 {
} else if (c == 1) {
return 1;
} else {
- return u8(2);
+ return @as(u8, 2);
}
}
@@ -58,7 +58,7 @@ test "labeled break inside comptime if inside runtime if" {
var c = true;
if (c) {
answer = if (true) blk: {
- break :blk i32(42);
+ break :blk @as(i32, 42);
};
}
expect(answer == 42);
test/stage1/behavior/import.zig
@@ -3,7 +3,7 @@ const expectEqual = @import("std").testing.expectEqual;
const a_namespace = @import("import/a_namespace.zig");
test "call fn via namespace lookup" {
- expectEqual(i32(1234), a_namespace.foo());
+ expectEqual(@as(i32, 1234), a_namespace.foo());
}
test "importing the same thing gives the same import" {
@@ -14,5 +14,5 @@ test "import in non-toplevel scope" {
const S = struct {
usingnamespace @import("import/a_namespace.zig");
};
- expectEqual(i32(1234), S.foo());
+ expectEqual(@as(i32, 1234), S.foo());
}
test/stage1/behavior/math.zig
@@ -186,9 +186,9 @@ fn testThreeExprInARow(f: bool, t: bool) void {
assertFalse(90 >> 1 >> 2 != 90 >> 3);
assertFalse(100 - 1 + 1000 != 1099);
assertFalse(5 * 4 / 2 % 3 != 1);
- assertFalse(i32(i32(5)) != 5);
+ assertFalse(@as(i32, @as(i32, 5)) != 5);
assertFalse(!!false);
- assertFalse(i32(7) != --(i32(7)));
+ assertFalse(@as(i32, 7) != --(@as(i32, 7)));
}
fn assertFalse(b: bool) void {
expect(!b);
@@ -256,10 +256,10 @@ const DivResult = struct {
test "binary not" {
expect(comptime x: {
- break :x ~u16(0b1010101010101010) == 0b0101010101010101;
+ break :x ~@as(u16, 0b1010101010101010) == 0b0101010101010101;
});
expect(comptime x: {
- break :x ~u64(2147483647) == 18446744071562067968;
+ break :x ~@as(u64, 2147483647) == 18446744071562067968;
});
testBinaryNot(0b1010101010101010);
}
@@ -472,7 +472,7 @@ test "comptime_int multiplication" {
test "comptime_int shifting" {
comptime {
- expect((u128(1) << 127) == 0x80000000000000000000000000000000);
+ expect((@as(u128, 1) << 127) == 0x80000000000000000000000000000000);
}
}
@@ -480,13 +480,13 @@ test "comptime_int multi-limb shift and mask" {
comptime {
var a = 0xefffffffa0000001eeeeeeefaaaaaaab;
- expect(u32(a & 0xffffffff) == 0xaaaaaaab);
+ expect(@as(u32, a & 0xffffffff) == 0xaaaaaaab);
a >>= 32;
- expect(u32(a & 0xffffffff) == 0xeeeeeeef);
+ expect(@as(u32, a & 0xffffffff) == 0xeeeeeeef);
a >>= 32;
- expect(u32(a & 0xffffffff) == 0xa0000001);
+ expect(@as(u32, a & 0xffffffff) == 0xa0000001);
a >>= 32;
- expect(u32(a & 0xffffffff) == 0xefffffff);
+ expect(@as(u32, a & 0xffffffff) == 0xefffffff);
a >>= 32;
expect(a == 0);
@@ -552,7 +552,7 @@ fn should_not_be_zero(x: f128) void {
test "comptime float rem int" {
comptime {
- var x = f32(1) % 2;
+ var x = @as(f32, 1) % 2;
expect(x == 1.0);
}
}
@@ -568,8 +568,8 @@ test "remainder division" {
}
fn remdiv(comptime T: type) void {
- expect(T(1) == T(1) % T(2));
- expect(T(1) == T(7) % T(3));
+ expect(@as(T, 1) == @as(T, 1) % @as(T, 2));
+ expect(@as(T, 1) == @as(T, 7) % @as(T, 3));
}
test "@sqrt" {
test/stage1/behavior/misc.zig
@@ -268,7 +268,7 @@ fn outer() i64 {
}
test "pointer dereferencing" {
- var x = i32(3);
+ var x = @as(i32, 3);
const y = &x;
y.* += 1;
@@ -500,7 +500,7 @@ fn TypeFromFn(comptime T: type) type {
}
test "double implicit cast in same expression" {
- var x = i32(u16(nine()));
+ var x = @as(i32, @as(u16, nine()));
expect(x == 9);
}
fn nine() u8 {
@@ -761,7 +761,7 @@ test "nested optional field in struct" {
fn maybe(x: bool) anyerror!?u32 {
return switch (x) {
- true => u32(42),
+ true => @as(u32, 42),
else => null,
};
}
test/stage1/behavior/popcount.zig
@@ -35,7 +35,7 @@ fn testPopCount() void {
expect(@popCount(i8, x) == 2);
}
comptime {
- expect(@popCount(u8, @bitCast(u8, i8(-120))) == 2);
+ expect(@popCount(u8, @bitCast(u8, @as(i8, -120))) == 2);
}
comptime {
expect(@popCount(i128, 0b11111111000110001100010000100001000011000011100101010001) == 24);
test/stage1/behavior/pub_enum.zig
@@ -9,5 +9,5 @@ fn pubEnumTest(foo: other.APubEnum) void {
}
test "cast with imported symbol" {
- expect(other.size_t(42) == 42);
+ expect(@as(other.size_t, 42) == 42);
}
test/stage1/behavior/shuffle.zig
@@ -7,39 +7,39 @@ test "@shuffle" {
fn doTheTest() void {
var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
- const mask: @Vector(4, i32) = [4]i32{ 0, ~i32(2), 3, ~i32(3) };
+ const mask: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) };
var res = @shuffle(i32, v, x, mask);
- expect(mem.eql(i32, ([4]i32)(res), [4]i32{ 2147483647, 3, 40, 4 }));
+ expect(mem.eql(i32, @as([4]i32,res), [4]i32{ 2147483647, 3, 40, 4 }));
// Implicit cast from array (of mask)
- res = @shuffle(i32, v, x, [4]i32{ 0, ~i32(2), 3, ~i32(3) });
- expect(mem.eql(i32, ([4]i32)(res), [4]i32{ 2147483647, 3, 40, 4 }));
+ res = @shuffle(i32, v, x, [4]i32{ 0, ~@as(i32, 2), 3, ~@as(i32, 3) });
+ expect(mem.eql(i32, @as([4]i32,res), [4]i32{ 2147483647, 3, 40, 4 }));
// Undefined
const mask2: @Vector(4, i32) = [4]i32{ 3, 1, 2, 0 };
res = @shuffle(i32, v, undefined, mask2);
- expect(mem.eql(i32, ([4]i32)(res), [4]i32{ 40, -2, 30, 2147483647 }));
+ expect(mem.eql(i32, @as([4]i32,res), [4]i32{ 40, -2, 30, 2147483647 }));
// Upcasting of b
var v2: @Vector(2, i32) = [2]i32{ 2147483647, undefined };
- const mask3: @Vector(4, i32) = [4]i32{ ~i32(0), 2, ~i32(0), 3 };
+ const mask3: @Vector(4, i32) = [4]i32{ ~@as(i32, 0), 2, ~@as(i32, 0), 3 };
res = @shuffle(i32, x, v2, mask3);
- expect(mem.eql(i32, ([4]i32)(res), [4]i32{ 2147483647, 3, 2147483647, 4 }));
+ expect(mem.eql(i32, @as([4]i32,res), [4]i32{ 2147483647, 3, 2147483647, 4 }));
// Upcasting of a
var v3: @Vector(2, i32) = [2]i32{ 2147483647, -2 };
- const mask4: @Vector(4, i32) = [4]i32{ 0, ~i32(2), 1, ~i32(3) };
+ const mask4: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 2), 1, ~@as(i32, 3) };
res = @shuffle(i32, v3, x, mask4);
- expect(mem.eql(i32, ([4]i32)(res), [4]i32{ 2147483647, 3, -2, 4 }));
+ expect(mem.eql(i32, @as([4]i32,res), [4]i32{ 2147483647, 3, -2, 4 }));
// bool
// Disabled because of #3317
if (@import("builtin").arch != .mipsel) {
var x2: @Vector(4, bool) = [4]bool{ false, true, false, true };
var v4: @Vector(2, bool) = [2]bool{ true, false };
- const mask5: @Vector(4, i32) = [4]i32{ 0, ~i32(1), 1, 2 };
+ const mask5: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
var res2 = @shuffle(bool, x2, v4, mask5);
- expect(mem.eql(bool, ([4]bool)(res2), [4]bool{ false, false, true, false }));
+ expect(mem.eql(bool, @as([4]bool,res2), [4]bool{ false, false, true, false }));
}
// TODO re-enable when LLVM codegen is fixed
@@ -47,9 +47,9 @@ test "@shuffle" {
if (false) {
var x2: @Vector(3, bool) = [3]bool{ false, true, false };
var v4: @Vector(2, bool) = [2]bool{ true, false };
- const mask5: @Vector(4, i32) = [4]i32{ 0, ~i32(1), 1, 2 };
+ const mask5: @Vector(4, i32) = [4]i32{ 0, ~@as(i32, 1), 1, 2 };
var res2 = @shuffle(bool, x2, v4, mask5);
- expect(mem.eql(bool, ([4]bool)(res2), [4]bool{ false, false, true, false }));
+ expect(mem.eql(bool, @as([4]bool,res2), [4]bool{ false, false, true, false }));
}
}
};
test/stage1/behavior/slicetobytes.zig
@@ -10,7 +10,7 @@ test "@sliceToBytes packed struct at runtime and comptime" {
const S = struct {
fn doTheTest() void {
var foo: Foo = undefined;
- var slice = @sliceToBytes(((*[1]Foo)(&foo))[0..1]);
+ var slice = @sliceToBytes(@as(*[1]Foo, &foo)[0..1]);
slice[0] = 0x13;
switch (builtin.endian) {
builtin.Endian.Big => {
test/stage1/behavior/struct.zig
@@ -388,8 +388,8 @@ test "runtime struct initialization of bitfield" {
expect(s2.y == @intCast(u4, x2));
}
-var x1 = u4(1);
-var x2 = u8(2);
+var x1 = @as(u4, 1);
+var x2 = @as(u8, 2);
const Nibbles = packed struct {
x: u4,
@@ -545,9 +545,9 @@ test "packed struct with fp fields" {
s.data[1] = 2.0;
s.data[2] = 3.0;
s.frob();
- expectEqual(f32(6.0), s.data[0]);
- expectEqual(f32(11.0), s.data[1]);
- expectEqual(f32(20.0), s.data[2]);
+ expectEqual(@as(f32, 6.0), s.data[0]);
+ expectEqual(@as(f32, 11.0), s.data[1]);
+ expectEqual(@as(f32, 20.0), s.data[2]);
}
test "use within struct scope" {
@@ -558,7 +558,7 @@ test "use within struct scope" {
}
};
};
- expectEqual(i32(42), S.inner());
+ expectEqual(@as(i32, 42), S.inner());
}
test "default struct initialization fields" {
@@ -583,7 +583,7 @@ test "extern fn returns struct by value" {
const S = struct {
fn entry() void {
var x = makeBar(10);
- expectEqual(i32(10), x.handle);
+ expectEqual(@as(i32, 10), x.handle);
}
const ExternBar = extern struct {
@@ -614,7 +614,7 @@ test "for loop over pointers to struct, getting field from struct pointer" {
const ArrayList = struct {
fn toSlice(self: *ArrayList) []*Foo {
- return ([*]*Foo)(undefined)[0..0];
+ return @as([*]*Foo, undefined)[0..0];
}
};
test/stage1/behavior/switch.zig
@@ -68,7 +68,7 @@ test "switch statement" {
}
fn nonConstSwitch(foo: SwitchStatmentFoo) void {
const val = switch (foo) {
- SwitchStatmentFoo.A => i32(1),
+ SwitchStatmentFoo.A => @as(i32, 1),
SwitchStatmentFoo.B => 2,
SwitchStatmentFoo.C => 3,
SwitchStatmentFoo.D => 4,
@@ -127,7 +127,7 @@ test "switch with multiple expressions" {
const x = switch (returnsFive()) {
1, 2, 3 => 1,
4, 5, 6 => 2,
- else => i32(3),
+ else => @as(i32, 3),
};
expect(x == 2);
}
@@ -186,7 +186,7 @@ fn testSwitchHandleAllCases() void {
fn testSwitchHandleAllCasesExhaustive(x: u2) u2 {
return switch (x) {
- 0 => u2(3),
+ 0 => @as(u2, 3),
1 => 2,
2 => 1,
3 => 0,
@@ -195,7 +195,7 @@ fn testSwitchHandleAllCasesExhaustive(x: u2) u2 {
fn testSwitchHandleAllCasesRange(x: u8) u8 {
return switch (x) {
- 0...100 => u8(0),
+ 0...100 => @as(u8, 0),
101...200 => 1,
201, 203 => 2,
202 => 4,
test/stage1/behavior/try.zig
@@ -8,7 +8,7 @@ test "try on error union" {
fn tryOnErrorUnionImpl() void {
const x = if (returnsTen()) |val| val + 1 else |err| switch (err) {
error.ItBroke, error.NoMem => 1,
- error.CrappedOut => i32(2),
+ error.CrappedOut => @as(i32, 2),
else => unreachable,
};
expect(x == 11);
@@ -19,10 +19,10 @@ fn returnsTen() anyerror!i32 {
}
test "try without vars" {
- const result1 = if (failIfTrue(true)) 1 else |_| i32(2);
+ const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2);
expect(result1 == 2);
- const result2 = if (failIfTrue(false)) 1 else |_| i32(2);
+ const result2 = if (failIfTrue(false)) 1 else |_| @as(i32, 2);
expect(result2 == 1);
}
test/stage1/behavior/type_info.zig
@@ -13,7 +13,7 @@ test "type info: tag type, void info" {
fn testBasic() void {
expect(@TagType(TypeInfo) == TypeId);
const void_info = @typeInfo(void);
- expect(TypeId(void_info) == TypeId.Void);
+ expect(@as(TypeId, void_info) == TypeId.Void);
expect(void_info.Void == {});
}
@@ -24,12 +24,12 @@ test "type info: integer, floating point type info" {
fn testIntFloat() void {
const u8_info = @typeInfo(u8);
- expect(TypeId(u8_info) == TypeId.Int);
+ expect(@as(TypeId, u8_info) == TypeId.Int);
expect(!u8_info.Int.is_signed);
expect(u8_info.Int.bits == 8);
const f64_info = @typeInfo(f64);
- expect(TypeId(f64_info) == TypeId.Float);
+ expect(@as(TypeId, f64_info) == TypeId.Float);
expect(f64_info.Float.bits == 64);
}
@@ -40,7 +40,7 @@ test "type info: pointer type info" {
fn testPointer() void {
const u32_ptr_info = @typeInfo(*u32);
- expect(TypeId(u32_ptr_info) == TypeId.Pointer);
+ expect(@as(TypeId, u32_ptr_info) == TypeId.Pointer);
expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.One);
expect(u32_ptr_info.Pointer.is_const == false);
expect(u32_ptr_info.Pointer.is_volatile == false);
@@ -55,7 +55,7 @@ test "type info: unknown length pointer type info" {
fn testUnknownLenPtr() void {
const u32_ptr_info = @typeInfo([*]const volatile f64);
- expect(TypeId(u32_ptr_info) == TypeId.Pointer);
+ expect(@as(TypeId,u32_ptr_info) == TypeId.Pointer);
expect(u32_ptr_info.Pointer.size == TypeInfo.Pointer.Size.Many);
expect(u32_ptr_info.Pointer.is_const == true);
expect(u32_ptr_info.Pointer.is_volatile == true);
@@ -70,7 +70,7 @@ test "type info: C pointer type info" {
fn testCPtr() void {
const ptr_info = @typeInfo([*c]align(4) const i8);
- expect(TypeId(ptr_info) == TypeId.Pointer);
+ expect(@as(TypeId,ptr_info) == TypeId.Pointer);
expect(ptr_info.Pointer.size == TypeInfo.Pointer.Size.C);
expect(ptr_info.Pointer.is_const);
expect(!ptr_info.Pointer.is_volatile);
@@ -85,7 +85,7 @@ test "type info: slice type info" {
fn testSlice() void {
const u32_slice_info = @typeInfo([]u32);
- expect(TypeId(u32_slice_info) == TypeId.Pointer);
+ expect(@as(TypeId, u32_slice_info) == TypeId.Pointer);
expect(u32_slice_info.Pointer.size == TypeInfo.Pointer.Size.Slice);
expect(u32_slice_info.Pointer.is_const == false);
expect(u32_slice_info.Pointer.is_volatile == false);
@@ -100,7 +100,7 @@ test "type info: array type info" {
fn testArray() void {
const arr_info = @typeInfo([42]bool);
- expect(TypeId(arr_info) == TypeId.Array);
+ expect(@as(TypeId, arr_info) == TypeId.Array);
expect(arr_info.Array.len == 42);
expect(arr_info.Array.child == bool);
}
@@ -112,7 +112,7 @@ test "type info: optional type info" {
fn testOptional() void {
const null_info = @typeInfo(?void);
- expect(TypeId(null_info) == TypeId.Optional);
+ expect(@as(TypeId, null_info) == TypeId.Optional);
expect(null_info.Optional.child == void);
}
@@ -129,18 +129,18 @@ fn testErrorSet() void {
};
const error_set_info = @typeInfo(TestErrorSet);
- expect(TypeId(error_set_info) == TypeId.ErrorSet);
+ expect(@as(TypeId, error_set_info) == TypeId.ErrorSet);
expect(error_set_info.ErrorSet.?.len == 3);
expect(mem.eql(u8, error_set_info.ErrorSet.?[0].name, "First"));
expect(error_set_info.ErrorSet.?[2].value == @errorToInt(TestErrorSet.Third));
const error_union_info = @typeInfo(TestErrorSet!usize);
- expect(TypeId(error_union_info) == TypeId.ErrorUnion);
+ expect(@as(TypeId, error_union_info) == TypeId.ErrorUnion);
expect(error_union_info.ErrorUnion.error_set == TestErrorSet);
expect(error_union_info.ErrorUnion.payload == usize);
const global_info = @typeInfo(anyerror);
- expect(TypeId(global_info) == TypeId.ErrorSet);
+ expect(@as(TypeId, global_info) == TypeId.ErrorSet);
expect(global_info.ErrorSet == null);
}
@@ -158,7 +158,7 @@ fn testEnum() void {
};
const os_info = @typeInfo(Os);
- expect(TypeId(os_info) == TypeId.Enum);
+ expect(@as(TypeId, os_info) == TypeId.Enum);
expect(os_info.Enum.layout == TypeInfo.ContainerLayout.Auto);
expect(os_info.Enum.fields.len == 4);
expect(mem.eql(u8, os_info.Enum.fields[1].name, "Macos"));
@@ -174,7 +174,7 @@ test "type info: union info" {
fn testUnion() void {
const typeinfo_info = @typeInfo(TypeInfo);
- expect(TypeId(typeinfo_info) == TypeId.Union);
+ expect(@as(TypeId, typeinfo_info) == TypeId.Union);
expect(typeinfo_info.Union.layout == TypeInfo.ContainerLayout.Auto);
expect(typeinfo_info.Union.tag_type.? == TypeId);
expect(typeinfo_info.Union.fields.len == 26);
@@ -189,7 +189,7 @@ fn testUnion() void {
};
const notag_union_info = @typeInfo(TestNoTagUnion);
- expect(TypeId(notag_union_info) == TypeId.Union);
+ expect(@as(TypeId, notag_union_info) == TypeId.Union);
expect(notag_union_info.Union.tag_type == null);
expect(notag_union_info.Union.layout == TypeInfo.ContainerLayout.Auto);
expect(notag_union_info.Union.fields.len == 2);
@@ -214,7 +214,7 @@ test "type info: struct info" {
fn testStruct() void {
const struct_info = @typeInfo(TestStruct);
- expect(TypeId(struct_info) == TypeId.Struct);
+ expect(@as(TypeId, struct_info) == TypeId.Struct);
expect(struct_info.Struct.layout == TypeInfo.ContainerLayout.Packed);
expect(struct_info.Struct.fields.len == 3);
expect(struct_info.Struct.fields[1].offset == null);
@@ -244,7 +244,7 @@ test "type info: function type info" {
fn testFunction() void {
const fn_info = @typeInfo(@typeOf(foo));
- expect(TypeId(fn_info) == TypeId.Fn);
+ expect(@as(TypeId, fn_info) == TypeId.Fn);
expect(fn_info.Fn.calling_convention == TypeInfo.CallingConvention.Unspecified);
expect(fn_info.Fn.is_generic);
expect(fn_info.Fn.args.len == 2);
@@ -253,7 +253,7 @@ fn testFunction() void {
const test_instance: TestStruct = undefined;
const bound_fn_info = @typeInfo(@typeOf(test_instance.foo));
- expect(TypeId(bound_fn_info) == TypeId.BoundFn);
+ expect(@as(TypeId, bound_fn_info) == TypeId.BoundFn);
expect(bound_fn_info.BoundFn.args[0].arg_type.? == *const TestStruct);
}
@@ -275,7 +275,7 @@ test "type info: vectors" {
fn testVector() void {
const vec_info = @typeInfo(@Vector(4, i32));
- expect(TypeId(vec_info) == TypeId.Vector);
+ expect(@as(TypeId, vec_info) == TypeId.Vector);
expect(vec_info.Vector.len == 4);
expect(vec_info.Vector.child == i32);
}
@@ -288,13 +288,13 @@ test "type info: anyframe and anyframe->T" {
fn testAnyFrame() void {
{
const anyframe_info = @typeInfo(anyframe->i32);
- expect(TypeId(anyframe_info) == .AnyFrame);
+ expect(@as(TypeId,anyframe_info) == .AnyFrame);
expect(anyframe_info.AnyFrame.child.? == i32);
}
{
const anyframe_info = @typeInfo(anyframe);
- expect(TypeId(anyframe_info) == .AnyFrame);
+ expect(@as(TypeId,anyframe_info) == .AnyFrame);
expect(anyframe_info.AnyFrame.child == null);
}
}
@@ -334,7 +334,7 @@ test "type info: extern fns with and without lib names" {
if (std.mem.eql(u8, decl.name, "bar1")) {
expect(decl.data.Fn.lib_name == null);
} else {
- std.testing.expectEqual(([]const u8)("cool"), decl.data.Fn.lib_name.?);
+ std.testing.expectEqual(@as([]const u8,"cool"), decl.data.Fn.lib_name.?);
}
}
}
@@ -342,7 +342,7 @@ test "type info: extern fns with and without lib names" {
test "data field is a compile-time value" {
const S = struct {
- const Bar = isize(-1);
+ const Bar = @as(isize, -1);
};
comptime expect(@typeInfo(S).Struct.decls[0].data.Var == isize);
}
test/stage1/behavior/union.zig
@@ -14,7 +14,7 @@ const Agg = struct {
const v1 = Value{ .Int = 1234 };
const v2 = Value{ .Array = [_]u8{3} ** 9 };
-const err = (anyerror!Agg)(Agg{
+const err = @as(anyerror!Agg, Agg{
.val1 = v1,
.val2 = v2,
});
@@ -110,11 +110,11 @@ fn doTest() void {
}
fn bar(value: Payload) i32 {
- expect(Letter(value) == Letter.A);
+ expect(@as(Letter,value) == Letter.A);
return switch (value) {
Payload.A => |x| return x - 1244,
- Payload.B => |x| if (x == 12.34) i32(20) else 21,
- Payload.C => |x| if (x) i32(30) else 31,
+ Payload.B => |x| if (x == 12.34) @as(i32, 20) else 21,
+ Payload.C => |x| if (x) @as(i32, 30) else 31,
};
}
@@ -127,7 +127,7 @@ const MultipleChoice = union(enum(u32)) {
test "simple union(enum(u32))" {
var x = MultipleChoice.C;
expect(x == MultipleChoice.C);
- expect(@enumToInt(@TagType(MultipleChoice)(x)) == 60);
+ expect(@enumToInt(@as(@TagType(MultipleChoice), x)) == 60);
}
const MultipleChoice2 = union(enum(u32)) {
@@ -149,11 +149,11 @@ test "union(enum(u32)) with specified and unspecified tag values" {
}
fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {
- expect(@enumToInt(@TagType(MultipleChoice2)(x)) == 60);
+ expect(@enumToInt(@as(@TagType(MultipleChoice2), x)) == 60);
expect(1123 == switch (x) {
MultipleChoice2.A => 1,
MultipleChoice2.B => 2,
- MultipleChoice2.C => |v| i32(1000) + v,
+ MultipleChoice2.C => |v| @as(i32, 1000) + v,
MultipleChoice2.D => 4,
MultipleChoice2.Unspecified1 => 5,
MultipleChoice2.Unspecified2 => 6,
@@ -208,12 +208,12 @@ test "cast union to tag type of union" {
}
fn testCastUnionToTagType(x: TheUnion) void {
- expect(TheTag(x) == TheTag.B);
+ expect(@as(TheTag,x) == TheTag.B);
}
test "cast tag type of union to union" {
var x: Value2 = Letter2.B;
- expect(Letter2(x) == Letter2.B);
+ expect(@as(Letter2, x) == Letter2.B);
}
const Letter2 = enum {
A,
@@ -297,7 +297,7 @@ const TaggedUnionWithAVoid = union(enum) {
fn testTaggedUnionInit(x: var) bool {
const y = TaggedUnionWithAVoid{ .A = x };
- return @TagType(TaggedUnionWithAVoid)(y) == TaggedUnionWithAVoid.A;
+ return @as(@TagType(TaggedUnionWithAVoid), y) == TaggedUnionWithAVoid.A;
}
pub const UnionEnumNoPayloads = union(enum) {
@@ -326,7 +326,7 @@ test "union with only 1 field casted to its enum type" {
var e = Expr{ .Literal = Literal{ .Bool = true } };
const Tag = @TagType(Expr);
comptime expect(@TagType(Tag) == u0);
- var t = Tag(e);
+ var t = @as(Tag, e);
expect(t == Expr.Literal);
}
@@ -346,7 +346,7 @@ test "union with only 1 field casted to its enum type which has enum value speci
var e = Expr{ .Literal = Literal{ .Bool = true } };
comptime expect(@TagType(Tag) == comptime_int);
- var t = Tag(e);
+ var t = @as(Tag, e);
expect(t == Expr.Literal);
expect(@enumToInt(t) == 33);
comptime expect(@enumToInt(t) == 33);
test/stage1/behavior/var_args.zig
@@ -1,7 +1,7 @@
const expect = @import("std").testing.expect;
fn add(args: ...) i32 {
- var sum = i32(0);
+ var sum = @as(i32, 0);
{
comptime var i: usize = 0;
inline while (i < args.len) : (i += 1) {
@@ -12,8 +12,8 @@ fn add(args: ...) i32 {
}
test "add arbitrary args" {
- expect(add(i32(1), i32(2), i32(3), i32(4)) == 10);
- expect(add(i32(1234)) == 1234);
+ expect(add(@as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4)) == 10);
+ expect(add(@as(i32, 1234)) == 1234);
expect(add() == 0);
}
@@ -26,8 +26,8 @@ test "send void arg to var args" {
}
test "pass args directly" {
- expect(addSomeStuff(i32(1), i32(2), i32(3), i32(4)) == 10);
- expect(addSomeStuff(i32(1234)) == 1234);
+ expect(addSomeStuff(@as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4)) == 10);
+ expect(addSomeStuff(@as(i32, 1234)) == 1234);
expect(addSomeStuff() == 0);
}
test/stage1/behavior/vector.zig
@@ -20,11 +20,11 @@ test "vector wrap operators" {
fn doTheTest() void {
var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 3, 4 };
- expect(mem.eql(i32, ([4]i32)(v +% x), [4]i32{ -2147483648, 2147483645, 33, 44 }));
- expect(mem.eql(i32, ([4]i32)(v -% x), [4]i32{ 2147483646, 2147483647, 27, 36 }));
- expect(mem.eql(i32, ([4]i32)(v *% x), [4]i32{ 2147483647, 2, 90, 160 }));
+ expect(mem.eql(i32, @as([4]i32, v +% x), [4]i32{ -2147483648, 2147483645, 33, 44 }));
+ expect(mem.eql(i32, @as([4]i32, v -% x), [4]i32{ 2147483646, 2147483647, 27, 36 }));
+ expect(mem.eql(i32, @as([4]i32, v *% x), [4]i32{ 2147483647, 2, 90, 160 }));
var z: @Vector(4, i32) = [4]i32{ 1, 2, 3, -2147483648 };
- expect(mem.eql(i32, ([4]i32)(-%z), [4]i32{ -1, -2, -3, -2147483648 }));
+ expect(mem.eql(i32, @as([4]i32, -%z), [4]i32{ -1, -2, -3, -2147483648 }));
}
};
S.doTheTest();
@@ -36,12 +36,12 @@ test "vector bin compares with mem.eql" {
fn doTheTest() void {
var v: @Vector(4, i32) = [4]i32{ 2147483647, -2, 30, 40 };
var x: @Vector(4, i32) = [4]i32{ 1, 2147483647, 30, 4 };
- expect(mem.eql(bool, ([4]bool)(v == x), [4]bool{ false, false, true, false }));
- expect(mem.eql(bool, ([4]bool)(v != x), [4]bool{ true, true, false, true }));
- expect(mem.eql(bool, ([4]bool)(v < x), [4]bool{ false, true, false, false }));
- expect(mem.eql(bool, ([4]bool)(v > x), [4]bool{ true, false, false, true }));
- expect(mem.eql(bool, ([4]bool)(v <= x), [4]bool{ false, true, true, false }));
- expect(mem.eql(bool, ([4]bool)(v >= x), [4]bool{ true, false, true, true }));
+ expect(mem.eql(bool, @as([4]bool, v == x), [4]bool{ false, false, true, false }));
+ expect(mem.eql(bool, @as([4]bool, v != x), [4]bool{ true, true, false, true }));
+ expect(mem.eql(bool, @as([4]bool, v < x), [4]bool{ false, true, false, false }));
+ expect(mem.eql(bool, @as([4]bool, v > x), [4]bool{ true, false, false, true }));
+ expect(mem.eql(bool, @as([4]bool, v <= x), [4]bool{ false, true, true, false }));
+ expect(mem.eql(bool, @as([4]bool, v >= x), [4]bool{ true, false, true, true }));
}
};
S.doTheTest();
@@ -53,10 +53,10 @@ test "vector int operators" {
fn doTheTest() void {
var v: @Vector(4, i32) = [4]i32{ 10, 20, 30, 40 };
var x: @Vector(4, i32) = [4]i32{ 1, 2, 3, 4 };
- expect(mem.eql(i32, ([4]i32)(v + x), [4]i32{ 11, 22, 33, 44 }));
- expect(mem.eql(i32, ([4]i32)(v - x), [4]i32{ 9, 18, 27, 36 }));
- expect(mem.eql(i32, ([4]i32)(v * x), [4]i32{ 10, 40, 90, 160 }));
- expect(mem.eql(i32, ([4]i32)(-v), [4]i32{ -10, -20, -30, -40 }));
+ expect(mem.eql(i32, @as([4]i32, v + x), [4]i32{ 11, 22, 33, 44 }));
+ expect(mem.eql(i32, @as([4]i32, v - x), [4]i32{ 9, 18, 27, 36 }));
+ expect(mem.eql(i32, @as([4]i32, v * x), [4]i32{ 10, 40, 90, 160 }));
+ expect(mem.eql(i32, @as([4]i32, -v), [4]i32{ -10, -20, -30, -40 }));
}
};
S.doTheTest();
@@ -68,10 +68,10 @@ test "vector float operators" {
fn doTheTest() void {
var v: @Vector(4, f32) = [4]f32{ 10, 20, 30, 40 };
var x: @Vector(4, f32) = [4]f32{ 1, 2, 3, 4 };
- expect(mem.eql(f32, ([4]f32)(v + x), [4]f32{ 11, 22, 33, 44 }));
- expect(mem.eql(f32, ([4]f32)(v - x), [4]f32{ 9, 18, 27, 36 }));
- expect(mem.eql(f32, ([4]f32)(v * x), [4]f32{ 10, 40, 90, 160 }));
- expect(mem.eql(f32, ([4]f32)(-x), [4]f32{ -1, -2, -3, -4 }));
+ expect(mem.eql(f32, @as([4]f32, v + x), [4]f32{ 11, 22, 33, 44 }));
+ expect(mem.eql(f32, @as([4]f32, v - x), [4]f32{ 9, 18, 27, 36 }));
+ expect(mem.eql(f32, @as([4]f32, v * x), [4]f32{ 10, 40, 90, 160 }));
+ expect(mem.eql(f32, @as([4]f32, -x), [4]f32{ -1, -2, -3, -4 }));
}
};
S.doTheTest();
@@ -83,9 +83,9 @@ test "vector bit operators" {
fn doTheTest() void {
var v: @Vector(4, u8) = [4]u8{ 0b10101010, 0b10101010, 0b10101010, 0b10101010 };
var x: @Vector(4, u8) = [4]u8{ 0b11110000, 0b00001111, 0b10101010, 0b01010101 };
- expect(mem.eql(u8, ([4]u8)(v ^ x), [4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
- expect(mem.eql(u8, ([4]u8)(v | x), [4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
- expect(mem.eql(u8, ([4]u8)(v & x), [4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));
+ expect(mem.eql(u8, @as([4]u8, v ^ x), [4]u8{ 0b01011010, 0b10100101, 0b00000000, 0b11111111 }));
+ expect(mem.eql(u8, @as([4]u8, v | x), [4]u8{ 0b11111010, 0b10101111, 0b10101010, 0b11111111 }));
+ expect(mem.eql(u8, @as([4]u8, v & x), [4]u8{ 0b10100000, 0b00001010, 0b10101010, 0b00000000 }));
}
};
S.doTheTest();
@@ -120,22 +120,22 @@ test "vector casts of sizes not divisable by 8" {
{
var v: @Vector(4, u3) = [4]u3{ 5, 2, 3, 0 };
var x: [4]u3 = v;
- expect(mem.eql(u3, x, ([4]u3)(v)));
+ expect(mem.eql(u3, x, @as([4]u3, v)));
}
{
var v: @Vector(4, u2) = [4]u2{ 1, 2, 3, 0 };
var x: [4]u2 = v;
- expect(mem.eql(u2, x, ([4]u2)(v)));
+ expect(mem.eql(u2, x, @as([4]u2, v)));
}
{
var v: @Vector(4, u1) = [4]u1{ 1, 0, 1, 0 };
var x: [4]u1 = v;
- expect(mem.eql(u1, x, ([4]u1)(v)));
+ expect(mem.eql(u1, x, @as([4]u1, v)));
}
{
var v: @Vector(4, bool) = [4]bool{ false, false, true, false };
var x: [4]bool = v;
- expect(mem.eql(bool, x, ([4]bool)(v)));
+ expect(mem.eql(bool, x, @as([4]bool, v)));
}
}
};
test/stage1/behavior/void.zig
@@ -26,7 +26,7 @@ test "iterate over a void slice" {
}
fn times(n: usize) []const void {
- return ([*]void)(undefined)[0..n];
+ return @as([*]void, undefined)[0..n];
}
test "void optional" {
test/stage1/behavior/while.zig
@@ -137,7 +137,7 @@ test "while on optional with else result follow else prong" {
const result = while (returnNull()) |value| {
break value;
} else
- i32(2);
+ @as(i32, 2);
expect(result == 2);
}
@@ -145,7 +145,7 @@ test "while on optional with else result follow break prong" {
const result = while (returnOptional(10)) |value| {
break value;
} else
- i32(2);
+ @as(i32, 2);
expect(result == 10);
}
@@ -153,7 +153,7 @@ test "while on error union with else result follow else prong" {
const result = while (returnError()) |value| {
break value;
} else |err|
- i32(2);
+ @as(i32, 2);
expect(result == 2);
}
@@ -161,23 +161,23 @@ test "while on error union with else result follow break prong" {
const result = while (returnSuccess(10)) |value| {
break value;
} else |err|
- i32(2);
+ @as(i32, 2);
expect(result == 10);
}
test "while on bool with else result follow else prong" {
const result = while (returnFalse()) {
- break i32(10);
+ break @as(i32, 10);
} else
- i32(2);
+ @as(i32, 2);
expect(result == 2);
}
test "while on bool with else result follow break prong" {
const result = while (returnTrue()) {
- break i32(10);
+ break @as(i32, 10);
} else
- i32(2);
+ @as(i32, 2);
expect(result == 10);
}
test/stage1/behavior.zig
@@ -1,7 +1,7 @@
comptime {
- _ = @import("behavior/align.zig");
+ //_ = @import("behavior/align.zig");
_ = @import("behavior/alignof.zig");
- _ = @import("behavior/array.zig");
+ //_ = @import("behavior/array.zig");
_ = @import("behavior/asm.zig");
_ = @import("behavior/async_fn.zig");
_ = @import("behavior/atomics.zig");
@@ -50,7 +50,7 @@ comptime {
_ = @import("behavior/bugs/920.zig");
_ = @import("behavior/byteswap.zig");
_ = @import("behavior/byval_arg_var.zig");
- _ = @import("behavior/cast.zig");
+ //_ = @import("behavior/cast.zig");
_ = @import("behavior/const_slice_child.zig");
_ = @import("behavior/defer.zig");
_ = @import("behavior/enum.zig");
@@ -59,7 +59,7 @@ comptime {
_ = @import("behavior/eval.zig");
_ = @import("behavior/field_parent_ptr.zig");
_ = @import("behavior/floatop.zig");
- _ = @import("behavior/fn.zig");
+ //_ = @import("behavior/fn.zig");
_ = @import("behavior/fn_in_struct_in_comptime.zig");
_ = @import("behavior/fn_delegation.zig");
_ = @import("behavior/for.zig");
@@ -73,7 +73,7 @@ comptime {
_ = @import("behavior/ir_block_deps.zig");
_ = @import("behavior/math.zig");
_ = @import("behavior/merge_error_sets.zig");
- _ = @import("behavior/misc.zig");
+ //_ = @import("behavior/misc.zig");
_ = @import("behavior/muladd.zig");
_ = @import("behavior/namespace_depends_on_compile_var.zig");
_ = @import("behavior/new_stack_call.zig");
test/compare_output.zig
@@ -122,7 +122,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\
\\pub fn main() void {
\\ const stdout = &(io.getStdOut() catch unreachable).outStream().stream;
- \\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", u32(12), u16(0x12), u8('a')) catch unreachable;
+ \\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", @as(u32, 12), @as(u16, 0x12), @as(u8, 'a')) catch unreachable;
\\}
, "Hello, world!\n 12 12 a\n");
@@ -166,54 +166,54 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\ _ = c.printf(c"\n");
\\
\\ _ = c.printf(c"0.0: %.013a\n",
- \\ f64(0.0));
+ \\ @as(f64, 0.0));
\\ _ = c.printf(c"0e0: %.013a\n",
- \\ f64(0e0));
+ \\ @as(f64, 0e0));
\\ _ = c.printf(c"0.0e0: %.013a\n",
- \\ f64(0.0e0));
+ \\ @as(f64, 0.0e0));
\\ _ = c.printf(c"000000000000000000000000000000000000000000000000000000000.0e0: %.013a\n",
- \\ f64(000000000000000000000000000000000000000000000000000000000.0e0));
+ \\ @as(f64, 000000000000000000000000000000000000000000000000000000000.0e0));
\\ _ = c.printf(c"0.000000000000000000000000000000000000000000000000000000000e0: %.013a\n",
- \\ f64(0.000000000000000000000000000000000000000000000000000000000e0));
+ \\ @as(f64, 0.000000000000000000000000000000000000000000000000000000000e0));
\\ _ = c.printf(c"0.0e000000000000000000000000000000000000000000000000000000000: %.013a\n",
- \\ f64(0.0e000000000000000000000000000000000000000000000000000000000));
+ \\ @as(f64, 0.0e000000000000000000000000000000000000000000000000000000000));
\\ _ = c.printf(c"1.0: %.013a\n",
- \\ f64(1.0));
+ \\ @as(f64, 1.0));
\\ _ = c.printf(c"10.0: %.013a\n",
- \\ f64(10.0));
+ \\ @as(f64, 10.0));
\\ _ = c.printf(c"10.5: %.013a\n",
- \\ f64(10.5));
+ \\ @as(f64, 10.5));
\\ _ = c.printf(c"10.5e5: %.013a\n",
- \\ f64(10.5e5));
+ \\ @as(f64, 10.5e5));
\\ _ = c.printf(c"10.5e+5: %.013a\n",
- \\ f64(10.5e+5));
+ \\ @as(f64, 10.5e+5));
\\ _ = c.printf(c"50.0e-2: %.013a\n",
- \\ f64(50.0e-2));
+ \\ @as(f64, 50.0e-2));
\\ _ = c.printf(c"50e-2: %.013a\n",
- \\ f64(50e-2));
+ \\ @as(f64, 50e-2));
\\
\\ _ = c.printf(c"\n");
\\
\\ _ = c.printf(c"0x1.0: %.013a\n",
- \\ f64(0x1.0));
+ \\ @as(f64, 0x1.0));
\\ _ = c.printf(c"0x10.0: %.013a\n",
- \\ f64(0x10.0));
+ \\ @as(f64, 0x10.0));
\\ _ = c.printf(c"0x100.0: %.013a\n",
- \\ f64(0x100.0));
+ \\ @as(f64, 0x100.0));
\\ _ = c.printf(c"0x103.0: %.013a\n",
- \\ f64(0x103.0));
+ \\ @as(f64, 0x103.0));
\\ _ = c.printf(c"0x103.7: %.013a\n",
- \\ f64(0x103.7));
+ \\ @as(f64, 0x103.7));
\\ _ = c.printf(c"0x103.70: %.013a\n",
- \\ f64(0x103.70));
+ \\ @as(f64, 0x103.70));
\\ _ = c.printf(c"0x103.70p4: %.013a\n",
- \\ f64(0x103.70p4));
+ \\ @as(f64, 0x103.70p4));
\\ _ = c.printf(c"0x103.70p5: %.013a\n",
- \\ f64(0x103.70p5));
+ \\ @as(f64, 0x103.70p5));
\\ _ = c.printf(c"0x103.70p+5: %.013a\n",
- \\ f64(0x103.70p+5));
+ \\ @as(f64, 0x103.70p+5));
\\ _ = c.printf(c"0x103.70p-5: %.013a\n",
- \\ f64(0x103.70p-5));
+ \\ @as(f64, 0x103.70p-5));
\\
\\ return 0;
\\}
@@ -323,7 +323,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
\\ const x: f64 = small;
\\ const y = @floatToInt(i32, x);
\\ const z = @intToFloat(f64, y);
- \\ _ = c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, f64(-0.4));
+ \\ _ = c.printf(c"%.2f\n%d\n%.2f\n%.2f\n", x, y, z, @as(f64, -0.4));
\\ return 0;
\\}
, "3.25\n3\n3.00\n-0.40\n");
test/compile_errors.zig
@@ -186,7 +186,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"shift amount has to be an integer type",
\\export fn entry() void {
- \\ const x = 1 << &u8(10);
+ \\ const x = 1 << &@as(u8, 10);
\\}
,
"tmp.zig:2:23: error: shift amount has to be an integer type, but found '*u8'",
@@ -196,7 +196,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"bit shifting only works on integer types",
\\export fn entry() void {
- \\ const x = &u8(1) << 10;
+ \\ const x = &@as(u8, 1) << 10;
\\}
,
"tmp.zig:2:18: error: bit shifting operation expected integer type, found '*u8'",
@@ -241,7 +241,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ var x: []align(true) i32 = undefined;
\\}
\\export fn entry2() void {
- \\ var x: *align(f64(12.34)) i32 = undefined;
+ \\ var x: *align(@as(f64, 12.34)) i32 = undefined;
\\}
,
"tmp.zig:2:20: error: expected type 'u29', found 'bool'",
@@ -1297,7 +1297,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"@truncate undefined value",
\\export fn entry() void {
- \\ var z = @truncate(u8, u16(undefined));
+ \\ var z = @truncate(u8, @as(u16, undefined));
\\}
,
"tmp.zig:2:30: error: use of undefined value here causes undefined behavior",
@@ -1686,7 +1686,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"non float passed to @floatToInt",
\\export fn entry() void {
- \\ const x = @floatToInt(i32, i32(54));
+ \\ const x = @floatToInt(i32, @as(i32, 54));
\\}
,
"tmp.zig:2:35: error: expected float type, found 'i32'",
@@ -2197,7 +2197,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"error when evaluating return type",
\\const Foo = struct {
- \\ map: i32(i32),
+ \\ map: @as(i32, i32),
\\
\\ fn init() Foo {
\\ return undefined;
@@ -2338,7 +2338,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"var not allowed in structs",
\\export fn entry() void {
- \\ var s = (struct{v: var}){.v=i32(10)};
+ \\ var s = (struct{v: var}){.v=@as(i32, 10)};
\\}
,
"tmp.zig:2:23: error: invalid token: 'var'",
@@ -2657,7 +2657,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"cast negative integer literal to usize",
\\export fn entry() void {
- \\ const x = usize(-10);
+ \\ const x = @as(usize, -10);
\\}
,
"tmp.zig:2:21: error: cannot cast negative value -10 to unsigned integer type 'usize'",
@@ -3384,7 +3384,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ const x : i32 = if (b) h: { break :h 1; };
\\}
\\fn g(b: bool) void {
- \\ const y = if (b) h: { break :h i32(1); };
+ \\ const y = if (b) h: { break :h @as(i32, 1); };
\\}
\\export fn entry() void { f(true); g(true); }
,
@@ -3520,7 +3520,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"cast unreachable",
\\fn f() i32 {
- \\ return i32(return 1);
+ \\ return @as(i32, return 1);
\\}
\\export fn entry() void { _ = f(); }
,
@@ -3595,7 +3595,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ switch (n) {
\\ Number.One => 1,
\\ Number.Two => 2,
- \\ Number.Three => i32(3),
+ \\ Number.Three => @as(i32, 3),
\\ }
\\}
\\
@@ -3616,7 +3616,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ switch (n) {
\\ Number.One => 1,
\\ Number.Two => 2,
- \\ Number.Three => i32(3),
+ \\ Number.Three => @as(i32, 3),
\\ Number.Four => 4,
\\ Number.Two => 2,
\\ }
@@ -3640,7 +3640,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\ switch (n) {
\\ Number.One => 1,
\\ Number.Two => 2,
- \\ Number.Three => i32(3),
+ \\ Number.Three => @as(i32, 3),
\\ Number.Four => 4,
\\ Number.Two => 2,
\\ else => 10,
@@ -3685,7 +3685,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"switch expression - duplicate or overlapping integer value",
\\fn foo(x: u8) u8 {
\\ return switch (x) {
- \\ 0 ... 100 => u8(0),
+ \\ 0 ... 100 => @as(u8, 0),
\\ 101 ... 200 => 1,
\\ 201, 203 ... 207 => 2,
\\ 206 ... 255 => 3,
@@ -3722,7 +3722,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"array concatenation with wrong type",
\\const src = "aoeu";
- \\const derp = usize(1234);
+ \\const derp = @as(usize, 1234);
\\const a = derp ++ "foo";
\\
\\export fn entry() usize { return @sizeOf(@typeOf(a)); }
@@ -3887,7 +3887,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"division by zero",
\\const lit_int_x = 1 / 0;
\\const lit_float_x = 1.0 / 0.0;
- \\const int_x = u32(1) / u32(0);
+ \\const int_x = @as(u32, 1) / @as(u32, 0);
\\const float_x = f32(1.0) / f32(0.0);
\\
\\export fn entry1() usize { return @sizeOf(@typeOf(lit_int_x)); }
@@ -4590,7 +4590,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\var bytes: [ext()]u8 = undefined;
\\export fn f() void {
\\ for (bytes) |*b, i| {
- \\ b.* = u8(i);
+ \\ b.* = @as(u8, i);
\\ }
\\}
,
@@ -4874,7 +4874,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\}
\\
\\fn foo() i32 {
- \\ return add(i32(1234));
+ \\ return add(@as(i32, 1234));
\\}
\\
\\export fn entry() usize { return @sizeOf(@typeOf(foo)); }
@@ -4886,7 +4886,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"pass integer literal to var args",
\\fn add(args: ...) i32 {
- \\ var sum = i32(0);
+ \\ var sum = @as(i32, 0);
\\ {comptime var i: usize = 0; inline while (i < args.len) : (i += 1) {
\\ sum += args[i];
\\ }}
@@ -5581,7 +5581,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"explicit cast float literal to integer when there is a fraction component",
\\export fn entry() i32 {
- \\ return i32(12.34);
+ \\ return @as(i32, 12.34);
\\}
,
"tmp.zig:2:16: error: fractional component prevents float value 12.340000 from being casted to type 'i32'",
@@ -5599,7 +5599,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"@shlExact shifts out 1 bits",
\\comptime {
- \\ const x = @shlExact(u8(0b01010101), 2);
+ \\ const x = @shlExact(@as(u8, 0b01010101), 2);
\\}
,
"tmp.zig:2:15: error: operation caused overflow",
@@ -5608,7 +5608,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"@shrExact shifts out 1 bits",
\\comptime {
- \\ const x = @shrExact(u8(0b10101010), 2);
+ \\ const x = @shrExact(@as(u8, 0b10101010), 2);
\\}
,
"tmp.zig:2:15: error: exact shift shifted out 1 bits",
@@ -5699,7 +5699,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
cases.add(
"@alignCast expects pointer or slice",
\\export fn entry() void {
- \\ @alignCast(4, u32(3));
+ \\ @alignCast(4, @as(u32, 3));
\\}
,
"tmp.zig:2:22: error: expected pointer or slice, found 'u32'",
@@ -5744,7 +5744,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
\\const Derp = @OpaqueType();
\\extern fn bar(d: *Derp) void;
\\export fn foo() void {
- \\ var x = u8(1);
+ \\ var x = @as(u8, 1);
\\ bar(@ptrCast(*c_void, &x));
\\}
,
@@ -5800,7 +5800,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"wrong types given to atomic order args in cmpxchg",
\\export fn entry() void {
\\ var x: i32 = 1234;
- \\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, u32(1234), u32(1234))) {}
+ \\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, @as(u32, 1234), @as(u32, 1234))) {}
\\}
,
"tmp.zig:3:50: error: expected type 'std.builtin.AtomicOrder', found 'u32'",
@@ -5810,7 +5810,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
"wrong types given to @export",
\\extern fn entry() void { }
\\comptime {
- \\ @export("entry", entry, u32(1234));
+ \\ @export("entry", entry, @as(u32, 1234));
\\}
,
"tmp.zig:3:32: error: expected type 'std.builtin.GlobalLinkage', found 'u32'",
test/tests.zig
@@ -411,7 +411,7 @@ pub fn addPkgTests(
const ArchTag = @TagType(builtin.Arch);
if (test_target.disable_native and
test_target.target.getOs() == builtin.os and
- ArchTag(test_target.target.getArch()) == ArchTag(builtin.arch))
+ @as(ArchTag,test_target.target.getArch()) == @as(ArchTag,builtin.arch))
{
continue;
}
@@ -429,7 +429,7 @@ pub fn addPkgTests(
"bare";
const triple_prefix = if (test_target.target == .Native)
- ([]const u8)("native")
+ @as([]const u8,"native")
else
test_target.target.zigTripleNoSubArch(b.allocator) catch unreachable;
test/translate_c.zig
@@ -28,9 +28,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
,
\\pub fn foo() void {
\\ var a: c_int = undefined;
- \\ var b: u8 = u8(123);
+ \\ var b: u8 = @as(u8, 123);
\\ const c: c_int = undefined;
- \\ const d: c_uint = c_uint(440);
+ \\ const d: c_uint = @as(c_uint, 440);
\\}
);
@@ -561,7 +561,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.add("u integer suffix after hex literal",
\\#define SDL_INIT_VIDEO 0x00000020u /**< SDL_INIT_VIDEO implies SDL_INIT_EVENTS */
,
- \\pub const SDL_INIT_VIDEO = c_uint(32);
+ \\pub const SDL_INIT_VIDEO = @as(c_uint, 32);
);
cases.add("l integer suffix after hex literal",
@@ -676,7 +676,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub export fn log2(_arg_a: c_uint) c_int {
\\ var a = _arg_a;
\\ var i: c_int = 0;
- \\ while (a > c_uint(0)) {
+ \\ while (a > @as(c_uint, 0)) {
\\ a >>= @import("std").math.Log2Int(c_uint)(1);
\\ }
\\ return i;
@@ -848,7 +848,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub export fn log2(_arg_a: u32) c_int {
\\ var a = _arg_a;
\\ var i: c_int = 0;
- \\ while (a > c_uint(0)) {
+ \\ while (a > @as(c_uint, 0)) {
\\ a >>= u5(1);
\\ }
\\ return i;
@@ -937,7 +937,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\}
,
\\pub export fn float_to_int(a: f32) c_int {
- \\ return c_int(a);
+ \\ return @as(c_int, a);
\\}
);
@@ -1103,35 +1103,35 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\}
,
\\pub export fn foo() void {
- \\ var a: c_uint = c_uint(0);
+ \\ var a: c_uint = @as(c_uint, 0);
\\ a +%= (x: {
\\ const _ref = &a;
- \\ _ref.* = (_ref.* +% c_uint(1));
+ \\ _ref.* = (_ref.* +% @as(c_uint, 1));
\\ break :x _ref.*;
\\ });
\\ a -%= (x: {
\\ const _ref = &a;
- \\ _ref.* = (_ref.* -% c_uint(1));
+ \\ _ref.* = (_ref.* -% @as(c_uint, 1));
\\ break :x _ref.*;
\\ });
\\ a *%= (x: {
\\ const _ref = &a;
- \\ _ref.* = (_ref.* *% c_uint(1));
+ \\ _ref.* = (_ref.* *% @as(c_uint, 1));
\\ break :x _ref.*;
\\ });
\\ a &= (x: {
\\ const _ref = &a;
- \\ _ref.* = (_ref.* & c_uint(1));
+ \\ _ref.* = (_ref.* & @as(c_uint, 1));
\\ break :x _ref.*;
\\ });
\\ a |= (x: {
\\ const _ref = &a;
- \\ _ref.* = (_ref.* | c_uint(1));
+ \\ _ref.* = (_ref.* | @as(c_uint, 1));
\\ break :x _ref.*;
\\ });
\\ a ^= (x: {
\\ const _ref = &a;
- \\ _ref.* = (_ref.* ^ c_uint(1));
+ \\ _ref.* = (_ref.* ^ @as(c_uint, 1));
\\ break :x _ref.*;
\\ });
\\ a >>= @import("std").math.Log2Int(c_uint)((x: {
@@ -1174,7 +1174,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
,
\\pub export fn foo() void {
\\ var i: c_int = 0;
- \\ var u: c_uint = c_uint(0);
+ \\ var u: c_uint = @as(c_uint, 0);
\\ i += 1;
\\ i -= 1;
\\ u +%= 1;
@@ -1222,7 +1222,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
,
\\pub export fn foo() void {
\\ var i: c_int = 0;
- \\ var u: c_uint = c_uint(0);
+ \\ var u: c_uint = @as(c_uint, 0);
\\ i += 1;
\\ i -= 1;
\\ u +%= 1;
@@ -1646,7 +1646,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.addC(
"u integer suffix after 0 (zero) in macro definition",
"#define ZERO 0U",
- "pub const ZERO = c_uint(0);",
+ "pub const ZERO = @as(c_uint, 0);",
);
cases.addC(
@@ -1688,7 +1688,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
cases.addC(
"bitwise not on u-suffixed 0 (zero) in macro definition",
"#define NOT_ZERO (~0U)",
- "pub const NOT_ZERO = ~c_uint(0);",
+ "pub const NOT_ZERO = ~@as(c_uint, 0);",
);
cases.addC("implicit casts",
@@ -1733,9 +1733,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\ fn_int(1094861636);
\\ fn_f32(@intToFloat(f32, 3));
\\ fn_f64(@intToFloat(f64, 3));
- \\ fn_char(u8('3'));
- \\ fn_char(u8('\x01'));
- \\ fn_char(u8(0));
+ \\ fn_char(@as(u8, '3'));
+ \\ fn_char(@as(u8, '\x01'));
+ \\ fn_char(@as(u8, 0));
\\ fn_f32(3.000000);
\\ fn_f64(3.000000);
\\ fn_bool(true);
@@ -1798,17 +1798,17 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\
,
\\pub export fn escapes() [*c]const u8 {
- \\ var a: u8 = u8('\'');
- \\ var b: u8 = u8('\\');
- \\ var c: u8 = u8('\x07');
- \\ var d: u8 = u8('\x08');
- \\ var e: u8 = u8('\x0c');
- \\ var f: u8 = u8('\n');
- \\ var g: u8 = u8('\r');
- \\ var h: u8 = u8('\t');
- \\ var i: u8 = u8('\x0b');
- \\ var j: u8 = u8('\x00');
- \\ var k: u8 = u8('\"');
+ \\ var a: u8 = @as(u8, '\'');
+ \\ var b: u8 = @as(u8, '\\');
+ \\ var c: u8 = @as(u8, '\x07');
+ \\ var d: u8 = @as(u8, '\x08');
+ \\ var e: u8 = @as(u8, '\x0c');
+ \\ var f: u8 = @as(u8, '\n');
+ \\ var g: u8 = @as(u8, '\r');
+ \\ var h: u8 = @as(u8, '\t');
+ \\ var i: u8 = @as(u8, '\x0b');
+ \\ var j: u8 = @as(u8, '\x00');
+ \\ var k: u8 = @as(u8, '\"');
\\ return c"\'\\\x07\x08\x0c\n\r\t\x0b\x00\"";
\\}
\\
build.zig
@@ -155,7 +155,7 @@ fn dependOnLib(b: *Builder, lib_exe_obj: var, dep: LibraryDep) void {
) catch unreachable;
for (dep.system_libs.toSliceConst()) |lib| {
const static_bare_name = if (mem.eql(u8, lib, "curses"))
- ([]const u8)("libncurses.a")
+ @as([]const u8,"libncurses.a")
else
b.fmt("lib{}.a", lib);
const static_lib_name = fs.path.join(