Commit 05cb944709d2a05a944e60f032638cae5ee01fb0 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-06-26 23:35:11+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-06-26 23:35:11+02:00
log	05cb944709d2a05a944e60f032638cae5ee01fb0
tree	6951331c63eec3a29f0961ee8d5e528a43b2328c
parent	b636906fb640a12107cd21637c2af67b8e9d6ebd
parent	f2d13f6d074139c01184e170fe24127a2d9db944

Merge pull request 'Sema: more fixes' (#35707) from sinon/zig:more-fixes into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/35707
Reviewed-by: Andrew Kelley <andrew@ziglang.org>

6 files changed, 90 insertions(+), 54 deletions(-)

src
- Sema.zig
test
- behavior
  - switch.zig
  - try.zig
- cases
  - safety
    @intCast negative to u0.zig
    @intCast positive to u0.zig
    @intCast to u0.zig

src/Sema.zig+15-32

 @@ -9314,7 +9314,7 @@ fn intCast(
                     break :ok all_in_range;
                 } else ok: {
                     const zero_inst = Air.internedToRef((try pt.intValue(operand_ty, 0)).toIntern());
-                    const is_in_range = try block.addBinOp(.cmp_lte, operand, zero_inst);
+                    const is_in_range = try block.addBinOp(.cmp_eq, operand, zero_inst);
                     break :ok is_in_range;
                 };
                 try sema.addSafetyCheck(block, src, ok, .integer_out_of_bounds);
 @@ -12012,15 +12012,12 @@ fn resolveSwitchPayloadCaptureTaggedUnion(
     const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]);
     const payload_ref: Air.Inst.Ref = payload_ref: {
         if (capture_by_ref) {
-            const operand_ptr_info = sema.typeOf(loaded_operand).ptrInfo(zcu);
+            const ptr_field_ty = try sema.typeOf(loaded_operand).fieldPtrType(field_index, pt);
-            const ptr_field_ty = try pt.ptrType(.{
+            if (try sema.resolveDefinedValue(case_block, operand_src, loaded_operand)) |op_ptr_val| {
-                .child = field_ty.toIntern(),
+                if (op_ptr_val.isUndef(zcu)) break :payload_ref try pt.undefRef(ptr_field_ty);
-                .flags = .{
+                const field_ptr_val = try op_ptr_val.ptrField(field_index, pt);
-                    .is_const = operand_ptr_info.flags.is_const,
+                break :payload_ref .fromValue(try pt.getCoerced(field_ptr_val, ptr_field_ty));
-                    .is_volatile = operand_ptr_info.flags.is_volatile,
+            }
-                    .address_space = operand_ptr_info.flags.address_space,
-                },
-            });
             break :payload_ref try case_block.addStructFieldPtr(loaded_operand, field_index, ptr_field_ty);
         }
         if (try sema.resolveDefinedValue(case_block, operand_src, loaded_operand)) |union_val| {
 @@ -17548,15 +17545,10 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
     const is_cold = sema.branch_hint == .cold;
     const operand_ty = sema.typeOf(operand);
-    const ptr_info = operand_ty.ptrInfo(zcu);
+    const res_ty = try pt.ptrType(info: {
-    const res_ty = try pt.ptrType(.{
+        var new = operand_ty.ptrInfo(zcu);
-        .child = err_union_ty.errorUnionPayload(zcu).toIntern(),
+        new.child = err_union_ty.errorUnionPayload(zcu).toIntern();
-        .flags = .{
+        break :info new;
-            .is_const = ptr_info.flags.is_const,
-            .is_volatile = ptr_info.flags.is_volatile,
-            .is_allowzero = ptr_info.flags.is_allowzero,
-            .address_space = ptr_info.flags.address_space,
-        },
     });
     const res_ty_ref = Air.internedToRef(res_ty.toIntern());
     try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.TryPtr).@"struct".field_names.len +
 @@ -26404,23 +26396,21 @@ fn fieldCallBind(
             .@"struct" => {
                 if (zcu.typeToStruct(concrete_ty)) |struct_type| {
                     const field_index = struct_type.nameIndex(ip, field_name) orelse break :find_field;
-                    const field_ty: Type = .fromInterned(struct_type.field_types.get(ip)[field_index]);
+                    return sema.finishFieldCallBind(block, src, ptr_ty, field_index, object_ptr);
-                    return sema.finishFieldCallBind(block, src, ptr_ty, field_ty, field_index, object_ptr);
                 } else if (concrete_ty.isTuple(zcu)) {
                     if (field_name.eqlSlice("len", ip)) {
                         return .{ .direct = try pt.intRef(.usize, concrete_ty.structFieldCount(zcu)) };
                     }
                     if (field_name.toUnsigned(ip)) |field_index| {
                         if (field_index >= concrete_ty.structFieldCount(zcu)) break :find_field;
-                        return sema.finishFieldCallBind(block, src, ptr_ty, concrete_ty.fieldType(field_index, zcu), field_index, object_ptr);
+                        return sema.finishFieldCallBind(block, src, ptr_ty, field_index, object_ptr);
                     }
                 } else {
                     const max = concrete_ty.structFieldCount(zcu);
                     for (0..max) |i_usize| {
                         const i: u32 = @intCast(i_usize);
                         if (field_name == concrete_ty.structFieldName(i, zcu).unwrap().?) {
-                            return sema.finishFieldCallBind(block, src, ptr_ty, concrete_ty.fieldType(i, zcu), i, object_ptr);
+                            return sema.finishFieldCallBind(block, src, ptr_ty, i, object_ptr);
                         }
                     }
                 }
 @@ -26536,19 +26526,12 @@ fn finishFieldCallBind(
     block: *Block,
     src: LazySrcLoc,
     ptr_ty: Type,
-    field_ty: Type,
     field_index: u32,
     object_ptr: Air.Inst.Ref,
 ) CompileError!ResolvedFieldCallee {
     const pt = sema.pt;
     const zcu = pt.zcu;
-    const ptr_field_ty = try pt.ptrType(.{
+    const ptr_field_ty = try ptr_ty.fieldPtrType(field_index, pt);
-        .child = field_ty.toIntern(),
-        .flags = .{
-            .is_const = !ptr_ty.ptrIsMutable(zcu),
-            .address_space = ptr_ty.ptrAddressSpace(zcu),
-        },
-    });
     const container_ty = ptr_ty.childType(zcu);
     if (container_ty.zigTypeTag(zcu) == .@"struct") {

test/behavior/switch.zig+19

...	@@ -1574,3 +1574,22 @@ test "repeated switch analysis overrides previous analysis results" {	...	@@ -1574,3 +1574,22 @@ test "repeated switch analysis overrides previous analysis results" {
1574	};	1574	};
1575	}	1575	}
1576	}	1576	}
		1577
		1578	test "union field pointer capture preserves alignment in inline prong" {
		1579	const U = union(enum) {
		1580	a: u32,
		1581	b: u32,
		1582	fn doTheTest(u: *align(1) const @This()) !void {
		1583	switch (u.*) {
		1584	inline .a, .b => \|*a_ptr\| {
		1585	comptime assert(@TypeOf(a_ptr) == *align(1) const u32);
		1586	try expect(a_ptr.* == 123);
		1587	},
		1588	}
		1589	}
		1590	};
		1591	try U.doTheTest(&.{ .a = 123 });
		1592	try U.doTheTest(&.{ .b = 123 });
		1593	try comptime U.doTheTest(&.{ .a = 123 });
		1594	try comptime U.doTheTest(&.{ .b = 123 });
		1595	}

test/behavior/try.zig+12

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
		3	const assert = std.debug.assert;
3	const expect = std.testing.expect;	4	const expect = std.testing.expect;
4		5
5	test "try on error union" {	6	test "try on error union" {
...	@@ -197,3 +198,14 @@ test "try ptr propagation mutate" {	...	@@ -197,3 +198,14 @@ test "try ptr propagation mutate" {
197	try S.doTheTest();	198	try S.doTheTest();
198	try comptime S.doTheTest();	199	try comptime S.doTheTest();
199	}	200	}
		201
		202	test "try pointer expression alignment" {
		203	const S = struct {
		204	fn doTheTest(p: *align(1) (anyerror!u32)) !void {
		205	comptime assert(@TypeOf(&(try p.)) == align(1) u32);
		206	try expect((try p.*) == 10);
		207	}
		208	};
		209	var x: anyerror!u32 = 10;
		210	try S.doTheTest(&x);
		211	}

test/cases/safety/@intCast negative to u0.zig created+22

...	@@ -0,0 +1,22 @@
1	const std = @import("std");
2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;
5	if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
6	std.process.exit(0);
7	}
8	std.process.exit(1);
9	}
10
11	pub fn main() !void {
12	bar(1, -1);
13	return error.TestFailed;
14	}
15
16	fn bar(one: u1, not_zero: i32) void {
17	const x = one << @intCast(not_zero);
18	_ = x;
19	}
20	// run
21	// backend=selfhosted,llvm
22	// target=x86_64-linux,aarch64-linux

test/cases/safety/@intCast positive to u0.zig created+22

...	@@ -0,0 +1,22 @@
1	const std = @import("std");
2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;
5	if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
6	std.process.exit(0);
7	}
8	std.process.exit(1);
9	}
10
11	pub fn main() !void {
12	bar(1, 1);
13	return error.TestFailed;
14	}
15
16	fn bar(one: u1, not_zero: i32) void {
17	const x = one << @intCast(not_zero);
18	_ = x;
19	}
20	// run
21	// backend=selfhosted,llvm
22	// target=x86_64-linux,aarch64-linux

test/cases/safety/@intCast to u0.zig deleted-22

...	@@ -1,22 +0,0 @@
1	const std = @import("std");
2
3	pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn {
4	_ = stack_trace;
5	if (std.mem.eql(u8, message, "integer does not fit in destination type")) {
6	std.process.exit(0);
7	}
8	std.process.exit(1);
9	}
10
11	pub fn main() !void {
12	bar(1, 1);
13	return error.TestFailed;
14	}
15
16	fn bar(one: u1, not_zero: i32) void {
17	const x = one << @intCast(not_zero);
18	_ = x;
19	}
20	// run
21	// backend=selfhosted,llvm
22	// target=x86_64-linux,aarch64-linux