| ... | ... | @@ -926,6 +926,12 @@ const ComptimeReason = union(enum) { |
| 926 | 926 | comptime_src: LazySrcLoc, |
| 927 | 927 | }, |
| 928 | 928 | |
| 929 | /// Evaluating at comptime because we're coercing to a restricted type. |
| 930 | restricted_coercion: struct { |
| 931 | restricted_ty: Type, |
| 932 | unrestricted_ty: Type, |
| 933 | }, |
| 934 | |
| 929 | 935 | fn explain(reason: ComptimeReason, sema: *Sema, src: LazySrcLoc, err_msg: *Zcu.ErrorMsg) !void { |
| 930 | 936 | switch (reason) { |
| 931 | 937 | .simple => |simple| { |
| ... | ... | @@ -955,6 +961,12 @@ const ComptimeReason = union(enum) { |
| 955 | 961 | try sema.errNote(src, err_msg, "argument to comptime parameter must be comptime-known", .{}); |
| 956 | 962 | try sema.errNote(cp.comptime_src, err_msg, "parameter declared comptime here", .{}); |
| 957 | 963 | }, |
| 964 | .restricted_coercion => |rc| { |
| 965 | try sema.errNote(src, err_msg, "coercion to restricted type '{f}' from underlying type '{f}' must be comptime-known", .{ |
| 966 | rc.restricted_ty.fmt(sema.pt), rc.unrestricted_ty.fmt(sema.pt), |
| 967 | }); |
| 968 | try sema.addDeclaredHereNote(err_msg, rc.restricted_ty); |
| 969 | }, |
| 958 | 970 | } |
| 959 | 971 | } |
| 960 | 972 | }; |
| ... | ... | @@ -4156,7 +4168,7 @@ fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE |
| 4156 | 4168 | const extra = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data; |
| 4157 | 4169 | const uncoerced_val = sema.resolveInst(extra.rhs); |
| 4158 | 4170 | const maybe_wrapped_ptr_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, extra.lhs) orelse return uncoerced_val; |
| 4159 | | const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu); |
| 4171 | const ptr_ty = maybe_wrapped_ptr_ty.restrictedOptEuBaseType(zcu); |
| 4160 | 4172 | assert(ptr_ty.zigTypeTag(zcu) == .pointer); // validated by a previous instruction |
| 4161 | 4173 | const elem_ty = ptr_ty.childType(zcu); |
| 4162 | 4174 | switch (ptr_ty.ptrSize(zcu)) { |
| ... | ... | @@ -4255,7 +4267,7 @@ fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr |
| 4255 | 4267 | // In case of GenericPoison, we don't actually have a type, so this will be |
| 4256 | 4268 | // treated as an untyped address-of operator. |
| 4257 | 4269 | const ty_operand = try sema.resolveTypeOrPoison(block, src, un_tok.operand) orelse return; |
| 4258 | | if (ty_operand.optEuBaseType(zcu).zigTypeTag(zcu) != .pointer) { |
| 4270 | if (ty_operand.restrictedOptEuBaseType(zcu).zigTypeTag(zcu) != .pointer) { |
| 4259 | 4271 | return sema.failWithOwnedErrorMsg(block, msg: { |
| 4260 | 4272 | const msg = try sema.errMsg(src, "expected type '{f}', found pointer", .{ty_operand.fmt(pt)}); |
| 4261 | 4273 | errdefer msg.destroy(sema.gpa); |
| ... | ... | @@ -4287,7 +4299,7 @@ fn zirValidateArrayInitRefTy( |
| 4287 | 4299 | const src = block.nodeOffset(pl_node.src_node); |
| 4288 | 4300 | const extra = sema.code.extraData(Zir.Inst.ArrayInitRefTy, pl_node.payload_index).data; |
| 4289 | 4301 | const maybe_wrapped_ptr_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, extra.ptr_ty) orelse return .generic_poison_type; |
| 4290 | | const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu); |
| 4302 | const ptr_ty = maybe_wrapped_ptr_ty.restrictedOptEuBaseType(zcu); |
| 4291 | 4303 | assert(ptr_ty.zigTypeTag(zcu) == .pointer); // validated by a previous instruction |
| 4292 | 4304 | switch (zcu.intern_pool.indexToKey(ptr_ty.toIntern())) { |
| 4293 | 4305 | .ptr_type => |ptr_type| switch (ptr_type.flags.size) { |
| ... | ... | @@ -4310,7 +4322,7 @@ fn zirValidateArrayInitRefTy( |
| 4310 | 4322 | // The actual array type is unknown, which we represent with a generic poison. |
| 4311 | 4323 | return .generic_poison_type; |
| 4312 | 4324 | } |
| 4313 | | const arr_ty = ret_ty.optEuBaseType(zcu); |
| 4325 | const arr_ty = ret_ty.restrictedOptEuBaseType(zcu); |
| 4314 | 4326 | try sema.validateArrayInitTy(block, src, src, extra.elem_count, arr_ty); |
| 4315 | 4327 | return Air.internedToRef(ret_ty.toIntern()); |
| 4316 | 4328 | } |
| ... | ... | @@ -4329,7 +4341,7 @@ fn zirValidateArrayInitTy( |
| 4329 | 4341 | const extra = sema.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data; |
| 4330 | 4342 | // It's okay for the type to be poison: this will result in an anonymous array init. |
| 4331 | 4343 | const ty = try sema.resolveTypeOrPoison(block, ty_src, extra.ty) orelse return; |
| 4332 | | const arr_ty = if (is_result_ty) ty.optEuBaseType(zcu) else ty; |
| 4344 | const arr_ty = if (is_result_ty) ty.restrictedOptEuBaseType(zcu) else ty; |
| 4333 | 4345 | return sema.validateArrayInitTy(block, src, ty_src, extra.init_count, arr_ty); |
| 4334 | 4346 | } |
| 4335 | 4347 | |
| ... | ... | @@ -4388,7 +4400,7 @@ fn zirValidateStructInitTy( |
| 4388 | 4400 | const src = block.nodeOffset(inst_data.src_node); |
| 4389 | 4401 | // It's okay for the type to be poison: this will result in an anonymous struct init. |
| 4390 | 4402 | const ty = try sema.resolveTypeOrPoison(block, src, inst_data.operand) orelse return; |
| 4391 | | const struct_ty = if (is_result_ty) ty.optEuBaseType(zcu) else ty; |
| 4403 | const struct_ty = if (is_result_ty) ty.restrictedOptEuBaseType(zcu) else ty; |
| 4392 | 4404 | |
| 4393 | 4405 | switch (struct_ty.zigTypeTag(zcu)) { |
| 4394 | 4406 | .@"struct", .@"union" => return, |
| ... | ... | @@ -4414,7 +4426,7 @@ fn zirValidatePtrStructInit( |
| 4414 | 4426 | const field_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node; |
| 4415 | 4427 | const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data; |
| 4416 | 4428 | const object_ptr = sema.resolveInst(field_ptr_extra.lhs); |
| 4417 | | const agg_ty = sema.typeOf(object_ptr).childType(zcu).optEuBaseType(zcu); |
| 4429 | const agg_ty = sema.typeOf(object_ptr).childType(zcu).restrictedOptEuBaseType(zcu); |
| 4418 | 4430 | switch (agg_ty.zigTypeTag(zcu)) { |
| 4419 | 4431 | .@"struct" => return sema.validateStructInit( |
| 4420 | 4432 | block, |
| ... | ... | @@ -4580,7 +4592,7 @@ fn zirValidatePtrArrayInit( |
| 4580 | 4592 | const first_elem_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node; |
| 4581 | 4593 | const elem_ptr_extra = sema.code.extraData(Zir.Inst.ElemPtrImm, first_elem_ptr_data.payload_index).data; |
| 4582 | 4594 | const array_ptr = sema.resolveInst(elem_ptr_extra.ptr); |
| 4583 | | const array_ty = sema.typeOf(array_ptr).childType(zcu).optEuBaseType(zcu); |
| 4595 | const array_ty = sema.typeOf(array_ptr).childType(zcu).restrictedOptEuBaseType(zcu); |
| 4584 | 4596 | const array_len = array_ty.arrayLen(zcu); |
| 4585 | 4597 | |
| 4586 | 4598 | // Analagously to `validateStructInit`, our job is to handle default fields; either emitting AIR |
| ... | ... | @@ -4705,21 +4717,14 @@ fn failWithBadMemberAccess( |
| 4705 | 4717 | const pt = sema.pt; |
| 4706 | 4718 | const zcu = pt.zcu; |
| 4707 | 4719 | const ip = &zcu.intern_pool; |
| 4708 | | const kw_name = switch (agg_ty.zigTypeTag(zcu)) { |
| 4709 | | .@"union" => "union", |
| 4710 | | .@"struct" => "struct", |
| 4711 | | .@"opaque" => "opaque", |
| 4712 | | .@"enum" => "enum", |
| 4713 | | else => unreachable, |
| 4714 | | }; |
| 4715 | 4720 | if (agg_ty.typeDeclInst(zcu)) |inst| if ((inst.resolve(ip) orelse return error.AnalysisFail) == .main_struct_inst) { |
| 4716 | 4721 | return sema.fail(block, field_src, "root source file struct '{f}' has no member named '{f}'", .{ |
| 4717 | 4722 | agg_ty.fmt(pt), field_name.fmt(ip), |
| 4718 | 4723 | }); |
| 4719 | 4724 | }; |
| 4720 | 4725 | |
| 4721 | | return sema.fail(block, field_src, "{s} '{f}' has no member named '{f}'", .{ |
| 4722 | | kw_name, agg_ty.fmt(pt), field_name.fmt(ip), |
| 4726 | return sema.fail(block, field_src, "{t} '{f}' has no member named '{f}'", .{ |
| 4727 | agg_ty.zigTypeTag(zcu), agg_ty.fmt(pt), field_name.fmt(ip), |
| 4723 | 4728 | }); |
| 4724 | 4729 | } |
| 4725 | 4730 | |
| ... | ... | @@ -4777,13 +4782,7 @@ fn failWithBadUnionFieldAccess( |
| 4777 | 4782 | pub fn addDeclaredHereNote(sema: *Sema, parent: *Zcu.ErrorMsg, decl_ty: Type) !void { |
| 4778 | 4783 | const zcu = sema.pt.zcu; |
| 4779 | 4784 | const src_loc = decl_ty.srcLocOrNull(zcu) orelse return; |
| 4780 | | const category = switch (decl_ty.zigTypeTag(zcu)) { |
| 4781 | | .@"union" => "union", |
| 4782 | | .@"struct" => "struct", |
| 4783 | | .@"enum" => "enum", |
| 4784 | | .@"opaque" => "opaque", |
| 4785 | | else => unreachable, |
| 4786 | | }; |
| 4785 | const category = if (zcu.intern_pool.isRestrictedType(decl_ty.toIntern())) "restricted type" else @tagName(decl_ty.zigTypeTag(zcu)); |
| 4787 | 4786 | try sema.errNote(src_loc, parent, "{s} declared here", .{category}); |
| 4788 | 4787 | } |
| 4789 | 4788 | |
| ... | ... | @@ -7420,7 +7419,7 @@ fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil |
| 7420 | 7419 | const zcu = pt.zcu; |
| 7421 | 7420 | const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin; |
| 7422 | 7421 | const maybe_wrapped_indexable_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, bin.lhs) orelse return .generic_poison_type; |
| 7423 | | const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(zcu); |
| 7422 | const indexable_ty = maybe_wrapped_indexable_ty.restrictedOptEuBaseType(zcu); |
| 7424 | 7423 | assert(indexable_ty.isIndexable(zcu)); // validated by a previous instruction |
| 7425 | 7424 | const elem_ty = switch (indexable_ty.zigTypeTag(zcu)) { |
| 7426 | 7425 | .@"struct" => indexable_ty.fieldType(@intFromEnum(bin.rhs), zcu), |
| ... | ... | @@ -7434,7 +7433,7 @@ fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai |
| 7434 | 7433 | const zcu = pt.zcu; |
| 7435 | 7434 | const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; |
| 7436 | 7435 | const maybe_wrapped_ptr_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, un_node.operand) orelse return .generic_poison_type; |
| 7437 | | const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu); |
| 7436 | const ptr_ty = maybe_wrapped_ptr_ty.restrictedOptEuBaseType(zcu); |
| 7438 | 7437 | assert(ptr_ty.zigTypeTag(zcu) == .pointer); // validated by a previous instruction |
| 7439 | 7438 | const elem_ty = ptr_ty.childType(zcu); |
| 7440 | 7439 | if (elem_ty.toIntern() == .anyopaque_type) { |
| ... | ... | @@ -7465,7 +7464,7 @@ fn zirSplatOpResultType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil |
| 7465 | 7464 | const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; |
| 7466 | 7465 | |
| 7467 | 7466 | const raw_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, un_node.operand) orelse return .generic_poison_type; |
| 7468 | | const vec_ty = raw_ty.optEuBaseType(zcu); |
| 7467 | const vec_ty = raw_ty.restrictedOptEuBaseType(zcu); |
| 7469 | 7468 | |
| 7470 | 7469 | switch (vec_ty.zigTypeTag(zcu)) { |
| 7471 | 7470 | .array, .vector => {}, |
| ... | ... | @@ -9451,13 +9450,8 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air |
| 9451 | 9450 | return sema.failWithOwnedErrorMsg(block, msg); |
| 9452 | 9451 | }, |
| 9453 | 9452 | .@"struct", .@"union" => if (dest_ty.containerLayout(zcu) == .auto) { |
| 9454 | | const container = switch (dest_ty.zigTypeTag(zcu)) { |
| 9455 | | .@"struct" => "struct", |
| 9456 | | .@"union" => "union", |
| 9457 | | else => unreachable, |
| 9458 | | }; |
| 9459 | | return sema.fail(block, src, "cannot @bitCast to '{f}'; {s} does not have a guaranteed in-memory layout", .{ |
| 9460 | | dest_ty.fmt(pt), container, |
| 9453 | return sema.fail(block, src, "cannot @bitCast to '{f}'; {t} does not have a guaranteed in-memory layout", .{ |
| 9454 | dest_ty.fmt(pt), dest_ty.zigTypeTag(zcu), |
| 9461 | 9455 | }); |
| 9462 | 9456 | }, |
| 9463 | 9457 | .array => { |
| ... | ... | @@ -9525,13 +9519,8 @@ fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air |
| 9525 | 9519 | return sema.failWithOwnedErrorMsg(block, msg); |
| 9526 | 9520 | }, |
| 9527 | 9521 | .@"struct", .@"union" => if (operand_ty.containerLayout(zcu) == .auto) { |
| 9528 | | const container = switch (operand_ty.zigTypeTag(zcu)) { |
| 9529 | | .@"struct" => "struct", |
| 9530 | | .@"union" => "union", |
| 9531 | | else => unreachable, |
| 9532 | | }; |
| 9533 | | return sema.fail(block, operand_src, "cannot @bitCast from '{f}'; {s} does not have a guaranteed in-memory layout", .{ |
| 9534 | | operand_ty.fmt(pt), container, |
| 9522 | return sema.fail(block, operand_src, "cannot @bitCast from '{f}'; {t} does not have a guaranteed in-memory layout", .{ |
| 9523 | operand_ty.fmt(pt), operand_ty.zigTypeTag(zcu), |
| 9535 | 9524 | }); |
| 9536 | 9525 | }, |
| 9537 | 9526 | .array => { |
| ... | ... | @@ -17857,7 +17846,7 @@ fn zirRetImplicit( |
| 17857 | 17846 | |
| 17858 | 17847 | const operand = sema.resolveInst(inst_data.operand); |
| 17859 | 17848 | const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = .zero }); |
| 17860 | | const base_tag = sema.fn_ret_ty.optEuBaseType(zcu).zigTypeTag(zcu); |
| 17849 | const base_tag = sema.fn_ret_ty.restrictedOptEuBaseType(zcu).zigTypeTag(zcu); |
| 17861 | 17850 | if (base_tag == .noreturn) { |
| 17862 | 17851 | const msg = msg: { |
| 17863 | 17852 | const msg = try sema.errMsg(ret_ty_src, "function declared '{f}' implicitly returns", .{ |
| ... | ... | @@ -18372,7 +18361,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is |
| 18372 | 18361 | }; |
| 18373 | 18362 | |
| 18374 | 18363 | const init_ty = if (is_byref) ty: { |
| 18375 | | const ptr_ty = ty_operand.optEuBaseType(zcu); |
| 18364 | const ptr_ty = ty_operand.restrictedOptEuBaseType(zcu); |
| 18376 | 18365 | assert(ptr_ty.zigTypeTag(zcu) == .pointer); // validated by a previous instruction |
| 18377 | 18366 | switch (ptr_ty.ptrSize(zcu)) { |
| 18378 | 18367 | // Use a zero-length array for a slice or many-ptr result |
| ... | ... | @@ -18409,7 +18398,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is |
| 18409 | 18398 | |
| 18410 | 18399 | try sema.ensureLayoutResolved(init_ty, src, .init); |
| 18411 | 18400 | |
| 18412 | | const obj_ty = init_ty.optEuBaseType(zcu); |
| 18401 | const obj_ty = init_ty.restrictedOptEuBaseType(zcu); |
| 18413 | 18402 | |
| 18414 | 18403 | const empty_ref = switch (obj_ty.zigTypeTag(zcu)) { |
| 18415 | 18404 | .@"struct" => try sema.structInitEmpty(block, obj_ty, src, src), |
| ... | ... | @@ -18527,7 +18516,7 @@ fn zirStructInit( |
| 18527 | 18516 | return sema.structInitAnon(block, src, inst, .typed_init, extra.data, extra.end, is_ref); |
| 18528 | 18517 | }; |
| 18529 | 18518 | try sema.ensureLayoutResolved(result_ty, src, .init); |
| 18530 | | const resolved_ty = result_ty.optEuBaseType(zcu); |
| 18519 | const resolved_ty = result_ty.restrictedOptEuBaseType(zcu); |
| 18531 | 18520 | |
| 18532 | 18521 | if (resolved_ty.zigTypeTag(zcu) == .@"struct") { |
| 18533 | 18522 | // This logic must be synchronized with that in `zirStructInitEmpty`. |
| ... | ... | @@ -19065,7 +19054,7 @@ fn zirArrayInit( |
| 19065 | 19054 | // The type wasn't actually known, so treat this as an anon array init. |
| 19066 | 19055 | return sema.arrayInitAnon(block, src, args[1..], is_ref); |
| 19067 | 19056 | }; |
| 19068 | | const array_ty = result_ty.optEuBaseType(zcu); |
| 19057 | const array_ty = result_ty.restrictedOptEuBaseType(zcu); |
| 19069 | 19058 | const is_tuple = array_ty.zigTypeTag(zcu) == .@"struct"; |
| 19070 | 19059 | const sentinel_val = array_ty.sentinel(zcu); |
| 19071 | 19060 | |
| ... | ... | @@ -19330,7 +19319,7 @@ fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp |
| 19330 | 19319 | const ty_src = block.nodeOffset(inst_data.src_node); |
| 19331 | 19320 | const field_name_src = block.src(.{ .node_offset_field_name_init = inst_data.src_node }); |
| 19332 | 19321 | const wrapped_aggregate_ty = try sema.resolveTypeOrPoison(block, ty_src, extra.container_type) orelse return .generic_poison_type; |
| 19333 | | const aggregate_ty = wrapped_aggregate_ty.optEuBaseType(zcu); |
| 19322 | const aggregate_ty = wrapped_aggregate_ty.restrictedOptEuBaseType(zcu); |
| 19334 | 19323 | const zir_field_name = sema.code.nullTerminatedString(extra.name_start); |
| 19335 | 19324 | const field_name = try ip.getOrPutString(gpa, io, pt.tid, zir_field_name, .no_embedded_nulls); |
| 19336 | 19325 | try sema.ensureLayoutResolved(aggregate_ty, ty_src, .init); |
| ... | ... | @@ -20871,7 +20860,7 @@ fn zirRoundCast( |
| 20871 | 20860 | .truncate => return sema.unaryMath(block, operand_src, operand, .trunc_float, Value.trunc), |
| 20872 | 20861 | // zig fmt: on |
| 20873 | 20862 | .exact => unreachable, |
| 20874 | | }).optEuBaseType(zcu); |
| 20863 | }).restrictedOptEuBaseType(zcu); |
| 20875 | 20864 | |
| 20876 | 20865 | const operand_ty = sema.typeOf(operand); |
| 20877 | 20866 | |
| ... | ... | @@ -25081,7 +25070,7 @@ fn zirFloatOpResultType(sema: *Sema, block: *Block, extended: Zir.Inst.Extended. |
| 25081 | 25070 | const operand_src = block.builtinCallArgSrc(extra.node, 0); |
| 25082 | 25071 | |
| 25083 | 25072 | const raw_ty = try sema.resolveTypeOrPoison(block, operand_src, extra.operand) orelse return .generic_poison_type; |
| 25084 | | const float_ty = raw_ty.optEuBaseType(zcu); |
| 25073 | const float_ty = raw_ty.restrictedOptEuBaseType(zcu); |
| 25085 | 25074 | |
| 25086 | 25075 | switch (float_ty.scalarType(zcu).zigTypeTag(zcu)) { |
| 25087 | 25076 | .float, .comptime_float => {}, |
| ... | ... | @@ -25106,7 +25095,7 @@ fn zirRoundOpType(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDa |
| 25106 | 25095 | return .generic_poison_type; |
| 25107 | 25096 | }; |
| 25108 | 25097 | |
| 25109 | | const float_ty = dest_ty.optEuBaseType(zcu); |
| 25098 | const float_ty = dest_ty.restrictedOptEuBaseType(zcu); |
| 25110 | 25099 | switch (float_ty.scalarType(zcu).zigTypeTag(zcu)) { |
| 25111 | 25100 | .float, .comptime_float => return .fromType(float_ty), |
| 25112 | 25101 | else => return .comptime_float_type, |
| ... | ... | @@ -27479,21 +27468,21 @@ fn coerceExtra( |
| 27479 | 27468 | if (dest_ty.eql(inst_ty, zcu)) |
| 27480 | 27469 | return inst; |
| 27481 | 27470 | |
| 27482 | | const maybe_inst_val = sema.resolveValue(inst); |
| 27483 | | |
| 27484 | 27471 | // Restricted coercions |
| 27485 | | if (maybe_inst_val != null) { |
| 27486 | | if (dest_ty.unrestrictedType(zcu)) |dest_unrestricted_ty| { |
| 27487 | | if (sema.resolveValue(try sema.coerceExtra(block, dest_unrestricted_ty, inst, inst_src, opts))) |dest_unrestricted_val| { |
| 27488 | | return .fromIntern(try pt.intern(if (dest_unrestricted_val.isUndef(zcu)) .{ |
| 27489 | | .undef = dest_ty.toIntern(), |
| 27490 | | } else .{ .restricted_value = .{ |
| 27491 | | .ty = dest_ty.toIntern(), |
| 27492 | | .unrestricted_value = dest_unrestricted_val.toIntern(), |
| 27493 | | } })); |
| 27494 | | } |
| 27495 | | } |
| 27472 | if (dest_ty.unrestrictedType(zcu)) |dest_unrestricted_ty| { |
| 27473 | const dest_unrestricted = try sema.coerceExtra(block, dest_unrestricted_ty, inst, inst_src, opts); |
| 27474 | const dest_unrestricted_val = try sema.resolveConstValue(block, inst_src, dest_unrestricted, .{ .restricted_coercion = .{ |
| 27475 | .restricted_ty = dest_ty, |
| 27476 | .unrestricted_ty = dest_unrestricted_ty, |
| 27477 | } }); |
| 27478 | return .fromIntern(try pt.intern(if (dest_unrestricted_val.isUndef(zcu)) .{ |
| 27479 | .undef = dest_ty.toIntern(), |
| 27480 | } else .{ .restricted_value = .{ |
| 27481 | .ty = dest_ty.toIntern(), |
| 27482 | .unrestricted_value = dest_unrestricted_val.toIntern(), |
| 27483 | } })); |
| 27496 | 27484 | } |
| 27485 | const maybe_inst_val = sema.resolveValue(inst); |
| 27497 | 27486 | if (inst_ty.unrestrictedType(zcu)) |inst_unrestricted_ty| { |
| 27498 | 27487 | const unrestricted_inst: Air.Inst.Ref = if (maybe_inst_val) |inst_val| |
| 27499 | 27488 | .fromIntern(ip.indexToKey(inst_val.toIntern()).restricted_value.unrestricted_value) |
| ... | ... | @@ -28268,7 +28257,7 @@ const InMemoryCoercionResult = union(enum) { |
| 28268 | 28257 | for ([_]Type{ pair.actual, pair.wanted }) |restricted_type| { |
| 28269 | 28258 | try sema.addDeclaredHereNote(msg, restricted_type); |
| 28270 | 28259 | const unrestricted_type = restricted_type.unrestrictedType(pt.zcu) orelse continue; |
| 28271 | | try sema.errNote(src, msg, "restricted type '{f}' is not guaranteed to have the same representation as its unrestricted type '{f}'", .{ |
| 28260 | try sema.errNote(src, msg, "restricted type '{f}' has a different representation than unrestricted type '{f}'", .{ |
| 28272 | 28261 | restricted_type.fmt(pt), unrestricted_type.fmt(pt), |
| 28273 | 28262 | }); |
| 28274 | 28263 | } |
Jacob Young <jacobly@ziglang.org> 2026-04-21 06:39:50-04:00