jimzah/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-26 15:12:31 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Fix peer type resolution with allowzero pointers
Some checks are pending
ci / x86_64-linux-debug (push) Waiting to run
Details
ci / x86_64-linux-release (push) Waiting to run
Details
ci / aarch64-linux-debug (push) Waiting to run
Details
ci / aarch64-linux-release (push) Waiting to run
Details
ci / x86_64-macos-release (push) Waiting to run
Details
ci / aarch64-macos-debug (push) Waiting to run
Details
ci / aarch64-macos-release (push) Waiting to run
Details
ci / x86_64-windows-debug (push) Waiting to run
Details
ci / x86_64-windows-release (push) Waiting to run
Details
ci / aarch64-windows (push) Waiting to run
Details

Browse Source
This commit is contained in:
xdBronch 2024-11-18 16:35:45 -05:00 committed by Veikka Tuominen
parent 865ef24518
commit 5f3a70ed5f
2 changed files with 51 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/Sema.zig
View File

@ -35076,6 +35076,7 @@ fn resolvePeerTypesInner(
ptr_info.flags.is_const = ptr_info.flags.is_const or peer_info.flags.is_const;
ptr_info.flags.is_volatile = ptr_info.flags.is_volatile or peer_info.flags.is_volatile;
ptr_info.flags.is_allowzero = ptr_info.flags.is_allowzero or peer_info.flags.is_allowzero;
const peer_sentinel: InternPool.Index = switch (peer_info.flags.size) {
.One => switch (ip.indexToKey(peer_info.child)) {

62
test/behavior/cast.zig
View File

@ -2200,39 +2200,77 @@ test "peer type resolution: pointer attributes are combined correctly" {
var buf_a align(4) = "foo".*;
var buf_b align(4) = "bar".*;
var buf_c align(4) = "baz".*;
var buf_d align(4) = "qux".*;
const a: [*:0]align(4) const u8 = &buf_a;
const b: *align(2) volatile [3:0]u8 = &buf_b;
const c: [*:0]align(4) u8 = &buf_c;
const d: [*:0]allowzero align(4) u8 = &buf_d;
comptime assert(@TypeOf(a, b, c) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(a, c, b) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(b, a, c) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(b, c, a) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(c, a, b) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(c, b, a) == [*:0]align(2) const volatile u8);
comptime assert(@TypeOf(a, b, c, d) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(a, b, d, c) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(a, c, b, d) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(a, c, d, b) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(a, d, b, c) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(a, d, c, b) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(b, a, c, d) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(b, a, d, c) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(b, c, a, d) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(b, c, d, a) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(b, d, c, a) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(b, d, a, c) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(c, a, b, d) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(c, a, d, b) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(c, b, a, d) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(c, b, d, a) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(c, d, b, a) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(c, d, a, b) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(d, a, b, c) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(d, a, c, b) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(d, b, a, c) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(d, b, c, a) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(d, c, b, a) == [*:0]allowzero align(2) const volatile u8);
comptime assert(@TypeOf(d, c, a, b) == [*:0]allowzero align(2) const volatile u8);
var x: u8 = 0;
_ = &x;
const r1 = switch (x) {
0 => a,
1 => b,
else => c,
2 => c,
else => d,
};
const r2 = switch (x) {
0 => b,
1 => a,
else => c,
2 => c,
else => d,
};
const r3 = switch (x) {
0 => c,
1 => a,
else => b,
2 => b,
else => d,
};
const r4 = switch (x) {
0 => d,
1 => a,
2 => b,
else => c,
};
try expectEqualSlices(u8, std.mem.span(@volatileCast(r1)), "foo");
try expectEqualSlices(u8, std.mem.span(@volatileCast(r2)), "bar");
try expectEqualSlices(u8, std.mem.span(@volatileCast(r3)), "baz");
const NonAllowZero = comptime blk: {
var ti = @typeInfo(@TypeOf(r1, r2, r3, r4));
ti.pointer.is_allowzero = false;
break :blk @Type(ti);
};
try expectEqualSlices(u8, std.mem.span(@volatileCast(@as(NonAllowZero, @ptrCast(r1)))), "foo");
try expectEqualSlices(u8, std.mem.span(@volatileCast(@as(NonAllowZero, @ptrCast(r2)))), "bar");
try expectEqualSlices(u8, std.mem.span(@volatileCast(@as(NonAllowZero, @ptrCast(r3)))), "baz");
try expectEqualSlices(u8, std.mem.span(@volatileCast(@as(NonAllowZero, @ptrCast(r4)))), "qux");
}
test "peer type resolution: arrays of compatible types" {