From ee149aaa03e586e48c32cce09bf488ae0e88d053 Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Fri, 25 Feb 2022 12:54:40 +0200 Subject: [PATCH 1/3] stage2: actually coerce in coerce_result_ptr at comptime --- src/Sema.zig | 31 ++++++++++++++++++++++++++++--- src/type.zig | 4 ++-- test/behavior/cast.zig | 6 ++++-- test/behavior/error.zig | 7 ++++--- test/behavior/struct.zig | 25 +++++++++++++++++++++++++ 5 files changed, 63 insertions(+), 10 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index 41398016e5..4f08fb12d0 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -1598,11 +1598,37 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE // we cannot do it. if (try sema.resolveDefinedValue(block, src, ptr)) |ptr_val| { if (ptr_val.isComptimeMutablePtr()) { + const sentinel_val = try sema.addConstant(pointee_ty, Value.initTag(.unreachable_value)); + const coerced = try sema.coerce(block, sema.typeOf(ptr).childType(), sentinel_val, src); + + var res_ptr = ptr_val; + var cur_val = (try sema.resolveMaybeUndefVal(block, .unneeded, coerced)).?; + while (true) switch (cur_val.tag()) { + .unreachable_value => break, + .opt_payload => { + res_ptr = try Value.Tag.opt_payload_ptr.create(sema.arena, res_ptr); + cur_val = cur_val.castTag(.opt_payload).?.data; + }, + .eu_payload => { + res_ptr = try Value.Tag.eu_payload_ptr.create(sema.arena, res_ptr); + cur_val = cur_val.castTag(.eu_payload).?.data; + }, + else => { + if (std.debug.runtime_safety) { + std.debug.panic("unexpected Value tag for coerce_result_ptr: {s}", .{ + cur_val.tag(), + }); + } else { + unreachable; + } + }, + }; + const ptr_ty = try Type.ptr(sema.arena, .{ .pointee_type = pointee_ty, .@"addrspace" = addr_space, }); - return sema.addConstant(ptr_ty, ptr_val); + return sema.addConstant(ptr_ty, res_ptr); } } @@ -1673,7 +1699,7 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE } }, } - } else unreachable; // TODO should not need else unreachable + } } pub fn analyzeStructDecl( @@ -16937,7 +16963,6 @@ fn wrapErrorUnionPayload( const dest_payload_ty = dest_ty.errorUnionPayload(); const coerced = try sema.coerce(block, dest_payload_ty, inst, inst_src); if (try sema.resolveMaybeUndefVal(block, inst_src, coerced)) |val| { - if (val.isUndef()) return sema.addConstUndef(dest_ty); return sema.addConstant(dest_ty, try Value.Tag.eu_payload.create(sema.arena, val)); } try sema.requireRuntimeBlock(block, inst_src); diff --git a/src/type.zig b/src/type.zig index 4eb78b0656..581465c51a 100644 --- a/src/type.zig +++ b/src/type.zig @@ -3980,7 +3980,7 @@ pub const Type = extern union { pub fn structFields(ty: Type) Module.Struct.Fields { switch (ty.tag()) { - .empty_struct => return .{}, + .empty_struct, .empty_struct_literal => return .{}, .@"struct" => { const struct_obj = ty.castTag(.@"struct").?.data; assert(struct_obj.haveFieldTypes()); @@ -3996,7 +3996,7 @@ pub const Type = extern union { const struct_obj = ty.castTag(.@"struct").?.data; return struct_obj.fields.count(); }, - .empty_struct => return 0, + .empty_struct, .empty_struct_literal => return 0, .tuple => return ty.castTag(.tuple).?.data.types.len, else => unreachable, } diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index 0ddbf6458a..50d99897c8 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -371,7 +371,9 @@ fn testPeerResolveArrayConstSlice(b: bool) !void { } test "implicitly cast from T to anyerror!?T" { - if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; try castToOptionalTypeError(1); comptime try castToOptionalTypeError(1); @@ -387,7 +389,7 @@ fn castToOptionalTypeError(z: i32) !void { const f = z; const g: anyerror!?i32 = f; - _ = g catch {}; + _ = try g; const a = A{ .a = z }; const b: anyerror!?A = a; diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 028bd26047..82814dc587 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -294,10 +294,11 @@ fn quux_1() !i32 { } test "error: Zero sized error set returned with value payload crash" { - if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO + if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; - _ = foo3(0) catch {}; - _ = comptime foo3(0) catch {}; + _ = try foo3(0); + _ = comptime try foo3(0); } const Error = error{}; diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index a1d60632a9..1da2b0373d 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -1237,3 +1237,28 @@ test "anon init through error union" { try S.doTheTest(); comptime try S.doTheTest(); } + +test "typed init through error unions and optionals" { + if (builtin.zig_backend == .stage1) return error.SkipZigTest; + if (builtin.zig_backend != .stage2_llvm) return error.SkipZigTest; // TODO + + const S = struct { + a: u32, + + fn foo() anyerror!?anyerror!@This() { + return @This(){ .a = 1 }; + } + fn bar() ?anyerror![2]u8 { + return [2]u8{ 1, 2 }; + } + + fn doTheTest() !void { + var a = try (try foo()).?; + var b = try bar().?; + try expect(a.a + b[1] == 3); + } + }; + + try S.doTheTest(); + comptime try S.doTheTest(); +} From bff7714a7c681ec41abf45a6cfc74a32ff8655dd Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Fri, 25 Feb 2022 16:20:57 +0200 Subject: [PATCH 2/3] stage2: fix toAllocatedBytes on slices --- src/value.zig | 23 ++++++++++++++--------- test/behavior.zig | 6 +++--- test/behavior/bugs/5398.zig | 6 +++--- 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/src/value.zig b/src/value.zig index 4df36f79a1..7c28398b73 100644 --- a/src/value.zig +++ b/src/value.zig @@ -791,19 +791,24 @@ pub const Value = extern union { return decl_val.toAllocatedBytes(decl.ty, allocator); }, .the_only_possible_value => return &[_]u8{}, - .slice => return toAllocatedBytes(val.castTag(.slice).?.data.ptr, ty, allocator), - else => { - const result = try allocator.alloc(u8, @intCast(usize, ty.arrayLen())); - var elem_value_buf: ElemValueBuffer = undefined; - for (result) |*elem, i| { - const elem_val = val.elemValueBuffer(i, &elem_value_buf); - elem.* = @intCast(u8, elem_val.toUnsignedInt()); - } - return result; + .slice => { + const slice = val.castTag(.slice).?.data; + return arrayToAllocatedBytes(slice.ptr, slice.len.toUnsignedInt(), allocator); }, + else => return arrayToAllocatedBytes(val, ty.arrayLen(), allocator), } } + fn arrayToAllocatedBytes(val: Value, len: u64, allocator: Allocator) ![]u8 { + const result = try allocator.alloc(u8, @intCast(usize, len)); + var elem_value_buf: ElemValueBuffer = undefined; + for (result) |*elem, i| { + const elem_val = val.elemValueBuffer(i, &elem_value_buf); + elem.* = @intCast(u8, elem_val.toUnsignedInt()); + } + return result; + } + pub const ToTypeBuffer = Type.Payload.Bits; /// Asserts that the value is representable as a type. diff --git a/test/behavior.zig b/test/behavior.zig index 12d840b195..2e27563afc 100644 --- a/test/behavior.zig +++ b/test/behavior.zig @@ -127,8 +127,11 @@ test { _ = @import("behavior/bugs/726.zig"); _ = @import("behavior/bugs/1421.zig"); _ = @import("behavior/bugs/1442.zig"); + _ = @import("behavior/bugs/1607.zig"); _ = @import("behavior/bugs/2114.zig"); + _ = @import("behavior/bugs/3384.zig"); _ = @import("behavior/bugs/3742.zig"); + _ = @import("behavior/bugs/5398.zig"); _ = @import("behavior/struct_contains_null_ptr_itself.zig"); _ = @import("behavior/switch_prong_err_enum.zig"); _ = @import("behavior/switch_prong_implicit_cast.zig"); @@ -147,11 +150,8 @@ test { _ = @import("behavior/bugs/828.zig"); _ = @import("behavior/bugs/920.zig"); _ = @import("behavior/bugs/1120.zig"); - _ = @import("behavior/bugs/1607.zig"); _ = @import("behavior/bugs/1851.zig"); - _ = @import("behavior/bugs/3384.zig"); _ = @import("behavior/bugs/3779.zig"); - _ = @import("behavior/bugs/5398.zig"); _ = @import("behavior/bugs/5413.zig"); _ = @import("behavior/bugs/5487.zig"); _ = @import("behavior/bugs/6456.zig"); diff --git a/test/behavior/bugs/5398.zig b/test/behavior/bugs/5398.zig index 4921c05703..8dc170c736 100644 --- a/test/behavior/bugs/5398.zig +++ b/test/behavior/bugs/5398.zig @@ -25,7 +25,7 @@ test "assignment of field with padding" { .emits_shadows = false, }, }; - try testing.expectEqual(false, renderable.material.transparent); - try testing.expectEqual(false, renderable.material.emits_shadows); - try testing.expectEqual(true, renderable.material.render_color); + try testing.expect(false == renderable.material.transparent); + try testing.expect(false == renderable.material.emits_shadows); + try testing.expect(true == renderable.material.render_color); } From bf5c055562b88f1a686815c85d2a29c0889a97ee Mon Sep 17 00:00:00 2001 From: Veikka Tuominen Date: Sat, 26 Feb 2022 10:47:38 +0200 Subject: [PATCH 3/3] stage2: unify runtime and comptime coerce_result_ptr --- src/Sema.zig | 52 +++++++++++----------------------------------------- 1 file changed, 11 insertions(+), 41 deletions(-) diff --git a/src/Sema.zig b/src/Sema.zig index 4f08fb12d0..4588f487e2 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -1593,53 +1593,16 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE } } - // We would like to rely on the mechanism below even for comptime values. - // However in the case that the pointer points to comptime-mutable value, - // we cannot do it. - if (try sema.resolveDefinedValue(block, src, ptr)) |ptr_val| { - if (ptr_val.isComptimeMutablePtr()) { - const sentinel_val = try sema.addConstant(pointee_ty, Value.initTag(.unreachable_value)); - const coerced = try sema.coerce(block, sema.typeOf(ptr).childType(), sentinel_val, src); - - var res_ptr = ptr_val; - var cur_val = (try sema.resolveMaybeUndefVal(block, .unneeded, coerced)).?; - while (true) switch (cur_val.tag()) { - .unreachable_value => break, - .opt_payload => { - res_ptr = try Value.Tag.opt_payload_ptr.create(sema.arena, res_ptr); - cur_val = cur_val.castTag(.opt_payload).?.data; - }, - .eu_payload => { - res_ptr = try Value.Tag.eu_payload_ptr.create(sema.arena, res_ptr); - cur_val = cur_val.castTag(.eu_payload).?.data; - }, - else => { - if (std.debug.runtime_safety) { - std.debug.panic("unexpected Value tag for coerce_result_ptr: {s}", .{ - cur_val.tag(), - }); - } else { - unreachable; - } - }, - }; - - const ptr_ty = try Type.ptr(sema.arena, .{ - .pointee_type = pointee_ty, - .@"addrspace" = addr_space, - }); - return sema.addConstant(ptr_ty, res_ptr); - } - } - // Make a dummy store through the pointer to test the coercion. // We will then use the generated instructions to decide what // kind of transformations to make on the result pointer. var trash_block = block.makeSubBlock(); + trash_block.is_comptime = false; defer trash_block.instructions.deinit(sema.gpa); + const dummy_ptr = try trash_block.addTy(.alloc, sema.typeOf(ptr)); const dummy_operand = try trash_block.addBitCast(pointee_ty, .void_value); - try sema.storePtr(&trash_block, src, ptr, dummy_operand); + try sema.storePtr(&trash_block, src, dummy_ptr, dummy_operand); { const air_tags = sema.air_instructions.items(.tag); @@ -1670,6 +1633,9 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE switch (air_tags[trash_inst]) { .bitcast => { if (Air.indexToRef(trash_inst) == dummy_operand) { + if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| { + return sema.addConstant(ptr_ty, ptr_val); + } return sema.bitCast(block, ptr_ty, new_ptr, src); } const ty_op = air_datas[trash_inst].ty_op; @@ -1678,7 +1644,11 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE .pointee_type = operand_ty, .@"addrspace" = addr_space, }); - new_ptr = try sema.bitCast(block, ptr_operand_ty, new_ptr, src); + if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| { + new_ptr = try sema.addConstant(ptr_operand_ty, ptr_val); + } else { + new_ptr = try sema.bitCast(block, ptr_operand_ty, new_ptr, src); + } }, .wrap_optional => { new_ptr = try sema.analyzeOptionalPayloadPtr(block, src, new_ptr, false, true);