| ... | ... | @@ -6938,12 +6938,19 @@ fn zirSwitchCapture( |
| 6938 | 6938 | const switch_info = zir_datas[capture_info.switch_inst].pl_node; |
| 6939 | 6939 | const switch_extra = sema.code.extraData(Zir.Inst.SwitchBlock, switch_info.payload_index); |
| 6940 | 6940 | const operand_src: LazySrcLoc = .{ .node_offset_switch_operand = switch_info.src_node }; |
| 6941 | const switch_src = switch_info.src(); |
| 6941 | 6942 | const operand_is_ref = switch_extra.data.bits.is_ref; |
| 6942 | 6943 | const cond_inst = Zir.refToIndex(switch_extra.data.operand).?; |
| 6943 | 6944 | const cond_info = sema.code.instructions.items(.data)[cond_inst].un_node; |
| 6944 | 6945 | const operand_ptr = sema.resolveInst(cond_info.operand); |
| 6945 | 6946 | const operand_ptr_ty = sema.typeOf(operand_ptr); |
| 6946 | 6947 | const operand_ty = if (operand_is_ref) operand_ptr_ty.childType() else operand_ptr_ty; |
| 6948 | const target = sema.mod.getTarget(); |
| 6949 | |
| 6950 | const operand = if (operand_is_ref) |
| 6951 | try sema.analyzeLoad(block, operand_src, operand_ptr, operand_src) |
| 6952 | else |
| 6953 | operand_ptr; |
| 6947 | 6954 | |
| 6948 | 6955 | if (capture_info.prong_index == std.math.maxInt(@TypeOf(capture_info.prong_index))) { |
| 6949 | 6956 | // It is the else/`_` prong. |
| ... | ... | @@ -6952,64 +6959,57 @@ fn zirSwitchCapture( |
| 6952 | 6959 | return operand_ptr; |
| 6953 | 6960 | } |
| 6954 | 6961 | |
| 6955 | | const operand = if (operand_is_ref) |
| 6956 | | try sema.analyzeLoad(block, operand_src, operand_ptr, operand_src) |
| 6957 | | else |
| 6958 | | operand_ptr; |
| 6959 | | |
| 6960 | 6962 | switch (operand_ty.zigTypeTag()) { |
| 6961 | 6963 | .ErrorSet => return sema.bitCast(block, block.switch_else_err_ty.?, operand, operand_src), |
| 6962 | 6964 | else => return operand, |
| 6963 | 6965 | } |
| 6964 | 6966 | } |
| 6965 | 6967 | |
| 6966 | | if (is_multi) { |
| 6967 | | const items = switch_extra.data.getMultiProng(sema.code, switch_extra.end, capture_info.prong_index).items; |
| 6968 | | |
| 6969 | | var names: Module.ErrorSet.NameMap = .{}; |
| 6970 | | try names.ensureUnusedCapacity(sema.arena, items.len); |
| 6971 | | for (items) |item| { |
| 6972 | | const item_ref = sema.resolveInst(item); |
| 6973 | | // Previous switch validation ensured this will succeed |
| 6974 | | const item_val = sema.resolveConstValue(block, .unneeded, item_ref) catch unreachable; |
| 6975 | | names.putAssumeCapacityNoClobber( |
| 6976 | | item_val.getError().?, |
| 6977 | | {}, |
| 6978 | | ); |
| 6979 | | } |
| 6980 | | |
| 6981 | | // names must be sorted |
| 6982 | | Module.ErrorSet.sortNames(&names); |
| 6983 | | const else_error_ty = try Type.Tag.error_set_merged.create(sema.arena, names); |
| 6984 | | |
| 6985 | | const operand = if (operand_is_ref) |
| 6986 | | try sema.analyzeLoad(block, operand_src, operand_ptr, operand_src) |
| 6987 | | else |
| 6988 | | operand_ptr; |
| 6989 | | return sema.bitCast(block, else_error_ty, operand, operand_src); |
| 6990 | | } |
| 6991 | | const scalar_prong = switch_extra.data.getScalarProng(sema.code, switch_extra.end, capture_info.prong_index); |
| 6992 | | const item = sema.resolveInst(scalar_prong.item); |
| 6993 | | // Previous switch validation ensured this will succeed |
| 6994 | | const item_val = sema.resolveConstValue(block, .unneeded, item) catch unreachable; |
| 6995 | | const target = sema.mod.getTarget(); |
| 6968 | const items = if (is_multi) |
| 6969 | switch_extra.data.getMultiProng(sema.code, switch_extra.end, capture_info.prong_index).items |
| 6970 | else |
| 6971 | &[_]Zir.Inst.Ref{ |
| 6972 | switch_extra.data.getScalarProng(sema.code, switch_extra.end, capture_info.prong_index).item, |
| 6973 | }; |
| 6996 | 6974 | |
| 6997 | 6975 | switch (operand_ty.zigTypeTag()) { |
| 6998 | 6976 | .Union => { |
| 6999 | 6977 | const union_obj = operand_ty.cast(Type.Payload.Union).?.data; |
| 7000 | 6978 | const enum_ty = union_obj.tag_ty; |
| 7001 | 6979 | |
| 7002 | | const field_index_usize = enum_ty.enumTagFieldIndex(item_val, target).?; |
| 7003 | | const field_index = @intCast(u32, field_index_usize); |
| 7004 | | const field = union_obj.fields.values()[field_index]; |
| 6980 | const first_item = sema.resolveInst(items[0]); |
| 6981 | // Previous switch validation ensured this will succeed |
| 6982 | const first_item_val = sema.resolveConstValue(block, .unneeded, first_item) catch unreachable; |
| 7005 | 6983 | |
| 7006 | | // TODO handle multiple union tags which have compatible types |
| 6984 | const first_field_index = @intCast(u32, enum_ty.enumTagFieldIndex(first_item_val, target).?); |
| 6985 | const first_field = union_obj.fields.values()[first_field_index]; |
| 6986 | |
| 6987 | for (items[1..]) |item| { |
| 6988 | const item_ref = sema.resolveInst(item); |
| 6989 | // Previous switch validation ensured this will succeed |
| 6990 | const item_val = sema.resolveConstValue(block, .unneeded, item_ref) catch unreachable; |
| 6991 | |
| 6992 | const field_index = enum_ty.enumTagFieldIndex(item_val, target).?; |
| 6993 | const field = union_obj.fields.values()[field_index]; |
| 6994 | if (!field.ty.eql(first_field.ty, target)) { |
| 6995 | const first_item_src = switch_src; // TODO better source location |
| 6996 | const item_src = switch_src; |
| 6997 | const msg = msg: { |
| 6998 | const msg = try sema.errMsg(block, switch_src, "capture group with incompatible types", .{}); |
| 6999 | errdefer msg.destroy(sema.gpa); |
| 7000 | try sema.errNote(block, first_item_src, msg, "type '{}' here", .{first_field.ty.fmt(target)}); |
| 7001 | try sema.errNote(block, item_src, msg, "type '{}' here", .{field.ty.fmt(target)}); |
| 7002 | break :msg msg; |
| 7003 | }; |
| 7004 | return sema.failWithOwnedErrorMsg(block, msg); |
| 7005 | } |
| 7006 | } |
| 7007 | 7007 | |
| 7008 | 7008 | if (is_ref) { |
| 7009 | 7009 | assert(operand_is_ref); |
| 7010 | 7010 | |
| 7011 | 7011 | const field_ty_ptr = try Type.ptr(sema.arena, target, .{ |
| 7012 | | .pointee_type = field.ty, |
| 7012 | .pointee_type = first_field.ty, |
| 7013 | 7013 | .@"addrspace" = .generic, |
| 7014 | 7014 | .mutable = operand_ptr_ty.ptrIsMutable(), |
| 7015 | 7015 | }); |
| ... | ... | @@ -7020,35 +7020,48 @@ fn zirSwitchCapture( |
| 7020 | 7020 | try Value.Tag.field_ptr.create(sema.arena, .{ |
| 7021 | 7021 | .container_ptr = op_ptr_val, |
| 7022 | 7022 | .container_ty = operand_ty, |
| 7023 | | .field_index = field_index, |
| 7023 | .field_index = first_field_index, |
| 7024 | 7024 | }), |
| 7025 | 7025 | ); |
| 7026 | 7026 | } |
| 7027 | 7027 | try sema.requireRuntimeBlock(block, operand_src); |
| 7028 | | return block.addStructFieldPtr(operand_ptr, field_index, field_ty_ptr); |
| 7028 | return block.addStructFieldPtr(operand_ptr, first_field_index, field_ty_ptr); |
| 7029 | 7029 | } |
| 7030 | 7030 | |
| 7031 | | const operand = if (operand_is_ref) |
| 7032 | | try sema.analyzeLoad(block, operand_src, operand_ptr, operand_src) |
| 7033 | | else |
| 7034 | | operand_ptr; |
| 7035 | | |
| 7036 | 7031 | if (try sema.resolveDefinedValue(block, operand_src, operand)) |operand_val| { |
| 7037 | 7032 | return sema.addConstant( |
| 7038 | | field.ty, |
| 7033 | first_field.ty, |
| 7039 | 7034 | operand_val.castTag(.@"union").?.data.val, |
| 7040 | 7035 | ); |
| 7041 | 7036 | } |
| 7042 | 7037 | try sema.requireRuntimeBlock(block, operand_src); |
| 7043 | | return block.addStructFieldVal(operand, field_index, field.ty); |
| 7038 | return block.addStructFieldVal(operand, first_field_index, first_field.ty); |
| 7044 | 7039 | }, |
| 7045 | 7040 | .ErrorSet => { |
| 7046 | | const item_ty = try Type.Tag.error_set_single.create(sema.arena, item_val.getError().?); |
| 7047 | | const operand = if (operand_is_ref) |
| 7048 | | try sema.analyzeLoad(block, operand_src, operand_ptr, operand_src) |
| 7049 | | else |
| 7050 | | operand_ptr; |
| 7051 | | return sema.bitCast(block, item_ty, operand, operand_src); |
| 7041 | if (is_multi) { |
| 7042 | var names: Module.ErrorSet.NameMap = .{}; |
| 7043 | try names.ensureUnusedCapacity(sema.arena, items.len); |
| 7044 | for (items) |item| { |
| 7045 | const item_ref = sema.resolveInst(item); |
| 7046 | // Previous switch validation ensured this will succeed |
| 7047 | const item_val = sema.resolveConstValue(block, .unneeded, item_ref) catch unreachable; |
| 7048 | names.putAssumeCapacityNoClobber( |
| 7049 | item_val.getError().?, |
| 7050 | {}, |
| 7051 | ); |
| 7052 | } |
| 7053 | // names must be sorted |
| 7054 | Module.ErrorSet.sortNames(&names); |
| 7055 | const else_error_ty = try Type.Tag.error_set_merged.create(sema.arena, names); |
| 7056 | |
| 7057 | return sema.bitCast(block, else_error_ty, operand, operand_src); |
| 7058 | } else { |
| 7059 | // Previous switch validation ensured this will succeed |
| 7060 | const item_val = sema.resolveConstValue(block, .unneeded, items[0]) catch unreachable; |
| 7061 | |
| 7062 | const item_ty = try Type.Tag.error_set_single.create(sema.arena, item_val.getError().?); |
| 7063 | return sema.bitCast(block, item_ty, operand, operand_src); |
| 7064 | } |
| 7052 | 7065 | }, |
| 7053 | 7066 | else => { |
| 7054 | 7067 | return sema.fail(block, operand_src, "switch on type '{}' provides no capture value", .{ |
Veikka Tuominen <git@vexu.eu> 2022-03-25 13:48:11+02:00