srctree

if (!dest_info.flags.is_const) {

const err_msg = err_msg: {

const err_msg = try sema.errMsg(block, inst_src, "cannot cast pointer to tuple to '{}'", .{dest_ty.fmt(mod)});

try sema.errNote(block, dest_ty_src, err_msg, "pointers to tuples can only coerce to constant pointers", .{});

break :err_msg err_msg;

};

 

if (try sema.compareScalar(start_value, .neq, end_value, Type.comptime_int)) {

if (try sema.compareScalar(start_value, .neq, Value.zero_comptime_int, Type.comptime_int)) {

} else if (try sema.compareScalar(end_value, .neq, Value.one_comptime_int, Type.comptime_int)) {

}

} else {

if (try sema.compareScalar(end_value, .gt, Value.one_comptime_int, Type.comptime_int)) {

 

var foo: u8 align(4) = 100;

 

test "global variable alignment" {

{

const slice = @as(*align(4) [1]u8, &foo)[0..];

}

}

 

try testIndex2(&array, 3, *u8);

}

fn testIndex(smaller: [*]align(2) u32, index: usize, comptime T: type) !void {

}

fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {

}

 

test "alignment of function with c calling convention" {

var node: S.Node = undefined;

node.massive_byte = 100;

try expect(node.massive_byte == 100);

try expect(@intFromPtr(&node.massive_byte) % 64 == 0);

}

 

 

const std = @import("std");

const expect = std.testing.expect;

const builtin = @import("builtin");

const native_arch = builtin.target.cpu.arch;

};

 

test "@alignOf(T) before referencing T" {

if (native_arch == .x86_64) {

}

}

 

 

const builtin = @import("builtin");

const testing = std.testing;

const mem = std.mem;

const expect = testing.expect;

const expectEqual = testing.expectEqual;

 

var arr = [4]u8{ 0, 0, 0, 0 };

const ptr = &arr;

try expect(arr.len == 4);

try expect(ptr.len == 4);

try expect(@TypeOf(arr.len) == usize);

}

 

};

 

try expect(S.storeArrayOfArrayOfStructs() == 15);

}

 

test "accessing multidimensional global array at comptime" {

 

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

const expectEqualStrings = std.testing.expectEqualStrings;

var global_result = false;

fn testSuspendBlock() callconv(.Async) void {

suspend {

a_promise = @frame();

}

 

_ = &foo;

var bytes: [64]u8 align(16) = undefined;

const f = @asyncCall(&bytes, {}, foo.bar, .{&data});

try expect(data == 2);

resume f;

try expect(data == 4);

_ = &foo;

var bytes: [64]u8 align(16) = undefined;

const f = @asyncCall(&bytes, {}, foo.bar, .{&data});

try expect(data == 2);

resume f;

try expect(data == 4);

const S = struct {

fn func(comptime x: anytype) anyerror!i32 {

const T = @TypeOf(async func(x));

return undefined;

}

};

 

 

test "truncate" {

try expect(testTruncate(0x10fd) == 0xfd);

}

fn testTruncate(x: u32) u8 {

return @as(u8, @truncate(x));

const addr1 = @as(*const u8, @ptrCast(&emptyFn));

test "comptime cast fn to ptr" {

const addr2 = @as(*const u8, @ptrCast(&emptyFn));

}

 

test "equality compare fn ptrs" {

const a = "OK" ++ " IT " ++ "WORKED";

const b = "OK IT WORKED";

 

 

const len = b.len;

const len_with_null = len + 1;

}

};

try expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);

}

 

test "extern variable with non-pointer opaque type" {

 

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

const math = std.math;

test "bitcast passed as tuple element" {

const S = struct {

fn foo(args: anytype) !void {

try expect(args[0] == 12.34);

}

};

test "triple level result location with bitcast sandwich passed as tuple element" {

const S = struct {

fn foo(args: anytype) !void {

try expect(args[0] > 12.33 and args[0] < 12.35);

}

};

 

const builtin = @import("builtin");

const std = @import("std");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

 

}

}.foo;

try expect(@call(.auto, foo, .{}) == 1234);

{

// comptime call without comptime keyword

const result = @call(.compile_time, foo, .{}) == 1234;

}

}

 

{

// comptime call without comptime keyword

const result = @call(.compile_time, foo, .{}) == 1234;

}

{

// call of non comptime-known function

try expect(@call(.auto, add, .{ a, b }) == 46);

try expect(@call(.auto, add, .{ 12, 34 }) == 46);

if (false) {

}

try expect(comptime @call(.auto, add, .{ 12, 34 }) == 46);

{

 

}

 

test "implicit cast comptime_int to comptime_float" {

try expect(2 == 2.0);

}

 

};

 

try expect(S.blah(0) == null);

try expect(S.blah(10).? == 1);

try expect(S.blah(-10).? == -1);

}

 

test "*const ?[*]const T to [*c]const [*c]const T" {

var y: i32 = -5;

_ = .{ &w, &x, &y };

const a = w + y + x;

try expect(a == 7);

}

 

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

 

try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));

try expect(mem.eql(u8, try testPeerErrorAndArray2(1), "OKK"));

}

 

fn testPeerErrorAndArray(x: u8) anyerror![]const u8 {

var array: [4:0]u8 = undefined;

array[4] = 0; // TODO remove this when #4372 is solved

const slice: [:0]u8 = array[0..4 :0];

}

 

test "peer type resolve array pointers, one of them const" {

var array1: [4]u8 = undefined;

const array2: [5]u8 = undefined;

}

 

test "peer type resolve array pointer and unknown pointer" {

var ptr: [*]u8 = undefined;

_ = .{ &const_ptr, &ptr };

 

 

 

 

}

 

test "comptime float casts" {

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

 

try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));

}

 

fn castToOptionalSlice() ?[]const u8 {

 

try expect(mem.eql(u8, boolToStr(true), "true"));

try expect(mem.eql(u8, boolToStr(false), "false"));

}

fn boolToStr(b: bool) []const u8 {

return if (b) "true" else "false";

 

{

var x = Small.One;

x = Small.Two;

}

{

var x = Small2.One;

x = Small2.Two;

}

}

 

const Enum = enum(u8) {

B = 2,

};

}

 

test "signed integer as enum tag" {

Two = 2,

Three = 1,

};

}

 

test "enum with one member default to u0 tag type" {

const E0 = enum { X };

}

 

const EnumWithOneMember = enum { Eof };

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));

}

 

fn testEnumTagNameBare(n: anytype) []const u8 {

if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

 

try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));

}

const NonExhaustive = enum(u8) { A, B, _ };

 

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

 

try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));

}

 

test "tag name with signed enum values" {

try expect(getA(&data) == A.Two);

try expect(getB(&data) == B.Three3);

try expect(getC(&data) == C.Four4);

 

data.b = B.Four3;

try expect(data.b == B.Four3);

 

const builtin = @import("builtin");

const std = @import("std");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

const mem = std.mem;

}

};

try expectError(error.Failure, S.errorable());

}

 

test "optional error set is the same size as error set" {

if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

 

const S = struct {

fn returnsOptErrSet() ?anyerror {

return null;

}

};

try expect(S.returnsOptErrSet() == null);

}

 

test "nested catch" {

 

 

test "const expr eval on single expr blocks" {

try expect(constExprEvalOnSingleExprBlocksFn(1, true) == 3);

}

 

fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {

}

 

test {

}

 

fn copyWithPartialInline(s: []u32, b: []u8) void {

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

 

try assertEqualPtrs(&hi1[0], &hi2[0]);

}

fn assertEqualPtrs(ptr1: *const u8, ptr2: *const u8) !void {

try expect(ptr1 == ptr2);

test "string literal used as comptime slice is memoized" {

const a = "link";

const b = "link";

}

 

pub fn TypeWithCompTimeSlice(comptime field_name: []const u8) type {

S.declarations(E1),

};

 

}

 

test "closure capture type of runtime-known parameter" {

const s = if (false) S{ .str = "a" } else S{ .str = "b" };

break :blk "foo" ++ s.str;

};

}

 

test "lazy sizeof is resolved in division" {

fnPtr(Nil),

};

};

}

 

test "container level const and var have unique addresses" {

 

const std = @import("std");

const builtin = @import("builtin");

const testing = std.testing;

const expect = testing.expect;

const expectEqual = testing.expectEqual;

 

}

 

fn addPointCoordsVar(pt: anytype) !i32 {

return pt.x + pt.y;

}

 

 

const builtin = @import("builtin");

const std = @import("std");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

const expectEqualSlices = std.testing.expectEqualSlices;

}

 

test "hex float literal parsing" {

}

 

test "hex float literal within range" {

const x = 14.0;

const y = x + 0.4;

const z = @round(y);

}

 

test "@round f80" {

 

const builtin = @import("builtin");

const std = @import("std");

const testing = std.testing;

const expect = testing.expect;

const expectEqual = testing.expectEqual;

const expectEqualStrings = std.testing.expectEqualStrings;

}

};

try expect(S.entry());

}

 

pub const EmptyStruct = struct {};

 

const builtin = @import("builtin");

const std = @import("std");

const testing = std.testing;

const expect = testing.expect;

const expectError = testing.expectError;

 

}

 

test "double pointer parsing" {

}

 

fn PtrOf(comptime T: type) type {

test "initialize const optional C pointer to null" {

const a: ?[*c]i32 = null;

try expect(a == null);

}

 

test "assigning integer to C pointer" {

var runtime_zero: usize = 0;

_ = &runtime_zero;

var slice = ptr[runtime_zero..10];

try expect(@intFromPtr(&slice[5]) == 20);

 

}

 

test "assign null directly to C pointer and test null equality" {

try expect((x orelse &otherx) == &otherx);

 

const y: [*c]i32 = null;

if (y) |same_y| {

_ = same_y;

@panic("fail");

}

const othery: i32 = undefined;

const ptr_othery = &othery;

 

var n: i32 = 1234;

const x1: [*c]i32 = &n;

 

const nc: i32 = 1234;

const y1: [*c]const i32 = &nc;

if (y1) |same_y1| {

try expect(same_y1.* == 1234);

} else {

@compileError("fail");

}

}

 

test "array initialization types" {

fn doTheTest() !void {

var ptr: [*:.sentinel]const Number = &[_:.sentinel]Number{ .one, .two, .two, .one };

_ = &ptr;

}

};

try S.doTheTest();

fn doTheTest() !void {

var ptr: [*:null]const ?i32 = &[_:null]?i32{ 1, 2, 3, 4 };

_ = &ptr;

}

};

try S.doTheTest();

const inf_f32 = comptime std.math.inf(f32);

var ptr: [*:inf_f32]const f32 = &[_:inf_f32]f32{ 1.1, 2.2, 3.3, 4.4 };

_ = &ptr;

}

};

try S.doTheTest();

const pointer = @as(?*u8, @ptrFromInt(0x000));

const x = @intFromPtr(pointer);

_ = x;

}

{

const pointer = @as(?*u8, @ptrFromInt(0xf00));

}

}

 

 

const builtin = @import("builtin");

const std = @import("std");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

 

var var_2: u8 = undefined;

var var_3: u64 = undefined;

_ = .{ &var_1, &var_2, &var_3 };

}

{

var var_1: f16 = undefined;

var var_2: f32 = undefined;

var var_3: f64 = undefined;

_ = .{ &var_1, &var_2, &var_3 };

}

{

var var_1: u16 = undefined;

_ = &var_1;

}

{

var var_1: f32 = undefined;

_ = &var_1;

}

}

 

};

var data: i32 = 0;

const T = @TypeOf(S.foo(i32, &data));

try expect(data == 0);

}

 

}

};

const T = @TypeOf(S.foo() catch undefined);

try expect(S.data == 0);

}

 

}

};

try expect(S.func() == 0);

}

 

test "array access of generic param in typeof expression" {

}

};

try expect(S.first("a") == 'a');

}

 

test "lazy size cast to float" {

 

const builtin = @import("builtin");

const std = @import("std");

const expect = std.testing.expect;

const expectEqualSlices = std.testing.expectEqualSlices;

const expectEqualStrings = std.testing.expectEqualStrings;

const S = struct {

fn doTheTest() !void {

const pointer = @as([*]u8, @ptrFromInt(0x04))[0..2];

const slice: []const u8 = pointer;

try expect(@intFromPtr(slice.ptr) == 4);

try expect(slice.len == 2);

}

var runtime_zero: usize = 0;

_ = &runtime_zero;

const array = [_]i32{ 1, 2, 3, 4 };

}

 

test "result location zero sized array inside struct field implicit cast to slice" {

 

var runtime_zero: usize = 0;

_ = &runtime_zero;

 

for (c_ptr[0..5]) |*cl| {

try expect(@as(u32, 42) == cl.*);

_ = &runtime_len;

const ptr2 = buf[0..runtime_len :0];

// ptr2 is a null-terminated slice

var runtime_zero: usize = 0;

_ = &runtime_zero;

}

 

test "empty array to slice" {

var array = [5]u8{ 1, 2, 3, 4, 5 };

const pointer: [*]u8 = &array;

const slice = pointer[1..];

try expect(slice[0] == 2);

try expect(slice[1] == 3);

}

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

const pointer: [*:0]u8 = &array;

 

 

const slice = pointer[1..];

try expect(slice[0] == 2);

try expect(slice[1] == 3);

}

fn testArray() !void {

var array = [5]u8{ 1, 2, 3, 4, 5 };

const slice = array[1..3];

try expect(slice[0] == 2);

try expect(slice[1] == 3);

}

 

fn testArrayZ() !void {

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

}

 

fn testArray0() !void {

{

var array = [0]u8{};

const slice = array[0..0];

}

{

var array = [0:0]u8{};

const slice = array[0..0];

try expect(slice[0] == 0);

}

}

fn testArrayAlign() !void {

var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };

const slice = array[4..5];

try expect(slice[0] == 5);

}

 

fn testPointer() !void {

var array = [5]u8{ 1, 2, 3, 4, 5 };

var pointer: [*]u8 = &array;

const slice = pointer[1..3];

try expect(slice[0] == 2);

try expect(slice[1] == 3);

}

fn testPointerZ() !void {

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

var pointer: [*:0]u8 = &array;

}

 

fn testPointer0() !void {

var pointer: [*]const u0 = &[1]u0{0};

const slice = pointer[0..1];

try expect(slice[0] == 0);

}

 

var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };

var pointer: [*]align(4) u8 = &array;

const slice = pointer[4..5];

try expect(slice[0] == 5);

}

 

fn testSlice() !void {

var array = [5]u8{ 1, 2, 3, 4, 5 };

var src_slice: []u8 = &array;

const slice = src_slice[1..3];

try expect(slice[0] == 2);

try expect(slice[1] == 3);

}

fn testSliceZ() !void {

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

var slice: [:0]u8 = &array;

if (@inComptime()) {

} else {

}

}

 

fn testSliceOpt() !void {

var array: [2]u8 = [2]u8{ 1, 2 };

var slice: ?[]u8 = &array;

}

 

fn testSliceAlign() !void {

var array align(4) = [5]u8{ 1, 2, 3, 4, 5 };

var src_slice: []align(4) u8 = &array;

const slice = src_slice[4..5];

try expect(slice[0] == 5);

}

 

fn testConcatStrLiterals() !void {

fn testSliceLength() !void {

var array = [5]u8{ 1, 2, 3, 4, 5 };

var slice: []u8 = &array;

}

 

fn testSliceLengthZ() !void {

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

var slice: [:0]u8 = &array;

}

 

fn testArrayLength() !void {

var array = [5]u8{ 1, 2, 3, 4, 5 };

}

 

fn testArrayLengthZ() !void {

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

}

 

fn testMultiPointer() !void {

var array = [5]u8{ 1, 2, 3, 4, 5 };

var ptr: [*]u8 = &array;

}

 

fn testMultiPointerLengthZ() !void {

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

var ptr: [*]u8 = &array;

 

var ptr_z: [*:0]u8 = &array;

}

 

fn testSingleItemPointer() !void {

var ptr = &value;

 

const slice = ptr[0..1];

try expect(slice[0] == 1);

 

}

};

 

 

var array = [5:0]u8{ 1, 2, 3, 4, 5 };

var slice: [:0]u8 = &array;

}

 

test "slice pointer-to-array zero length" {

var array = [0]u8{};

var src_slice: []u8 = &array;

const slice = src_slice[0..0];

}

{

var array = [0:0]u8{};

var src_slice: [:0]u8 = &array;

const slice = src_slice[0..0];

}

}

 

 

try expect(getA(&data) == 1);

try expect(getB(&data) == 2);

try expect(getC(&data) == 3);

 

data.b += 1;

try expect(data.b == 3);

};

var s = S{ .f0 = 0 };

_ = &s;

}

 

test "access to global struct fields" {

 

var foo: T = undefined;

_ = &foo;

}

 

test "tuple element initialized with fn call" {

 

try expect(1 == S.doTheTest(S.P1));

try expect(2 == S.doTheTest(S.P2));

try expect(3 == S.doTheTest(S.P3));

}

 

test "switch on error set with single else" {

 

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

 

test "truncate u0 to larger integer allowed and has comptime-known result" {

var x: u0 = 0;

_ = &x;

const y = @as(u8, @truncate(x));

}

 

test "truncate.u0.literal" {

var x: i0 = 0;

_ = &x;

const y: i8 = @truncate(x);

}

 

test "truncate.i0.literal" {

 

const Type = std.builtin.Type;

const TypeId = std.builtin.TypeId;

 

const expect = std.testing.expect;

const expectEqualStrings = std.testing.expectEqualStrings;

 

@compileError("test failed");

}

};

}

 

fn add(a: i32, b: i32) i32 {

 

int: u64,

};

test "extern union size" {

}

 

test "0-sized extern union definition" {

const B = void;

};

 

}

 

test "constant tagged union with payload" {

int: u64,

};

test "packed union size" {

}

 

const ZeroBits = union {

OnlyField: void,

};

test "union with only 1 field which is void should be zero bits" {

}

 

test "tagged union initialization with runtime void" {

var e = Expr{ .Literal = Literal{ .Bool = true } };

_ = &e;

const ExprTag = Tag(Expr);

var t = @as(ExprTag, e);

_ = &t;

try expect(t == Expr.Literal);

const U0 = union(enum) {

X: u32,

};

}

 

const Foo1 = union(enum) {

if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

 

try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });

try comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });

}

 

var e = Expr{ .Literal = Literal{ .Bool = true } };

_ = &e;

const t = comptime @as(ExprTag, e);

try expect(t == Expr.Literal);

try expect(@intFromEnum(t) == 33);

}

 

test "@intFromEnum works on unions" {

Y: u16,

Z: u8,

};

}

 

test "extern union doesn't trigger field check at comptime" {

};

 

const x = U{ .x = 0x55AAAA55 };

}

 

test "anonymous union literal syntax" {

 

const value = V{ 1, -1, 1, -1 };

const result = value > @as(V, @splat(0));

// result is { true, false, true, false };

const is_all_true = @reduce(.And, result);

try expect(is_all_true == false);

}