| ... | ... | @@ -509,7 +509,7 @@ pub const Block = struct { |
| 509 | 509 | .parent = parent, |
| 510 | 510 | .sema = parent.sema, |
| 511 | 511 | .namespace = parent.namespace, |
| 512 | | .instructions = .{}, |
| 512 | .instructions = .empty, |
| 513 | 513 | .label = null, |
| 514 | 514 | .inlining = parent.inlining, |
| 515 | 515 | .comptime_reason = parent.comptime_reason, |
| ... | ... | @@ -1927,9 +1927,8 @@ fn analyzeBodyInner( |
| 1927 | 1927 | break :msg msg; |
| 1928 | 1928 | }); |
| 1929 | 1929 | } |
| 1930 | | const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union); |
| 1931 | | assert(is_non_err != .none); |
| 1932 | | const is_non_err_val = try sema.resolveConstDefinedValue(block, operand_src, is_non_err, null); |
| 1930 | const is_non_err_val = (try sema.resolveIsNonErrVal(block, operand_src, err_union)).?; |
| 1931 | if (is_non_err_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, operand_src, null); |
| 1933 | 1932 | if (is_non_err_val.toBool()) { |
| 1934 | 1933 | break :blk try sema.analyzeErrUnionPayload(block, src, err_union_ty, err_union, operand_src, false); |
| 1935 | 1934 | } |
| ... | ... | @@ -1945,9 +1944,8 @@ fn analyzeBodyInner( |
| 1945 | 1944 | const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len); |
| 1946 | 1945 | const operand = try sema.resolveInst(extra.data.operand); |
| 1947 | 1946 | const err_union = try sema.analyzeLoad(block, src, operand, operand_src); |
| 1948 | | const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union); |
| 1949 | | assert(is_non_err != .none); |
| 1950 | | const is_non_err_val = try sema.resolveConstDefinedValue(block, operand_src, is_non_err, null); |
| 1947 | const is_non_err_val = (try sema.resolveIsNonErrVal(block, operand_src, err_union)).?; |
| 1948 | if (is_non_err_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, operand_src, null); |
| 1951 | 1949 | if (is_non_err_val.toBool()) { |
| 1952 | 1950 | break :blk try sema.analyzeErrUnionPayloadPtr(block, src, operand, false, false); |
| 1953 | 1951 | } |
| ... | ... | @@ -6498,26 +6496,23 @@ fn zirSwitchContinue(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) Com |
| 6498 | 6496 | |
| 6499 | 6497 | switch (sema.code.instructions.items(.tag)[@intFromEnum(switch_inst)]) { |
| 6500 | 6498 | .switch_block, .switch_block_ref => {}, |
| 6499 | .switch_block_err_union => unreachable, // wrong code path! |
| 6501 | 6500 | else => unreachable, // assertion failure |
| 6502 | 6501 | } |
| 6503 | 6502 | |
| 6504 | | const switch_payload_index = sema.code.instructions.items(.data)[@intFromEnum(switch_inst)].pl_node.payload_index; |
| 6505 | | const switch_operand_ref = sema.code.extraData(Zir.Inst.SwitchBlock, switch_payload_index).data.operand; |
| 6506 | | const switch_operand_ty = sema.typeOf(try sema.resolveInst(switch_operand_ref)); |
| 6507 | | |
| 6508 | | const operand = try sema.coerce(start_block, switch_operand_ty, uncoerced_operand, operand_src); |
| 6509 | | |
| 6503 | const operand_ty = (try sema.resolveInst(switch_inst.toRef())).toType(); |
| 6504 | const operand = try sema.coerce(start_block, operand_ty, uncoerced_operand, operand_src); |
| 6510 | 6505 | try sema.validateRuntimeValue(start_block, operand_src, operand); |
| 6511 | 6506 | |
| 6512 | 6507 | // We want to generate a `switch_dispatch` instruction with the switch condition, |
| 6513 | 6508 | // possibly preceded by a store to the stack alloc containing the raw operand. |
| 6514 | 6509 | // However, to avoid too much special-case state in Sema, this is handled by the |
| 6515 | | // `switch` lowering logic. As such, we will find the `Block` corresponding to the |
| 6516 | | // parent `switch_block[_ref]` instruction, create a dummy `br`, and add a merge |
| 6517 | | // to signal to the switch logic to rewrite this into an appropriate dispatch. |
| 6510 | // `switch` lowering logic. As such, we will find the `Block` corresponding to |
| 6511 | // the parent `switch_block[_ref]` instruction, create a dummy `br`, and add a |
| 6512 | // merge to signal to the switch logic to rewrite this into an appropriate dispatch. |
| 6518 | 6513 | |
| 6519 | 6514 | var block = start_block; |
| 6520 | | while (true) { |
| 6515 | while (true) : (block = block.parent.?) { |
| 6521 | 6516 | if (block.label) |label| { |
| 6522 | 6517 | if (label.zir_block == switch_inst) { |
| 6523 | 6518 | const br_ref = try start_block.addBr(label.merges.block_inst, operand); |
| ... | ... | @@ -6531,7 +6526,6 @@ fn zirSwitchContinue(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) Com |
| 6531 | 6526 | return; |
| 6532 | 6527 | } |
| 6533 | 6528 | } |
| 6534 | | block = block.parent.?; |
| 6535 | 6529 | } |
| 6536 | 6530 | } |
| 6537 | 6531 | |
| ... | ... | @@ -8485,8 +8479,20 @@ fn zirDeclLiteral(sema: *Sema, block: *Block, inst: Zir.Inst.Index, do_coerce: b |
| 8485 | 8479 | sema.code.nullTerminatedString(extra.field_name_start), |
| 8486 | 8480 | .no_embedded_nulls, |
| 8487 | 8481 | ); |
| 8488 | | |
| 8489 | 8482 | const orig_ty: Type = try sema.resolveTypeOrPoison(block, src, extra.lhs) orelse .generic_poison; |
| 8483 | return sema.analyzeDeclLiteral(block, src, name, orig_ty, do_coerce); |
| 8484 | } |
| 8485 | |
| 8486 | fn analyzeDeclLiteral( |
| 8487 | sema: *Sema, |
| 8488 | block: *Block, |
| 8489 | src: LazySrcLoc, |
| 8490 | name: InternPool.NullTerminatedString, |
| 8491 | orig_ty: Type, |
| 8492 | do_coerce: bool, |
| 8493 | ) CompileError!Air.Inst.Ref { |
| 8494 | const pt = sema.pt; |
| 8495 | const zcu = pt.zcu; |
| 8490 | 8496 | |
| 8491 | 8497 | const uncoerced_result = res: { |
| 8492 | 8498 | if (orig_ty.toIntern() == .generic_poison_type) { |
| ... | ... | @@ -8960,6 +8966,7 @@ fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air |
| 8960 | 8966 | const result_ty = operand_ty.errorUnionSet(zcu); |
| 8961 | 8967 | |
| 8962 | 8968 | if (try sema.resolveDefinedValue(block, src, operand)) |val| { |
| 8969 | if (val.getErrorName(zcu) == .none) return .unreachable_value; |
| 8963 | 8970 | return Air.internedToRef((try pt.intern(.{ .err = .{ |
| 8964 | 8971 | .ty = result_ty.toIntern(), |
| 8965 | 8972 | .name = zcu.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name, |
| ... | ... | @@ -8997,7 +9004,7 @@ fn analyzeErrUnionCodePtr(sema: *Sema, block: *Block, src: LazySrcLoc, operand: |
| 8997 | 9004 | |
| 8998 | 9005 | if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| { |
| 8999 | 9006 | if (try sema.pointerDeref(block, src, pointer_val, operand_ty)) |val| { |
| 9000 | | assert(val.getErrorName(zcu) != .none); |
| 9007 | if (val.getErrorName(zcu) == .none) return .unreachable_value; |
| 9001 | 9008 | return Air.internedToRef((try pt.intern(.{ .err = .{ |
| 9002 | 9009 | .ty = result_ty.toIntern(), |
| 9003 | 9010 | .name = zcu.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name, |
| ... | ... | @@ -10519,1284 +10526,1581 @@ fn zirSliceSentinelTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE |
| 10519 | 10526 | return Air.internedToRef(sentinel_ty.toIntern()); |
| 10520 | 10527 | } |
| 10521 | 10528 | |
| 10522 | | /// Holds common data used when analyzing or resolving switch prong bodies, |
| 10523 | | /// including setting up captures. |
| 10524 | | const SwitchProngAnalysis = struct { |
| 10525 | | sema: *Sema, |
| 10526 | | /// The block containing the `switch_block` itself. |
| 10527 | | parent_block: *Block, |
| 10528 | | operand: Operand, |
| 10529 | | /// If this switch is on an error set, this is the type to assign to the |
| 10530 | | /// `else` prong. If `null`, the prong should be unreachable. |
| 10531 | | else_error_ty: ?Type, |
| 10532 | | /// The index of the `switch_block` instruction itself. |
| 10533 | | switch_block_inst: Zir.Inst.Index, |
| 10534 | | /// The dummy index into which inline tag captures should be placed. May be |
| 10535 | | /// undefined if no prong has a tag capture. |
| 10536 | | tag_capture_inst: Zir.Inst.Index, |
| 10537 | | |
| 10538 | | const Operand = union(enum) { |
| 10539 | | /// This switch will be dispatched only once, with the given operand. |
| 10540 | | simple: struct { |
| 10541 | | /// The raw switch operand value. Always defined. |
| 10542 | | by_val: Air.Inst.Ref, |
| 10543 | | /// The switch operand *pointer*. Defined only if there is a prong |
| 10544 | | /// with a by-ref capture. |
| 10545 | | by_ref: Air.Inst.Ref, |
| 10546 | | /// The switch condition value. For unions, `operand` is the union |
| 10547 | | /// and `cond` is its enum tag value. |
| 10548 | | cond: Air.Inst.Ref, |
| 10549 | | }, |
| 10550 | | /// This switch may be dispatched multiple times with `continue` syntax. |
| 10551 | | /// As such, the operand is stored in an alloc if needed. |
| 10552 | | loop: struct { |
| 10553 | | /// The `alloc` containing the `switch` operand for the active dispatch. |
| 10554 | | /// Each prong must load from this `alloc` to get captures. |
| 10555 | | /// If there are no captures, this may be undefined. |
| 10556 | | operand_alloc: Air.Inst.Ref, |
| 10557 | | /// Whether `operand_alloc` contains a by-val operand or a by-ref |
| 10558 | | /// operand. |
| 10559 | | operand_is_ref: bool, |
| 10560 | | /// The switch condition value for the *initial* dispatch. For |
| 10561 | | /// unions, this is the enum tag value. |
| 10562 | | init_cond: Air.Inst.Ref, |
| 10563 | | }, |
| 10564 | | }; |
| 10565 | | |
| 10566 | | /// Resolve a switch prong which is determined at comptime to have no peers. |
| 10567 | | /// Uses `resolveBlockBody`. Sets up captures as needed. |
| 10568 | | fn resolveProngComptime( |
| 10569 | | spa: SwitchProngAnalysis, |
| 10570 | | child_block: *Block, |
| 10571 | | prong_type: enum { normal, special }, |
| 10572 | | prong_body: []const Zir.Inst.Index, |
| 10573 | | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 10574 | | /// Must use the `switch_capture` field in `offset`. |
| 10575 | | capture_src: LazySrcLoc, |
| 10576 | | /// The set of all values which can reach this prong. May be undefined |
| 10577 | | /// if the prong is special or contains ranges. |
| 10578 | | case_vals: []const Air.Inst.Ref, |
| 10579 | | /// The inline capture of this prong. If this is not an inline prong, |
| 10580 | | /// this is `.none`. |
| 10581 | | inline_case_capture: Air.Inst.Ref, |
| 10582 | | /// Whether this prong has an inline tag capture. If `true`, then |
| 10583 | | /// `inline_case_capture` cannot be `.none`. |
| 10584 | | has_tag_capture: bool, |
| 10585 | | merges: *Block.Merges, |
| 10586 | | ) CompileError!Air.Inst.Ref { |
| 10587 | | const sema = spa.sema; |
| 10588 | | const src = spa.parent_block.nodeOffset( |
| 10589 | | sema.code.instructions.items(.data)[@intFromEnum(spa.switch_block_inst)].pl_node.src_node, |
| 10590 | | ); |
| 10529 | fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { |
| 10530 | const tracy = trace(@src()); |
| 10531 | defer tracy.end(); |
| 10591 | 10532 | |
| 10592 | | // We can propagate `.cold` hints from this branch since it's comptime-known |
| 10593 | | // to be taken from the parent branch. |
| 10594 | | const parent_hint = sema.branch_hint; |
| 10595 | | defer sema.branch_hint = parent_hint orelse if (sema.branch_hint == .cold) .cold else null; |
| 10533 | const pt = sema.pt; |
| 10534 | const zcu = pt.zcu; |
| 10535 | const gpa = sema.gpa; |
| 10596 | 10536 | |
| 10597 | | if (has_tag_capture) { |
| 10598 | | const tag_ref = try spa.analyzeTagCapture(child_block, capture_src, inline_case_capture); |
| 10599 | | sema.inst_map.putAssumeCapacity(spa.tag_capture_inst, tag_ref); |
| 10600 | | } |
| 10601 | | defer if (has_tag_capture) assert(sema.inst_map.remove(spa.tag_capture_inst)); |
| 10537 | const zir_switch = sema.code.getSwitchBlock(inst); |
| 10538 | const src_node_offset = zir_switch.catch_or_if_src_node_offset.unwrap().?; |
| 10539 | const src = block.src(.{ .node_offset_main_token = src_node_offset }); |
| 10540 | const operand_src = block.src(.{ .node_offset_if_cond = src_node_offset }); |
| 10602 | 10541 | |
| 10603 | | switch (capture) { |
| 10604 | | .none => { |
| 10605 | | return sema.resolveBlockBody(spa.parent_block, src, child_block, prong_body, spa.switch_block_inst, merges); |
| 10606 | | }, |
| 10542 | assert(!zir_switch.has_continue); // wrong codepath! |
| 10607 | 10543 | |
| 10608 | | .by_val, .by_ref => { |
| 10609 | | const capture_ref = try spa.analyzeCapture( |
| 10610 | | child_block, |
| 10611 | | capture == .by_ref, |
| 10612 | | prong_type == .special, |
| 10613 | | capture_src, |
| 10614 | | case_vals, |
| 10615 | | inline_case_capture, |
| 10616 | | ); |
| 10544 | const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); |
| 10545 | try sema.air_instructions.append(gpa, .{ |
| 10546 | .tag = .block, |
| 10547 | .data = undefined, |
| 10548 | }); |
| 10549 | var label: Block.Label = .{ |
| 10550 | .zir_block = inst, |
| 10551 | .merges = .{ |
| 10552 | .src_locs = .{}, |
| 10553 | .results = .{}, |
| 10554 | .br_list = .{}, |
| 10555 | .block_inst = block_inst, |
| 10556 | }, |
| 10557 | }; |
| 10558 | var child_block = block.makeSubBlock(); |
| 10559 | child_block.label = &label; |
| 10560 | const merges = &child_block.label.?.merges; |
| 10561 | defer child_block.instructions.deinit(gpa); |
| 10562 | defer merges.deinit(gpa); |
| 10617 | 10563 | |
| 10618 | | if (sema.typeOf(capture_ref).isNoReturn(sema.pt.zcu)) { |
| 10619 | | // This prong should be unreachable! |
| 10620 | | return .unreachable_value; |
| 10621 | | } |
| 10564 | const non_err_case = zir_switch.non_err_case.?; |
| 10565 | |
| 10566 | var non_err_block: Block = child_block.makeSubBlock(); |
| 10567 | non_err_block.runtime_loop = null; |
| 10568 | non_err_block.runtime_cond = operand_src; |
| 10569 | non_err_block.runtime_index.increment(); |
| 10570 | non_err_block.need_debug_scope = null; |
| 10571 | defer non_err_block.instructions.deinit(gpa); |
| 10572 | |
| 10573 | var switch_block: Block = child_block.makeSubBlock(); |
| 10574 | switch_block.runtime_loop = null; |
| 10575 | switch_block.runtime_cond = operand_src; |
| 10576 | switch_block.runtime_index.increment(); |
| 10577 | switch_block.need_debug_scope = null; |
| 10578 | defer switch_block.instructions.deinit(gpa); |
| 10579 | |
| 10580 | // We begin with unwrapping the error union we're switching on as necessary. |
| 10581 | // Then we analyze the non-error prong if it's not comptime-unreachable. |
| 10582 | // Lastly, we analyze the error prong(s) as a regular switch. |
| 10583 | |
| 10584 | const raw_switch_operand, const non_err_cond, const non_err_hint = non_err: { |
| 10585 | const eu_maybe_ptr = try sema.resolveInst(zir_switch.main_operand); |
| 10586 | const err_union_ty: Type = err_union_ty: { |
| 10587 | const raw_operand_ty = sema.typeOf(eu_maybe_ptr); |
| 10588 | if (!non_err_case.operand_is_ref) break :err_union_ty raw_operand_ty; |
| 10589 | try sema.checkPtrOperand(block, operand_src, raw_operand_ty); |
| 10590 | break :err_union_ty raw_operand_ty.childType(zcu); |
| 10591 | }; |
| 10592 | if (err_union_ty.zigTypeTag(zcu) != .error_union) { |
| 10593 | return sema.fail(block, operand_src, "expected error union type, found '{f}'", .{ |
| 10594 | err_union_ty.fmt(pt), |
| 10595 | }); |
| 10596 | } |
| 10622 | 10597 | |
| 10623 | | sema.inst_map.putAssumeCapacity(spa.switch_block_inst, capture_ref); |
| 10624 | | defer assert(sema.inst_map.remove(spa.switch_block_inst)); |
| 10598 | const non_err_cond = if (non_err_case.operand_is_ref) |
| 10599 | try sema.analyzePtrIsNonErr(block, operand_src, eu_maybe_ptr) |
| 10600 | else |
| 10601 | try sema.analyzeIsNonErr(block, operand_src, eu_maybe_ptr); |
| 10625 | 10602 | |
| 10626 | | return sema.resolveBlockBody(spa.parent_block, src, child_block, prong_body, spa.switch_block_inst, merges); |
| 10627 | | }, |
| 10628 | | } |
| 10629 | | } |
| 10603 | const non_err_hint: std.builtin.BranchHint = hint: { |
| 10604 | // don't analyze the non-error body if it's unreachable |
| 10605 | if (non_err_cond == .bool_false) { |
| 10606 | break :hint undefined; |
| 10607 | } |
| 10630 | 10608 | |
| 10631 | | /// Analyze a switch prong which may have peers at runtime. |
| 10632 | | /// Uses `analyzeBodyRuntimeBreak`. Sets up captures as needed. |
| 10633 | | /// Returns the `BranchHint` for the prong. |
| 10634 | | fn analyzeProngRuntime( |
| 10635 | | spa: SwitchProngAnalysis, |
| 10636 | | case_block: *Block, |
| 10637 | | prong_type: enum { normal, special }, |
| 10638 | | prong_body: []const Zir.Inst.Index, |
| 10639 | | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 10640 | | /// Must use the `switch_capture` field in `offset`. |
| 10641 | | capture_src: LazySrcLoc, |
| 10642 | | /// The set of all values which can reach this prong. May be undefined |
| 10643 | | /// if the prong is special or contains ranges. |
| 10644 | | case_vals: []const Air.Inst.Ref, |
| 10645 | | /// The inline capture of this prong. If this is not an inline prong, |
| 10646 | | /// this is `.none`. |
| 10647 | | inline_case_capture: Air.Inst.Ref, |
| 10648 | | /// Whether this prong has an inline tag capture. If `true`, then |
| 10649 | | /// `inline_case_capture` cannot be `.none`. |
| 10650 | | has_tag_capture: bool, |
| 10651 | | ) CompileError!std.builtin.BranchHint { |
| 10652 | | const sema = spa.sema; |
| 10609 | const eu_payload: Air.Inst.Ref = switch (non_err_case.capture) { |
| 10610 | .by_val => try sema.analyzeErrUnionPayload(&non_err_block, src, err_union_ty, eu_maybe_ptr, operand_src, false), |
| 10611 | .by_ref => try sema.analyzeErrUnionPayloadPtr(&non_err_block, src, eu_maybe_ptr, false, false), |
| 10612 | .none => undefined, |
| 10613 | }; |
| 10614 | if (non_err_case.capture != .none) sema.inst_map.putAssumeCapacity(inst, eu_payload); |
| 10615 | defer if (non_err_case.capture != .none) assert(sema.inst_map.remove(inst)); |
| 10653 | 10616 | |
| 10654 | | if (has_tag_capture) { |
| 10655 | | const tag_ref = try spa.analyzeTagCapture(case_block, capture_src, inline_case_capture); |
| 10656 | | sema.inst_map.putAssumeCapacity(spa.tag_capture_inst, tag_ref); |
| 10657 | | } |
| 10658 | | defer if (has_tag_capture) assert(sema.inst_map.remove(spa.tag_capture_inst)); |
| 10617 | if (non_err_cond == .bool_true) { |
| 10618 | // Early return; we don't analyze the switch as it's unreachable. |
| 10619 | return sema.resolveBlockBody(block, src, &non_err_block, non_err_case.body, inst, merges); |
| 10620 | } |
| 10621 | break :hint try sema.analyzeBodyRuntimeBreak(&non_err_block, non_err_case.body); |
| 10622 | }; |
| 10659 | 10623 | |
| 10660 | | switch (capture) { |
| 10661 | | .none => { |
| 10662 | | return sema.analyzeBodyRuntimeBreak(case_block, prong_body); |
| 10663 | | }, |
| 10624 | // Emit this into the switch block as it's our error case! |
| 10625 | const eu_code = if (non_err_case.operand_is_ref) |
| 10626 | try sema.analyzeErrUnionCodePtr(&switch_block, operand_src, eu_maybe_ptr) |
| 10627 | else |
| 10628 | try sema.analyzeErrUnionCode(&switch_block, operand_src, eu_maybe_ptr); |
| 10664 | 10629 | |
| 10665 | | .by_val, .by_ref => { |
| 10666 | | const capture_ref = try spa.analyzeCapture( |
| 10667 | | case_block, |
| 10668 | | capture == .by_ref, |
| 10669 | | prong_type == .special, |
| 10670 | | capture_src, |
| 10671 | | case_vals, |
| 10672 | | inline_case_capture, |
| 10673 | | ); |
| 10630 | break :non_err .{ |
| 10631 | eu_code, |
| 10632 | non_err_cond, |
| 10633 | non_err_hint, |
| 10634 | }; |
| 10635 | }; |
| 10674 | 10636 | |
| 10675 | | if (sema.typeOf(capture_ref).isNoReturn(sema.pt.zcu)) { |
| 10676 | | // No need to analyze any further, the prong is unreachable |
| 10677 | | return .none; |
| 10678 | | } |
| 10637 | const validated_switch = try sema.validateSwitchBlock(block, raw_switch_operand, false, inst, &zir_switch); |
| 10679 | 10638 | |
| 10680 | | sema.inst_map.putAssumeCapacity(spa.switch_block_inst, capture_ref); |
| 10681 | | defer assert(sema.inst_map.remove(spa.switch_block_inst)); |
| 10639 | const maybe_switch_ref: ?Air.Inst.Ref = ref: { |
| 10640 | // make err capture (i.e. switch operand) available to switch prong bodies |
| 10641 | sema.inst_map.putAssumeCapacityNoClobber(inst, raw_switch_operand); |
| 10642 | defer assert(sema.inst_map.remove(inst)); |
| 10643 | break :ref try sema.analyzeSwitchBlock(block, &switch_block, raw_switch_operand, false, merges, inst, &zir_switch, &validated_switch); |
| 10644 | }; |
| 10682 | 10645 | |
| 10683 | | return sema.analyzeBodyRuntimeBreak(case_block, prong_body); |
| 10684 | | }, |
| 10685 | | } |
| 10646 | if (non_err_cond == .bool_false) { |
| 10647 | return maybe_switch_ref orelse { |
| 10648 | const switch_src = block.nodeOffset(zir_switch.switch_src_node_offset); |
| 10649 | return sema.resolveAnalyzedBlock(block, switch_src, &switch_block, merges, false); |
| 10650 | }; |
| 10686 | 10651 | } |
| 10687 | 10652 | |
| 10688 | | fn analyzeTagCapture( |
| 10689 | | spa: SwitchProngAnalysis, |
| 10690 | | block: *Block, |
| 10691 | | capture_src: LazySrcLoc, |
| 10692 | | inline_case_capture: Air.Inst.Ref, |
| 10693 | | ) CompileError!Air.Inst.Ref { |
| 10694 | | const sema = spa.sema; |
| 10695 | | const pt = sema.pt; |
| 10696 | | const zcu = pt.zcu; |
| 10697 | | const operand_ty = switch (spa.operand) { |
| 10698 | | .simple => |s| sema.typeOf(s.by_val), |
| 10699 | | .loop => |l| ty: { |
| 10700 | | const alloc_ty = sema.typeOf(l.operand_alloc); |
| 10701 | | const alloc_child = alloc_ty.childType(zcu); |
| 10702 | | if (l.operand_is_ref) break :ty alloc_child.childType(zcu); |
| 10703 | | break :ty alloc_child; |
| 10704 | | }, |
| 10705 | | }; |
| 10706 | | if (operand_ty.zigTypeTag(zcu) != .@"union") { |
| 10707 | | const tag_capture_src: LazySrcLoc = .{ |
| 10708 | | .base_node_inst = capture_src.base_node_inst, |
| 10709 | | .offset = .{ .switch_tag_capture = capture_src.offset.switch_capture }, |
| 10710 | | }; |
| 10711 | | return sema.fail(block, tag_capture_src, "cannot capture tag of non-union type '{f}'", .{ |
| 10712 | | operand_ty.fmt(pt), |
| 10713 | | }); |
| 10653 | if (maybe_switch_ref) |switch_ref| { |
| 10654 | if (sema.typeOf(switch_ref).isNoReturn(zcu)) { |
| 10655 | _ = try switch_block.addNoOp(.unreach); |
| 10656 | } else { |
| 10657 | const br_ref = try switch_block.addBr(merges.block_inst, switch_ref); |
| 10658 | try merges.results.append(gpa, switch_ref); |
| 10659 | try merges.br_list.append(gpa, br_ref.toIndex().?); |
| 10660 | try merges.src_locs.append(gpa, null); |
| 10714 | 10661 | } |
| 10715 | | assert(inline_case_capture != .none); |
| 10716 | | return inline_case_capture; |
| 10717 | 10662 | } |
| 10718 | 10663 | |
| 10719 | | fn analyzeCapture( |
| 10720 | | spa: SwitchProngAnalysis, |
| 10721 | | block: *Block, |
| 10722 | | capture_byref: bool, |
| 10723 | | is_special_prong: bool, |
| 10724 | | capture_src: LazySrcLoc, |
| 10725 | | case_vals: []const Air.Inst.Ref, |
| 10726 | | inline_case_capture: Air.Inst.Ref, |
| 10727 | | ) CompileError!Air.Inst.Ref { |
| 10728 | | const sema = spa.sema; |
| 10729 | | const pt = sema.pt; |
| 10730 | | const zcu = pt.zcu; |
| 10731 | | const ip = &zcu.intern_pool; |
| 10732 | | |
| 10733 | | const zir_datas = sema.code.instructions.items(.data); |
| 10734 | | const switch_node_offset = zir_datas[@intFromEnum(spa.switch_block_inst)].pl_node.src_node; |
| 10664 | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).@"struct".fields.len + |
| 10665 | non_err_block.instructions.items.len + switch_block.instructions.items.len); |
| 10666 | const cond_br_payload = sema.addExtraAssumeCapacity(Air.CondBr{ |
| 10667 | .then_body_len = @intCast(non_err_block.instructions.items.len), |
| 10668 | .else_body_len = @intCast(switch_block.instructions.items.len), |
| 10669 | .branch_hints = .{ |
| 10670 | .true = non_err_hint, |
| 10671 | .false = .unlikely, // errors are unlikely |
| 10672 | // Code coverage is desired for error handling. |
| 10673 | .then_cov = .poi, |
| 10674 | .else_cov = .poi, |
| 10675 | }, |
| 10676 | }); |
| 10677 | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(non_err_block.instructions.items)); |
| 10678 | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(switch_block.instructions.items)); |
| 10735 | 10679 | |
| 10736 | | const operand_src = block.src(.{ .node_offset_switch_operand = switch_node_offset }); |
| 10680 | _ = try child_block.addInst(.{ .tag = .cond_br, .data = .{ .pl_op = .{ |
| 10681 | .operand = non_err_cond, |
| 10682 | .payload = cond_br_payload, |
| 10683 | } } }); |
| 10737 | 10684 | |
| 10738 | | const operand_val, const operand_ptr = switch (spa.operand) { |
| 10739 | | .simple => |s| .{ s.by_val, s.by_ref }, |
| 10740 | | .loop => |l| op: { |
| 10741 | | const loaded = try sema.analyzeLoad(block, operand_src, l.operand_alloc, operand_src); |
| 10742 | | if (l.operand_is_ref) { |
| 10743 | | const by_val = try sema.analyzeLoad(block, operand_src, loaded, operand_src); |
| 10744 | | break :op .{ by_val, loaded }; |
| 10745 | | } else { |
| 10746 | | break :op .{ loaded, undefined }; |
| 10747 | | } |
| 10748 | | }, |
| 10749 | | }; |
| 10685 | return sema.resolveAnalyzedBlock(block, src, &child_block, merges, false); |
| 10686 | } |
| 10750 | 10687 | |
| 10751 | | const operand_ty = sema.typeOf(operand_val); |
| 10752 | | const operand_ptr_ty = if (capture_byref) sema.typeOf(operand_ptr) else undefined; |
| 10688 | fn zirSwitchBlock( |
| 10689 | sema: *Sema, |
| 10690 | block: *Block, |
| 10691 | inst: Zir.Inst.Index, |
| 10692 | operand_is_ref: bool, |
| 10693 | ) CompileError!Air.Inst.Ref { |
| 10694 | const tracy = trace(@src()); |
| 10695 | defer tracy.end(); |
| 10696 | const zir_switch = sema.code.getSwitchBlock(inst); |
| 10753 | 10697 | |
| 10754 | | if (inline_case_capture != .none) { |
| 10755 | | const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, inline_case_capture, undefined) catch unreachable; |
| 10756 | | if (operand_ty.zigTypeTag(zcu) == .@"union") { |
| 10757 | | const field_index: u32 = @intCast(operand_ty.unionTagFieldIndex(item_val, zcu).?); |
| 10758 | | const union_obj = zcu.typeToUnion(operand_ty).?; |
| 10759 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]); |
| 10760 | | if (capture_byref) { |
| 10761 | | const ptr_field_ty = try pt.ptrTypeSema(.{ |
| 10762 | | .child = field_ty.toIntern(), |
| 10763 | | .flags = .{ |
| 10764 | | .is_const = !operand_ptr_ty.ptrIsMutable(zcu), |
| 10765 | | .is_volatile = operand_ptr_ty.isVolatilePtr(zcu), |
| 10766 | | .address_space = operand_ptr_ty.ptrAddressSpace(zcu), |
| 10767 | | }, |
| 10768 | | }); |
| 10769 | | if (try sema.resolveDefinedValue(block, operand_src, operand_ptr)) |union_ptr| { |
| 10770 | | return Air.internedToRef((try union_ptr.ptrField(field_index, pt)).toIntern()); |
| 10771 | | } |
| 10772 | | return block.addStructFieldPtr(operand_ptr, field_index, ptr_field_ty); |
| 10773 | | } else { |
| 10774 | | if (try sema.resolveDefinedValue(block, operand_src, operand_val)) |union_val| { |
| 10775 | | const tag_and_val = ip.indexToKey(union_val.toIntern()).un; |
| 10776 | | return Air.internedToRef(tag_and_val.val); |
| 10777 | | } |
| 10778 | | return block.addStructFieldVal(operand_val, field_index, field_ty); |
| 10779 | | } |
| 10780 | | } else if (capture_byref) { |
| 10781 | | return sema.uavRef(item_val.toIntern()); |
| 10782 | | } else { |
| 10783 | | return inline_case_capture; |
| 10784 | | } |
| 10785 | | } |
| 10698 | const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); |
| 10699 | try sema.air_instructions.append(sema.gpa, .{ |
| 10700 | .tag = .block, |
| 10701 | .data = undefined, |
| 10702 | }); |
| 10703 | var label: Block.Label = .{ |
| 10704 | .zir_block = inst, |
| 10705 | .merges = .{ |
| 10706 | .src_locs = .{}, |
| 10707 | .results = .{}, |
| 10708 | .br_list = .{}, |
| 10709 | .block_inst = block_inst, |
| 10710 | }, |
| 10711 | }; |
| 10712 | var child_block = block.makeSubBlock(); |
| 10713 | child_block.label = &label; |
| 10714 | const merges = &child_block.label.?.merges; |
| 10715 | defer child_block.instructions.deinit(sema.gpa); |
| 10716 | defer merges.deinit(sema.gpa); |
| 10786 | 10717 | |
| 10787 | | if (is_special_prong) { |
| 10788 | | if (capture_byref) { |
| 10789 | | return operand_ptr; |
| 10790 | | } |
| 10718 | const raw_operand = try sema.resolveInst(zir_switch.main_operand); |
| 10719 | const validated_switch = try sema.validateSwitchBlock(block, raw_operand, operand_is_ref, inst, &zir_switch); |
| 10720 | const maybe_ref = try sema.analyzeSwitchBlock(block, &child_block, raw_operand, operand_is_ref, merges, inst, &zir_switch, &validated_switch); |
| 10721 | return maybe_ref orelse { |
| 10722 | const src = block.nodeOffset(zir_switch.switch_src_node_offset); |
| 10723 | return sema.resolveAnalyzedBlock(block, src, &child_block, merges, false); |
| 10724 | }; |
| 10725 | } |
| 10791 | 10726 | |
| 10792 | | switch (operand_ty.zigTypeTag(zcu)) { |
| 10793 | | .error_set => if (spa.else_error_ty) |ty| { |
| 10794 | | return sema.bitCast(block, ty, operand_val, operand_src, null); |
| 10795 | | } else { |
| 10796 | | try sema.analyzeUnreachable(block, operand_src, false); |
| 10797 | | return .unreachable_value; |
| 10798 | | }, |
| 10799 | | else => return operand_val, |
| 10800 | | } |
| 10801 | | } |
| 10727 | /// If the switch can be resolved to a value at comptime, this will return a `Ref` |
| 10728 | /// that's never `.none`. |
| 10729 | /// If not, this will return `null` and emit its instructions into `child_block`. |
| 10730 | fn analyzeSwitchBlock( |
| 10731 | sema: *Sema, |
| 10732 | block: *Block, |
| 10733 | child_block: *Block, |
| 10734 | raw_operand: Air.Inst.Ref, |
| 10735 | operand_is_ref: bool, |
| 10736 | merges: *Block.Merges, |
| 10737 | switch_inst: Zir.Inst.Index, |
| 10738 | zir_switch: *const Zir.UnwrappedSwitchBlock, |
| 10739 | validated_switch: *const ValidatedSwitchBlock, |
| 10740 | ) CompileError!?Air.Inst.Ref { |
| 10741 | const pt = sema.pt; |
| 10742 | const zcu = pt.zcu; |
| 10743 | const gpa = sema.gpa; |
| 10802 | 10744 | |
| 10803 | | switch (operand_ty.zigTypeTag(zcu)) { |
| 10804 | | .@"union" => { |
| 10805 | | const union_obj = zcu.typeToUnion(operand_ty).?; |
| 10806 | | const first_item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, case_vals[0], undefined) catch unreachable; |
| 10745 | const src_node_offset = zir_switch.switch_src_node_offset; |
| 10746 | const src = block.nodeOffset(src_node_offset); |
| 10747 | const operand_src = block.src(.{ .node_offset_switch_operand = src_node_offset }); |
| 10807 | 10748 | |
| 10808 | | const first_field_index: u32 = zcu.unionTagFieldIndex(union_obj, first_item_val).?; |
| 10809 | | const first_field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[first_field_index]); |
| 10749 | const has_else = zir_switch.else_case != null; |
| 10750 | const has_under = zir_switch.has_under; |
| 10810 | 10751 | |
| 10811 | | const field_indices = try sema.arena.alloc(u32, case_vals.len); |
| 10812 | | for (case_vals, field_indices) |item, *field_idx| { |
| 10813 | | const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable; |
| 10814 | | field_idx.* = zcu.unionTagFieldIndex(union_obj, item_val).?; |
| 10815 | | } |
| 10752 | const else_case = validated_switch.else_case; |
| 10816 | 10753 | |
| 10817 | | // Fast path: if all the operands are the same type already, we don't need to hit |
| 10818 | | // PTR! This will also allow us to emit simpler code. |
| 10819 | | const same_types = for (field_indices[1..]) |field_idx| { |
| 10820 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 10821 | | if (!field_ty.eql(first_field_ty, zcu)) break false; |
| 10822 | | } else true; |
| 10754 | const operand: SwitchOperand, const operand_ty: Type, const maybe_operand_opv: ?Value, const item_ty: Type = operand: { |
| 10755 | const val, const ref = if (operand_is_ref) |
| 10756 | .{ try sema.analyzeLoad(block, src, raw_operand, operand_src), raw_operand } |
| 10757 | else |
| 10758 | .{ raw_operand, undefined }; |
| 10823 | 10759 | |
| 10824 | | const capture_ty = if (same_types) first_field_ty else capture_ty: { |
| 10825 | | // We need values to run PTR on, so make a bunch of undef constants. |
| 10826 | | const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len); |
| 10827 | | for (dummy_captures, field_indices) |*dummy, field_idx| { |
| 10828 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 10829 | | dummy.* = try pt.undefRef(field_ty); |
| 10830 | | } |
| 10760 | const operand_ty = sema.typeOf(val); |
| 10761 | const maybe_operand_opv = try sema.typeHasOnePossibleValue(operand_ty); |
| 10762 | const init_cond: Air.Inst.Ref, const item_ty: Type = switch (operand_ty.zigTypeTag(zcu)) { |
| 10763 | .@"union" => tag: { |
| 10764 | const tag_ty = operand_ty.unionTagType(zcu).?; |
| 10765 | const tag_val = try sema.unionToTag(block, tag_ty, val, operand_src); |
| 10766 | break :tag .{ tag_val, tag_ty }; |
| 10767 | }, |
| 10768 | else => .{ |
| 10769 | if (maybe_operand_opv) |operand_opv| .fromValue(operand_opv) else val, |
| 10770 | operand_ty, |
| 10771 | }, |
| 10772 | }; |
| 10831 | 10773 | |
| 10832 | | const case_srcs = try sema.arena.alloc(?LazySrcLoc, case_vals.len); |
| 10833 | | for (case_srcs, 0..) |*case_src, i| { |
| 10834 | | case_src.* = .{ |
| 10835 | | .base_node_inst = capture_src.base_node_inst, |
| 10836 | | .offset = .{ .switch_case_item = .{ |
| 10837 | | .switch_node_offset = switch_node_offset, |
| 10838 | | .case_idx = capture_src.offset.switch_capture.case_idx, |
| 10839 | | .item_idx = .{ .kind = .single, .index = @intCast(i) }, |
| 10840 | | } }, |
| 10841 | | }; |
| 10842 | | } |
| 10774 | if (zir_switch.has_continue and !block.isComptime()) { |
| 10775 | const operand_alloc: Air.Inst.Ref = if (zir_switch.any_maybe_runtime_capture and |
| 10776 | maybe_operand_opv == null) |
| 10777 | alloc: { |
| 10778 | const operand_ptr_ty = try pt.singleMutPtrType(sema.typeOf(raw_operand)); |
| 10779 | const operand_alloc = try block.addTy(.alloc, operand_ptr_ty); |
| 10780 | _ = try block.addBinOp(.store, operand_alloc, raw_operand); |
| 10781 | break :alloc operand_alloc; |
| 10782 | } else undefined; |
| 10783 | break :operand .{ .{ .loop = .{ |
| 10784 | .operand_alloc = operand_alloc, |
| 10785 | .operand_is_ref = operand_is_ref, |
| 10786 | .init_cond = init_cond, |
| 10787 | } }, operand_ty, maybe_operand_opv, item_ty }; |
| 10788 | } else { |
| 10789 | // We always use `simple` in the comptime/OPV case, because as far as the |
| 10790 | // dispatching logic is concerned, it really is dispatching a single prong. |
| 10791 | break :operand .{ .{ .simple = .{ |
| 10792 | .by_val = val, |
| 10793 | .by_ref = ref, |
| 10794 | .cond = init_cond, |
| 10795 | } }, operand_ty, maybe_operand_opv, item_ty }; |
| 10796 | } |
| 10797 | }; |
| 10843 | 10798 | |
| 10844 | | break :capture_ty sema.resolvePeerTypes(block, capture_src, dummy_captures, .{ .override = case_srcs }) catch |err| switch (err) { |
| 10845 | | error.AnalysisFail => { |
| 10846 | | const msg = sema.err orelse return error.AnalysisFail; |
| 10847 | | try sema.reparentOwnedErrorMsg(capture_src, msg, "capture group with incompatible types", .{}); |
| 10848 | | return error.AnalysisFail; |
| 10849 | | }, |
| 10850 | | else => |e| return e, |
| 10851 | | }; |
| 10852 | | }; |
| 10799 | const raw_operand_ty = sema.typeOf(raw_operand); |
| 10853 | 10800 | |
| 10854 | | // By-reference captures have some further restrictions which make them easier to emit |
| 10855 | | if (capture_byref) { |
| 10856 | | const operand_ptr_info = operand_ptr_ty.ptrInfo(zcu); |
| 10857 | | const capture_ptr_ty = resolve: { |
| 10858 | | // By-ref captures of hetereogeneous types are only allowed if all field |
| 10859 | | // pointer types are peer resolvable to each other. |
| 10860 | | // We need values to run PTR on, so make a bunch of undef constants. |
| 10861 | | const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len); |
| 10862 | | for (field_indices, dummy_captures) |field_idx, *dummy| { |
| 10863 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 10864 | | const field_ptr_ty = try pt.ptrTypeSema(.{ |
| 10865 | | .child = field_ty.toIntern(), |
| 10866 | | .flags = .{ |
| 10867 | | .is_const = operand_ptr_info.flags.is_const, |
| 10868 | | .is_volatile = operand_ptr_info.flags.is_volatile, |
| 10869 | | .address_space = operand_ptr_info.flags.address_space, |
| 10870 | | .alignment = union_obj.fieldAlign(ip, field_idx), |
| 10871 | | }, |
| 10872 | | }); |
| 10873 | | dummy.* = try pt.undefRef(field_ptr_ty); |
| 10874 | | } |
| 10875 | | const case_srcs = try sema.arena.alloc(?LazySrcLoc, case_vals.len); |
| 10876 | | for (case_srcs, 0..) |*case_src, i| { |
| 10877 | | case_src.* = .{ |
| 10878 | | .base_node_inst = capture_src.base_node_inst, |
| 10879 | | .offset = .{ .switch_case_item = .{ |
| 10880 | | .switch_node_offset = switch_node_offset, |
| 10881 | | .case_idx = capture_src.offset.switch_capture.case_idx, |
| 10882 | | .item_idx = .{ .kind = .single, .index = @intCast(i) }, |
| 10883 | | } }, |
| 10884 | | }; |
| 10885 | | } |
| 10801 | const union_originally = operand_ty.zigTypeTag(zcu) == .@"union"; |
| 10802 | const err_set = operand_ty.zigTypeTag(zcu) == .error_set; |
| 10886 | 10803 | |
| 10887 | | break :resolve sema.resolvePeerTypes(block, capture_src, dummy_captures, .{ .override = case_srcs }) catch |err| switch (err) { |
| 10888 | | error.AnalysisFail => { |
| 10889 | | const msg = sema.err orelse return error.AnalysisFail; |
| 10890 | | try sema.errNote(capture_src, msg, "this coercion is only possible when capturing by value", .{}); |
| 10891 | | try sema.reparentOwnedErrorMsg(capture_src, msg, "capture group with incompatible types", .{}); |
| 10892 | | return error.AnalysisFail; |
| 10893 | | }, |
| 10894 | | else => |e| return e, |
| 10895 | | }; |
| 10896 | | }; |
| 10804 | if (item_ty.zigTypeTag(zcu) == .@"enum" and |
| 10805 | validated_switch.seen_enum_fields.len == 0 and |
| 10806 | !operand_ty.isNonexhaustiveEnum(zcu)) |
| 10807 | { |
| 10808 | return .void_value; // switch on empty enum/union |
| 10809 | } |
| 10897 | 10810 | |
| 10898 | | if (try sema.resolveDefinedValue(block, operand_src, operand_ptr)) |op_ptr_val| { |
| 10899 | | if (op_ptr_val.isUndef(zcu)) return pt.undefRef(capture_ptr_ty); |
| 10900 | | const field_ptr_val = try op_ptr_val.ptrField(first_field_index, pt); |
| 10901 | | return Air.internedToRef((try pt.getCoerced(field_ptr_val, capture_ptr_ty)).toIntern()); |
| 10902 | | } |
| 10811 | const cond_ref = switch (operand) { |
| 10812 | .simple => |s| s.cond, |
| 10813 | .loop => |l| l.init_cond, |
| 10814 | }; |
| 10903 | 10815 | |
| 10904 | | try sema.requireRuntimeBlock(block, operand_src, null); |
| 10905 | | return block.addStructFieldPtr(operand_ptr, first_field_index, capture_ptr_ty); |
| 10906 | | } |
| 10816 | // We treat `else` and `_` the same, except if both are present. |
| 10817 | const else_is_named_only = has_else and has_under; |
| 10818 | const catch_all_case: CatchAllSwitchCase = |
| 10819 | if (has_under) .under else if (has_else) .@"else" else .none; |
| 10907 | 10820 | |
| 10908 | | if (try sema.resolveDefinedValue(block, operand_src, operand_val)) |operand_val_val| { |
| 10909 | | if (operand_val_val.isUndef(zcu)) return pt.undefRef(capture_ty); |
| 10910 | | const union_val = ip.indexToKey(operand_val_val.toIntern()).un; |
| 10911 | | if (Value.fromInterned(union_val.tag).isUndef(zcu)) return pt.undefRef(capture_ty); |
| 10912 | | const uncoerced = Air.internedToRef(union_val.val); |
| 10913 | | return sema.coerce(block, capture_ty, uncoerced, operand_src); |
| 10914 | | } |
| 10821 | resolve_at_comptime: { |
| 10822 | // always runtime; evaluation in comptime scope uses `simple` |
| 10823 | if (operand == .loop) break :resolve_at_comptime; |
| 10915 | 10824 | |
| 10916 | | try sema.requireRuntimeBlock(block, operand_src, null); |
| 10825 | var cur_cond_val = try sema.resolveDefinedValue(child_block, src, cond_ref) orelse { |
| 10826 | break :resolve_at_comptime; |
| 10827 | }; |
| 10828 | var cur_operand = operand; |
| 10917 | 10829 | |
| 10918 | | if (same_types) { |
| 10919 | | return block.addStructFieldVal(operand_val, first_field_index, capture_ty); |
| 10920 | | } |
| 10830 | while (true) { |
| 10831 | if (sema.resolveSwitchBlock( |
| 10832 | block, |
| 10833 | child_block, |
| 10834 | cur_operand, |
| 10835 | raw_operand_ty, |
| 10836 | cur_cond_val, |
| 10837 | catch_all_case, |
| 10838 | else_is_named_only, |
| 10839 | merges, |
| 10840 | switch_inst, |
| 10841 | zir_switch, |
| 10842 | validated_switch, |
| 10843 | )) |result| { |
| 10844 | return result; |
| 10845 | } else |err| switch (err) { |
| 10846 | error.ComptimeBreak => { |
| 10847 | const break_inst = sema.code.instructions.get(@intFromEnum(sema.comptime_break_inst)); |
| 10848 | if (break_inst.tag != .switch_continue) return error.ComptimeBreak; |
| 10849 | const extra = sema.code.extraData(Zir.Inst.Break, break_inst.data.@"break".payload_index).data; |
| 10850 | if (extra.block_inst != switch_inst) return error.ComptimeBreak; |
| 10851 | // This is a `switch_continue` targeting this block. Change the operand and start over. |
| 10852 | const new_operand_src = child_block.nodeOffset(extra.operand_src_node.unwrap().?); |
| 10853 | const new_operand_uncoerced = try sema.resolveInst(break_inst.data.@"break".operand); |
| 10854 | const new_operand = try sema.coerce(child_block, raw_operand_ty, new_operand_uncoerced, new_operand_src); |
| 10855 | |
| 10856 | try sema.emitBackwardBranch(child_block, src); |
| 10857 | |
| 10858 | const new_val, const new_ref = if (operand_is_ref) |
| 10859 | .{ try sema.analyzeLoad(child_block, src, new_operand, new_operand_src), new_operand } |
| 10860 | else |
| 10861 | .{ new_operand, undefined }; |
| 10921 | 10862 | |
| 10922 | | // We may have to emit a switch block which coerces the operand to the capture type. |
| 10923 | | // If we can, try to avoid that using in-memory coercions. |
| 10924 | | const first_non_imc = in_mem: { |
| 10925 | | for (field_indices, 0..) |field_idx, i| { |
| 10926 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 10927 | | if (.ok != try sema.coerceInMemoryAllowed(block, capture_ty, field_ty, false, zcu.getTarget(), LazySrcLoc.unneeded, LazySrcLoc.unneeded, null)) { |
| 10928 | | break :in_mem i; |
| 10929 | | } |
| 10930 | | } |
| 10931 | | // All fields are in-memory coercible to the resolved type! |
| 10932 | | // Just take the first field and bitcast the result. |
| 10933 | | const uncoerced = try block.addStructFieldVal(operand_val, first_field_index, first_field_ty); |
| 10934 | | return block.addBitCast(capture_ty, uncoerced); |
| 10935 | | }; |
| 10863 | const new_cond_ref = if (union_originally) |
| 10864 | try sema.unionToTag(child_block, item_ty, new_val, src) |
| 10865 | else |
| 10866 | new_val; |
| 10936 | 10867 | |
| 10937 | | // By-val capture with heterogeneous types which are not all in-memory coercible to |
| 10938 | | // the resolved capture type. We finally have to fall back to the ugly method. |
| 10868 | cur_cond_val = try sema.resolveConstDefinedValue(child_block, src, new_cond_ref, null); |
| 10869 | cur_operand = .{ .simple = .{ |
| 10870 | .by_val = new_val, |
| 10871 | .by_ref = new_ref, |
| 10872 | .cond = new_cond_ref, |
| 10873 | } }; |
| 10874 | }, |
| 10875 | else => |e| return e, |
| 10876 | } |
| 10877 | } |
| 10878 | } |
| 10939 | 10879 | |
| 10940 | | // However, let's first track which operands are in-memory coercible. There may well |
| 10941 | | // be several, and we can squash all of these cases into the same switch prong using |
| 10942 | | // a simple bitcast. We'll make this the 'else' prong. |
| 10880 | if (child_block.isComptime()) { |
| 10881 | _ = try sema.resolveConstDefinedValue(child_block, operand_src, operand.simple.cond, null); |
| 10882 | unreachable; |
| 10883 | } |
| 10943 | 10884 | |
| 10944 | | var in_mem_coercible = try std.DynamicBitSet.initFull(sema.arena, field_indices.len); |
| 10945 | | in_mem_coercible.unset(first_non_imc); |
| 10946 | | { |
| 10947 | | const next = first_non_imc + 1; |
| 10948 | | for (field_indices[next..], next..) |field_idx, i| { |
| 10949 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 10950 | | if (.ok != try sema.coerceInMemoryAllowed(block, capture_ty, field_ty, false, zcu.getTarget(), LazySrcLoc.unneeded, LazySrcLoc.unneeded, null)) { |
| 10951 | | in_mem_coercible.unset(i); |
| 10885 | if (try sema.typeHasOnePossibleValue(item_ty)) |item_opv| { |
| 10886 | // We simplify conditions with OPV to either a `loop` or a `block` since |
| 10887 | // we cannot switch on a value which doesn't exist at runtime. |
| 10888 | assert(operand == .loop); // `simple` should have already been comptime-resolved above! |
| 10889 | |
| 10890 | var case_block = child_block.makeSubBlock(); |
| 10891 | case_block.runtime_loop = null; |
| 10892 | case_block.runtime_cond = operand_src; |
| 10893 | case_block.runtime_index.increment(); |
| 10894 | case_block.need_debug_scope = null; // this body is emitted regardless |
| 10895 | defer case_block.instructions.deinit(gpa); |
| 10896 | |
| 10897 | const case_vals = validated_switch.case_vals; |
| 10898 | |
| 10899 | const index, const body, const capture, const has_tag_capture, const is_inline, const is_special = find_prong: { |
| 10900 | var case_val_idx: usize = 0; |
| 10901 | var case_it = zir_switch.iterateCases(); |
| 10902 | var extra_index = zir_switch.end; |
| 10903 | while (case_it.next()) |case| { |
| 10904 | const prong_info = case.prong_info; |
| 10905 | const prong_body = sema.code.bodySlice(extra_index, prong_info.body_len); |
| 10906 | extra_index += prong_body.len; |
| 10907 | skip_case: { |
| 10908 | if (!err_set) break :skip_case; |
| 10909 | // This case might consist of errors which are not in the set |
| 10910 | // we're switching on. If so we have to skip it! |
| 10911 | const item_refs = case_vals[case_val_idx..][0..case.item_infos.len]; |
| 10912 | case_val_idx += item_refs.len; |
| 10913 | assert(case.range_infos.len == 0); |
| 10914 | for (case.item_infos, item_refs) |item_info, item_ref| { |
| 10915 | if (item_info.bodyLen()) |body_len| extra_index += body_len; |
| 10916 | if (sema.wantSwitchProngBodyAnalysis(block, item_ref, operand_ty, false, true, prong_info.is_comptime_unreach)) { |
| 10917 | break :skip_case; |
| 10952 | 10918 | } |
| 10953 | 10919 | } |
| 10920 | continue; |
| 10954 | 10921 | } |
| 10922 | break :find_prong .{ case.index, prong_body, prong_info.capture, prong_info.has_tag_capture, prong_info.is_inline, false }; |
| 10923 | } |
| 10924 | if (has_else) { |
| 10925 | // This *has* to be checked after iterating all regular cases because |
| 10926 | // we allow simple noreturn else prongs when switching on error sets! |
| 10927 | break :find_prong .{ else_case.index, else_case.body, else_case.capture, else_case.has_tag_capture, else_case.is_inline, true }; |
| 10928 | } |
| 10929 | unreachable; // malformed validated switch |
| 10930 | }; |
| 10955 | 10931 | |
| 10956 | | const capture_block_inst = try block.addInstAsIndex(.{ |
| 10957 | | .tag = .block, |
| 10958 | | .data = .{ |
| 10959 | | .ty_pl = .{ |
| 10960 | | .ty = Air.internedToRef(capture_ty.toIntern()), |
| 10961 | | .payload = undefined, // updated below |
| 10962 | | }, |
| 10963 | | }, |
| 10964 | | }); |
| 10965 | | |
| 10966 | | const prong_count = field_indices.len - in_mem_coercible.count(); |
| 10967 | | |
| 10968 | | const estimated_extra = prong_count * 6 + (prong_count / 10); // 2 for Case, 1 item, probably 3 insts; plus hints |
| 10969 | | var cases_extra = try std.array_list.Managed(u32).initCapacity(sema.gpa, estimated_extra); |
| 10970 | | defer cases_extra.deinit(); |
| 10971 | | |
| 10972 | | { |
| 10973 | | // All branch hints are `.none`, so just add zero elems. |
| 10974 | | comptime assert(@intFromEnum(std.builtin.BranchHint.none) == 0); |
| 10975 | | const need_elems = std.math.divCeil(usize, prong_count + 1, 10) catch unreachable; |
| 10976 | | try cases_extra.appendNTimes(0, need_elems); |
| 10977 | | } |
| 10978 | | |
| 10979 | | { |
| 10980 | | // Non-bitcast cases |
| 10981 | | var it = in_mem_coercible.iterator(.{ .kind = .unset }); |
| 10982 | | while (it.next()) |idx| { |
| 10983 | | var coerce_block = block.makeSubBlock(); |
| 10984 | | defer coerce_block.instructions.deinit(sema.gpa); |
| 10932 | const analyze_body = sema.wantSwitchProngBodyAnalysis(block, .fromValue(item_opv), operand_ty, union_originally, err_set, false); |
| 10933 | if (!analyze_body) return .unreachable_value; |
| 10985 | 10934 | |
| 10986 | | const case_src: LazySrcLoc = .{ |
| 10987 | | .base_node_inst = capture_src.base_node_inst, |
| 10988 | | .offset = .{ .switch_case_item = .{ |
| 10989 | | .switch_node_offset = switch_node_offset, |
| 10990 | | .case_idx = capture_src.offset.switch_capture.case_idx, |
| 10991 | | .item_idx = .{ .kind = .single, .index = @intCast(idx) }, |
| 10992 | | } }, |
| 10993 | | }; |
| 10935 | if (!(err_set and |
| 10936 | try sema.maybeErrorUnwrap(&case_block, body, cond_ref, operand_src, true))) |
| 10937 | { |
| 10938 | // Set up captures manually to avoid special cases in the main logic. |
| 10939 | const payload_inst: Zir.Inst.Index = if (capture != .none) inst: { |
| 10940 | const payload_inst = zir_switch.payload_capture_placeholder.unwrap() orelse switch_inst; |
| 10941 | const payload_ref: Air.Inst.Ref = payload_ref: { |
| 10942 | const item_val: InternPool.Index = switch (operand_ty.zigTypeTag(zcu)) { |
| 10943 | .@"union" => item_val: { |
| 10944 | if (maybe_operand_opv) |operand_opv| { |
| 10945 | break :item_val zcu.intern_pool.indexToKey(operand_opv.toIntern()).un.val; |
| 10946 | } |
| 10947 | assert(union_originally); // operand type must be union, otherwise it would be an OPV type here |
| 10948 | assert(zir_switch.any_maybe_runtime_capture); // there's a payload capture |
| 10949 | const operand_val, const operand_ref = switch (operand) { |
| 10950 | .simple => unreachable, |
| 10951 | .loop => |l| load_operand: { |
| 10952 | const loaded = try sema.analyzeLoad(block, src, l.operand_alloc, src); |
| 10953 | if (l.operand_is_ref) { |
| 10954 | const by_val = try sema.analyzeLoad(block, src, loaded, src); |
| 10955 | break :load_operand .{ by_val, loaded }; |
| 10956 | } else { |
| 10957 | break :load_operand .{ loaded, undefined }; |
| 10958 | } |
| 10959 | }, |
| 10960 | }; |
| 10961 | break :payload_ref try sema.analyzeSwitchPayloadCapture( |
| 10962 | &case_block, |
| 10963 | operand, |
| 10964 | operand_val, |
| 10965 | operand_ref, |
| 10966 | operand_ty, |
| 10967 | operand_src, |
| 10968 | block.src(.{ .switch_capture = .{ |
| 10969 | .switch_node_offset = src_node_offset, |
| 10970 | .case_idx = index, |
| 10971 | } }), |
| 10972 | capture == .by_ref, |
| 10973 | is_special, |
| 10974 | if (!is_special) case_vals else undefined, |
| 10975 | if (is_inline) .fromValue(item_opv) else .none, |
| 10976 | validated_switch.else_err_ty, |
| 10977 | ); |
| 10978 | }, |
| 10979 | else => item_opv.toIntern(), |
| 10980 | }; |
| 10981 | break :payload_ref switch (capture) { |
| 10982 | .by_val => .fromIntern(item_val), |
| 10983 | .by_ref => try sema.uavRef(item_val), |
| 10984 | .none => unreachable, |
| 10985 | }; |
| 10986 | }; |
| 10987 | assert(!sema.typeOf(payload_ref).isNoReturn(sema.pt.zcu)); |
| 10988 | sema.inst_map.putAssumeCapacity(payload_inst, payload_ref); |
| 10989 | break :inst payload_inst; |
| 10990 | } else undefined; |
| 10991 | defer if (capture != .none) assert(sema.inst_map.remove(payload_inst)); |
| 10994 | 10992 | |
| 10995 | | const field_idx = field_indices[idx]; |
| 10996 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 10997 | | const uncoerced = try coerce_block.addStructFieldVal(operand_val, field_idx, field_ty); |
| 10998 | | const coerced = try sema.coerce(&coerce_block, capture_ty, uncoerced, case_src); |
| 10999 | | _ = try coerce_block.addBr(capture_block_inst, coerced); |
| 11000 | | |
| 11001 | | try cases_extra.ensureUnusedCapacity(@typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 11002 | | 1 + // `item`, no ranges |
| 11003 | | coerce_block.instructions.items.len); |
| 11004 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 11005 | | .items_len = 1, |
| 11006 | | .ranges_len = 0, |
| 11007 | | .body_len = @intCast(coerce_block.instructions.items.len), |
| 11008 | | })); |
| 11009 | | cases_extra.appendAssumeCapacity(@intFromEnum(case_vals[idx])); // item |
| 11010 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(coerce_block.instructions.items)); // body |
| 11011 | | } |
| 11012 | | } |
| 11013 | | const else_body_len = len: { |
| 11014 | | // 'else' prong uses a bitcast |
| 11015 | | var coerce_block = block.makeSubBlock(); |
| 11016 | | defer coerce_block.instructions.deinit(sema.gpa); |
| 10993 | const tag_inst: Zir.Inst.Index = if (has_tag_capture) inst: { |
| 10994 | const tag_inst = zir_switch.tag_capture_placeholder.unwrap() orelse switch_inst; |
| 10995 | sema.inst_map.putAssumeCapacity(tag_inst, .fromValue(item_opv)); |
| 10996 | break :inst tag_inst; |
| 10997 | } else undefined; |
| 10998 | defer if (has_tag_capture) assert(sema.inst_map.remove(tag_inst)); |
| 11017 | 10999 | |
| 11018 | | const first_imc_item_idx = in_mem_coercible.findFirstSet().?; |
| 11019 | | const first_imc_field_idx = field_indices[first_imc_item_idx]; |
| 11020 | | const first_imc_field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[first_imc_field_idx]); |
| 11021 | | const uncoerced = try coerce_block.addStructFieldVal(operand_val, first_imc_field_idx, first_imc_field_ty); |
| 11022 | | const coerced = try coerce_block.addBitCast(capture_ty, uncoerced); |
| 11023 | | _ = try coerce_block.addBr(capture_block_inst, coerced); |
| 11000 | if (zir_switch.has_continue) sema.inst_map.putAssumeCapacity(switch_inst, .fromType(raw_operand_ty)); |
| 11001 | defer if (zir_switch.has_continue) assert(sema.inst_map.remove(switch_inst)); |
| 11024 | 11002 | |
| 11025 | | try cases_extra.appendSlice(@ptrCast(coerce_block.instructions.items)); |
| 11026 | | break :len coerce_block.instructions.items.len; |
| 11027 | | }; |
| 11003 | _ = try sema.analyzeBodyRuntimeBreak(&case_block, body); |
| 11004 | } |
| 11028 | 11005 | |
| 11029 | | try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.SwitchBr).@"struct".fields.len + |
| 11030 | | cases_extra.items.len + |
| 11031 | | @typeInfo(Air.Block).@"struct".fields.len + |
| 11032 | | 1); |
| 11033 | | |
| 11034 | | const switch_br_inst: u32 = @intCast(sema.air_instructions.len); |
| 11035 | | try sema.air_instructions.append(sema.gpa, .{ |
| 11036 | | .tag = .switch_br, |
| 11037 | | .data = .{ |
| 11038 | | .pl_op = .{ |
| 11039 | | .operand = undefined, // set by switch below |
| 11040 | | .payload = sema.addExtraAssumeCapacity(Air.SwitchBr{ |
| 11041 | | .cases_len = @intCast(prong_count), |
| 11042 | | .else_body_len = @intCast(else_body_len), |
| 11043 | | }), |
| 11044 | | }, |
| 11045 | | }, |
| 11046 | | }); |
| 11047 | | sema.air_extra.appendSliceAssumeCapacity(cases_extra.items); |
| 11048 | | |
| 11049 | | // Set up block body |
| 11050 | | switch (spa.operand) { |
| 11051 | | .simple => |s| { |
| 11052 | | const air_datas = sema.air_instructions.items(.data); |
| 11053 | | air_datas[switch_br_inst].pl_op.operand = s.cond; |
| 11054 | | air_datas[@intFromEnum(capture_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ |
| 11055 | | .body_len = 1, |
| 11056 | | }); |
| 11057 | | sema.air_extra.appendAssumeCapacity(switch_br_inst); |
| 11058 | | }, |
| 11059 | | .loop => { |
| 11060 | | // The block must first extract the tag from the loaded union. |
| 11061 | | const tag_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); |
| 11062 | | try sema.air_instructions.append(sema.gpa, .{ |
| 11063 | | .tag = .get_union_tag, |
| 11064 | | .data = .{ .ty_op = .{ |
| 11065 | | .ty = Air.internedToRef(union_obj.enum_tag_ty), |
| 11066 | | .operand = operand_val, |
| 11067 | | } }, |
| 11068 | | }); |
| 11069 | | const air_datas = sema.air_instructions.items(.data); |
| 11070 | | air_datas[switch_br_inst].pl_op.operand = tag_inst.toRef(); |
| 11071 | | air_datas[@intFromEnum(capture_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ |
| 11072 | | .body_len = 2, |
| 11073 | | }); |
| 11074 | | sema.air_extra.appendAssumeCapacity(@intFromEnum(tag_inst)); |
| 11075 | | sema.air_extra.appendAssumeCapacity(switch_br_inst); |
| 11076 | | }, |
| 11077 | | } |
| 11006 | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".fields.len + |
| 11007 | case_block.instructions.items.len); |
| 11008 | const payload_index = sema.addExtraAssumeCapacity(Air.Block{ |
| 11009 | .body_len = @intCast(case_block.instructions.items.len), |
| 11010 | }); |
| 11011 | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 11078 | 11012 | |
| 11079 | | return capture_block_inst.toRef(); |
| 11080 | | }, |
| 11081 | | .error_set => { |
| 11082 | | if (capture_byref) { |
| 11083 | | return sema.fail( |
| 11084 | | block, |
| 11085 | | capture_src, |
| 11086 | | "error set cannot be captured by reference", |
| 11087 | | .{}, |
| 11088 | | ); |
| 11089 | | } |
| 11013 | const air_tag: Air.Inst.Tag = if (merges.extra_insts.items.len > 0) |
| 11014 | .loop |
| 11015 | else |
| 11016 | .block; |
| 11017 | const air_loop_ref = try child_block.addInst(.{ |
| 11018 | .tag = air_tag, |
| 11019 | .data = .{ .ty_pl = .{ |
| 11020 | .ty = .noreturn_type, |
| 11021 | .payload = payload_index, |
| 11022 | } }, |
| 11023 | }); |
| 11024 | try sema.fixupSwitchContinues( |
| 11025 | block, |
| 11026 | src, |
| 11027 | air_loop_ref, |
| 11028 | operand, |
| 11029 | operand_is_ref, |
| 11030 | item_ty, |
| 11031 | .opv, |
| 11032 | zir_switch.any_maybe_runtime_capture, |
| 11033 | merges, |
| 11034 | ); |
| 11035 | return null; |
| 11036 | } |
| 11090 | 11037 | |
| 11091 | | if (case_vals.len == 1) { |
| 11092 | | const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, case_vals[0], undefined) catch unreachable; |
| 11093 | | const item_ty = try pt.singleErrorSetType(item_val.getErrorName(zcu).unwrap().?); |
| 11094 | | return sema.bitCast(block, item_ty, operand_val, operand_src, null); |
| 11095 | | } |
| 11038 | assert(maybe_operand_opv == null); // `operand_ty` can only be an OPV type if `item_ty` is one too! |
| 11096 | 11039 | |
| 11097 | | var names: InferredErrorSet.NameMap = .{}; |
| 11098 | | try names.ensureUnusedCapacity(sema.arena, case_vals.len); |
| 11099 | | for (case_vals) |err| { |
| 11100 | | const err_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, err, undefined) catch unreachable; |
| 11101 | | names.putAssumeCapacityNoClobber(err_val.getErrorName(zcu).unwrap().?, {}); |
| 11102 | | } |
| 11103 | | const error_ty = try pt.errorSetFromUnsortedNames(names.keys()); |
| 11104 | | return sema.bitCast(block, error_ty, operand_val, operand_src, null); |
| 11105 | | }, |
| 11106 | | else => { |
| 11107 | | // In this case the capture value is just the passed-through value |
| 11108 | | // of the switch condition. |
| 11109 | | if (capture_byref) { |
| 11110 | | return operand_ptr; |
| 11111 | | } else { |
| 11112 | | return operand_val; |
| 11113 | | } |
| 11114 | | }, |
| 11115 | | } |
| 11116 | | } |
| 11117 | | }; |
| 11040 | try sema.finishSwitchBr( |
| 11041 | block, |
| 11042 | child_block, |
| 11043 | operand, |
| 11044 | raw_operand_ty, |
| 11045 | operand_is_ref, |
| 11046 | merges, |
| 11047 | switch_inst, |
| 11048 | zir_switch, |
| 11049 | validated_switch, |
| 11050 | ); |
| 11051 | return null; |
| 11052 | } |
| 11118 | 11053 | |
| 11119 | | fn switchCond( |
| 11054 | fn finishSwitchBr( |
| 11120 | 11055 | sema: *Sema, |
| 11121 | 11056 | block: *Block, |
| 11122 | | src: LazySrcLoc, |
| 11123 | | operand: Air.Inst.Ref, |
| 11124 | | ) CompileError!Air.Inst.Ref { |
| 11057 | child_block: *Block, |
| 11058 | operand: SwitchOperand, |
| 11059 | raw_operand_ty: Type, |
| 11060 | operand_is_ref: bool, |
| 11061 | merges: *Block.Merges, |
| 11062 | switch_inst: Zir.Inst.Index, |
| 11063 | zir_switch: *const Zir.UnwrappedSwitchBlock, |
| 11064 | validated_switch: *const ValidatedSwitchBlock, |
| 11065 | ) CompileError!void { |
| 11125 | 11066 | const pt = sema.pt; |
| 11126 | 11067 | const zcu = pt.zcu; |
| 11127 | | const operand_ty = sema.typeOf(operand); |
| 11128 | | switch (operand_ty.zigTypeTag(zcu)) { |
| 11129 | | .type, |
| 11130 | | .void, |
| 11131 | | .bool, |
| 11132 | | .int, |
| 11133 | | .float, |
| 11134 | | .comptime_float, |
| 11135 | | .comptime_int, |
| 11136 | | .enum_literal, |
| 11137 | | .pointer, |
| 11138 | | .@"fn", |
| 11139 | | .error_set, |
| 11140 | | .@"enum", |
| 11141 | | => { |
| 11142 | | if (operand_ty.isSlice(zcu)) { |
| 11143 | | return sema.fail(block, src, "switch on type '{f}'", .{operand_ty.fmt(pt)}); |
| 11144 | | } |
| 11145 | | if ((try sema.typeHasOnePossibleValue(operand_ty))) |opv| { |
| 11146 | | return Air.internedToRef(opv.toIntern()); |
| 11147 | | } |
| 11148 | | return operand; |
| 11149 | | }, |
| 11068 | const ip = &zcu.intern_pool; |
| 11069 | const gpa = sema.gpa; |
| 11150 | 11070 | |
| 11151 | | .@"union" => { |
| 11152 | | try operand_ty.resolveFields(pt); |
| 11153 | | const enum_ty = operand_ty.unionTagType(zcu) orelse { |
| 11154 | | const msg = msg: { |
| 11155 | | const msg = try sema.errMsg(src, "switch on union with no attached enum", .{}); |
| 11156 | | errdefer msg.destroy(sema.gpa); |
| 11157 | | if (operand_ty.srcLocOrNull(zcu)) |union_src| { |
| 11158 | | try sema.errNote(union_src, msg, "consider 'union(enum)' here", .{}); |
| 11159 | | } |
| 11160 | | break :msg msg; |
| 11161 | | }; |
| 11162 | | return sema.failWithOwnedErrorMsg(block, msg); |
| 11163 | | }; |
| 11164 | | return sema.unionToTag(block, enum_ty, operand, src); |
| 11165 | | }, |
| 11071 | const src_node_offset = zir_switch.switch_src_node_offset; |
| 11072 | const src = block.nodeOffset(src_node_offset); |
| 11073 | const operand_src = block.src(.{ .node_offset_switch_operand = src_node_offset }); |
| 11166 | 11074 | |
| 11167 | | .error_union, |
| 11168 | | .noreturn, |
| 11169 | | .array, |
| 11170 | | .@"struct", |
| 11171 | | .undefined, |
| 11172 | | .null, |
| 11173 | | .optional, |
| 11174 | | .@"opaque", |
| 11175 | | .vector, |
| 11176 | | .frame, |
| 11177 | | .@"anyframe", |
| 11178 | | => return sema.fail(block, src, "switch on type '{f}'", .{operand_ty.fmt(pt)}), |
| 11179 | | } |
| 11180 | | } |
| 11075 | const has_else = zir_switch.else_case != null; |
| 11076 | const has_under = zir_switch.has_under; |
| 11181 | 11077 | |
| 11182 | | const SwitchErrorSet = std.AutoHashMap(InternPool.NullTerminatedString, LazySrcLoc); |
| 11078 | const else_case = validated_switch.else_case; |
| 11183 | 11079 | |
| 11184 | | fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { |
| 11185 | | const tracy = trace(@src()); |
| 11186 | | defer tracy.end(); |
| 11080 | const scalar_cases_len = zir_switch.scalarCasesLen(); |
| 11081 | const multi_cases_len = zir_switch.multiCasesLen(); |
| 11187 | 11082 | |
| 11188 | | const pt = sema.pt; |
| 11189 | | const zcu = pt.zcu; |
| 11190 | | const gpa = sema.gpa; |
| 11191 | | const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; |
| 11192 | | const switch_src = block.nodeOffset(inst_data.src_node); |
| 11193 | | const switch_src_node_offset = inst_data.src_node; |
| 11194 | | const switch_operand_src = block.src(.{ .node_offset_switch_operand = switch_src_node_offset }); |
| 11195 | | const else_prong_src = block.src(.{ .node_offset_switch_else_prong = switch_src_node_offset }); |
| 11196 | | const extra = sema.code.extraData(Zir.Inst.SwitchBlockErrUnion, inst_data.payload_index); |
| 11197 | | const main_operand_src = block.src(.{ .node_offset_if_cond = extra.data.main_src_node_offset }); |
| 11198 | | const main_src = block.src(.{ .node_offset_main_token = extra.data.main_src_node_offset }); |
| 11083 | const operand_ty = if (operand_is_ref) |
| 11084 | raw_operand_ty.childType(zcu) |
| 11085 | else |
| 11086 | raw_operand_ty; |
| 11199 | 11087 | |
| 11200 | | const raw_operand_val = try sema.resolveInst(extra.data.operand); |
| 11088 | const cond_ref = switch (operand) { |
| 11089 | .simple => |s| s.cond, |
| 11090 | .loop => |l| l.init_cond, |
| 11091 | }; |
| 11201 | 11092 | |
| 11202 | 11093 | // AstGen guarantees that the instruction immediately preceding |
| 11203 | | // switch_block_err_union is a dbg_stmt |
| 11204 | | const cond_dbg_node_index: Zir.Inst.Index = @enumFromInt(@intFromEnum(inst) - 1); |
| 11205 | | |
| 11206 | | var header_extra_index: usize = extra.end; |
| 11094 | // switch_block[_ref]/switch_block_err_union is a dbg_stmt. |
| 11095 | const cond_dbg_node_index: Zir.Inst.Index = @enumFromInt(@intFromEnum(switch_inst) - 1); |
| 11207 | 11096 | |
| 11208 | | const scalar_cases_len = extra.data.bits.scalar_cases_len; |
| 11209 | | const multi_cases_len = if (extra.data.bits.has_multi_cases) blk: { |
| 11210 | | const multi_cases_len = sema.code.extra[header_extra_index]; |
| 11211 | | header_extra_index += 1; |
| 11212 | | break :blk multi_cases_len; |
| 11213 | | } else 0; |
| 11097 | const else_is_named_only = has_else and has_under; |
| 11098 | const catch_all_case: CatchAllSwitchCase = |
| 11099 | if (has_under) .under else if (has_else) .@"else" else .none; |
| 11214 | 11100 | |
| 11215 | | const err_capture_inst: Zir.Inst.Index = if (extra.data.bits.any_uses_err_capture) blk: { |
| 11216 | | const err_capture_inst: Zir.Inst.Index = @enumFromInt(sema.code.extra[header_extra_index]); |
| 11217 | | header_extra_index += 1; |
| 11218 | | // SwitchProngAnalysis wants inst_map to have space for the tag capture. |
| 11219 | | // Note that the normal capture is referred to via the switch block |
| 11220 | | // index, which there is already necessarily space for. |
| 11221 | | try sema.inst_map.ensureSpaceForInstructions(gpa, &.{err_capture_inst}); |
| 11222 | | break :blk err_capture_inst; |
| 11223 | | } else undefined; |
| 11101 | const item_ty = switch (operand_ty.zigTypeTag(zcu)) { |
| 11102 | .@"union" => operand_ty.unionTagType(zcu).?, |
| 11103 | else => operand_ty, |
| 11104 | }; |
| 11105 | const union_originally = operand_ty.zigTypeTag(zcu) == .@"union"; |
| 11106 | const err_set = operand_ty.zigTypeTag(zcu) == .error_set; |
| 11224 | 11107 | |
| 11225 | | var case_vals = try std.ArrayList(Air.Inst.Ref).initCapacity(gpa, scalar_cases_len + 2 * multi_cases_len); |
| 11226 | | defer case_vals.deinit(gpa); |
| 11108 | const estimated_cases_len: u32 = scalar_cases_len + multi_cases_len + |
| 11109 | @intFromBool(has_else or has_under); |
| 11227 | 11110 | |
| 11228 | | const NonError = struct { |
| 11229 | | body: []const Zir.Inst.Index, |
| 11230 | | end: usize, |
| 11231 | | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 11111 | const BranchHints = struct { |
| 11112 | bags: std.ArrayList(u32), |
| 11113 | count: u32, |
| 11114 | const hints_per_bag = 10; |
| 11115 | fn ensureUnusedCapacity(hints: *@This(), gpa_inner: Allocator, additional_count: u32) Allocator.Error!void { |
| 11116 | const unused_hints = hints.bags.capacity * hints_per_bag - hints.count; |
| 11117 | if (unused_hints >= additional_count) return; |
| 11118 | const bags_required = std.math.divCeil(u32, hints.count + additional_count, hints_per_bag) catch unreachable; |
| 11119 | return hints.bags.ensureUnusedCapacity(gpa_inner, bags_required); |
| 11120 | } |
| 11121 | fn appendAssumeCapacity(hints: *@This(), hint: std.builtin.BranchHint) void { |
| 11122 | const idx_in_bag = hints.count % hints_per_bag; |
| 11123 | var bag: u32 = if (idx_in_bag > 0) hints.bags.pop().? else 0; |
| 11124 | bag |= @as(u32, @intFromEnum(hint)) << @intCast(@bitSizeOf(std.builtin.BranchHint) * idx_in_bag); |
| 11125 | hints.count += 1; |
| 11126 | return hints.bags.appendAssumeCapacity(bag); |
| 11127 | } |
| 11128 | fn append(hints: *@This(), gpa_inner: Allocator, hint: std.builtin.BranchHint) Allocator.Error!void { |
| 11129 | try hints.ensureUnusedCapacity(gpa_inner, 1); |
| 11130 | return hints.appendAssumeCapacity(hint); |
| 11131 | } |
| 11232 | 11132 | }; |
| 11233 | | |
| 11234 | | const non_error_case: NonError = non_error: { |
| 11235 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[header_extra_index]); |
| 11236 | | const extra_body_start = header_extra_index + 1; |
| 11237 | | break :non_error .{ |
| 11238 | | .body = sema.code.bodySlice(extra_body_start, info.body_len), |
| 11239 | | .end = extra_body_start + info.body_len, |
| 11240 | | .capture = info.capture, |
| 11241 | | }; |
| 11133 | var branch_hints: BranchHints = hints: { |
| 11134 | const num_bags = std.math.divCeil(u32, estimated_cases_len, BranchHints.hints_per_bag) catch unreachable; |
| 11135 | break :hints .{ .bags = try .initCapacity(gpa, num_bags), .count = 0 }; |
| 11242 | 11136 | }; |
| 11137 | defer branch_hints.bags.deinit(gpa); |
| 11243 | 11138 | |
| 11244 | | const Else = struct { |
| 11245 | | body: []const Zir.Inst.Index, |
| 11246 | | end: usize, |
| 11247 | | is_inline: bool, |
| 11248 | | has_capture: bool, |
| 11249 | | }; |
| 11250 | | |
| 11251 | | const else_case: Else = if (!extra.data.bits.has_else) .{ |
| 11252 | | .body = &.{}, |
| 11253 | | .end = non_error_case.end, |
| 11254 | | .is_inline = false, |
| 11255 | | .has_capture = false, |
| 11256 | | } else special: { |
| 11257 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[non_error_case.end]); |
| 11258 | | const extra_body_start = non_error_case.end + 1; |
| 11259 | | assert(info.capture != .by_ref); |
| 11260 | | assert(!info.has_tag_capture); |
| 11261 | | break :special .{ |
| 11262 | | .body = sema.code.bodySlice(extra_body_start, info.body_len), |
| 11263 | | .end = extra_body_start + info.body_len, |
| 11264 | | .is_inline = info.is_inline, |
| 11265 | | .has_capture = info.capture != .none, |
| 11266 | | }; |
| 11267 | | }; |
| 11139 | var cases_extra: std.ArrayList(u32) = try .initCapacity(gpa, estimated_cases_len * |
| 11140 | @typeInfo(Air.SwitchBr.Case).@"struct".fields.len); |
| 11141 | defer cases_extra.deinit(gpa); |
| 11268 | 11142 | |
| 11269 | | var seen_errors = SwitchErrorSet.init(gpa); |
| 11270 | | defer seen_errors.deinit(); |
| 11143 | // We will reuse this block for each case. |
| 11144 | var case_block = child_block.makeSubBlock(); |
| 11145 | case_block.runtime_loop = null; |
| 11146 | case_block.runtime_cond = operand_src; |
| 11147 | case_block.runtime_index.increment(); |
| 11148 | case_block.need_debug_scope = null; // this body is emitted regardless |
| 11149 | defer case_block.instructions.deinit(gpa); |
| 11271 | 11150 | |
| 11272 | | const operand_ty = sema.typeOf(raw_operand_val); |
| 11273 | | const operand_err_set = if (extra.data.bits.payload_is_ref) |
| 11274 | | operand_ty.childType(zcu) |
| 11275 | | else |
| 11276 | | operand_ty; |
| 11151 | const case_vals = validated_switch.case_vals; |
| 11152 | var case_val_idx: usize = 0; |
| 11153 | var case_it = zir_switch.iterateCases(); |
| 11154 | var extra_index = zir_switch.end; |
| 11277 | 11155 | |
| 11278 | | if (operand_err_set.zigTypeTag(zcu) != .error_union) { |
| 11279 | | return sema.fail(block, switch_src, "expected error union type, found '{f}'", .{ |
| 11280 | | operand_ty.fmt(pt), |
| 11281 | | }); |
| 11282 | | } |
| 11156 | var under_prong: ?struct { |
| 11157 | index: Zir.UnwrappedSwitchBlock.Case.Index, |
| 11158 | body: []const Zir.Inst.Index, |
| 11159 | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 11160 | has_tag_capture: bool, |
| 11161 | } = null; |
| 11283 | 11162 | |
| 11284 | | const operand_err_set_ty = operand_err_set.errorUnionSet(zcu); |
| 11163 | var cases_len: u32 = 0; |
| 11164 | while (case_it.next()) |case| { |
| 11165 | const item_refs = case_vals[case_val_idx..][0..case.item_infos.len]; |
| 11166 | case_val_idx += item_refs.len; |
| 11167 | const range_refs: []const [2]Air.Inst.Ref = |
| 11168 | @ptrCast(case_vals[case_val_idx..][0 .. 2 * case.range_infos.len]); |
| 11169 | case_val_idx += 2 * range_refs.len; |
| 11285 | 11170 | |
| 11286 | | const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); |
| 11287 | | try sema.air_instructions.append(gpa, .{ |
| 11288 | | .tag = .block, |
| 11289 | | .data = undefined, |
| 11290 | | }); |
| 11291 | | var label: Block.Label = .{ |
| 11292 | | .zir_block = inst, |
| 11293 | | .merges = .{ |
| 11294 | | .src_locs = .{}, |
| 11295 | | .results = .{}, |
| 11296 | | .br_list = .{}, |
| 11297 | | .block_inst = block_inst, |
| 11298 | | }, |
| 11299 | | }; |
| 11171 | const prong_info = case.prong_info; |
| 11172 | const prong_body = sema.code.bodySlice(extra_index, prong_info.body_len); |
| 11173 | extra_index += prong_body.len; |
| 11300 | 11174 | |
| 11301 | | var child_block: Block = .{ |
| 11302 | | .parent = block, |
| 11303 | | .sema = sema, |
| 11304 | | .namespace = block.namespace, |
| 11305 | | .instructions = .{}, |
| 11306 | | .label = &label, |
| 11307 | | .inlining = block.inlining, |
| 11308 | | .comptime_reason = block.comptime_reason, |
| 11309 | | .is_typeof = block.is_typeof, |
| 11310 | | .c_import_buf = block.c_import_buf, |
| 11311 | | .runtime_cond = block.runtime_cond, |
| 11312 | | .runtime_loop = block.runtime_loop, |
| 11313 | | .runtime_index = block.runtime_index, |
| 11314 | | .error_return_trace_index = block.error_return_trace_index, |
| 11315 | | .want_safety = block.want_safety, |
| 11316 | | .src_base_inst = block.src_base_inst, |
| 11317 | | .type_name_ctx = block.type_name_ctx, |
| 11318 | | }; |
| 11319 | | const merges = &child_block.label.?.merges; |
| 11320 | | defer child_block.instructions.deinit(gpa); |
| 11321 | | defer merges.deinit(gpa); |
| 11175 | // Enough capacity for inlining regular items, we can't really predict |
| 11176 | // how many range items we will end up with (at least not in a safe and |
| 11177 | // cheap manner) so we allocate on demand for those. |
| 11178 | if (prong_info.is_inline) { |
| 11179 | try branch_hints.ensureUnusedCapacity(gpa, @intCast(case.item_infos.len)); |
| 11180 | } |
| 11322 | 11181 | |
| 11323 | | const resolved_err_set = try sema.resolveInferredErrorSetTy(block, main_src, operand_err_set_ty.toIntern()); |
| 11324 | | if (Type.fromInterned(resolved_err_set).errorSetIsEmpty(zcu)) { |
| 11325 | | return sema.resolveBlockBody(block, main_operand_src, &child_block, non_error_case.body, inst, merges); |
| 11326 | | } |
| 11182 | var emit_bb = false; |
| 11183 | var any_analyze_body = false; |
| 11184 | var is_under_prong = false; |
| 11185 | for (case.item_infos, item_refs, 0..) |item_info, item_ref, item_i| { |
| 11186 | if (item_ref == .none) is_under_prong = true; |
| 11187 | if (item_info.bodyLen()) |body_len| extra_index += body_len; |
| 11327 | 11188 | |
| 11328 | | const else_error_ty: ?Type = try validateErrSetSwitch( |
| 11329 | | sema, |
| 11330 | | block, |
| 11331 | | &seen_errors, |
| 11332 | | &case_vals, |
| 11333 | | operand_err_set_ty, |
| 11334 | | inst_data, |
| 11335 | | scalar_cases_len, |
| 11336 | | multi_cases_len, |
| 11337 | | .{ .body = else_case.body, .end = else_case.end, .src = else_prong_src }, |
| 11338 | | extra.data.bits.has_else, |
| 11339 | | ); |
| 11189 | const analyze_body = sema.wantSwitchProngBodyAnalysis(block, item_ref, operand_ty, union_originally, err_set, prong_info.is_comptime_unreach); |
| 11190 | if (analyze_body) any_analyze_body = true; |
| 11340 | 11191 | |
| 11341 | | var spa: SwitchProngAnalysis = .{ |
| 11342 | | .sema = sema, |
| 11343 | | .parent_block = block, |
| 11344 | | .operand = .{ |
| 11345 | | .simple = .{ |
| 11346 | | .by_val = undefined, // must be set to the unwrapped error code before use |
| 11347 | | .by_ref = undefined, |
| 11348 | | .cond = raw_operand_val, |
| 11349 | | }, |
| 11350 | | }, |
| 11351 | | .else_error_ty = else_error_ty, |
| 11352 | | .switch_block_inst = inst, |
| 11353 | | .tag_capture_inst = undefined, |
| 11354 | | }; |
| 11192 | if (prong_info.is_inline) { |
| 11193 | cases_len += 1; |
| 11194 | case_block.instructions.clearRetainingCapacity(); |
| 11195 | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 11355 | 11196 | |
| 11356 | | if (try sema.resolveDefinedValue(&child_block, main_src, raw_operand_val)) |ov| { |
| 11357 | | const operand_val = if (extra.data.bits.payload_is_ref) |
| 11358 | | (try sema.pointerDeref(&child_block, main_src, ov, operand_ty)).? |
| 11359 | | else |
| 11360 | | ov; |
| 11197 | if (emit_bb) { |
| 11198 | const bb_src = block.src(.{ .switch_case_item = .{ |
| 11199 | .switch_node_offset = src_node_offset, |
| 11200 | .case_idx = case.index, |
| 11201 | .item_idx = .{ .kind = .single, .value = @intCast(item_i) }, |
| 11202 | } }); |
| 11203 | try sema.emitBackwardBranch(block, bb_src); |
| 11204 | } |
| 11205 | emit_bb = true; |
| 11361 | 11206 | |
| 11362 | | if (operand_val.errorUnionIsPayload(zcu)) { |
| 11363 | | return sema.resolveBlockBody(block, main_operand_src, &child_block, non_error_case.body, inst, merges); |
| 11364 | | } else { |
| 11365 | | const err_val = Value.fromInterned(try pt.intern(.{ |
| 11366 | | .err = .{ |
| 11367 | | .ty = operand_err_set_ty.toIntern(), |
| 11368 | | .name = operand_val.getErrorName(zcu).unwrap().?, |
| 11369 | | }, |
| 11370 | | })); |
| 11371 | | spa.operand.simple.by_val = if (extra.data.bits.payload_is_ref) |
| 11372 | | try sema.analyzeErrUnionCodePtr(block, switch_operand_src, raw_operand_val) |
| 11373 | | else |
| 11374 | | try sema.analyzeErrUnionCode(block, switch_operand_src, raw_operand_val); |
| 11207 | const prong_hint: std.builtin.BranchHint = hint: { |
| 11208 | if (analyze_body) break :hint try sema.analyzeSwitchProng( |
| 11209 | &case_block, |
| 11210 | operand, |
| 11211 | operand_ty, |
| 11212 | raw_operand_ty, |
| 11213 | prong_body, |
| 11214 | block.src(.{ .switch_capture = .{ |
| 11215 | .switch_node_offset = src_node_offset, |
| 11216 | .case_idx = case.index, |
| 11217 | } }), |
| 11218 | prong_info.capture, |
| 11219 | prong_info.has_tag_capture, |
| 11220 | item_ref, |
| 11221 | .{ .item_refs = &.{item_ref} }, |
| 11222 | validated_switch.else_err_ty, |
| 11223 | switch_inst, |
| 11224 | zir_switch, |
| 11225 | ); |
| 11226 | _ = try case_block.addNoOp(.unreach); |
| 11227 | break :hint .cold; // unreachable branches are cold |
| 11228 | }; |
| 11229 | branch_hints.appendAssumeCapacity(prong_hint); |
| 11375 | 11230 | |
| 11376 | | if (extra.data.bits.any_uses_err_capture) { |
| 11377 | | sema.inst_map.putAssumeCapacity(err_capture_inst, spa.operand.simple.by_val); |
| 11231 | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 11232 | 1 + // `item`, no ranges |
| 11233 | case_block.instructions.items.len); |
| 11234 | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 11235 | .items_len = 1, |
| 11236 | .ranges_len = 0, |
| 11237 | .body_len = @intCast(case_block.instructions.items.len), |
| 11238 | })); |
| 11239 | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 11240 | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 11378 | 11241 | } |
| 11379 | | defer if (extra.data.bits.any_uses_err_capture) assert(sema.inst_map.remove(err_capture_inst)); |
| 11380 | | |
| 11381 | | return resolveSwitchComptime( |
| 11382 | | sema, |
| 11383 | | spa, |
| 11384 | | &child_block, |
| 11385 | | try sema.switchCond(block, switch_operand_src, spa.operand.simple.by_val), |
| 11386 | | err_val, |
| 11387 | | operand_err_set_ty, |
| 11388 | | switch_src_node_offset, |
| 11389 | | null, |
| 11390 | | .{ |
| 11391 | | .body = else_case.body, |
| 11392 | | .end = else_case.end, |
| 11393 | | .capture = if (else_case.has_capture) .by_val else .none, |
| 11394 | | .is_inline = else_case.is_inline, |
| 11395 | | .has_tag_capture = false, |
| 11396 | | }, |
| 11397 | | false, |
| 11398 | | case_vals, |
| 11399 | | scalar_cases_len, |
| 11400 | | multi_cases_len, |
| 11401 | | true, |
| 11402 | | false, |
| 11403 | | ); |
| 11404 | 11242 | } |
| 11405 | | } |
| 11243 | for (case.range_infos, range_refs, 0..) |range_info, range_ref, range_i| { |
| 11244 | if (range_info[0].bodyLen()) |body_len| extra_index += body_len; |
| 11245 | if (range_info[1].bodyLen()) |body_len| extra_index += body_len; |
| 11406 | 11246 | |
| 11407 | | if (scalar_cases_len + multi_cases_len == 0) { |
| 11408 | | if (else_error_ty) |ty| if (ty.errorSetIsEmpty(zcu)) { |
| 11409 | | return sema.resolveBlockBody(block, main_operand_src, &child_block, non_error_case.body, inst, merges); |
| 11410 | | }; |
| 11411 | | } |
| 11412 | | |
| 11413 | | if (child_block.isComptime()) { |
| 11414 | | _ = try sema.resolveConstDefinedValue(&child_block, main_operand_src, raw_operand_val, null); |
| 11415 | | unreachable; |
| 11416 | | } |
| 11247 | any_analyze_body = true; // always an integer range, always needs analysis |
| 11417 | 11248 | |
| 11418 | | const cond = if (extra.data.bits.payload_is_ref) blk: { |
| 11419 | | try sema.checkErrorType(block, main_src, sema.typeOf(raw_operand_val).elemType2(zcu)); |
| 11420 | | const loaded = try sema.analyzeLoad(block, main_src, raw_operand_val, main_src); |
| 11421 | | break :blk try sema.analyzeIsNonErr(block, main_src, loaded); |
| 11422 | | } else blk: { |
| 11423 | | try sema.checkErrorType(block, main_src, sema.typeOf(raw_operand_val)); |
| 11424 | | break :blk try sema.analyzeIsNonErr(block, main_src, raw_operand_val); |
| 11425 | | }; |
| 11249 | if (prong_info.is_inline) { |
| 11250 | var item = sema.resolveConstDefinedValue(block, .unneeded, range_ref[0], undefined) catch unreachable; |
| 11251 | const item_last = sema.resolveConstDefinedValue(block, .unneeded, range_ref[1], undefined) catch unreachable; |
| 11426 | 11252 | |
| 11427 | | var sub_block = child_block.makeSubBlock(); |
| 11428 | | sub_block.runtime_loop = null; |
| 11429 | | sub_block.runtime_cond = main_operand_src; |
| 11430 | | sub_block.runtime_index.increment(); |
| 11431 | | sub_block.need_debug_scope = null; // this body is emitted regardless |
| 11432 | | defer sub_block.instructions.deinit(gpa); |
| 11253 | if (try item.getUnsignedIntSema(pt)) |first_int| { |
| 11254 | if (try item_last.getUnsignedIntSema(pt)) |last_int| { |
| 11255 | if (std.math.cast(u32, last_int - first_int)) |range_len| { |
| 11256 | try branch_hints.ensureUnusedCapacity(gpa, range_len); |
| 11257 | } |
| 11258 | } |
| 11259 | } |
| 11433 | 11260 | |
| 11434 | | const non_error_hint = try sema.analyzeBodyRuntimeBreak(&sub_block, non_error_case.body); |
| 11435 | | const true_instructions = try sub_block.instructions.toOwnedSlice(gpa); |
| 11436 | | defer gpa.free(true_instructions); |
| 11261 | var prev_result_overflowed = false; |
| 11262 | while (item.compareScalar(.lte, item_last, operand_ty, zcu)) : ({ |
| 11263 | // Previous validation has resolved any possible lazy values. |
| 11264 | const int_val: Value, const int_ty: Type = switch (operand_ty.zigTypeTag(zcu)) { |
| 11265 | .int => .{ item, operand_ty }, |
| 11266 | .@"enum" => b: { |
| 11267 | const int_val: Value = .fromInterned(ip.indexToKey(item.toIntern()).enum_tag.int); |
| 11268 | break :b .{ int_val, int_val.typeOf(zcu) }; |
| 11269 | }, |
| 11270 | else => unreachable, |
| 11271 | }; |
| 11272 | assert(!prev_result_overflowed); |
| 11273 | const result = try arith.incrementDefinedInt(sema, int_ty, int_val); |
| 11274 | prev_result_overflowed = result.overflow; |
| 11275 | item = switch (operand_ty.zigTypeTag(zcu)) { |
| 11276 | .int => result.val, |
| 11277 | .@"enum" => .fromInterned(try pt.intern(.{ .enum_tag = .{ |
| 11278 | .ty = operand_ty.toIntern(), |
| 11279 | .int = result.val.toIntern(), |
| 11280 | } })), |
| 11281 | else => unreachable, |
| 11282 | }; |
| 11283 | }) { |
| 11284 | cases_len += 1; |
| 11285 | case_block.instructions.clearRetainingCapacity(); |
| 11286 | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 11437 | 11287 | |
| 11438 | | spa.operand.simple.by_val = if (extra.data.bits.payload_is_ref) |
| 11439 | | try sema.analyzeErrUnionCodePtr(&sub_block, switch_operand_src, raw_operand_val) |
| 11440 | | else |
| 11441 | | try sema.analyzeErrUnionCode(&sub_block, switch_operand_src, raw_operand_val); |
| 11442 | | |
| 11443 | | if (extra.data.bits.any_uses_err_capture) { |
| 11444 | | sema.inst_map.putAssumeCapacity(err_capture_inst, spa.operand.simple.by_val); |
| 11445 | | } |
| 11446 | | defer if (extra.data.bits.any_uses_err_capture) assert(sema.inst_map.remove(err_capture_inst)); |
| 11447 | | _ = try sema.analyzeSwitchRuntimeBlock( |
| 11448 | | spa, |
| 11449 | | &sub_block, |
| 11450 | | switch_src, |
| 11451 | | try sema.switchCond(block, switch_operand_src, spa.operand.simple.by_val), |
| 11452 | | operand_err_set_ty, |
| 11453 | | switch_operand_src, |
| 11454 | | case_vals, |
| 11455 | | .{ |
| 11456 | | .body = else_case.body, |
| 11457 | | .end = else_case.end, |
| 11458 | | .capture = if (else_case.has_capture) .by_val else .none, |
| 11459 | | .is_inline = else_case.is_inline, |
| 11460 | | .has_tag_capture = false, |
| 11461 | | }, |
| 11462 | | scalar_cases_len, |
| 11463 | | multi_cases_len, |
| 11464 | | false, |
| 11465 | | undefined, |
| 11466 | | true, |
| 11467 | | switch_src_node_offset, |
| 11468 | | else_prong_src, |
| 11469 | | false, |
| 11470 | | undefined, |
| 11471 | | seen_errors, |
| 11472 | | undefined, |
| 11473 | | undefined, |
| 11474 | | undefined, |
| 11475 | | cond_dbg_node_index, |
| 11476 | | true, |
| 11477 | | null, |
| 11478 | | undefined, |
| 11479 | | &.{}, |
| 11480 | | &.{}, |
| 11481 | | ); |
| 11288 | const item_ref: Air.Inst.Ref = .fromValue(item); |
| 11482 | 11289 | |
| 11483 | | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.CondBr).@"struct".fields.len + |
| 11484 | | true_instructions.len + sub_block.instructions.items.len); |
| 11290 | if (emit_bb) { |
| 11291 | const bb_src = block.src(.{ .switch_case_item = .{ |
| 11292 | .switch_node_offset = src_node_offset, |
| 11293 | .case_idx = case.index, |
| 11294 | .item_idx = .{ .kind = .range, .value = @intCast(range_i) }, |
| 11295 | } }); |
| 11296 | try sema.emitBackwardBranch(block, bb_src); |
| 11297 | } |
| 11298 | emit_bb = true; |
| 11485 | 11299 | |
| 11486 | | _ = try child_block.addInst(.{ |
| 11487 | | .tag = .cond_br, |
| 11488 | | .data = .{ |
| 11489 | | .pl_op = .{ |
| 11490 | | .operand = cond, |
| 11491 | | .payload = sema.addExtraAssumeCapacity(Air.CondBr{ |
| 11492 | | .then_body_len = @intCast(true_instructions.len), |
| 11493 | | .else_body_len = @intCast(sub_block.instructions.items.len), |
| 11494 | | .branch_hints = .{ |
| 11495 | | .true = non_error_hint, |
| 11496 | | .false = .none, |
| 11497 | | // Code coverage is desired for error handling. |
| 11498 | | .then_cov = .poi, |
| 11499 | | .else_cov = .poi, |
| 11500 | | }, |
| 11501 | | }), |
| 11502 | | }, |
| 11503 | | }, |
| 11504 | | }); |
| 11505 | | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(true_instructions)); |
| 11506 | | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(sub_block.instructions.items)); |
| 11300 | const prong_hint = try sema.analyzeSwitchProng( |
| 11301 | &case_block, |
| 11302 | operand, |
| 11303 | operand_ty, |
| 11304 | raw_operand_ty, |
| 11305 | prong_body, |
| 11306 | block.src(.{ .switch_capture = .{ |
| 11307 | .switch_node_offset = src_node_offset, |
| 11308 | .case_idx = case.index, |
| 11309 | } }), |
| 11310 | prong_info.capture, |
| 11311 | prong_info.has_tag_capture, |
| 11312 | item_ref, |
| 11313 | .has_ranges, |
| 11314 | validated_switch.else_err_ty, |
| 11315 | switch_inst, |
| 11316 | zir_switch, |
| 11317 | ); |
| 11318 | try branch_hints.append(gpa, prong_hint); |
| 11507 | 11319 | |
| 11508 | | return sema.resolveAnalyzedBlock(block, main_src, &child_block, merges, false); |
| 11509 | | } |
| 11320 | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 11321 | 1 + // `item`, no ranges |
| 11322 | case_block.instructions.items.len); |
| 11323 | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 11324 | .items_len = 1, |
| 11325 | .ranges_len = 0, |
| 11326 | .body_len = @intCast(case_block.instructions.items.len), |
| 11327 | })); |
| 11328 | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 11329 | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 11330 | } |
| 11331 | } |
| 11332 | } |
| 11510 | 11333 | |
| 11511 | | fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_ref: bool) CompileError!Air.Inst.Ref { |
| 11512 | | const tracy = trace(@src()); |
| 11513 | | defer tracy.end(); |
| 11334 | if (prong_info.is_inline) continue; // handled above |
| 11514 | 11335 | |
| 11515 | | const pt = sema.pt; |
| 11516 | | const zcu = pt.zcu; |
| 11517 | | const ip = &zcu.intern_pool; |
| 11518 | | const gpa = sema.gpa; |
| 11519 | | const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; |
| 11520 | | const src = block.nodeOffset(inst_data.src_node); |
| 11521 | | const src_node_offset = inst_data.src_node; |
| 11522 | | const operand_src = block.src(.{ .node_offset_switch_operand = src_node_offset }); |
| 11523 | | const else_prong_src = block.src(.{ .node_offset_switch_else_prong = src_node_offset }); |
| 11524 | | const under_prong_src = block.src(.{ .node_offset_switch_under_prong = src_node_offset }); |
| 11525 | | const extra = sema.code.extraData(Zir.Inst.SwitchBlock, inst_data.payload_index); |
| 11336 | if (is_under_prong) { |
| 11337 | under_prong = .{ |
| 11338 | .index = case.index, |
| 11339 | .body = prong_body, |
| 11340 | .capture = case.prong_info.capture, |
| 11341 | .has_tag_capture = case.prong_info.has_tag_capture, |
| 11342 | }; |
| 11343 | continue; |
| 11344 | } |
| 11526 | 11345 | |
| 11527 | | const operand: SwitchProngAnalysis.Operand, const raw_operand_ty: Type = op: { |
| 11528 | | const maybe_ptr = try sema.resolveInst(extra.data.operand); |
| 11529 | | const val, const ref = if (operand_is_ref) |
| 11530 | | .{ try sema.analyzeLoad(block, src, maybe_ptr, operand_src), maybe_ptr } |
| 11531 | | else |
| 11532 | | .{ maybe_ptr, undefined }; |
| 11346 | cases_len += 1; |
| 11347 | case_block.instructions.clearRetainingCapacity(); |
| 11348 | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 11533 | 11349 | |
| 11534 | | const init_cond = try sema.switchCond(block, operand_src, val); |
| 11350 | const prong_hint: std.builtin.BranchHint = hint: { |
| 11351 | if (any_analyze_body) break :hint try sema.analyzeSwitchProng( |
| 11352 | &case_block, |
| 11353 | operand, |
| 11354 | operand_ty, |
| 11355 | raw_operand_ty, |
| 11356 | prong_body, |
| 11357 | block.src(.{ .switch_capture = .{ |
| 11358 | .switch_node_offset = src_node_offset, |
| 11359 | .case_idx = case.index, |
| 11360 | } }), |
| 11361 | prong_info.capture, |
| 11362 | prong_info.has_tag_capture, |
| 11363 | .none, |
| 11364 | .{ .item_refs = item_refs }, |
| 11365 | validated_switch.else_err_ty, |
| 11366 | switch_inst, |
| 11367 | zir_switch, |
| 11368 | ); |
| 11369 | _ = try case_block.addNoOp(.unreach); |
| 11370 | break :hint .cold; // unreachable branches are cold |
| 11371 | }; |
| 11372 | try branch_hints.append(gpa, prong_hint); |
| 11535 | 11373 | |
| 11536 | | const operand_ty = sema.typeOf(val); |
| 11374 | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 11375 | item_refs.len + |
| 11376 | 2 * range_refs.len + |
| 11377 | case_block.instructions.items.len); |
| 11378 | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 11379 | .items_len = @intCast(item_refs.len), |
| 11380 | .ranges_len = @intCast(range_refs.len), |
| 11381 | .body_len = @intCast(case_block.instructions.items.len), |
| 11382 | })); |
| 11383 | cases_extra.appendSliceAssumeCapacity(@ptrCast(item_refs)); |
| 11384 | cases_extra.appendSliceAssumeCapacity(@ptrCast(range_refs)); |
| 11385 | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 11386 | } |
| 11537 | 11387 | |
| 11538 | | if (extra.data.bits.has_continue and !block.isComptime()) { |
| 11539 | | // Even if the operand is comptime-known, this `switch` is runtime. |
| 11540 | | if (try operand_ty.comptimeOnlySema(pt)) { |
| 11541 | | return sema.failWithOwnedErrorMsg(block, msg: { |
| 11542 | | const msg = try sema.errMsg(operand_src, "operand of switch loop has comptime-only type '{f}'", .{operand_ty.fmt(pt)}); |
| 11543 | | errdefer msg.destroy(gpa); |
| 11544 | | try sema.errNote(operand_src, msg, "switch loops are evaluated at runtime outside of comptime scopes", .{}); |
| 11545 | | break :msg msg; |
| 11388 | const catch_all_extra: []const u32 = catch_all_extra: { |
| 11389 | if (catch_all_case == .none and !case_block.wantSafety()) { |
| 11390 | try branch_hints.append(gpa, .none); |
| 11391 | break :catch_all_extra &.{}; |
| 11392 | } |
| 11393 | var emit_bb = false; |
| 11394 | if (has_else and else_case.is_inline) { |
| 11395 | const else_prong_src = block.src(.{ .node_offset_switch_else_prong = src_node_offset }); |
| 11396 | var error_names: InternPool.NullTerminatedString.Slice = undefined; |
| 11397 | var min_int: Value = undefined; |
| 11398 | check_enumerable: { |
| 11399 | switch (item_ty.zigTypeTag(zcu)) { |
| 11400 | .@"union" => unreachable, |
| 11401 | .@"enum" => if (else_is_named_only or |
| 11402 | !item_ty.isNonexhaustiveEnum(zcu) or union_originally) |
| 11403 | { |
| 11404 | try branch_hints.ensureUnusedCapacity(gpa, @intCast(validated_switch.seen_enum_fields.len)); |
| 11405 | break :check_enumerable; |
| 11406 | }, |
| 11407 | .error_set => if (!operand_ty.isAnyError(zcu)) { |
| 11408 | error_names = item_ty.errorSetNames(zcu); |
| 11409 | try branch_hints.ensureUnusedCapacity(gpa, error_names.len); |
| 11410 | break :check_enumerable; |
| 11411 | }, |
| 11412 | .int => { |
| 11413 | min_int = try item_ty.minInt(pt, item_ty); |
| 11414 | break :check_enumerable; |
| 11415 | }, |
| 11416 | .bool, .void => break :check_enumerable, |
| 11417 | else => {}, |
| 11418 | } |
| 11419 | return sema.fail(block, else_prong_src, "cannot enumerate values of type '{f}' for 'inline else'", .{ |
| 11420 | item_ty.fmt(pt), |
| 11546 | 11421 | }); |
| 11547 | 11422 | } |
| 11548 | | try sema.validateRuntimeValue(block, operand_src, maybe_ptr); |
| 11549 | | const operand_alloc = if (extra.data.bits.any_non_inline_capture) a: { |
| 11550 | | const operand_ptr_ty = try pt.singleMutPtrType(sema.typeOf(maybe_ptr)); |
| 11551 | | const operand_alloc = try block.addTy(.alloc, operand_ptr_ty); |
| 11552 | | _ = try block.addBinOp(.store, operand_alloc, maybe_ptr); |
| 11553 | | break :a operand_alloc; |
| 11554 | | } else undefined; |
| 11555 | | break :op .{ |
| 11556 | | .{ .loop = .{ |
| 11557 | | .operand_alloc = operand_alloc, |
| 11558 | | .operand_is_ref = operand_is_ref, |
| 11559 | | .init_cond = init_cond, |
| 11560 | | } }, |
| 11561 | | operand_ty, |
| 11562 | | }; |
| 11563 | | } |
| 11423 | var unhandled_it = validated_switch.iterateUnhandledItems(error_names, min_int); |
| 11424 | while (try unhandled_it.next(sema, item_ty)) |item_val| { |
| 11425 | cases_len += 1; |
| 11426 | case_block.instructions.clearRetainingCapacity(); |
| 11427 | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 11564 | 11428 | |
| 11565 | | // We always use `simple` in the comptime case, because as far as the dispatching logic |
| 11566 | | // is concerned, it really is dispatching a single prong. `resolveSwitchComptime` will |
| 11567 | | // be resposible for recursively resolving different prongs as needed. |
| 11568 | | break :op .{ |
| 11569 | | .{ .simple = .{ |
| 11570 | | .by_val = val, |
| 11571 | | .by_ref = ref, |
| 11572 | | .cond = init_cond, |
| 11573 | | } }, |
| 11574 | | operand_ty, |
| 11575 | | }; |
| 11576 | | }; |
| 11429 | const item_ref: Air.Inst.Ref = .fromValue(item_val); |
| 11577 | 11430 | |
| 11578 | | const union_originally = raw_operand_ty.zigTypeTag(zcu) == .@"union"; |
| 11579 | | const err_set = raw_operand_ty.zigTypeTag(zcu) == .error_set; |
| 11580 | | const cond_ty = switch (raw_operand_ty.zigTypeTag(zcu)) { |
| 11581 | | .@"union" => raw_operand_ty.unionTagType(zcu).?, // validated by `switchCond` above |
| 11582 | | else => raw_operand_ty, |
| 11583 | | }; |
| 11431 | const analyze_body = sema.wantSwitchProngBodyAnalysis(block, item_ref, operand_ty, union_originally, err_set, false); |
| 11584 | 11432 | |
| 11585 | | // AstGen guarantees that the instruction immediately preceding |
| 11586 | | // switch_block(_ref) is a dbg_stmt |
| 11587 | | const cond_dbg_node_index: Zir.Inst.Index = @enumFromInt(@intFromEnum(inst) - 1); |
| 11433 | if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); |
| 11434 | emit_bb = true; |
| 11588 | 11435 | |
| 11589 | | var header_extra_index: usize = extra.end; |
| 11436 | const prong_hint: std.builtin.BranchHint = hint: { |
| 11437 | if (analyze_body) break :hint try sema.analyzeSwitchProng( |
| 11438 | &case_block, |
| 11439 | operand, |
| 11440 | operand_ty, |
| 11441 | raw_operand_ty, |
| 11442 | else_case.body, |
| 11443 | block.src(.{ .switch_capture = .{ |
| 11444 | .switch_node_offset = src_node_offset, |
| 11445 | .case_idx = else_case.index, |
| 11446 | } }), |
| 11447 | else_case.capture, |
| 11448 | else_case.has_tag_capture, |
| 11449 | item_ref, |
| 11450 | .special, |
| 11451 | validated_switch.else_err_ty, |
| 11452 | switch_inst, |
| 11453 | zir_switch, |
| 11454 | ); |
| 11455 | _ = try case_block.addNoOp(.unreach); |
| 11456 | break :hint .cold; // unreachable branches are cold |
| 11457 | }; |
| 11458 | try branch_hints.append(gpa, prong_hint); |
| 11590 | 11459 | |
| 11591 | | const scalar_cases_len = extra.data.bits.scalar_cases_len; |
| 11592 | | const multi_cases_len = if (extra.data.bits.has_multi_cases) blk: { |
| 11593 | | const multi_cases_len = sema.code.extra[header_extra_index]; |
| 11594 | | header_extra_index += 1; |
| 11595 | | break :blk multi_cases_len; |
| 11596 | | } else 0; |
| 11460 | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 11461 | 1 + // `item`, no ranges |
| 11462 | case_block.instructions.items.len); |
| 11463 | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 11464 | .items_len = 1, |
| 11465 | .ranges_len = 0, |
| 11466 | .body_len = @intCast(case_block.instructions.items.len), |
| 11467 | })); |
| 11468 | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 11469 | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 11470 | } |
| 11471 | } |
| 11597 | 11472 | |
| 11598 | | const tag_capture_inst: Zir.Inst.Index = if (extra.data.bits.any_has_tag_capture) blk: { |
| 11599 | | const tag_capture_inst: Zir.Inst.Index = @enumFromInt(sema.code.extra[header_extra_index]); |
| 11600 | | header_extra_index += 1; |
| 11601 | | // SwitchProngAnalysis wants inst_map to have space for the tag capture. |
| 11602 | | // Note that the normal capture is referred to via the switch block |
| 11603 | | // index, which there is already necessarily space for. |
| 11604 | | try sema.inst_map.ensureSpaceForInstructions(gpa, &.{tag_capture_inst}); |
| 11605 | | break :blk tag_capture_inst; |
| 11606 | | } else undefined; |
| 11473 | case_block.instructions.clearRetainingCapacity(); |
| 11474 | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 11607 | 11475 | |
| 11608 | | var case_vals = try std.ArrayList(Air.Inst.Ref).initCapacity(gpa, scalar_cases_len + 2 * multi_cases_len); |
| 11609 | | defer case_vals.deinit(gpa); |
| 11610 | | |
| 11611 | | var single_absorbed_item: Zir.Inst.Ref = .none; |
| 11612 | | var absorbed_items: []const Zir.Inst.Ref = &.{}; |
| 11613 | | var absorbed_ranges: []const Zir.Inst.Ref = &.{}; |
| 11614 | | |
| 11615 | | const special_prongs = extra.data.bits.special_prongs; |
| 11616 | | const has_else = special_prongs.hasElse(); |
| 11617 | | const has_under = special_prongs.hasUnder(); |
| 11618 | | const special_else: SpecialProng = if (has_else) blk: { |
| 11619 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[header_extra_index]); |
| 11620 | | const extra_body_start = header_extra_index + 1; |
| 11621 | | break :blk .{ |
| 11622 | | .body = sema.code.bodySlice(extra_body_start, info.body_len), |
| 11623 | | .end = extra_body_start + info.body_len, |
| 11624 | | .capture = info.capture, |
| 11625 | | .is_inline = info.is_inline, |
| 11626 | | .has_tag_capture = info.has_tag_capture, |
| 11627 | | }; |
| 11628 | | } else .{ |
| 11629 | | .body = &.{}, |
| 11630 | | .end = header_extra_index, |
| 11631 | | .capture = .none, |
| 11632 | | .is_inline = false, |
| 11633 | | .has_tag_capture = false, |
| 11634 | | }; |
| 11635 | | const special_under: SpecialProng = if (has_under) blk: { |
| 11636 | | var extra_index = special_else.end; |
| 11637 | | var trailing_items_len: usize = 0; |
| 11638 | | if (special_prongs.hasOneAdditionalItem()) { |
| 11639 | | single_absorbed_item = @enumFromInt(sema.code.extra[extra_index]); |
| 11640 | | extra_index += 1; |
| 11641 | | absorbed_items = @ptrCast(&single_absorbed_item); |
| 11642 | | } else if (special_prongs.hasManyAdditionalItems()) { |
| 11643 | | const items_len = sema.code.extra[extra_index]; |
| 11644 | | extra_index += 1; |
| 11645 | | const ranges_len = sema.code.extra[extra_index]; |
| 11646 | | extra_index += 1; |
| 11647 | | absorbed_items = sema.code.refSlice(extra_index + 1, items_len); |
| 11648 | | absorbed_ranges = sema.code.refSlice(extra_index + 1 + items_len, ranges_len * 2); |
| 11649 | | trailing_items_len = items_len + ranges_len * 2; |
| 11650 | | } |
| 11651 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11652 | | extra_index += 1 + trailing_items_len; |
| 11653 | | break :blk .{ |
| 11654 | | .body = sema.code.bodySlice(extra_index, info.body_len), |
| 11655 | | .end = extra_index + info.body_len, |
| 11656 | | .capture = info.capture, |
| 11657 | | .is_inline = info.is_inline, |
| 11658 | | .has_tag_capture = info.has_tag_capture, |
| 11659 | | }; |
| 11660 | | } else .{ |
| 11661 | | .body = &.{}, |
| 11662 | | .end = special_else.end, |
| 11663 | | .capture = .none, |
| 11664 | | .is_inline = false, |
| 11665 | | .has_tag_capture = false, |
| 11666 | | }; |
| 11667 | | const special_end = special_under.end; |
| 11476 | if (zcu.backendSupportsFeature(.is_named_enum_value) and |
| 11477 | catch_all_case != .none and block.wantSafety() and |
| 11478 | item_ty.zigTypeTag(zcu) == .@"enum" and |
| 11479 | (!operand_ty.isNonexhaustiveEnum(zcu) or union_originally)) |
| 11480 | { |
| 11481 | try sema.zirDbgStmt(&case_block, cond_dbg_node_index); |
| 11482 | const ok = try case_block.addUnOp(.is_named_enum_value, cond_ref); |
| 11483 | if (else_is_named_only) {} else { |
| 11484 | try sema.addSafetyCheck(&case_block, src, ok, .corrupt_switch); |
| 11485 | } |
| 11486 | } |
| 11668 | 11487 | |
| 11669 | | // Duplicate checking variables later also used for `inline else`. |
| 11670 | | var seen_enum_fields: []?LazySrcLoc = &.{}; |
| 11671 | | var seen_errors = SwitchErrorSet.init(gpa); |
| 11672 | | var range_set = RangeSet.init(gpa, zcu); |
| 11673 | | var true_count: u8 = 0; |
| 11674 | | var false_count: u8 = 0; |
| 11488 | if (else_is_named_only and !else_case.is_inline) { |
| 11489 | // If we have both an `else` and an `_` prong, all named values go |
| 11490 | // into the `else` prong and all unnamed ones go into the `_` prong. |
| 11491 | // We will manually enumerate all named values which haven't been |
| 11492 | // encountered yet and create an extra prong for them, which will |
| 11493 | // evaulate to the `else` body. |
| 11675 | 11494 | |
| 11676 | | defer { |
| 11677 | | range_set.deinit(); |
| 11678 | | gpa.free(seen_enum_fields); |
| 11679 | | seen_errors.deinit(); |
| 11680 | | } |
| 11495 | assert(operand_ty.isNonexhaustiveEnum(zcu)); |
| 11681 | 11496 | |
| 11682 | | var empty_enum = false; |
| 11497 | cases_len += 1; |
| 11683 | 11498 | |
| 11684 | | var else_error_ty: ?Type = null; |
| 11499 | const prong_hint: std.builtin.BranchHint = hint: { |
| 11500 | if (!else_case.is_inline) break :hint try sema.analyzeSwitchProng( |
| 11501 | &case_block, |
| 11502 | operand, |
| 11503 | operand_ty, |
| 11504 | raw_operand_ty, |
| 11505 | else_case.body, |
| 11506 | block.src(.{ .switch_capture = .{ |
| 11507 | .switch_node_offset = src_node_offset, |
| 11508 | .case_idx = else_case.index, |
| 11509 | } }), |
| 11510 | else_case.capture, |
| 11511 | else_case.has_tag_capture, |
| 11512 | .none, |
| 11513 | .special, |
| 11514 | validated_switch.else_err_ty, |
| 11515 | switch_inst, |
| 11516 | zir_switch, |
| 11517 | ); |
| 11518 | _ = try case_block.addNoOp(.unreach); |
| 11519 | break :hint .cold; // unreachable branches are cold |
| 11520 | }; |
| 11521 | try branch_hints.append(gpa, prong_hint); |
| 11685 | 11522 | |
| 11686 | | // Validate usage of '_' prongs. |
| 11687 | | if (has_under and !raw_operand_ty.isNonexhaustiveEnum(zcu)) { |
| 11688 | | const msg = msg: { |
| 11689 | | const msg = try sema.errMsg( |
| 11690 | | src, |
| 11691 | | "'_' prong only allowed when switching on non-exhaustive enums", |
| 11692 | | .{}, |
| 11693 | | ); |
| 11694 | | errdefer msg.destroy(gpa); |
| 11695 | | try sema.errNote( |
| 11696 | | under_prong_src, |
| 11697 | | msg, |
| 11698 | | "'_' prong here", |
| 11699 | | .{}, |
| 11700 | | ); |
| 11701 | | try sema.errNote( |
| 11702 | | src, |
| 11703 | | msg, |
| 11704 | | "consider using 'else'", |
| 11705 | | .{}, |
| 11523 | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 11524 | (validated_switch.seen_enum_fields.len + 1 - zir_switch.totalItemsLen()) + // +1 because totalItemsLen includes the _ |
| 11525 | case_block.instructions.items.len); |
| 11526 | const extra_case = cases_extra.addManyAsArrayAssumeCapacity( |
| 11527 | @typeInfo(Air.SwitchBr.Case).@"struct".fields.len, |
| 11706 | 11528 | ); |
| 11707 | | break :msg msg; |
| 11708 | | }; |
| 11709 | | return sema.failWithOwnedErrorMsg(block, msg); |
| 11710 | | } |
| 11529 | var items_len: u32 = 0; |
| 11530 | for (validated_switch.seen_enum_fields, 0..) |seen_field, field_i| { |
| 11531 | if (seen_field != null) continue; |
| 11532 | const item_val = try pt.enumValueFieldIndex(item_ty, @intCast(field_i)); |
| 11533 | const item_ref: Air.Inst.Ref = .fromValue(item_val); |
| 11534 | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 11535 | items_len += 1; |
| 11536 | } |
| 11537 | assert(items_len > 0); // `else` must be reachable at this point |
| 11538 | extra_case.* = payloadToExtraItems(Air.SwitchBr.Case{ |
| 11539 | .items_len = items_len, |
| 11540 | .ranges_len = 0, |
| 11541 | .body_len = @intCast(case_block.instructions.items.len), |
| 11542 | }); |
| 11543 | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 11711 | 11544 | |
| 11712 | | // Validate for duplicate items, missing else prong, and invalid range. |
| 11713 | | switch (cond_ty.zigTypeTag(zcu)) { |
| 11714 | | .@"union" => unreachable, // handled in `switchCond` |
| 11715 | | .@"enum" => { |
| 11716 | | seen_enum_fields = try gpa.alloc(?LazySrcLoc, cond_ty.enumFieldCount(zcu)); |
| 11717 | | empty_enum = seen_enum_fields.len == 0 and !cond_ty.isNonexhaustiveEnum(zcu); |
| 11718 | | @memset(seen_enum_fields, null); |
| 11719 | | // `range_set` is used for non-exhaustive enum values that do not correspond to any tags. |
| 11545 | // We fall through to the regular catch-all prong generation. |
| 11720 | 11546 | |
| 11721 | | for (absorbed_items, 0..) |item_ref, item_i| { |
| 11722 | | _ = try sema.validateSwitchItemEnum( |
| 11723 | | block, |
| 11724 | | seen_enum_fields, |
| 11725 | | &range_set, |
| 11726 | | item_ref, |
| 11727 | | cond_ty, |
| 11728 | | block.src(.{ .switch_case_item = .{ |
| 11729 | | .switch_node_offset = src_node_offset, |
| 11730 | | .case_idx = .special_under, |
| 11731 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 11732 | | } }), |
| 11733 | | ); |
| 11734 | | } |
| 11735 | | try sema.validateSwitchNoRange(block, @intCast(absorbed_ranges.len), cond_ty, src_node_offset); |
| 11547 | case_block.instructions.clearRetainingCapacity(); |
| 11548 | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 11549 | } |
| 11736 | 11550 | |
| 11737 | | var extra_index: usize = special_end; |
| 11738 | | { |
| 11739 | | var scalar_i: u32 = 0; |
| 11740 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 11741 | | const item_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 11742 | | extra_index += 1; |
| 11743 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11744 | | extra_index += 1 + info.body_len; |
| 11745 | | |
| 11746 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemEnum( |
| 11747 | | block, |
| 11748 | | seen_enum_fields, |
| 11749 | | &range_set, |
| 11750 | | item_ref, |
| 11751 | | cond_ty, |
| 11752 | | block.src(.{ .switch_case_item = .{ |
| 11753 | | .switch_node_offset = src_node_offset, |
| 11754 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 11755 | | .item_idx = .{ .kind = .single, .index = 0 }, |
| 11756 | | } }), |
| 11757 | | )); |
| 11758 | | } |
| 11551 | const analyze_catch_all_body = analyze_body: { |
| 11552 | switch (catch_all_case) { |
| 11553 | .none => break :analyze_body false, // we still may want a safety check! |
| 11554 | .under => break :analyze_body true, // can't be a union anyway |
| 11555 | .@"else" => if (else_case.is_inline) break :analyze_body false, |
| 11759 | 11556 | } |
| 11760 | | { |
| 11761 | | var multi_i: u32 = 0; |
| 11762 | | while (multi_i < multi_cases_len) : (multi_i += 1) { |
| 11763 | | const items_len = sema.code.extra[extra_index]; |
| 11764 | | extra_index += 1; |
| 11765 | | const ranges_len = sema.code.extra[extra_index]; |
| 11766 | | extra_index += 1; |
| 11767 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11768 | | extra_index += 1; |
| 11769 | | const items = sema.code.refSlice(extra_index, items_len); |
| 11770 | | extra_index += items_len + info.body_len; |
| 11771 | | |
| 11772 | | try case_vals.ensureUnusedCapacity(gpa, items.len); |
| 11773 | | for (items, 0..) |item_ref, item_i| { |
| 11774 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemEnum( |
| 11775 | | block, |
| 11776 | | seen_enum_fields, |
| 11777 | | &range_set, |
| 11778 | | item_ref, |
| 11779 | | cond_ty, |
| 11780 | | block.src(.{ .switch_case_item = .{ |
| 11781 | | .switch_node_offset = src_node_offset, |
| 11782 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 11783 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 11784 | | } }), |
| 11785 | | )); |
| 11786 | | } |
| 11787 | | |
| 11788 | | try sema.validateSwitchNoRange(block, ranges_len, cond_ty, src_node_offset); |
| 11557 | if (union_originally) { |
| 11558 | const union_obj = zcu.typeToUnion(operand_ty).?; |
| 11559 | for (validated_switch.seen_enum_fields, 0..) |seen_field, field_i| { |
| 11560 | if (seen_field != null) continue; |
| 11561 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_i]); |
| 11562 | if (!field_ty.isNoReturn(zcu)) break :analyze_body true; |
| 11789 | 11563 | } |
| 11564 | break :analyze_body false; |
| 11790 | 11565 | } |
| 11791 | | const all_tags_handled = for (seen_enum_fields) |seen_src| { |
| 11792 | | if (seen_src == null) break false; |
| 11793 | | } else true; |
| 11566 | if (err_set) { |
| 11567 | const else_err_ty = validated_switch.else_err_ty orelse { |
| 11568 | assert(else_case.is_simple_noreturn); |
| 11569 | break :analyze_body false; |
| 11570 | }; |
| 11571 | if (else_err_ty.errorSetIsEmpty(zcu)) break :analyze_body false; |
| 11572 | } |
| 11573 | break :analyze_body true; |
| 11574 | }; |
| 11794 | 11575 | |
| 11795 | | if (has_else) { |
| 11796 | | if (all_tags_handled) { |
| 11797 | | if (cond_ty.isNonexhaustiveEnum(zcu)) { |
| 11798 | | if (has_under) return sema.fail( |
| 11799 | | block, |
| 11576 | const catch_all_hint = hint: { |
| 11577 | if (analyze_catch_all_body) { |
| 11578 | const index, const body, const capture, const has_tag_capture = switch (catch_all_case) { |
| 11579 | .@"else" => .{ else_case.index, else_case.body, else_case.capture, else_case.has_tag_capture }, |
| 11580 | .under => .{ under_prong.?.index, under_prong.?.body, under_prong.?.capture, under_prong.?.has_tag_capture }, |
| 11581 | .none => unreachable, |
| 11582 | }; |
| 11583 | break :hint try sema.analyzeSwitchProng( |
| 11584 | &case_block, |
| 11585 | operand, |
| 11586 | operand_ty, |
| 11587 | raw_operand_ty, |
| 11588 | body, |
| 11589 | block.src(.{ .switch_capture = .{ |
| 11590 | .switch_node_offset = src_node_offset, |
| 11591 | .case_idx = index, |
| 11592 | } }), |
| 11593 | capture, |
| 11594 | has_tag_capture, |
| 11595 | .none, |
| 11596 | .special, |
| 11597 | validated_switch.else_err_ty, |
| 11598 | switch_inst, |
| 11599 | zir_switch, |
| 11600 | ); |
| 11601 | } |
| 11602 | // We still need a terminator in this block, but we have proven |
| 11603 | // that it is unreachable. |
| 11604 | if (case_block.wantSafety()) { |
| 11605 | try sema.zirDbgStmt(&case_block, cond_dbg_node_index); |
| 11606 | try sema.safetyPanic(&case_block, src, .corrupt_switch); |
| 11607 | } else { |
| 11608 | _ = try case_block.addNoOp(.unreach); |
| 11609 | } |
| 11610 | break :hint .cold; // Safety check / unreachable branches are cold. |
| 11611 | }; |
| 11612 | try branch_hints.append(gpa, catch_all_hint); |
| 11613 | break :catch_all_extra @ptrCast(case_block.instructions.items); |
| 11614 | }; |
| 11615 | |
| 11616 | assert(branch_hints.count == cases_len + 1); // +1 for catch-all hint |
| 11617 | |
| 11618 | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr).@"struct".fields.len + |
| 11619 | branch_hints.bags.items.len + |
| 11620 | cases_extra.items.len + |
| 11621 | catch_all_extra.len); |
| 11622 | const payload_index = sema.addExtraAssumeCapacity(Air.SwitchBr{ |
| 11623 | .cases_len = @intCast(cases_len), |
| 11624 | .else_body_len = @intCast(catch_all_extra.len), |
| 11625 | }); |
| 11626 | sema.air_extra.appendSliceAssumeCapacity(branch_hints.bags.items); |
| 11627 | sema.air_extra.appendSliceAssumeCapacity(cases_extra.items); |
| 11628 | sema.air_extra.appendSliceAssumeCapacity(catch_all_extra); |
| 11629 | |
| 11630 | const air_tag: Air.Inst.Tag = if (operand == .loop and merges.extra_insts.items.len > 0) |
| 11631 | .loop_switch_br |
| 11632 | else |
| 11633 | .switch_br; |
| 11634 | const air_switch_ref = try child_block.addInst(.{ |
| 11635 | .tag = air_tag, |
| 11636 | .data = .{ .pl_op = .{ |
| 11637 | .operand = cond_ref, |
| 11638 | .payload = payload_index, |
| 11639 | } }, |
| 11640 | }); |
| 11641 | try sema.fixupSwitchContinues( |
| 11642 | block, |
| 11643 | src, |
| 11644 | air_switch_ref, |
| 11645 | operand, |
| 11646 | operand_is_ref, |
| 11647 | item_ty, |
| 11648 | .normal, |
| 11649 | zir_switch.any_maybe_runtime_capture, |
| 11650 | merges, |
| 11651 | ); |
| 11652 | } |
| 11653 | |
| 11654 | /// This is the counterpart to `zirSwitchContinue`; replaces placeholder `br` insts |
| 11655 | /// with their respective finalized inst pointing back at `switch_ref`. |
| 11656 | fn fixupSwitchContinues( |
| 11657 | sema: *Sema, |
| 11658 | block: *Block, |
| 11659 | switch_src: LazySrcLoc, |
| 11660 | switch_ref: Air.Inst.Ref, |
| 11661 | operand: SwitchOperand, |
| 11662 | operand_is_ref: bool, |
| 11663 | item_ty: Type, |
| 11664 | mode: enum { normal, opv }, |
| 11665 | any_non_inline_capture: bool, |
| 11666 | merges: *const Block.Merges, |
| 11667 | ) CompileError!void { |
| 11668 | const pt = sema.pt; |
| 11669 | const zcu = pt.zcu; |
| 11670 | const gpa = sema.gpa; |
| 11671 | |
| 11672 | const air_tag = sema.air_instructions.items(.tag)[@intFromEnum(switch_ref.toIndex().?)]; |
| 11673 | switch (air_tag) { |
| 11674 | .loop_switch_br, .switch_br => assert(mode == .normal), |
| 11675 | .loop, .block => assert(mode == .opv), |
| 11676 | else => unreachable, |
| 11677 | } |
| 11678 | switch (air_tag) { |
| 11679 | .loop_switch_br, .loop => assert(merges.extra_insts.items.len > 0), |
| 11680 | .switch_br, .block => assert(merges.extra_insts.items.len == 0), |
| 11681 | else => unreachable, |
| 11682 | } |
| 11683 | |
| 11684 | for (merges.extra_insts.items, merges.extra_src_locs.items) |placeholder_inst, dispatch_src| { |
| 11685 | var replacement_block = block.makeSubBlock(); |
| 11686 | defer replacement_block.instructions.deinit(gpa); |
| 11687 | |
| 11688 | assert(sema.air_instructions.items(.tag)[@intFromEnum(placeholder_inst)] == .br); |
| 11689 | const new_operand_maybe_ref = sema.air_instructions.items(.data)[@intFromEnum(placeholder_inst)].br.operand; |
| 11690 | |
| 11691 | if (any_non_inline_capture and mode != .opv) { |
| 11692 | _ = try replacement_block.addBinOp(.store, operand.loop.operand_alloc, new_operand_maybe_ref); |
| 11693 | } |
| 11694 | |
| 11695 | const new_operand_val = if (operand_is_ref) |
| 11696 | try sema.analyzeLoad(&replacement_block, dispatch_src, new_operand_maybe_ref, dispatch_src) |
| 11697 | else |
| 11698 | new_operand_maybe_ref; |
| 11699 | |
| 11700 | const new_cond = try sema.coerce(&replacement_block, item_ty, new_operand_val, dispatch_src); |
| 11701 | |
| 11702 | if (zcu.backendSupportsFeature(.is_named_enum_value) and block.wantSafety() and |
| 11703 | item_ty.zigTypeTag(zcu) == .@"enum" and !item_ty.isNonexhaustiveEnum(zcu) and |
| 11704 | mode == .normal and !try sema.isComptimeKnown(new_cond)) |
| 11705 | { |
| 11706 | const ok = try replacement_block.addUnOp(.is_named_enum_value, new_cond); |
| 11707 | try sema.addSafetyCheck(&replacement_block, switch_src, ok, .corrupt_switch); |
| 11708 | } |
| 11709 | |
| 11710 | switch (mode) { |
| 11711 | .normal => { |
| 11712 | _ = try replacement_block.addInst(.{ |
| 11713 | .tag = .switch_dispatch, |
| 11714 | .data = .{ .br = .{ |
| 11715 | .block_inst = switch_ref.toIndex().?, |
| 11716 | .operand = new_cond, |
| 11717 | } }, |
| 11718 | }); |
| 11719 | }, |
| 11720 | .opv => { |
| 11721 | _ = try replacement_block.addInst(.{ |
| 11722 | .tag = .repeat, |
| 11723 | .data = .{ .repeat = .{ |
| 11724 | .loop_inst = switch_ref.toIndex().?, |
| 11725 | } }, |
| 11726 | }); |
| 11727 | }, |
| 11728 | } |
| 11729 | |
| 11730 | if (replacement_block.instructions.items.len == 1) { |
| 11731 | // Optimization: we don't need a block! |
| 11732 | sema.air_instructions.set( |
| 11733 | @intFromEnum(placeholder_inst), |
| 11734 | sema.air_instructions.get(@intFromEnum(replacement_block.instructions.items[0])), |
| 11735 | ); |
| 11736 | continue; |
| 11737 | } |
| 11738 | |
| 11739 | // Replace placeholder with a block. |
| 11740 | // No `br` is needed as the block is a switch dispatch so necessarily `noreturn`. |
| 11741 | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".fields.len + |
| 11742 | replacement_block.instructions.items.len); |
| 11743 | sema.air_instructions.set(@intFromEnum(placeholder_inst), .{ |
| 11744 | .tag = .block, |
| 11745 | .data = .{ .ty_pl = .{ |
| 11746 | .ty = .noreturn_type, |
| 11747 | .payload = sema.addExtraAssumeCapacity(Air.Block{ |
| 11748 | .body_len = @intCast(replacement_block.instructions.items.len), |
| 11749 | }), |
| 11750 | } }, |
| 11751 | }); |
| 11752 | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(replacement_block.instructions.items)); |
| 11753 | } |
| 11754 | } |
| 11755 | |
| 11756 | const ValidatedSwitchBlock = struct { |
| 11757 | seen_enum_fields: []const ?LazySrcLoc, |
| 11758 | seen_errors: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, LazySrcLoc), |
| 11759 | seen_ranges: []const RangeSet.Range, |
| 11760 | true_src: ?LazySrcLoc, |
| 11761 | false_src: ?LazySrcLoc, |
| 11762 | void_src: ?LazySrcLoc, |
| 11763 | |
| 11764 | case_vals: []const Air.Inst.Ref, |
| 11765 | else_case: Zir.UnwrappedSwitchBlock.Case.Else, |
| 11766 | else_err_ty: ?Type, |
| 11767 | |
| 11768 | fn iterateUnhandledItems( |
| 11769 | validated_switch: *const ValidatedSwitchBlock, |
| 11770 | /// May be `undefined` if `item_ty` isn't an `error_set`. |
| 11771 | error_names: InternPool.NullTerminatedString.Slice, |
| 11772 | /// May be `undefined` if `item_ty` isn't an `int`. |
| 11773 | min_int: Value, |
| 11774 | ) UnhandledIterator { |
| 11775 | return .{ |
| 11776 | .next_idx = 0, |
| 11777 | .next_val = min_int, |
| 11778 | .error_names = error_names, |
| 11779 | .seen_enum_fields = validated_switch.seen_enum_fields, |
| 11780 | .seen_errors = &validated_switch.seen_errors, |
| 11781 | .seen_ranges = validated_switch.seen_ranges, |
| 11782 | .seen_true = validated_switch.true_src != null, |
| 11783 | .seen_false = validated_switch.false_src != null, |
| 11784 | .seen_void = validated_switch.void_src != null, |
| 11785 | }; |
| 11786 | } |
| 11787 | |
| 11788 | const UnhandledIterator = struct { |
| 11789 | next_idx: u32, |
| 11790 | next_val: ?Value, |
| 11791 | error_names: InternPool.NullTerminatedString.Slice, |
| 11792 | seen_enum_fields: []const ?LazySrcLoc, |
| 11793 | seen_errors: *const std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, LazySrcLoc), |
| 11794 | seen_ranges: []const RangeSet.Range, |
| 11795 | seen_true: bool, |
| 11796 | seen_false: bool, |
| 11797 | seen_void: bool, |
| 11798 | |
| 11799 | fn next(it: *UnhandledIterator, sema: *Sema, item_ty: Type) CompileError!?Value { |
| 11800 | const pt = sema.pt; |
| 11801 | const zcu = pt.zcu; |
| 11802 | const ip = &zcu.intern_pool; |
| 11803 | switch (item_ty.zigTypeTag(zcu)) { |
| 11804 | .@"union" => unreachable, |
| 11805 | .@"enum" => { |
| 11806 | for (it.seen_enum_fields[it.next_idx..], it.next_idx..) |seen_field, field_i| { |
| 11807 | if (seen_field != null) continue; |
| 11808 | it.next_idx = @intCast(field_i + 1); |
| 11809 | return try pt.enumValueFieldIndex(item_ty, @intCast(field_i)); |
| 11810 | } |
| 11811 | return null; |
| 11812 | }, |
| 11813 | .error_set => { |
| 11814 | for (it.error_names.get(ip)[it.next_idx..], it.next_idx..) |err_name, name_i| { |
| 11815 | if (it.seen_errors.contains(err_name)) continue; |
| 11816 | it.next_idx = @intCast(name_i + 1); |
| 11817 | return .fromInterned(try pt.intern(.{ .err = .{ |
| 11818 | .ty = item_ty.toIntern(), |
| 11819 | .name = err_name, |
| 11820 | } })); |
| 11821 | } |
| 11822 | return null; |
| 11823 | }, |
| 11824 | .int => { |
| 11825 | var cur = it.next_val orelse return null; |
| 11826 | while (it.next_idx < it.seen_ranges.len and |
| 11827 | cur.eql(it.seen_ranges[it.next_idx].first, item_ty, zcu)) |
| 11828 | { |
| 11829 | defer it.next_idx += 1; |
| 11830 | const incr = try arith.incrementDefinedInt( |
| 11831 | sema, |
| 11832 | item_ty, |
| 11833 | it.seen_ranges[it.next_idx].last, |
| 11834 | ); |
| 11835 | if (incr.overflow) { |
| 11836 | it.next_val = null; |
| 11837 | return null; |
| 11838 | } |
| 11839 | cur = incr.val; |
| 11840 | } |
| 11841 | const incr = try arith.incrementDefinedInt(sema, item_ty, cur); |
| 11842 | it.next_val = if (incr.overflow) null else incr.val; |
| 11843 | return cur; |
| 11844 | }, |
| 11845 | .bool => { |
| 11846 | if (!it.seen_true) { |
| 11847 | it.seen_true = true; |
| 11848 | return .true; |
| 11849 | } |
| 11850 | if (!it.seen_false) { |
| 11851 | it.seen_false = true; |
| 11852 | return .false; |
| 11853 | } |
| 11854 | return null; |
| 11855 | }, |
| 11856 | .void => { |
| 11857 | if (!it.seen_void) { |
| 11858 | it.seen_void = true; |
| 11859 | return .void; |
| 11860 | } |
| 11861 | return null; |
| 11862 | }, |
| 11863 | else => unreachable, // item type is not enumerable |
| 11864 | } |
| 11865 | } |
| 11866 | }; |
| 11867 | }; |
| 11868 | |
| 11869 | /// Validates operand type and `else`/`_` prong usage, resolves all prong items |
| 11870 | /// and checks them for duplicates/invalid ranges. Does not emit into `block`. |
| 11871 | /// Reserves inst map space for all placeholders associated with `zir_switch`. |
| 11872 | /// Contents of returned `ValidatedSwitchBlock` belong to `sema.arena`. |
| 11873 | fn validateSwitchBlock( |
| 11874 | sema: *Sema, |
| 11875 | block: *Block, |
| 11876 | raw_operand: Air.Inst.Ref, |
| 11877 | operand_is_ref: bool, |
| 11878 | switch_inst: Zir.Inst.Index, |
| 11879 | zir_switch: *const Zir.UnwrappedSwitchBlock, |
| 11880 | ) CompileError!ValidatedSwitchBlock { |
| 11881 | const pt = sema.pt; |
| 11882 | const zcu = pt.zcu; |
| 11883 | const ip = &zcu.intern_pool; |
| 11884 | const gpa = sema.gpa; |
| 11885 | const arena = sema.arena; |
| 11886 | |
| 11887 | const src_node_offset = zir_switch.switch_src_node_offset; |
| 11888 | const src = block.nodeOffset(src_node_offset); |
| 11889 | const operand_src = block.src(.{ .node_offset_switch_operand = src_node_offset }); |
| 11890 | const else_prong_src = block.src(.{ .node_offset_switch_else_prong = src_node_offset }); |
| 11891 | var extra_index = zir_switch.end; |
| 11892 | |
| 11893 | // We want to map values to our placeholders later on. |
| 11894 | if (zir_switch.payload_capture_placeholder.unwrap()) |payload_capture_inst| { |
| 11895 | assert(payload_capture_inst != switch_inst); // malformed zir |
| 11896 | try sema.inst_map.ensureSpaceForInstructions(gpa, &.{payload_capture_inst}); |
| 11897 | } |
| 11898 | if (zir_switch.tag_capture_placeholder.unwrap()) |tag_capture_inst| { |
| 11899 | assert(tag_capture_inst != switch_inst); // malformed zir |
| 11900 | try sema.inst_map.ensureSpaceForInstructions(gpa, &.{tag_capture_inst}); |
| 11901 | } |
| 11902 | |
| 11903 | const operand_ty: Type, const item_ty: Type = check_operand: { |
| 11904 | const operand_ty = operand_ty: { |
| 11905 | const raw_operand_ty = sema.typeOf(raw_operand); |
| 11906 | if (operand_is_ref) { |
| 11907 | try sema.checkPtrType(block, operand_src, raw_operand_ty, false); |
| 11908 | break :operand_ty raw_operand_ty.childType(zcu); |
| 11909 | } |
| 11910 | break :operand_ty raw_operand_ty; |
| 11911 | }; |
| 11912 | |
| 11913 | const item_ty: Type = item_ty: { |
| 11914 | switch (operand_ty.zigTypeTag(zcu)) { |
| 11915 | .@"enum", |
| 11916 | .error_set, |
| 11917 | .int, |
| 11918 | .comptime_int, |
| 11919 | .type, |
| 11920 | .enum_literal, |
| 11921 | .@"fn", |
| 11922 | .bool, |
| 11923 | .void, |
| 11924 | => break :item_ty operand_ty, |
| 11925 | |
| 11926 | .@"union" => { |
| 11927 | try operand_ty.resolveFields(pt); |
| 11928 | const enum_ty = operand_ty.unionTagType(zcu) orelse { |
| 11929 | return sema.failWithOwnedErrorMsg(block, msg: { |
| 11930 | const msg = try sema.errMsg(operand_src, "switch on union with no attached enum", .{}); |
| 11931 | errdefer msg.destroy(sema.gpa); |
| 11932 | if (operand_ty.srcLocOrNull(zcu)) |union_src| { |
| 11933 | try sema.errNote(union_src, msg, "consider 'union(enum)' here", .{}); |
| 11934 | } |
| 11935 | break :msg msg; |
| 11936 | }); |
| 11937 | }; |
| 11938 | break :item_ty enum_ty; |
| 11939 | }, |
| 11940 | |
| 11941 | .pointer => { |
| 11942 | if (!operand_ty.isSlice(zcu)) { |
| 11943 | break :item_ty operand_ty; |
| 11944 | } |
| 11945 | }, |
| 11946 | |
| 11947 | else => {}, |
| 11948 | } |
| 11949 | return sema.fail(block, operand_src, "switch on type '{f}'", .{operand_ty.fmt(pt)}); |
| 11950 | }; |
| 11951 | |
| 11952 | if (zir_switch.has_continue and !block.isComptime()) { |
| 11953 | if (try operand_ty.comptimeOnlySema(pt)) { |
| 11954 | // Even if the operand is comptime-known, this `switch` is runtime. |
| 11955 | return sema.failWithOwnedErrorMsg(block, msg: { |
| 11956 | const msg = try sema.errMsg(operand_src, "operand of switch loop has comptime-only type '{f}'", .{operand_ty.fmt(pt)}); |
| 11957 | errdefer msg.destroy(gpa); |
| 11958 | try sema.errNote(operand_src, msg, "switch loops are evaluated at runtime outside of comptime scopes", .{}); |
| 11959 | try sema.explainWhyTypeIsComptime(msg, operand_src, operand_ty); |
| 11960 | break :msg msg; |
| 11961 | }); |
| 11962 | } |
| 11963 | try sema.validateRuntimeValue(block, operand_src, raw_operand); |
| 11964 | } |
| 11965 | |
| 11966 | break :check_operand .{ operand_ty, item_ty }; |
| 11967 | }; |
| 11968 | |
| 11969 | const has_else = zir_switch.else_case != null; |
| 11970 | const has_under = zir_switch.has_under; |
| 11971 | |
| 11972 | var case_vals: std.ArrayList(Air.Inst.Ref) = .empty; |
| 11973 | try case_vals.ensureUnusedCapacity(arena, zir_switch.item_infos.len); |
| 11974 | |
| 11975 | // Duplicate checking variables later also used for `inline else`. |
| 11976 | var seen_enum_fields: []?LazySrcLoc = &.{}; |
| 11977 | var seen_errors: std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, LazySrcLoc) = .empty; |
| 11978 | var seen_sparse_values: std.AutoHashMapUnmanaged(InternPool.Index, LazySrcLoc) = .empty; |
| 11979 | var range_set: RangeSet = .empty; |
| 11980 | var true_src: ?LazySrcLoc = null; |
| 11981 | var false_src: ?LazySrcLoc = null; |
| 11982 | var void_src: ?LazySrcLoc = null; |
| 11983 | |
| 11984 | var else_err_ty: ?Type = null; |
| 11985 | |
| 11986 | const else_case = zir_switch.else_case orelse undefined; |
| 11987 | |
| 11988 | switch (item_ty.zigTypeTag(zcu)) { |
| 11989 | .@"union" => unreachable, |
| 11990 | .@"enum" => { |
| 11991 | seen_enum_fields = try arena.alloc(?LazySrcLoc, item_ty.enumFieldCount(zcu)); |
| 11992 | @memset(seen_enum_fields, null); |
| 11993 | // `range_set` is used for non-exhaustive enum values that do not |
| 11994 | // correspond to any tags. Since this is rare, we only allocate on |
| 11995 | // demand in `validateSwitchItem`. |
| 11996 | }, |
| 11997 | .error_set => { |
| 11998 | try seen_errors.ensureUnusedCapacity(arena, zir_switch.totalItemsLen()); |
| 11999 | }, |
| 12000 | .int, .comptime_int => { |
| 12001 | try range_set.ensureUnusedCapacity(arena, zir_switch.totalItemsLen()); |
| 12002 | }, |
| 12003 | .enum_literal, .@"fn", .pointer, .type => { |
| 12004 | try seen_sparse_values.ensureUnusedCapacity(arena, zir_switch.totalItemsLen()); |
| 12005 | }, |
| 12006 | .bool, .void => {}, |
| 12007 | |
| 12008 | else => unreachable, |
| 12009 | } |
| 12010 | |
| 12011 | // Validate for duplicate items and invalid ranges. |
| 12012 | var case_it = zir_switch.iterateCases(); |
| 12013 | while (case_it.next()) |case| { |
| 12014 | const prong_info = case.prong_info; |
| 12015 | extra_index += prong_info.body_len; |
| 12016 | for (case.item_infos, 0..) |item_info, item_i| { |
| 12017 | const item_src = block.src(.{ .switch_case_item = .{ |
| 12018 | .switch_node_offset = src_node_offset, |
| 12019 | .case_idx = case.index, |
| 12020 | .item_idx = .{ .kind = .single, .value = @intCast(item_i) }, |
| 12021 | } }); |
| 12022 | if (item_info.unwrap() == .under) { |
| 12023 | if (!operand_ty.isNonexhaustiveEnum(zcu)) return sema.failWithOwnedErrorMsg(block, msg: { |
| 12024 | const msg = try sema.errMsg( |
| 12025 | src, |
| 12026 | "'_' prong only allowed when switching on non-exhaustive enums", |
| 12027 | .{}, |
| 12028 | ); |
| 12029 | errdefer msg.destroy(gpa); |
| 12030 | try sema.errNote( |
| 12031 | item_src, |
| 12032 | msg, |
| 12033 | "'_' prong here", |
| 12034 | .{}, |
| 12035 | ); |
| 12036 | try sema.errNote( |
| 12037 | src, |
| 12038 | msg, |
| 12039 | "consider using 'else'", |
| 12040 | .{}, |
| 12041 | ); |
| 12042 | break :msg msg; |
| 12043 | }); |
| 12044 | case_vals.appendAssumeCapacity(.none); |
| 12045 | } else { |
| 12046 | const item, extra_index = try sema.resolveSwitchItem(block, item_src, item_ty, item_info, extra_index, switch_inst, prong_info.is_comptime_unreach); |
| 12047 | try sema.validateSwitchItemOrRange(block, item_src, item.val, null, item_ty, seen_enum_fields, &seen_errors, &seen_sparse_values, &range_set, &true_src, &false_src, &void_src); |
| 12048 | case_vals.appendAssumeCapacity(item.ref); |
| 12049 | } |
| 12050 | } |
| 12051 | for (case.range_infos, 0..) |range_info, range_i| { |
| 12052 | const range_offset: LazySrcLoc.Offset.SwitchItem = .{ |
| 12053 | .switch_node_offset = src_node_offset, |
| 12054 | .case_idx = case.index, |
| 12055 | .item_idx = .{ .kind = .range, .value = @intCast(range_i) }, |
| 12056 | }; |
| 12057 | const range_src = block.src(.{ .switch_case_item = range_offset }); |
| 12058 | const first_src = block.src(.{ .switch_case_item_range_first = range_offset }); |
| 12059 | const last_src = block.src(.{ .switch_case_item_range_last = range_offset }); |
| 12060 | const first_item, extra_index = try sema.resolveSwitchItem(block, first_src, item_ty, range_info[0], extra_index, switch_inst, prong_info.is_comptime_unreach); |
| 12061 | const last_item, extra_index = try sema.resolveSwitchItem(block, last_src, item_ty, range_info[1], extra_index, switch_inst, prong_info.is_comptime_unreach); |
| 12062 | try sema.validateSwitchItemOrRange(block, range_src, first_item.val, last_item.val, item_ty, seen_enum_fields, &seen_errors, &seen_sparse_values, &range_set, &true_src, &false_src, &void_src); |
| 12063 | case_vals.appendSliceAssumeCapacity(&.{ first_item.ref, last_item.ref }); |
| 12064 | } |
| 12065 | } |
| 12066 | |
| 12067 | switch (item_ty.zigTypeTag(zcu)) { |
| 12068 | .@"union" => unreachable, |
| 12069 | .int, .comptime_int => {}, |
| 12070 | else => if (zir_switch.anyRanges()) { |
| 12071 | const range_src = block.src(.{ .node_offset_switch_range = src_node_offset }); |
| 12072 | const msg = msg: { |
| 12073 | const msg = try sema.errMsg( |
| 12074 | operand_src, |
| 12075 | "ranges not allowed when switching on type '{f}'", |
| 12076 | .{operand_ty.fmt(sema.pt)}, |
| 12077 | ); |
| 12078 | errdefer msg.destroy(sema.gpa); |
| 12079 | try sema.errNote( |
| 12080 | range_src, |
| 12081 | msg, |
| 12082 | "range here", |
| 12083 | .{}, |
| 12084 | ); |
| 12085 | break :msg msg; |
| 12086 | }; |
| 12087 | return sema.failWithOwnedErrorMsg(block, msg); |
| 12088 | }, |
| 12089 | } |
| 12090 | |
| 12091 | // Validate for missing special prongs. |
| 12092 | switch (item_ty.zigTypeTag(zcu)) { |
| 12093 | .@"union" => unreachable, |
| 12094 | .@"enum" => { |
| 12095 | const all_tags_handled = for (seen_enum_fields) |seen_src| { |
| 12096 | if (seen_src == null) break false; |
| 12097 | } else true; |
| 12098 | |
| 12099 | if (has_else) { |
| 12100 | if (all_tags_handled) { |
| 12101 | if (item_ty.isNonexhaustiveEnum(zcu)) { |
| 12102 | if (has_under) return sema.fail( |
| 12103 | block, |
| 11800 | 12104 | else_prong_src, |
| 11801 | 12105 | "unreachable else prong; all explicit cases already handled", |
| 11802 | 12106 | .{}, |
| ... | ... | @@ -11819,9 +12123,9 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 11819 | 12123 | for (seen_enum_fields, 0..) |seen_src, i| { |
| 11820 | 12124 | if (seen_src != null) continue; |
| 11821 | 12125 | |
| 11822 | | const field_name = cond_ty.enumFieldName(i, zcu); |
| 12126 | const field_name = item_ty.enumFieldName(i, zcu); |
| 11823 | 12127 | try sema.addFieldErrNote( |
| 11824 | | cond_ty, |
| 12128 | item_ty, |
| 11825 | 12129 | i, |
| 11826 | 12130 | msg, |
| 11827 | 12131 | "unhandled enumeration value: '{f}'", |
| ... | ... | @@ -11829,15 +12133,17 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 11829 | 12133 | ); |
| 11830 | 12134 | } |
| 11831 | 12135 | try sema.errNote( |
| 11832 | | cond_ty.srcLoc(zcu), |
| 12136 | item_ty.srcLoc(zcu), |
| 11833 | 12137 | msg, |
| 11834 | 12138 | "enum '{f}' declared here", |
| 11835 | | .{cond_ty.fmt(pt)}, |
| 12139 | .{item_ty.fmt(pt)}, |
| 11836 | 12140 | ); |
| 11837 | 12141 | break :msg msg; |
| 11838 | 12142 | }; |
| 11839 | 12143 | return sema.failWithOwnedErrorMsg(block, msg); |
| 11840 | | } else if (special_prongs == .none and cond_ty.isNonexhaustiveEnum(zcu) and !union_originally) { |
| 12144 | } else if (!has_else and !has_under and |
| 12145 | item_ty.isNonexhaustiveEnum(zcu) and operand_ty.zigTypeTag(zcu) != .@"union") |
| 12146 | { |
| 11841 | 12147 | return sema.fail( |
| 11842 | 12148 | block, |
| 11843 | 12149 | src, |
| ... | ... | @@ -11846,101 +12152,83 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 11846 | 12152 | ); |
| 11847 | 12153 | } |
| 11848 | 12154 | }, |
| 11849 | | .error_set => else_error_ty = try validateErrSetSwitch( |
| 11850 | | sema, |
| 11851 | | block, |
| 11852 | | &seen_errors, |
| 11853 | | &case_vals, |
| 11854 | | cond_ty, |
| 11855 | | inst_data, |
| 11856 | | scalar_cases_len, |
| 11857 | | multi_cases_len, |
| 11858 | | .{ .body = special_else.body, .end = special_else.end, .src = else_prong_src }, |
| 11859 | | has_else, |
| 11860 | | ), |
| 11861 | | .int, .comptime_int => { |
| 11862 | | var extra_index: usize = special_end; |
| 11863 | | { |
| 11864 | | var scalar_i: u32 = 0; |
| 11865 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 11866 | | const item_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 11867 | | extra_index += 1; |
| 11868 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11869 | | extra_index += 1 + info.body_len; |
| 11870 | | |
| 11871 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemInt( |
| 11872 | | block, |
| 11873 | | &range_set, |
| 11874 | | item_ref, |
| 11875 | | cond_ty, |
| 11876 | | block.src(.{ .switch_case_item = .{ |
| 11877 | | .switch_node_offset = src_node_offset, |
| 11878 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 11879 | | .item_idx = .{ .kind = .single, .index = 0 }, |
| 11880 | | } }), |
| 11881 | | )); |
| 11882 | | } |
| 11883 | | } |
| 11884 | | { |
| 11885 | | var multi_i: u32 = 0; |
| 11886 | | while (multi_i < multi_cases_len) : (multi_i += 1) { |
| 11887 | | const items_len = sema.code.extra[extra_index]; |
| 11888 | | extra_index += 1; |
| 11889 | | const ranges_len = sema.code.extra[extra_index]; |
| 11890 | | extra_index += 1; |
| 11891 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11892 | | extra_index += 1; |
| 11893 | | const items = sema.code.refSlice(extra_index, items_len); |
| 11894 | | extra_index += items_len; |
| 11895 | | |
| 11896 | | try case_vals.ensureUnusedCapacity(gpa, items.len); |
| 11897 | | for (items, 0..) |item_ref, item_i| { |
| 11898 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemInt( |
| 12155 | .error_set => { |
| 12156 | else_err_ty = ty: switch (try sema.resolveInferredErrorSetTy(block, src, item_ty.toIntern())) { |
| 12157 | .anyerror_type => { |
| 12158 | if (!has_else) { |
| 12159 | return sema.fail( |
| 11899 | 12160 | block, |
| 11900 | | &range_set, |
| 11901 | | item_ref, |
| 11902 | | cond_ty, |
| 11903 | | block.src(.{ .switch_case_item = .{ |
| 11904 | | .switch_node_offset = src_node_offset, |
| 11905 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 11906 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 11907 | | } }), |
| 11908 | | )); |
| 12161 | src, |
| 12162 | "else prong required when switching on type 'anyerror'", |
| 12163 | .{}, |
| 12164 | ); |
| 12165 | } |
| 12166 | break :ty .anyerror; |
| 12167 | }, |
| 12168 | else => |err_set_ty_index| { |
| 12169 | const error_names = ip.indexToKey(err_set_ty_index).error_set_type.names; |
| 12170 | var maybe_msg: ?*Zcu.ErrorMsg = null; |
| 12171 | errdefer if (maybe_msg) |msg| msg.destroy(sema.gpa); |
| 12172 | |
| 12173 | var seen_errors_from_set: u32 = 0; |
| 12174 | for (error_names.get(ip)) |error_name| { |
| 12175 | if (seen_errors.contains(error_name)) { |
| 12176 | seen_errors_from_set += 1; |
| 12177 | } else if (!has_else) { |
| 12178 | const msg = maybe_msg orelse blk: { |
| 12179 | maybe_msg = try sema.errMsg( |
| 12180 | src, |
| 12181 | "switch must handle all possibilities", |
| 12182 | .{}, |
| 12183 | ); |
| 12184 | break :blk maybe_msg.?; |
| 12185 | }; |
| 12186 | |
| 12187 | try sema.errNote( |
| 12188 | src, |
| 12189 | msg, |
| 12190 | "unhandled error value: 'error.{f}'", |
| 12191 | .{error_name.fmt(ip)}, |
| 12192 | ); |
| 12193 | } |
| 11909 | 12194 | } |
| 11910 | 12195 | |
| 11911 | | try case_vals.ensureUnusedCapacity(gpa, 2 * ranges_len); |
| 11912 | | var range_i: u32 = 0; |
| 11913 | | while (range_i < ranges_len) : (range_i += 1) { |
| 11914 | | const item_first: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 11915 | | extra_index += 1; |
| 11916 | | const item_last: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 11917 | | extra_index += 1; |
| 12196 | if (maybe_msg) |msg| { |
| 12197 | maybe_msg = null; |
| 12198 | try sema.addDeclaredHereNote(msg, operand_ty); |
| 12199 | return sema.failWithOwnedErrorMsg(block, msg); |
| 12200 | } |
| 11918 | 12201 | |
| 11919 | | const vals = try sema.validateSwitchRange( |
| 12202 | if (has_else and seen_errors_from_set == error_names.len) { |
| 12203 | // This prong is unreachable anyway so we don't need its |
| 12204 | // error set type, but we still allow it to exist. |
| 12205 | if (else_case.is_simple_noreturn) break :ty null; |
| 12206 | return sema.fail( |
| 11920 | 12207 | block, |
| 11921 | | &range_set, |
| 11922 | | item_first, |
| 11923 | | item_last, |
| 11924 | | cond_ty, |
| 11925 | | block.src(.{ .switch_case_item = .{ |
| 11926 | | .switch_node_offset = src_node_offset, |
| 11927 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 11928 | | .item_idx = .{ .kind = .range, .index = @intCast(range_i) }, |
| 11929 | | } }), |
| 12208 | else_prong_src, |
| 12209 | "unreachable else prong; all cases already handled", |
| 12210 | .{}, |
| 11930 | 12211 | ); |
| 11931 | | case_vals.appendAssumeCapacity(vals[0]); |
| 11932 | | case_vals.appendAssumeCapacity(vals[1]); |
| 11933 | 12212 | } |
| 11934 | 12213 | |
| 11935 | | extra_index += info.body_len; |
| 11936 | | } |
| 11937 | | } |
| 11938 | | |
| 12214 | var names: InferredErrorSet.NameMap = .{}; |
| 12215 | try names.ensureUnusedCapacity(sema.arena, error_names.len); |
| 12216 | for (error_names.get(ip)) |error_name| { |
| 12217 | if (seen_errors.contains(error_name)) continue; |
| 12218 | names.putAssumeCapacityNoClobber(error_name, {}); |
| 12219 | } |
| 12220 | // No need to keep the hash map metadata correct; here we |
| 12221 | // extract the (sorted) keys only. |
| 12222 | break :ty try pt.errorSetFromUnsortedNames(names.keys()); |
| 12223 | }, |
| 12224 | }; |
| 12225 | }, |
| 12226 | .int, .comptime_int => |type_tag| { |
| 11939 | 12227 | check_range: { |
| 11940 | | if (cond_ty.zigTypeTag(zcu) == .int) { |
| 11941 | | const min_int = try cond_ty.minInt(pt, cond_ty); |
| 11942 | | const max_int = try cond_ty.maxInt(pt, cond_ty); |
| 11943 | | if (try range_set.spans(min_int.toIntern(), max_int.toIntern())) { |
| 12228 | if (type_tag == .int) { |
| 12229 | const min_int = try item_ty.minInt(pt, item_ty); |
| 12230 | const max_int = try item_ty.maxInt(pt, item_ty); |
| 12231 | if (try range_set.spans(arena, min_int, max_int, item_ty, zcu)) { |
| 11944 | 12232 | if (has_else) { |
| 11945 | 12233 | return sema.fail( |
| 11946 | 12234 | block, |
| ... | ... | @@ -11952,7 +12240,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 11952 | 12240 | break :check_range; |
| 11953 | 12241 | } |
| 11954 | 12242 | } |
| 11955 | | if (special_prongs == .none) { |
| 12243 | if (!has_else) { |
| 11956 | 12244 | return sema.fail( |
| 11957 | 12245 | block, |
| 11958 | 12246 | src, |
| ... | ... | @@ -11962,61 +12250,24 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 11962 | 12250 | } |
| 11963 | 12251 | } |
| 11964 | 12252 | }, |
| 11965 | | .bool => { |
| 11966 | | var extra_index: usize = special_end; |
| 11967 | | { |
| 11968 | | var scalar_i: u32 = 0; |
| 11969 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 11970 | | const item_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 11971 | | extra_index += 1; |
| 11972 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11973 | | extra_index += 1 + info.body_len; |
| 11974 | | |
| 11975 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemBool( |
| 11976 | | block, |
| 11977 | | &true_count, |
| 11978 | | &false_count, |
| 11979 | | item_ref, |
| 11980 | | block.src(.{ .switch_case_item = .{ |
| 11981 | | .switch_node_offset = src_node_offset, |
| 11982 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 11983 | | .item_idx = .{ .kind = .single, .index = 0 }, |
| 11984 | | } }), |
| 11985 | | )); |
| 11986 | | } |
| 11987 | | } |
| 11988 | | { |
| 11989 | | var multi_i: u32 = 0; |
| 11990 | | while (multi_i < multi_cases_len) : (multi_i += 1) { |
| 11991 | | const items_len = sema.code.extra[extra_index]; |
| 11992 | | extra_index += 1; |
| 11993 | | const ranges_len = sema.code.extra[extra_index]; |
| 11994 | | extra_index += 1; |
| 11995 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 11996 | | extra_index += 1; |
| 11997 | | const items = sema.code.refSlice(extra_index, items_len); |
| 11998 | | extra_index += items_len + info.body_len; |
| 11999 | | |
| 12000 | | try case_vals.ensureUnusedCapacity(gpa, items.len); |
| 12001 | | for (items, 0..) |item_ref, item_i| { |
| 12002 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemBool( |
| 12003 | | block, |
| 12004 | | &true_count, |
| 12005 | | &false_count, |
| 12006 | | item_ref, |
| 12007 | | block.src(.{ .switch_case_item = .{ |
| 12008 | | .switch_node_offset = src_node_offset, |
| 12009 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12010 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 12011 | | } }), |
| 12012 | | )); |
| 12013 | | } |
| 12014 | | |
| 12015 | | try sema.validateSwitchNoRange(block, ranges_len, cond_ty, src_node_offset); |
| 12016 | | } |
| 12253 | .enum_literal, .@"fn", .pointer, .type => { |
| 12254 | if (!has_else) { |
| 12255 | return sema.fail( |
| 12256 | block, |
| 12257 | src, |
| 12258 | "else prong required when switching on type '{f}'", |
| 12259 | .{item_ty.fmt(pt)}, |
| 12260 | ); |
| 12017 | 12261 | } |
| 12262 | }, |
| 12263 | .bool, .void => |type_tag| { |
| 12264 | const all_values_handled = switch (type_tag) { |
| 12265 | .bool => true_src != null and false_src != null, |
| 12266 | .void => void_src != null, |
| 12267 | else => unreachable, |
| 12268 | }; |
| 12018 | 12269 | if (has_else) { |
| 12019 | | if (true_count + false_count == 2) { |
| 12270 | if (all_values_handled) { |
| 12020 | 12271 | return sema.fail( |
| 12021 | 12272 | block, |
| 12022 | 12273 | else_prong_src, |
| ... | ... | @@ -12025,7 +12276,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 12025 | 12276 | ); |
| 12026 | 12277 | } |
| 12027 | 12278 | } else { |
| 12028 | | if (true_count + false_count < 2) { |
| 12279 | if (!all_values_handled) { |
| 12029 | 12280 | return sema.fail( |
| 12030 | 12281 | block, |
| 12031 | 12282 | src, |
| ... | ... | @@ -12035,1775 +12286,1086 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r |
| 12035 | 12286 | } |
| 12036 | 12287 | } |
| 12037 | 12288 | }, |
| 12038 | | .enum_literal, .void, .@"fn", .pointer, .type => { |
| 12039 | | if (!has_else) { |
| 12040 | | return sema.fail( |
| 12041 | | block, |
| 12042 | | src, |
| 12043 | | "else prong required when switching on type '{f}'", |
| 12044 | | .{cond_ty.fmt(pt)}, |
| 12045 | | ); |
| 12046 | | } |
| 12047 | | |
| 12048 | | var seen_values = ValueSrcMap{}; |
| 12049 | | defer seen_values.deinit(gpa); |
| 12050 | | |
| 12051 | | var extra_index: usize = special_end; |
| 12052 | | { |
| 12053 | | var scalar_i: u32 = 0; |
| 12054 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 12055 | | const item_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 12056 | | extra_index += 1; |
| 12057 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 12058 | | extra_index += 1; |
| 12059 | | extra_index += info.body_len; |
| 12060 | | |
| 12061 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemSparse( |
| 12062 | | block, |
| 12063 | | &seen_values, |
| 12064 | | item_ref, |
| 12065 | | cond_ty, |
| 12066 | | block.src(.{ .switch_case_item = .{ |
| 12067 | | .switch_node_offset = src_node_offset, |
| 12068 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 12069 | | .item_idx = .{ .kind = .single, .index = 0 }, |
| 12070 | | } }), |
| 12071 | | )); |
| 12072 | | } |
| 12073 | | } |
| 12074 | | { |
| 12075 | | var multi_i: u32 = 0; |
| 12076 | | while (multi_i < multi_cases_len) : (multi_i += 1) { |
| 12077 | | const items_len = sema.code.extra[extra_index]; |
| 12078 | | extra_index += 1; |
| 12079 | | const ranges_len = sema.code.extra[extra_index]; |
| 12080 | | extra_index += 1; |
| 12081 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 12082 | | extra_index += 1; |
| 12083 | | const items = sema.code.refSlice(extra_index, items_len); |
| 12084 | | extra_index += items_len + info.body_len; |
| 12085 | | |
| 12086 | | try case_vals.ensureUnusedCapacity(gpa, items.len); |
| 12087 | | for (items, 0..) |item_ref, item_i| { |
| 12088 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemSparse( |
| 12089 | | block, |
| 12090 | | &seen_values, |
| 12091 | | item_ref, |
| 12092 | | cond_ty, |
| 12093 | | block.src(.{ .switch_case_item = .{ |
| 12094 | | .switch_node_offset = src_node_offset, |
| 12095 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12096 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 12097 | | } }), |
| 12098 | | )); |
| 12099 | | } |
| 12100 | | |
| 12101 | | try sema.validateSwitchNoRange(block, ranges_len, cond_ty, src_node_offset); |
| 12102 | | } |
| 12103 | | } |
| 12104 | | }, |
| 12105 | | |
| 12106 | | .error_union, |
| 12107 | | .noreturn, |
| 12108 | | .array, |
| 12109 | | .@"struct", |
| 12110 | | .undefined, |
| 12111 | | .null, |
| 12112 | | .optional, |
| 12113 | | .@"opaque", |
| 12114 | | .vector, |
| 12115 | | .frame, |
| 12116 | | .@"anyframe", |
| 12117 | | .comptime_float, |
| 12118 | | .float, |
| 12119 | | => return sema.fail(block, operand_src, "invalid switch operand type '{f}'", .{ |
| 12120 | | raw_operand_ty.fmt(pt), |
| 12121 | | }), |
| 12289 | else => unreachable, |
| 12122 | 12290 | } |
| 12123 | 12291 | |
| 12124 | | var special_members_only: ?SpecialProng = null; |
| 12125 | | var special_members_only_src: LazySrcLoc = undefined; |
| 12126 | | const special_generic, const special_generic_src = if (has_under) b: { |
| 12127 | | if (has_else) { |
| 12128 | | special_members_only = special_else; |
| 12129 | | special_members_only_src = else_prong_src; |
| 12130 | | } |
| 12131 | | break :b .{ special_under, under_prong_src }; |
| 12132 | | } else .{ special_else, else_prong_src }; |
| 12133 | | |
| 12134 | | const spa: SwitchProngAnalysis = .{ |
| 12135 | | .sema = sema, |
| 12136 | | .parent_block = block, |
| 12137 | | .operand = operand, |
| 12138 | | .else_error_ty = else_error_ty, |
| 12139 | | .switch_block_inst = inst, |
| 12140 | | .tag_capture_inst = tag_capture_inst, |
| 12141 | | }; |
| 12142 | | |
| 12143 | | const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); |
| 12144 | | try sema.air_instructions.append(gpa, .{ |
| 12145 | | .tag = .block, |
| 12146 | | .data = undefined, |
| 12147 | | }); |
| 12148 | | var label: Block.Label = .{ |
| 12149 | | .zir_block = inst, |
| 12150 | | .merges = .{ |
| 12151 | | .src_locs = .{}, |
| 12152 | | .results = .{}, |
| 12153 | | .br_list = .{}, |
| 12154 | | .block_inst = block_inst, |
| 12155 | | }, |
| 12156 | | }; |
| 12292 | return .{ |
| 12293 | .seen_enum_fields = seen_enum_fields, |
| 12294 | .seen_errors = seen_errors, |
| 12295 | .seen_ranges = range_set.ranges.items, |
| 12296 | .true_src = true_src, |
| 12297 | .false_src = false_src, |
| 12298 | .void_src = void_src, |
| 12157 | 12299 | |
| 12158 | | var child_block: Block = .{ |
| 12159 | | .parent = block, |
| 12160 | | .sema = sema, |
| 12161 | | .namespace = block.namespace, |
| 12162 | | .instructions = .{}, |
| 12163 | | .label = &label, |
| 12164 | | .inlining = block.inlining, |
| 12165 | | .comptime_reason = block.comptime_reason, |
| 12166 | | .is_typeof = block.is_typeof, |
| 12167 | | .c_import_buf = block.c_import_buf, |
| 12168 | | .runtime_cond = block.runtime_cond, |
| 12169 | | .runtime_loop = block.runtime_loop, |
| 12170 | | .runtime_index = block.runtime_index, |
| 12171 | | .want_safety = block.want_safety, |
| 12172 | | .error_return_trace_index = block.error_return_trace_index, |
| 12173 | | .src_base_inst = block.src_base_inst, |
| 12174 | | .type_name_ctx = block.type_name_ctx, |
| 12300 | .case_vals = case_vals.items, |
| 12301 | .else_case = else_case, |
| 12302 | .else_err_ty = else_err_ty, |
| 12175 | 12303 | }; |
| 12176 | | const merges = &child_block.label.?.merges; |
| 12177 | | defer child_block.instructions.deinit(gpa); |
| 12178 | | defer merges.deinit(gpa); |
| 12179 | | |
| 12180 | | if (scalar_cases_len + multi_cases_len == 0 and |
| 12181 | | special_members_only == null and |
| 12182 | | !special_generic.is_inline) |
| 12183 | | { |
| 12184 | | if (empty_enum) { |
| 12185 | | return .void_value; |
| 12186 | | } |
| 12187 | | if (special_prongs == .none) { |
| 12188 | | return sema.fail(block, src, "switch must handle all possibilities", .{}); |
| 12189 | | } |
| 12190 | | const init_cond = switch (operand) { |
| 12191 | | .simple => |s| s.cond, |
| 12192 | | .loop => |l| l.init_cond, |
| 12193 | | }; |
| 12194 | | if (zcu.backendSupportsFeature(.is_named_enum_value) and block.wantSafety() and |
| 12195 | | raw_operand_ty.zigTypeTag(zcu) == .@"enum" and !raw_operand_ty.isNonexhaustiveEnum(zcu)) |
| 12196 | | { |
| 12197 | | try sema.zirDbgStmt(block, cond_dbg_node_index); |
| 12198 | | const ok = try block.addUnOp(.is_named_enum_value, init_cond); |
| 12199 | | try sema.addSafetyCheck(block, src, ok, .corrupt_switch); |
| 12200 | | } |
| 12201 | | if (err_set and try sema.maybeErrorUnwrap(block, special_generic.body, init_cond, operand_src, false)) { |
| 12202 | | return .unreachable_value; |
| 12203 | | } |
| 12204 | | } |
| 12205 | | |
| 12206 | | switch (operand) { |
| 12207 | | .loop => {}, // always runtime; evaluation in comptime scope uses `simple` |
| 12208 | | .simple => |s| { |
| 12209 | | if (try sema.resolveDefinedValue(&child_block, src, s.cond)) |cond_val| { |
| 12210 | | return resolveSwitchComptimeLoop( |
| 12211 | | sema, |
| 12212 | | spa, |
| 12213 | | &child_block, |
| 12214 | | if (operand_is_ref) |
| 12215 | | sema.typeOf(s.by_ref) |
| 12216 | | else |
| 12217 | | raw_operand_ty, |
| 12218 | | cond_ty, |
| 12219 | | cond_val, |
| 12220 | | src_node_offset, |
| 12221 | | special_members_only, |
| 12222 | | special_generic, |
| 12223 | | has_under, |
| 12224 | | case_vals, |
| 12225 | | scalar_cases_len, |
| 12226 | | multi_cases_len, |
| 12227 | | err_set, |
| 12228 | | empty_enum, |
| 12229 | | operand_is_ref, |
| 12230 | | ); |
| 12231 | | } |
| 12232 | | |
| 12233 | | if (scalar_cases_len + multi_cases_len == 0 and |
| 12234 | | special_members_only == null and |
| 12235 | | !special_generic.is_inline and |
| 12236 | | !extra.data.bits.has_continue) |
| 12237 | | { |
| 12238 | | return spa.resolveProngComptime( |
| 12239 | | &child_block, |
| 12240 | | .special, |
| 12241 | | special_generic.body, |
| 12242 | | special_generic.capture, |
| 12243 | | block.src(.{ .switch_capture = .{ |
| 12244 | | .switch_node_offset = src_node_offset, |
| 12245 | | .case_idx = if (has_under) .special_under else .special_else, |
| 12246 | | } }), |
| 12247 | | undefined, // case_vals may be undefined for special prongs |
| 12248 | | .none, |
| 12249 | | false, |
| 12250 | | merges, |
| 12251 | | ); |
| 12252 | | } |
| 12253 | | }, |
| 12254 | | } |
| 12255 | | |
| 12256 | | if (child_block.isComptime()) { |
| 12257 | | _ = try sema.resolveConstDefinedValue(&child_block, operand_src, operand.simple.cond, null); |
| 12258 | | unreachable; |
| 12259 | | } |
| 12260 | | |
| 12261 | | var extra_case_vals: struct { |
| 12262 | | items: std.ArrayList(Air.Inst.Ref), |
| 12263 | | ranges: std.ArrayList([2]Air.Inst.Ref), |
| 12264 | | } = .{ .items = .empty, .ranges = .empty }; |
| 12265 | | defer { |
| 12266 | | extra_case_vals.items.deinit(gpa); |
| 12267 | | extra_case_vals.ranges.deinit(gpa); |
| 12268 | | } |
| 12269 | | |
| 12270 | | // Runtime switch, if we have a special_members_only prong we need to unroll |
| 12271 | | // it to a prong with explicit items. |
| 12272 | | // Although this is potentially the same as `inline else` it does not count |
| 12273 | | // towards the backward branch quota because it's an implementation detail. |
| 12274 | | if (special_members_only != null) gen: { |
| 12275 | | assert(cond_ty.isNonexhaustiveEnum(zcu)); |
| 12276 | | |
| 12277 | | var min_i: usize = math.maxInt(usize); |
| 12278 | | var max_i: usize = 0; |
| 12279 | | var seen_field_count: usize = 0; |
| 12280 | | for (seen_enum_fields, 0..) |seen, enum_i| { |
| 12281 | | if (seen != null) { |
| 12282 | | seen_field_count += 1; |
| 12283 | | } else { |
| 12284 | | min_i = @min(min_i, enum_i); |
| 12285 | | max_i = @max(max_i, enum_i); |
| 12286 | | } |
| 12287 | | } |
| 12288 | | if (min_i == max_i) { |
| 12289 | | seen_enum_fields[min_i] = special_members_only_src; |
| 12290 | | const item_val = try pt.enumValueFieldIndex(cond_ty, @intCast(min_i)); |
| 12291 | | const item_ref = Air.internedToRef(item_val.toIntern()); |
| 12292 | | try extra_case_vals.items.append(gpa, item_ref); |
| 12293 | | break :gen; |
| 12294 | | } |
| 12295 | | const missing_field_count = seen_enum_fields.len - seen_field_count; |
| 12296 | | |
| 12297 | | extra_case_vals.items = try .initCapacity(gpa, missing_field_count / 2); |
| 12298 | | extra_case_vals.ranges = try .initCapacity(gpa, missing_field_count / 4); |
| 12299 | | const int_ty = cond_ty.intTagType(zcu); |
| 12300 | | |
| 12301 | | var last_val = try pt.enumValueFieldIndex(cond_ty, @intCast(min_i)); |
| 12302 | | var first_ref = Air.internedToRef(last_val.toIntern()); |
| 12303 | | seen_enum_fields[min_i] = special_members_only_src; |
| 12304 | | for (seen_enum_fields[(min_i + 1)..(max_i + 1)], (min_i + 1)..) |seen, enum_i| { |
| 12305 | | if (seen != null) continue; |
| 12306 | | seen_enum_fields[enum_i] = special_members_only_src; |
| 12307 | | |
| 12308 | | const item_val = try pt.enumValueFieldIndex(cond_ty, @intCast(enum_i)); |
| 12309 | | const item_ref = Air.internedToRef(item_val.toIntern()); |
| 12310 | | |
| 12311 | | const is_next = is_next: { |
| 12312 | | const prev_int = ip.indexToKey(last_val.toIntern()).enum_tag.int; |
| 12313 | | |
| 12314 | | const result = try arith.incrementDefinedInt(sema, int_ty, .fromInterned(prev_int)); |
| 12315 | | if (result.overflow) break :is_next false; |
| 12316 | | |
| 12317 | | const item_int = ip.indexToKey(item_val.toIntern()).enum_tag.int; |
| 12318 | | break :is_next try sema.valuesEqual(.fromInterned(item_int), result.val, int_ty); |
| 12319 | | }; |
| 12320 | | |
| 12321 | | if (is_next) { |
| 12322 | | last_val = item_val; |
| 12323 | | } else { |
| 12324 | | const last_ref = Air.internedToRef(last_val.toIntern()); |
| 12325 | | if (first_ref == last_ref) { |
| 12326 | | try extra_case_vals.items.append(gpa, first_ref); |
| 12327 | | } else { |
| 12328 | | try extra_case_vals.ranges.append(gpa, .{ first_ref, last_ref }); |
| 12329 | | } |
| 12330 | | first_ref = item_ref; |
| 12331 | | last_val = item_val; |
| 12332 | | } |
| 12333 | | } |
| 12334 | | const last_ref = Air.internedToRef(last_val.toIntern()); |
| 12335 | | if (first_ref == last_ref) { |
| 12336 | | try extra_case_vals.items.append(gpa, first_ref); |
| 12337 | | } else { |
| 12338 | | try extra_case_vals.ranges.append(gpa, .{ first_ref, last_ref }); |
| 12339 | | } |
| 12340 | | } |
| 12341 | | |
| 12342 | | const air_switch_ref = try sema.analyzeSwitchRuntimeBlock( |
| 12343 | | spa, |
| 12344 | | &child_block, |
| 12345 | | src, |
| 12346 | | switch (operand) { |
| 12347 | | .simple => |s| s.cond, |
| 12348 | | .loop => |l| l.init_cond, |
| 12349 | | }, |
| 12350 | | cond_ty, |
| 12351 | | operand_src, |
| 12352 | | case_vals, |
| 12353 | | special_generic, |
| 12354 | | scalar_cases_len, |
| 12355 | | multi_cases_len, |
| 12356 | | union_originally, |
| 12357 | | raw_operand_ty, |
| 12358 | | err_set, |
| 12359 | | src_node_offset, |
| 12360 | | special_generic_src, |
| 12361 | | has_under, |
| 12362 | | seen_enum_fields, |
| 12363 | | seen_errors, |
| 12364 | | range_set, |
| 12365 | | true_count, |
| 12366 | | false_count, |
| 12367 | | cond_dbg_node_index, |
| 12368 | | false, |
| 12369 | | special_members_only, |
| 12370 | | special_members_only_src, |
| 12371 | | extra_case_vals.items.items, |
| 12372 | | extra_case_vals.ranges.items, |
| 12373 | | ); |
| 12374 | | |
| 12375 | | for (merges.extra_insts.items, merges.extra_src_locs.items) |placeholder_inst, dispatch_src| { |
| 12376 | | var replacement_block = block.makeSubBlock(); |
| 12377 | | defer replacement_block.instructions.deinit(gpa); |
| 12378 | | |
| 12379 | | assert(sema.air_instructions.items(.tag)[@intFromEnum(placeholder_inst)] == .br); |
| 12380 | | const new_operand_maybe_ref = sema.air_instructions.items(.data)[@intFromEnum(placeholder_inst)].br.operand; |
| 12381 | | |
| 12382 | | if (extra.data.bits.any_non_inline_capture) { |
| 12383 | | _ = try replacement_block.addBinOp(.store, operand.loop.operand_alloc, new_operand_maybe_ref); |
| 12384 | | } |
| 12385 | | |
| 12386 | | const new_operand_val = if (operand_is_ref) |
| 12387 | | try sema.analyzeLoad(&replacement_block, dispatch_src, new_operand_maybe_ref, dispatch_src) |
| 12388 | | else |
| 12389 | | new_operand_maybe_ref; |
| 12390 | | |
| 12391 | | const new_cond = try sema.switchCond(&replacement_block, dispatch_src, new_operand_val); |
| 12392 | | |
| 12393 | | if (zcu.backendSupportsFeature(.is_named_enum_value) and block.wantSafety() and |
| 12394 | | cond_ty.zigTypeTag(zcu) == .@"enum" and !cond_ty.isNonexhaustiveEnum(zcu) and |
| 12395 | | !try sema.isComptimeKnown(new_cond)) |
| 12396 | | { |
| 12397 | | const ok = try replacement_block.addUnOp(.is_named_enum_value, new_cond); |
| 12398 | | try sema.addSafetyCheck(&replacement_block, src, ok, .corrupt_switch); |
| 12399 | | } |
| 12400 | | |
| 12401 | | _ = try replacement_block.addInst(.{ |
| 12402 | | .tag = .switch_dispatch, |
| 12403 | | .data = .{ .br = .{ |
| 12404 | | .block_inst = air_switch_ref.toIndex().?, |
| 12405 | | .operand = new_cond, |
| 12406 | | } }, |
| 12407 | | }); |
| 12408 | | |
| 12409 | | if (replacement_block.instructions.items.len == 1) { |
| 12410 | | // Optimization: we don't need a block! |
| 12411 | | sema.air_instructions.set( |
| 12412 | | @intFromEnum(placeholder_inst), |
| 12413 | | sema.air_instructions.get(@intFromEnum(replacement_block.instructions.items[0])), |
| 12414 | | ); |
| 12415 | | continue; |
| 12416 | | } |
| 12304 | } |
| 12417 | 12305 | |
| 12418 | | // Replace placeholder with a block. |
| 12419 | | // No `br` is needed as the block is a switch dispatch so necessarily `noreturn`. |
| 12420 | | try sema.air_extra.ensureUnusedCapacity( |
| 12421 | | gpa, |
| 12422 | | @typeInfo(Air.Block).@"struct".fields.len + replacement_block.instructions.items.len, |
| 12423 | | ); |
| 12424 | | sema.air_instructions.set(@intFromEnum(placeholder_inst), .{ |
| 12425 | | .tag = .block, |
| 12426 | | .data = .{ .ty_pl = .{ |
| 12427 | | .ty = .noreturn_type, |
| 12428 | | .payload = sema.addExtraAssumeCapacity(Air.Block{ |
| 12429 | | .body_len = @intCast(replacement_block.instructions.items.len), |
| 12430 | | }), |
| 12431 | | } }, |
| 12432 | | }); |
| 12433 | | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(replacement_block.instructions.items)); |
| 12434 | | } |
| 12435 | | |
| 12436 | | return sema.resolveAnalyzedBlock(block, src, &child_block, merges, false); |
| 12437 | | } |
| 12438 | | |
| 12439 | | const SpecialProng = struct { |
| 12440 | | body: []const Zir.Inst.Index, |
| 12441 | | end: usize, |
| 12442 | | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 12443 | | is_inline: bool, |
| 12444 | | has_tag_capture: bool, |
| 12445 | | }; |
| 12446 | | |
| 12447 | | fn analyzeSwitchRuntimeBlock( |
| 12306 | fn resolveSwitchBlock( |
| 12448 | 12307 | sema: *Sema, |
| 12449 | | spa: SwitchProngAnalysis, |
| 12450 | | child_block: *Block, |
| 12451 | | src: LazySrcLoc, |
| 12452 | | operand: Air.Inst.Ref, |
| 12453 | | operand_ty: Type, |
| 12454 | | operand_src: LazySrcLoc, |
| 12455 | | case_vals: std.ArrayList(Air.Inst.Ref), |
| 12456 | | else_prong: SpecialProng, |
| 12457 | | scalar_cases_len: usize, |
| 12458 | | multi_cases_len: usize, |
| 12459 | | union_originally: bool, |
| 12460 | | maybe_union_ty: Type, |
| 12461 | | err_set: bool, |
| 12462 | | switch_node_offset: std.zig.Ast.Node.Offset, |
| 12463 | | else_prong_src: LazySrcLoc, |
| 12464 | | else_prong_is_underscore: bool, |
| 12465 | | seen_enum_fields: []?LazySrcLoc, |
| 12466 | | seen_errors: SwitchErrorSet, |
| 12467 | | range_set: RangeSet, |
| 12468 | | true_count: u8, |
| 12469 | | false_count: u8, |
| 12470 | | cond_dbg_node_index: Zir.Inst.Index, |
| 12471 | | allow_err_code_unwrap: bool, |
| 12472 | | extra_prong: ?SpecialProng, |
| 12473 | | /// May be `undefined` if `extra_prong` is `null` |
| 12474 | | extra_prong_src: LazySrcLoc, |
| 12475 | | extra_prong_items: []const Air.Inst.Ref, |
| 12476 | | extra_prong_ranges: []const [2]Air.Inst.Ref, |
| 12477 | | ) CompileError!Air.Inst.Ref { |
| 12478 | | const pt = sema.pt; |
| 12479 | | const zcu = pt.zcu; |
| 12480 | | const gpa = sema.gpa; |
| 12481 | | const ip = &zcu.intern_pool; |
| 12482 | | |
| 12483 | | const block = child_block.parent.?; |
| 12484 | | |
| 12485 | | const estimated_cases_extra = (scalar_cases_len + multi_cases_len) * |
| 12486 | | @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + 2; |
| 12487 | | var cases_extra = try std.ArrayList(u32).initCapacity(gpa, estimated_cases_extra); |
| 12488 | | defer cases_extra.deinit(gpa); |
| 12489 | | |
| 12490 | | var branch_hints = try std.ArrayList(std.builtin.BranchHint).initCapacity(gpa, scalar_cases_len); |
| 12491 | | defer branch_hints.deinit(gpa); |
| 12492 | | |
| 12493 | | var case_block = child_block.makeSubBlock(); |
| 12494 | | case_block.runtime_loop = null; |
| 12495 | | case_block.runtime_cond = operand_src; |
| 12496 | | case_block.runtime_index.increment(); |
| 12497 | | case_block.need_debug_scope = null; // this body is emitted regardless |
| 12498 | | defer case_block.instructions.deinit(gpa); |
| 12499 | | |
| 12500 | | var extra_index: usize = else_prong.end; |
| 12501 | | |
| 12502 | | var scalar_i: usize = 0; |
| 12503 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 12504 | | extra_index += 1; |
| 12505 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 12506 | | extra_index += 1; |
| 12507 | | const body = sema.code.bodySlice(extra_index, info.body_len); |
| 12508 | | extra_index += info.body_len; |
| 12509 | | |
| 12510 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12511 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12512 | | |
| 12513 | | const item = case_vals.items[scalar_i]; |
| 12514 | | // `item` is already guaranteed to be constant known. |
| 12515 | | |
| 12516 | | const analyze_body = if (union_originally) blk: { |
| 12517 | | const unresolved_item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable; |
| 12518 | | const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable; |
| 12519 | | const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?; |
| 12520 | | break :blk field_ty.zigTypeTag(zcu) != .noreturn; |
| 12521 | | } else true; |
| 12522 | | |
| 12523 | | const prong_hint: std.builtin.BranchHint = if (err_set and |
| 12524 | | try sema.maybeErrorUnwrap(&case_block, body, operand, operand_src, allow_err_code_unwrap)) |
| 12525 | | h: { |
| 12526 | | // nothing to do here. weight against error branch |
| 12527 | | break :h .unlikely; |
| 12528 | | } else if (analyze_body) h: { |
| 12529 | | break :h try spa.analyzeProngRuntime( |
| 12530 | | &case_block, |
| 12531 | | .normal, |
| 12532 | | body, |
| 12533 | | info.capture, |
| 12534 | | child_block.src(.{ .switch_capture = .{ |
| 12535 | | .switch_node_offset = switch_node_offset, |
| 12536 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 12537 | | } }), |
| 12538 | | &.{item}, |
| 12539 | | if (info.is_inline) item else .none, |
| 12540 | | info.has_tag_capture, |
| 12541 | | ); |
| 12542 | | } else h: { |
| 12543 | | _ = try case_block.addNoOp(.unreach); |
| 12544 | | break :h .none; |
| 12545 | | }; |
| 12546 | | |
| 12547 | | try branch_hints.append(gpa, prong_hint); |
| 12548 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12549 | | 1 + // `item`, no ranges |
| 12550 | | case_block.instructions.items.len); |
| 12551 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12552 | | .items_len = 1, |
| 12553 | | .ranges_len = 0, |
| 12554 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12555 | | })); |
| 12556 | | cases_extra.appendAssumeCapacity(@intFromEnum(item)); |
| 12557 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12558 | | } |
| 12559 | | |
| 12560 | | var cases_len = scalar_cases_len; |
| 12561 | | var case_val_idx: usize = scalar_cases_len; |
| 12562 | | const multi_cases_len_with_extra_prong = multi_cases_len + @intFromBool(extra_prong != null); |
| 12563 | | var multi_i: u32 = 0; |
| 12564 | | while (multi_i < multi_cases_len_with_extra_prong) : (multi_i += 1) { |
| 12565 | | const is_extra_prong = multi_i == multi_cases_len; |
| 12566 | | var items: []const Air.Inst.Ref = undefined; |
| 12567 | | var info: Zir.Inst.SwitchBlock.ProngInfo = undefined; |
| 12568 | | var ranges: []const [2]Air.Inst.Ref = undefined; |
| 12569 | | var body: []const Zir.Inst.Index = undefined; |
| 12570 | | if (is_extra_prong) { |
| 12571 | | const prong = extra_prong.?; |
| 12572 | | items = extra_prong_items; |
| 12573 | | ranges = extra_prong_ranges; |
| 12574 | | body = prong.body; |
| 12575 | | info = .{ |
| 12576 | | .body_len = undefined, |
| 12577 | | .capture = prong.capture, |
| 12578 | | .is_inline = prong.is_inline, |
| 12579 | | .has_tag_capture = prong.has_tag_capture, |
| 12580 | | }; |
| 12581 | | } else { |
| 12582 | | @branchHint(.likely); |
| 12583 | | const items_len = sema.code.extra[extra_index]; |
| 12584 | | extra_index += 1; |
| 12585 | | const ranges_len = sema.code.extra[extra_index]; |
| 12586 | | extra_index += 1; |
| 12587 | | info = @bitCast(sema.code.extra[extra_index]); |
| 12588 | | extra_index += 1 + items_len + ranges_len * 2; |
| 12589 | | |
| 12590 | | items = case_vals.items[case_val_idx..][0..items_len]; |
| 12591 | | case_val_idx += items_len; |
| 12592 | | ranges = @ptrCast(case_vals.items[case_val_idx..][0 .. ranges_len * 2]); |
| 12593 | | case_val_idx += ranges_len * 2; |
| 12594 | | |
| 12595 | | body = sema.code.bodySlice(extra_index, info.body_len); |
| 12596 | | extra_index += info.body_len; |
| 12597 | | } |
| 12598 | | |
| 12599 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12600 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12601 | | |
| 12602 | | // Generate all possible cases as scalar prongs. |
| 12603 | | if (info.is_inline) { |
| 12604 | | var emit_bb = false; |
| 12605 | | |
| 12606 | | for (ranges, 0..) |range_items, range_i| { |
| 12607 | | var item = sema.resolveConstDefinedValue(block, .unneeded, range_items[0], undefined) catch unreachable; |
| 12608 | | const item_last = sema.resolveConstDefinedValue(block, .unneeded, range_items[1], undefined) catch unreachable; |
| 12609 | | |
| 12610 | | while (item.compareScalar(.lte, item_last, operand_ty, zcu)) : ({ |
| 12611 | | // Previous validation has resolved any possible lazy values. |
| 12612 | | const int_val: Value, const int_ty: Type = switch (operand_ty.zigTypeTag(zcu)) { |
| 12613 | | .int => .{ item, operand_ty }, |
| 12614 | | .@"enum" => b: { |
| 12615 | | const int_val = Value.fromInterned(ip.indexToKey(item.toIntern()).enum_tag.int); |
| 12616 | | break :b .{ int_val, int_val.typeOf(zcu) }; |
| 12617 | | }, |
| 12618 | | else => unreachable, |
| 12619 | | }; |
| 12620 | | const result = try arith.incrementDefinedInt(sema, int_ty, int_val); |
| 12621 | | assert(!result.overflow); |
| 12622 | | item = switch (operand_ty.zigTypeTag(zcu)) { |
| 12623 | | .int => result.val, |
| 12624 | | .@"enum" => .fromInterned(try pt.intern(.{ .enum_tag = .{ |
| 12625 | | .ty = operand_ty.toIntern(), |
| 12626 | | .int = result.val.toIntern(), |
| 12627 | | } })), |
| 12628 | | else => unreachable, |
| 12629 | | }; |
| 12630 | | }) { |
| 12631 | | cases_len += 1; |
| 12632 | | |
| 12633 | | const item_ref = Air.internedToRef(item.toIntern()); |
| 12634 | | |
| 12635 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12636 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12637 | | |
| 12638 | | if (emit_bb) { |
| 12639 | | const bb_src = if (is_extra_prong) extra_prong_src else block.src(.{ .switch_case_item = .{ |
| 12640 | | .switch_node_offset = switch_node_offset, |
| 12641 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12642 | | .item_idx = .{ .kind = .range, .index = @intCast(range_i) }, |
| 12643 | | } }); |
| 12644 | | try sema.emitBackwardBranch(block, bb_src); |
| 12645 | | } |
| 12646 | | emit_bb = true; |
| 12647 | | |
| 12648 | | const prong_hint = try spa.analyzeProngRuntime( |
| 12649 | | &case_block, |
| 12650 | | .normal, |
| 12651 | | body, |
| 12652 | | info.capture, |
| 12653 | | child_block.src(.{ .switch_capture = .{ |
| 12654 | | .switch_node_offset = switch_node_offset, |
| 12655 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12656 | | } }), |
| 12657 | | undefined, // case_vals may be undefined for ranges |
| 12658 | | item_ref, |
| 12659 | | info.has_tag_capture, |
| 12660 | | ); |
| 12661 | | try branch_hints.append(gpa, prong_hint); |
| 12662 | | |
| 12663 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12664 | | 1 + // `item`, no ranges |
| 12665 | | case_block.instructions.items.len); |
| 12666 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12667 | | .items_len = 1, |
| 12668 | | .ranges_len = 0, |
| 12669 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12670 | | })); |
| 12671 | | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 12672 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12673 | | |
| 12674 | | if (item.compareScalar(.eq, item_last, operand_ty, zcu)) break; |
| 12675 | | } |
| 12676 | | } |
| 12677 | | |
| 12678 | | for (items, 0..) |item, item_i| { |
| 12679 | | cases_len += 1; |
| 12680 | | |
| 12681 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12682 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12683 | | |
| 12684 | | const analyze_body = if (union_originally) blk: { |
| 12685 | | const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable; |
| 12686 | | const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?; |
| 12687 | | break :blk field_ty.zigTypeTag(zcu) != .noreturn; |
| 12688 | | } else true; |
| 12689 | | |
| 12690 | | if (emit_bb) { |
| 12691 | | const bb_src = if (is_extra_prong) extra_prong_src else block.src(.{ .switch_case_item = .{ |
| 12692 | | .switch_node_offset = switch_node_offset, |
| 12693 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12694 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 12695 | | } }); |
| 12696 | | try sema.emitBackwardBranch(block, bb_src); |
| 12697 | | } |
| 12698 | | emit_bb = true; |
| 12699 | | |
| 12700 | | const prong_hint: std.builtin.BranchHint = if (analyze_body) h: { |
| 12701 | | break :h try spa.analyzeProngRuntime( |
| 12702 | | &case_block, |
| 12703 | | .normal, |
| 12704 | | body, |
| 12705 | | info.capture, |
| 12706 | | child_block.src(.{ .switch_capture = .{ |
| 12707 | | .switch_node_offset = switch_node_offset, |
| 12708 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12709 | | } }), |
| 12710 | | &.{item}, |
| 12711 | | item, |
| 12712 | | info.has_tag_capture, |
| 12713 | | ); |
| 12714 | | } else h: { |
| 12715 | | _ = try case_block.addNoOp(.unreach); |
| 12716 | | break :h .none; |
| 12717 | | }; |
| 12718 | | try branch_hints.append(gpa, prong_hint); |
| 12719 | | |
| 12720 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12721 | | 1 + // `item`, no ranges |
| 12722 | | case_block.instructions.items.len); |
| 12723 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12724 | | .items_len = 1, |
| 12725 | | .ranges_len = 0, |
| 12726 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12727 | | })); |
| 12728 | | cases_extra.appendAssumeCapacity(@intFromEnum(item)); |
| 12729 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12730 | | } |
| 12731 | | |
| 12732 | | continue; |
| 12733 | | } |
| 12734 | | |
| 12735 | | cases_len += 1; |
| 12736 | | |
| 12737 | | const analyze_body = if (union_originally) |
| 12738 | | for (items) |item| { |
| 12739 | | const item_val = sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, item, undefined) catch unreachable; |
| 12740 | | const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?; |
| 12741 | | if (field_ty.zigTypeTag(zcu) != .noreturn) break true; |
| 12742 | | } else false |
| 12743 | | else |
| 12744 | | true; |
| 12745 | | |
| 12746 | | const prong_hint: std.builtin.BranchHint = if (err_set and |
| 12747 | | try sema.maybeErrorUnwrap(&case_block, body, operand, operand_src, allow_err_code_unwrap)) |
| 12748 | | h: { |
| 12749 | | // nothing to do here. weight against error branch |
| 12750 | | break :h .unlikely; |
| 12751 | | } else if (analyze_body) h: { |
| 12752 | | break :h try spa.analyzeProngRuntime( |
| 12753 | | &case_block, |
| 12754 | | .normal, |
| 12755 | | body, |
| 12756 | | info.capture, |
| 12757 | | child_block.src(.{ .switch_capture = .{ |
| 12758 | | .switch_node_offset = switch_node_offset, |
| 12759 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 12760 | | } }), |
| 12761 | | items, |
| 12762 | | .none, |
| 12763 | | false, |
| 12764 | | ); |
| 12765 | | } else h: { |
| 12766 | | _ = try case_block.addNoOp(.unreach); |
| 12767 | | break :h .none; |
| 12768 | | }; |
| 12769 | | |
| 12770 | | try branch_hints.append(gpa, prong_hint); |
| 12771 | | |
| 12772 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12773 | | items.len + ranges.len * 2 + |
| 12774 | | case_block.instructions.items.len); |
| 12775 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12776 | | .items_len = @intCast(items.len), |
| 12777 | | .ranges_len = @intCast(ranges.len), |
| 12778 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12779 | | })); |
| 12780 | | |
| 12781 | | for (items) |item| { |
| 12782 | | cases_extra.appendAssumeCapacity(@intFromEnum(item)); |
| 12783 | | } |
| 12784 | | for (ranges) |range| { |
| 12785 | | cases_extra.appendSliceAssumeCapacity(&.{ |
| 12786 | | @intFromEnum(range[0]), |
| 12787 | | @intFromEnum(range[1]), |
| 12788 | | }); |
| 12789 | | } |
| 12790 | | |
| 12791 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12792 | | } |
| 12793 | | |
| 12794 | | const else_body: []const Air.Inst.Index = if (else_prong.body.len != 0 or case_block.wantSafety()) else_body: { |
| 12795 | | var emit_bb = false; |
| 12796 | | // If this is true we must have a 'true' else prong and not an underscore because |
| 12797 | | // underscore prongs can never be inlined. We've already checked for this. |
| 12798 | | if (else_prong.is_inline) switch (operand_ty.zigTypeTag(zcu)) { |
| 12799 | | .@"enum" => { |
| 12800 | | if (operand_ty.isNonexhaustiveEnum(zcu) and !union_originally) { |
| 12801 | | return sema.fail(block, else_prong_src, "cannot enumerate values of type '{f}' for 'inline else'", .{ |
| 12802 | | operand_ty.fmt(pt), |
| 12803 | | }); |
| 12804 | | } |
| 12805 | | for (seen_enum_fields, 0..) |f, i| { |
| 12806 | | if (f != null) continue; |
| 12807 | | cases_len += 1; |
| 12808 | | |
| 12809 | | const item_val = try pt.enumValueFieldIndex(operand_ty, @intCast(i)); |
| 12810 | | const item_ref = Air.internedToRef(item_val.toIntern()); |
| 12811 | | |
| 12812 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12813 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12814 | | |
| 12815 | | const analyze_body = if (union_originally) blk: { |
| 12816 | | const field_ty = maybe_union_ty.unionFieldType(item_val, zcu).?; |
| 12817 | | break :blk field_ty.zigTypeTag(zcu) != .noreturn; |
| 12818 | | } else true; |
| 12819 | | |
| 12820 | | if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); |
| 12821 | | emit_bb = true; |
| 12822 | | |
| 12823 | | const prong_hint: std.builtin.BranchHint = if (analyze_body) h: { |
| 12824 | | break :h try spa.analyzeProngRuntime( |
| 12825 | | &case_block, |
| 12826 | | .special, |
| 12827 | | else_prong.body, |
| 12828 | | else_prong.capture, |
| 12829 | | child_block.src(.{ .switch_capture = .{ |
| 12830 | | .switch_node_offset = switch_node_offset, |
| 12831 | | .case_idx = .special_else, |
| 12832 | | } }), |
| 12833 | | &.{item_ref}, |
| 12834 | | item_ref, |
| 12835 | | else_prong.has_tag_capture, |
| 12836 | | ); |
| 12837 | | } else h: { |
| 12838 | | _ = try case_block.addNoOp(.unreach); |
| 12839 | | break :h .none; |
| 12840 | | }; |
| 12841 | | try branch_hints.append(gpa, prong_hint); |
| 12842 | | |
| 12843 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12844 | | 1 + // `item`, no ranges |
| 12845 | | case_block.instructions.items.len); |
| 12846 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12847 | | .items_len = 1, |
| 12848 | | .ranges_len = 0, |
| 12849 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12850 | | })); |
| 12851 | | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 12852 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12853 | | } |
| 12854 | | }, |
| 12855 | | .error_set => { |
| 12856 | | if (operand_ty.isAnyError(zcu)) { |
| 12857 | | return sema.fail(block, else_prong_src, "cannot enumerate values of type '{f}' for 'inline else'", .{ |
| 12858 | | operand_ty.fmt(pt), |
| 12859 | | }); |
| 12860 | | } |
| 12861 | | const error_names = operand_ty.errorSetNames(zcu); |
| 12862 | | for (0..error_names.len) |name_index| { |
| 12863 | | const error_name = error_names.get(ip)[name_index]; |
| 12864 | | if (seen_errors.contains(error_name)) continue; |
| 12865 | | cases_len += 1; |
| 12866 | | |
| 12867 | | const item_val = try pt.intern(.{ .err = .{ |
| 12868 | | .ty = operand_ty.toIntern(), |
| 12869 | | .name = error_name, |
| 12870 | | } }); |
| 12871 | | const item_ref = Air.internedToRef(item_val); |
| 12872 | | |
| 12873 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12874 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12875 | | |
| 12876 | | if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); |
| 12877 | | emit_bb = true; |
| 12878 | | |
| 12879 | | const prong_hint = try spa.analyzeProngRuntime( |
| 12880 | | &case_block, |
| 12881 | | .special, |
| 12882 | | else_prong.body, |
| 12883 | | else_prong.capture, |
| 12884 | | child_block.src(.{ .switch_capture = .{ |
| 12885 | | .switch_node_offset = switch_node_offset, |
| 12886 | | .case_idx = .special_else, |
| 12887 | | } }), |
| 12888 | | &.{item_ref}, |
| 12889 | | item_ref, |
| 12890 | | else_prong.has_tag_capture, |
| 12891 | | ); |
| 12892 | | try branch_hints.append(gpa, prong_hint); |
| 12893 | | |
| 12894 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12895 | | 1 + // `item`, no ranges |
| 12896 | | case_block.instructions.items.len); |
| 12897 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12898 | | .items_len = 1, |
| 12899 | | .ranges_len = 0, |
| 12900 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12901 | | })); |
| 12902 | | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 12903 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12904 | | } |
| 12905 | | }, |
| 12906 | | .int => { |
| 12907 | | var it = try RangeSetUnhandledIterator.init(sema, operand_ty, range_set); |
| 12908 | | while (try it.next()) |cur| { |
| 12909 | | cases_len += 1; |
| 12910 | | |
| 12911 | | const item_ref = Air.internedToRef(cur); |
| 12912 | | |
| 12913 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12914 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12915 | | |
| 12916 | | if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); |
| 12917 | | emit_bb = true; |
| 12918 | | |
| 12919 | | const prong_hint = try spa.analyzeProngRuntime( |
| 12920 | | &case_block, |
| 12921 | | .special, |
| 12922 | | else_prong.body, |
| 12923 | | else_prong.capture, |
| 12924 | | child_block.src(.{ .switch_capture = .{ |
| 12925 | | .switch_node_offset = switch_node_offset, |
| 12926 | | .case_idx = .special_else, |
| 12927 | | } }), |
| 12928 | | &.{item_ref}, |
| 12929 | | item_ref, |
| 12930 | | else_prong.has_tag_capture, |
| 12931 | | ); |
| 12932 | | try branch_hints.append(gpa, prong_hint); |
| 12933 | | |
| 12934 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12935 | | 1 + // `item`, no ranges |
| 12936 | | case_block.instructions.items.len); |
| 12937 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12938 | | .items_len = 1, |
| 12939 | | .ranges_len = 0, |
| 12940 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12941 | | })); |
| 12942 | | cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); |
| 12943 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12944 | | } |
| 12945 | | }, |
| 12946 | | .bool => { |
| 12947 | | if (true_count == 0) { |
| 12948 | | cases_len += 1; |
| 12949 | | |
| 12950 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12951 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12952 | | |
| 12953 | | if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); |
| 12954 | | emit_bb = true; |
| 12955 | | |
| 12956 | | const prong_hint = try spa.analyzeProngRuntime( |
| 12957 | | &case_block, |
| 12958 | | .special, |
| 12959 | | else_prong.body, |
| 12960 | | else_prong.capture, |
| 12961 | | child_block.src(.{ .switch_capture = .{ |
| 12962 | | .switch_node_offset = switch_node_offset, |
| 12963 | | .case_idx = .special_else, |
| 12964 | | } }), |
| 12965 | | &.{.bool_true}, |
| 12966 | | .bool_true, |
| 12967 | | else_prong.has_tag_capture, |
| 12968 | | ); |
| 12969 | | try branch_hints.append(gpa, prong_hint); |
| 12970 | | |
| 12971 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 12972 | | 1 + // `item`, no ranges |
| 12973 | | case_block.instructions.items.len); |
| 12974 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 12975 | | .items_len = 1, |
| 12976 | | .ranges_len = 0, |
| 12977 | | .body_len = @intCast(case_block.instructions.items.len), |
| 12978 | | })); |
| 12979 | | cases_extra.appendAssumeCapacity(@intFromEnum(Air.Inst.Ref.bool_true)); |
| 12980 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 12981 | | } |
| 12982 | | if (false_count == 0) { |
| 12983 | | cases_len += 1; |
| 12984 | | |
| 12985 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 12986 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 12987 | | |
| 12988 | | if (emit_bb) try sema.emitBackwardBranch(block, else_prong_src); |
| 12989 | | emit_bb = true; |
| 12990 | | |
| 12991 | | const prong_hint = try spa.analyzeProngRuntime( |
| 12992 | | &case_block, |
| 12993 | | .special, |
| 12994 | | else_prong.body, |
| 12995 | | else_prong.capture, |
| 12996 | | child_block.src(.{ .switch_capture = .{ |
| 12997 | | .switch_node_offset = switch_node_offset, |
| 12998 | | .case_idx = .special_else, |
| 12999 | | } }), |
| 13000 | | &.{.bool_false}, |
| 13001 | | .bool_false, |
| 13002 | | else_prong.has_tag_capture, |
| 13003 | | ); |
| 13004 | | try branch_hints.append(gpa, prong_hint); |
| 13005 | | |
| 13006 | | try cases_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 13007 | | 1 + // `item`, no ranges |
| 13008 | | case_block.instructions.items.len); |
| 13009 | | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 13010 | | .items_len = 1, |
| 13011 | | .ranges_len = 0, |
| 13012 | | .body_len = @intCast(case_block.instructions.items.len), |
| 13013 | | })); |
| 13014 | | cases_extra.appendAssumeCapacity(@intFromEnum(Air.Inst.Ref.bool_false)); |
| 13015 | | cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); |
| 13016 | | } |
| 13017 | | }, |
| 13018 | | else => return sema.fail(block, else_prong_src, "cannot enumerate values of type '{f}' for 'inline else'", .{ |
| 13019 | | operand_ty.fmt(pt), |
| 13020 | | }), |
| 13021 | | }; |
| 13022 | | |
| 13023 | | case_block.instructions.shrinkRetainingCapacity(0); |
| 13024 | | case_block.error_return_trace_index = child_block.error_return_trace_index; |
| 13025 | | |
| 13026 | | if (zcu.backendSupportsFeature(.is_named_enum_value) and |
| 13027 | | else_prong.body.len != 0 and block.wantSafety() and |
| 13028 | | operand_ty.zigTypeTag(zcu) == .@"enum" and |
| 13029 | | (!operand_ty.isNonexhaustiveEnum(zcu) or union_originally)) |
| 13030 | | { |
| 13031 | | try sema.zirDbgStmt(&case_block, cond_dbg_node_index); |
| 13032 | | const ok = try case_block.addUnOp(.is_named_enum_value, operand); |
| 13033 | | try sema.addSafetyCheck(&case_block, src, ok, .corrupt_switch); |
| 13034 | | } |
| 13035 | | |
| 13036 | | const else_src_idx: LazySrcLoc.Offset.SwitchCaseIndex = if (else_prong_is_underscore) |
| 13037 | | .special_under |
| 13038 | | else |
| 13039 | | .special_else; |
| 13040 | | |
| 13041 | | const analyze_body = if (union_originally and !else_prong.is_inline) |
| 13042 | | for (seen_enum_fields, 0..) |seen_field, index| { |
| 13043 | | if (seen_field != null) continue; |
| 13044 | | const union_obj = zcu.typeToUnion(maybe_union_ty).?; |
| 13045 | | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[index]); |
| 13046 | | if (field_ty.zigTypeTag(zcu) != .noreturn) break true; |
| 13047 | | } else false |
| 13048 | | else |
| 13049 | | true; |
| 13050 | | const else_hint: std.builtin.BranchHint = if (else_prong.body.len != 0 and err_set and |
| 13051 | | try sema.maybeErrorUnwrap(&case_block, else_prong.body, operand, operand_src, allow_err_code_unwrap)) |
| 13052 | | h: { |
| 13053 | | // nothing to do here. weight against error branch |
| 13054 | | break :h .unlikely; |
| 13055 | | } else if (else_prong.body.len != 0 and analyze_body and !else_prong.is_inline) h: { |
| 13056 | | break :h try spa.analyzeProngRuntime( |
| 13057 | | &case_block, |
| 13058 | | .special, |
| 13059 | | else_prong.body, |
| 13060 | | else_prong.capture, |
| 13061 | | child_block.src(.{ .switch_capture = .{ |
| 13062 | | .switch_node_offset = switch_node_offset, |
| 13063 | | .case_idx = else_src_idx, |
| 13064 | | } }), |
| 13065 | | undefined, // case_vals may be undefined for special prongs |
| 13066 | | .none, |
| 13067 | | false, |
| 13068 | | ); |
| 13069 | | } else h: { |
| 13070 | | // We still need a terminator in this block, but we have proven |
| 13071 | | // that it is unreachable. |
| 13072 | | if (case_block.wantSafety()) { |
| 13073 | | try sema.zirDbgStmt(&case_block, cond_dbg_node_index); |
| 13074 | | try sema.safetyPanic(&case_block, src, .corrupt_switch); |
| 13075 | | } else { |
| 13076 | | _ = try case_block.addNoOp(.unreach); |
| 13077 | | } |
| 13078 | | // Safety check / unreachable branches are cold. |
| 13079 | | break :h .cold; |
| 13080 | | }; |
| 13081 | | |
| 13082 | | try branch_hints.append(gpa, else_hint); |
| 13083 | | break :else_body case_block.instructions.items; |
| 13084 | | } else else_body: { |
| 13085 | | try branch_hints.append(gpa, .none); |
| 13086 | | break :else_body &.{}; |
| 13087 | | }; |
| 13088 | | |
| 13089 | | assert(branch_hints.items.len == cases_len + 1); |
| 13090 | | |
| 13091 | | try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.SwitchBr).@"struct".fields.len + |
| 13092 | | cases_extra.items.len + else_body.len + |
| 13093 | | (std.math.divCeil(usize, branch_hints.items.len, 10) catch unreachable)); // branch hints |
| 13094 | | |
| 13095 | | const payload_index = sema.addExtraAssumeCapacity(Air.SwitchBr{ |
| 13096 | | .cases_len = @intCast(cases_len), |
| 13097 | | .else_body_len = @intCast(else_body.len), |
| 13098 | | }); |
| 13099 | | |
| 13100 | | { |
| 13101 | | // Add branch hints. |
| 13102 | | var cur_bag: u32 = 0; |
| 13103 | | for (branch_hints.items, 0..) |hint, idx| { |
| 13104 | | const idx_in_bag = idx % 10; |
| 13105 | | cur_bag |= @as(u32, @intFromEnum(hint)) << @intCast(idx_in_bag * 3); |
| 13106 | | if (idx_in_bag == 9) { |
| 13107 | | sema.air_extra.appendAssumeCapacity(cur_bag); |
| 13108 | | cur_bag = 0; |
| 13109 | | } |
| 13110 | | } |
| 13111 | | if (branch_hints.items.len % 10 != 0) { |
| 13112 | | sema.air_extra.appendAssumeCapacity(cur_bag); |
| 13113 | | } |
| 13114 | | } |
| 13115 | | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(cases_extra.items)); |
| 13116 | | sema.air_extra.appendSliceAssumeCapacity(@ptrCast(else_body)); |
| 13117 | | |
| 13118 | | const has_any_continues = spa.operand == .loop and child_block.label.?.merges.extra_insts.items.len > 0; |
| 13119 | | |
| 13120 | | return try child_block.addInst(.{ |
| 13121 | | .tag = if (has_any_continues) .loop_switch_br else .switch_br, |
| 13122 | | .data = .{ .pl_op = .{ |
| 13123 | | .operand = operand, |
| 13124 | | .payload = payload_index, |
| 13125 | | } }, |
| 13126 | | }); |
| 13127 | | } |
| 13128 | | |
| 13129 | | fn resolveSwitchComptimeLoop( |
| 13130 | | sema: *Sema, |
| 13131 | | init_spa: SwitchProngAnalysis, |
| 13132 | | child_block: *Block, |
| 13133 | | maybe_ptr_operand_ty: Type, |
| 13134 | | cond_ty: Type, |
| 13135 | | init_cond_val: Value, |
| 13136 | | switch_node_offset: std.zig.Ast.Node.Offset, |
| 13137 | | special_members_only: ?SpecialProng, |
| 13138 | | special_generic: SpecialProng, |
| 13139 | | special_generic_is_under: bool, |
| 13140 | | case_vals: std.ArrayList(Air.Inst.Ref), |
| 13141 | | scalar_cases_len: u32, |
| 13142 | | multi_cases_len: u32, |
| 13143 | | err_set: bool, |
| 13144 | | empty_enum: bool, |
| 13145 | | operand_is_ref: bool, |
| 13146 | | ) CompileError!Air.Inst.Ref { |
| 13147 | | var spa = init_spa; |
| 13148 | | var cond_val = init_cond_val; |
| 13149 | | |
| 13150 | | while (true) { |
| 13151 | | if (resolveSwitchComptime( |
| 13152 | | sema, |
| 13153 | | spa, |
| 13154 | | child_block, |
| 13155 | | spa.operand.simple.cond, |
| 13156 | | cond_val, |
| 13157 | | cond_ty, |
| 13158 | | switch_node_offset, |
| 13159 | | special_members_only, |
| 13160 | | special_generic, |
| 13161 | | special_generic_is_under, |
| 13162 | | case_vals, |
| 13163 | | scalar_cases_len, |
| 13164 | | multi_cases_len, |
| 13165 | | err_set, |
| 13166 | | empty_enum, |
| 13167 | | )) |result| { |
| 13168 | | return result; |
| 13169 | | } else |err| switch (err) { |
| 13170 | | error.ComptimeBreak => { |
| 13171 | | const break_inst = sema.code.instructions.get(@intFromEnum(sema.comptime_break_inst)); |
| 13172 | | if (break_inst.tag != .switch_continue) return error.ComptimeBreak; |
| 13173 | | const extra = sema.code.extraData(Zir.Inst.Break, break_inst.data.@"break".payload_index).data; |
| 13174 | | if (extra.block_inst != spa.switch_block_inst) return error.ComptimeBreak; |
| 13175 | | // This is a `switch_continue` targeting this block. Change the operand and start over. |
| 13176 | | const src = child_block.nodeOffset(extra.operand_src_node.unwrap().?); |
| 13177 | | const new_operand_uncoerced = try sema.resolveInst(break_inst.data.@"break".operand); |
| 13178 | | const new_operand = try sema.coerce(child_block, maybe_ptr_operand_ty, new_operand_uncoerced, src); |
| 13179 | | |
| 13180 | | try sema.emitBackwardBranch(child_block, src); |
| 13181 | | |
| 13182 | | const val, const ref = if (operand_is_ref) |
| 13183 | | .{ try sema.analyzeLoad(child_block, src, new_operand, src), new_operand } |
| 13184 | | else |
| 13185 | | .{ new_operand, undefined }; |
| 13186 | | |
| 13187 | | const cond_ref = try sema.switchCond(child_block, src, val); |
| 13188 | | |
| 13189 | | cond_val = try sema.resolveConstDefinedValue(child_block, src, cond_ref, null); |
| 13190 | | spa.operand = .{ .simple = .{ |
| 13191 | | .by_val = val, |
| 13192 | | .by_ref = ref, |
| 13193 | | .cond = cond_ref, |
| 13194 | | } }; |
| 13195 | | }, |
| 13196 | | else => |e| return e, |
| 13197 | | } |
| 13198 | | } |
| 13199 | | } |
| 13200 | | |
| 13201 | | fn resolveSwitchComptime( |
| 13202 | | sema: *Sema, |
| 13203 | | spa: SwitchProngAnalysis, |
| 12308 | block: *Block, |
| 13204 | 12309 | child_block: *Block, |
| 13205 | | cond_operand: Air.Inst.Ref, |
| 13206 | | operand_val: Value, |
| 13207 | | operand_ty: Type, |
| 13208 | | switch_node_offset: std.zig.Ast.Node.Offset, |
| 13209 | | special_members_only: ?SpecialProng, |
| 13210 | | special_generic: SpecialProng, |
| 13211 | | special_generic_is_under: bool, |
| 13212 | | case_vals: std.ArrayList(Air.Inst.Ref), |
| 13213 | | scalar_cases_len: u32, |
| 13214 | | multi_cases_len: u32, |
| 13215 | | err_set: bool, |
| 13216 | | empty_enum: bool, |
| 12310 | operand: SwitchOperand, |
| 12311 | raw_operand_ty: Type, |
| 12312 | maybe_lazy_cond_val: Value, |
| 12313 | catch_all_case: CatchAllSwitchCase, |
| 12314 | else_is_named_only: bool, |
| 12315 | merges: *Block.Merges, |
| 12316 | switch_inst: Zir.Inst.Index, |
| 12317 | zir_switch: *const Zir.UnwrappedSwitchBlock, |
| 12318 | validated_switch: *const ValidatedSwitchBlock, |
| 13217 | 12319 | ) CompileError!Air.Inst.Ref { |
| 13218 | | const zcu = sema.pt.zcu; |
| 13219 | | const merges = &child_block.label.?.merges; |
| 13220 | | const resolved_operand_val = try sema.resolveLazyValue(operand_val); |
| 12320 | const pt = sema.pt; |
| 12321 | const zcu = pt.zcu; |
| 13221 | 12322 | |
| 13222 | | var extra_index: usize = special_generic.end; |
| 13223 | | { |
| 13224 | | var scalar_i: usize = 0; |
| 13225 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 13226 | | extra_index += 1; |
| 13227 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 13228 | | extra_index += 1; |
| 13229 | | const body = sema.code.bodySlice(extra_index, info.body_len); |
| 13230 | | extra_index += info.body_len; |
| 13231 | | |
| 13232 | | const item = case_vals.items[scalar_i]; |
| 13233 | | const item_val = sema.resolveConstDefinedValue(child_block, LazySrcLoc.unneeded, item, undefined) catch unreachable; |
| 13234 | | if (operand_val.eql(item_val, operand_ty, sema.pt.zcu)) { |
| 13235 | | if (err_set) try sema.maybeErrorUnwrapComptime(child_block, body, cond_operand); |
| 13236 | | return spa.resolveProngComptime( |
| 12323 | const switch_node_offset = zir_switch.switch_src_node_offset; |
| 12324 | |
| 12325 | const operand_ty = sema.typeOf(operand.simple.by_val); |
| 12326 | const item_ty = switch (operand_ty.zigTypeTag(zcu)) { |
| 12327 | .@"union" => operand_ty.unionTagType(zcu).?, |
| 12328 | else => operand_ty, |
| 12329 | }; |
| 12330 | const union_originally = operand_ty.zigTypeTag(zcu) == .@"union"; |
| 12331 | const err_set = item_ty.zigTypeTag(zcu) == .error_set; |
| 12332 | |
| 12333 | const cond_ref = operand.simple.cond; |
| 12334 | // We have to resolve lazy values to ensure that comparisons with switch |
| 12335 | // prong items don't produce false negatives. |
| 12336 | const cond_val = try sema.resolveLazyValue(maybe_lazy_cond_val); |
| 12337 | |
| 12338 | const case_vals = validated_switch.case_vals; |
| 12339 | var case_val_idx: usize = 0; |
| 12340 | var extra_index = zir_switch.end; |
| 12341 | var case_it = zir_switch.iterateCases(); |
| 12342 | var under_prong: ?struct { |
| 12343 | index: Zir.UnwrappedSwitchBlock.Case.Index, |
| 12344 | body: []const Zir.Inst.Index, |
| 12345 | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 12346 | has_tag_capture: bool, |
| 12347 | } = null; |
| 12348 | while (case_it.next()) |case| { |
| 12349 | const prong_info = case.prong_info; |
| 12350 | const prong_body = sema.code.bodySlice(extra_index, prong_info.body_len); |
| 12351 | extra_index += prong_body.len; |
| 12352 | for (case.item_infos) |item_info| { |
| 12353 | if (item_info.bodyLen()) |body_len| extra_index += body_len; |
| 12354 | } |
| 12355 | for (case.range_infos) |range_info| { |
| 12356 | if (range_info[0].bodyLen()) |body_len| extra_index += body_len; |
| 12357 | if (range_info[1].bodyLen()) |body_len| extra_index += body_len; |
| 12358 | } |
| 12359 | |
| 12360 | const item_refs = case_vals[case_val_idx..][0..case.item_infos.len]; |
| 12361 | case_val_idx += item_refs.len; |
| 12362 | const range_refs: []const [2]Air.Inst.Ref = @ptrCast(case_vals[case_val_idx..][0 .. 2 * case.range_infos.len]); |
| 12363 | case_val_idx += 2 * range_refs.len; |
| 12364 | for (item_refs) |item_ref| { |
| 12365 | if (item_ref == .none) { |
| 12366 | under_prong = .{ |
| 12367 | .index = case.index, |
| 12368 | .body = prong_body, |
| 12369 | .capture = case.prong_info.capture, |
| 12370 | .has_tag_capture = case.prong_info.has_tag_capture, |
| 12371 | }; |
| 12372 | continue; |
| 12373 | } |
| 12374 | const item_val = sema.resolveConstDefinedValue(child_block, .unneeded, item_ref, undefined) catch unreachable; |
| 12375 | if (cond_val.eql(item_val, item_ty, zcu)) { |
| 12376 | if (err_set) try sema.maybeErrorUnwrapComptime(child_block, prong_body, cond_ref); |
| 12377 | if (union_originally and operand_ty.unionFieldType(item_val, zcu).?.isNoReturn(zcu)) { |
| 12378 | // This prong should be unreachable! |
| 12379 | return .unreachable_value; |
| 12380 | } |
| 12381 | return sema.resolveSwitchProng( |
| 12382 | block, |
| 13237 | 12383 | child_block, |
| 13238 | | .normal, |
| 13239 | | body, |
| 13240 | | info.capture, |
| 13241 | | child_block.src(.{ .switch_capture = .{ |
| 12384 | operand, |
| 12385 | raw_operand_ty, |
| 12386 | prong_body, |
| 12387 | block.src(.{ .switch_capture = .{ |
| 13242 | 12388 | .switch_node_offset = switch_node_offset, |
| 13243 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 12389 | .case_idx = case.index, |
| 13244 | 12390 | } }), |
| 13245 | | &.{item}, |
| 13246 | | if (info.is_inline) cond_operand else .none, |
| 13247 | | info.has_tag_capture, |
| 12391 | prong_info.capture, |
| 12392 | prong_info.has_tag_capture, |
| 12393 | if (prong_info.is_inline) cond_ref else .none, |
| 12394 | .{ .item_refs = item_refs }, |
| 12395 | validated_switch.else_err_ty, |
| 13248 | 12396 | merges, |
| 12397 | switch_inst, |
| 12398 | zir_switch, |
| 13249 | 12399 | ); |
| 13250 | 12400 | } |
| 13251 | 12401 | } |
| 13252 | | } |
| 13253 | | { |
| 13254 | | var multi_i: usize = 0; |
| 13255 | | var case_val_idx: usize = scalar_cases_len; |
| 13256 | | while (multi_i < multi_cases_len) : (multi_i += 1) { |
| 13257 | | const items_len = sema.code.extra[extra_index]; |
| 13258 | | extra_index += 1; |
| 13259 | | const ranges_len = sema.code.extra[extra_index]; |
| 13260 | | extra_index += 1; |
| 13261 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 13262 | | extra_index += 1 + items_len; |
| 13263 | | const body = sema.code.bodySlice(extra_index + 2 * ranges_len, info.body_len); |
| 13264 | | |
| 13265 | | const items = case_vals.items[case_val_idx..][0..items_len]; |
| 13266 | | case_val_idx += items_len; |
| 13267 | | |
| 13268 | | for (items) |item| { |
| 13269 | | // Validation above ensured these will succeed. |
| 13270 | | const item_val = sema.resolveConstDefinedValue(child_block, LazySrcLoc.unneeded, item, undefined) catch unreachable; |
| 13271 | | if (operand_val.eql(item_val, operand_ty, sema.pt.zcu)) { |
| 13272 | | if (err_set) try sema.maybeErrorUnwrapComptime(child_block, body, cond_operand); |
| 13273 | | return spa.resolveProngComptime( |
| 13274 | | child_block, |
| 13275 | | .normal, |
| 13276 | | body, |
| 13277 | | info.capture, |
| 13278 | | child_block.src(.{ .switch_capture = .{ |
| 13279 | | .switch_node_offset = switch_node_offset, |
| 13280 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 13281 | | } }), |
| 13282 | | items, |
| 13283 | | if (info.is_inline) cond_operand else .none, |
| 13284 | | info.has_tag_capture, |
| 13285 | | merges, |
| 13286 | | ); |
| 13287 | | } |
| 12402 | for (range_refs) |range_ref| { |
| 12403 | const first_val = sema.resolveConstDefinedValue(child_block, .unneeded, range_ref[0], undefined) catch unreachable; |
| 12404 | const last_val = sema.resolveConstDefinedValue(child_block, .unneeded, range_ref[1], undefined) catch unreachable; |
| 12405 | if ((try sema.compareAll(cond_val, .gte, first_val, item_ty)) and |
| 12406 | (try sema.compareAll(cond_val, .lte, last_val, item_ty))) |
| 12407 | { |
| 12408 | return sema.resolveSwitchProng( |
| 12409 | block, |
| 12410 | child_block, |
| 12411 | operand, |
| 12412 | raw_operand_ty, |
| 12413 | prong_body, |
| 12414 | block.src(.{ .switch_capture = .{ |
| 12415 | .switch_node_offset = switch_node_offset, |
| 12416 | .case_idx = case.index, |
| 12417 | } }), |
| 12418 | prong_info.capture, |
| 12419 | prong_info.has_tag_capture, |
| 12420 | if (prong_info.is_inline) cond_ref else .none, |
| 12421 | .has_ranges, |
| 12422 | validated_switch.else_err_ty, |
| 12423 | merges, |
| 12424 | switch_inst, |
| 12425 | zir_switch, |
| 12426 | ); |
| 13288 | 12427 | } |
| 12428 | } |
| 12429 | } |
| 13289 | 12430 | |
| 13290 | | var range_i: usize = 0; |
| 13291 | | while (range_i < ranges_len) : (range_i += 1) { |
| 13292 | | const range_items = case_vals.items[case_val_idx..][0..2]; |
| 13293 | | extra_index += 2; |
| 13294 | | case_val_idx += 2; |
| 12431 | const else_case = validated_switch.else_case; |
| 13295 | 12432 | |
| 13296 | | // Validation above ensured these will succeed. |
| 13297 | | const first_val = sema.resolveConstDefinedValue(child_block, LazySrcLoc.unneeded, range_items[0], undefined) catch unreachable; |
| 13298 | | const last_val = sema.resolveConstDefinedValue(child_block, LazySrcLoc.unneeded, range_items[1], undefined) catch unreachable; |
| 13299 | | if ((try sema.compareAll(resolved_operand_val, .gte, first_val, operand_ty)) and |
| 13300 | | (try sema.compareAll(resolved_operand_val, .lte, last_val, operand_ty))) |
| 13301 | | { |
| 13302 | | if (err_set) try sema.maybeErrorUnwrapComptime(child_block, body, cond_operand); |
| 13303 | | return spa.resolveProngComptime( |
| 13304 | | child_block, |
| 13305 | | .normal, |
| 13306 | | body, |
| 13307 | | info.capture, |
| 13308 | | child_block.src(.{ .switch_capture = .{ |
| 13309 | | .switch_node_offset = switch_node_offset, |
| 13310 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 13311 | | } }), |
| 13312 | | undefined, // case_vals may be undefined for ranges |
| 13313 | | if (info.is_inline) cond_operand else .none, |
| 13314 | | info.has_tag_capture, |
| 13315 | | merges, |
| 13316 | | ); |
| 13317 | | } |
| 13318 | | } |
| 12433 | // named-only prong |
| 13319 | 12434 | |
| 13320 | | extra_index += info.body_len; |
| 13321 | | } |
| 13322 | | } |
| 13323 | | if (err_set) try sema.maybeErrorUnwrapComptime(child_block, special_generic.body, cond_operand); |
| 13324 | | if (empty_enum) { |
| 13325 | | return .void_value; |
| 12435 | if (else_is_named_only and item_ty.enumTagFieldIndex(cond_val, zcu) != null) { |
| 12436 | assert(item_ty.isNonexhaustiveEnum(zcu)); |
| 12437 | return sema.resolveSwitchProng( |
| 12438 | block, |
| 12439 | child_block, |
| 12440 | operand, |
| 12441 | raw_operand_ty, |
| 12442 | else_case.body, |
| 12443 | block.src(.{ .switch_capture = .{ |
| 12444 | .switch_node_offset = switch_node_offset, |
| 12445 | .case_idx = else_case.index, |
| 12446 | } }), |
| 12447 | else_case.capture, |
| 12448 | else_case.has_tag_capture, |
| 12449 | if (else_case.is_inline) cond_ref else .none, |
| 12450 | .special, |
| 12451 | validated_switch.else_err_ty, |
| 12452 | merges, |
| 12453 | switch_inst, |
| 12454 | zir_switch, |
| 12455 | ); |
| 13326 | 12456 | } |
| 13327 | | if (special_members_only) |special| { |
| 13328 | | assert(operand_ty.isNonexhaustiveEnum(zcu)); |
| 13329 | | if (operand_ty.enumTagFieldIndex(operand_val, zcu)) |_| { |
| 13330 | | return spa.resolveProngComptime( |
| 13331 | | child_block, |
| 13332 | | .special, |
| 13333 | | special.body, |
| 13334 | | special.capture, |
| 13335 | | child_block.src(.{ .switch_capture = .{ |
| 13336 | | .switch_node_offset = switch_node_offset, |
| 13337 | | .case_idx = .special_else, |
| 13338 | | } }), |
| 13339 | | undefined, // case_vals may be undefined for special prongs |
| 13340 | | if (special.is_inline) cond_operand else .none, |
| 13341 | | special.has_tag_capture, |
| 13342 | | merges, |
| 13343 | | ); |
| 12457 | |
| 12458 | // catch-all prong |
| 12459 | |
| 12460 | const index, const body, const capture, const has_tag_capture, const is_inline = switch (catch_all_case) { |
| 12461 | .@"else" => .{ else_case.index, else_case.body, else_case.capture, else_case.has_tag_capture, else_case.is_inline }, |
| 12462 | .under => .{ under_prong.?.index, under_prong.?.body, under_prong.?.capture, under_prong.?.has_tag_capture, false }, |
| 12463 | .none => unreachable, |
| 12464 | }; |
| 12465 | if (err_set) try sema.maybeErrorUnwrapComptime(child_block, body, cond_ref); |
| 12466 | if (union_originally) { |
| 12467 | for (validated_switch.seen_enum_fields, 0..) |maybe_seen, field_i| { |
| 12468 | if (maybe_seen != null) continue; |
| 12469 | if (!operand_ty.unionFieldTypeByIndex(field_i, zcu).isNoReturn(zcu)) break; |
| 12470 | } else { |
| 12471 | // This prong should be unreachable! |
| 12472 | return .unreachable_value; |
| 13344 | 12473 | } |
| 13345 | 12474 | } |
| 13346 | | |
| 13347 | | return spa.resolveProngComptime( |
| 12475 | return sema.resolveSwitchProng( |
| 12476 | block, |
| 13348 | 12477 | child_block, |
| 13349 | | .special, |
| 13350 | | special_generic.body, |
| 13351 | | special_generic.capture, |
| 13352 | | child_block.src(.{ .switch_capture = .{ |
| 12478 | operand, |
| 12479 | raw_operand_ty, |
| 12480 | body, |
| 12481 | block.src(.{ .switch_capture = .{ |
| 13353 | 12482 | .switch_node_offset = switch_node_offset, |
| 13354 | | .case_idx = if (special_generic_is_under) |
| 13355 | | .special_under |
| 13356 | | else |
| 13357 | | .special_else, |
| 12483 | .case_idx = index, |
| 13358 | 12484 | } }), |
| 13359 | | undefined, // case_vals may be undefined for special prongs |
| 13360 | | if (special_generic.is_inline) cond_operand else .none, |
| 13361 | | special_generic.has_tag_capture, |
| 12485 | capture, |
| 12486 | has_tag_capture, |
| 12487 | if (is_inline) cond_ref else .none, |
| 12488 | .special, |
| 12489 | validated_switch.else_err_ty, |
| 13362 | 12490 | merges, |
| 12491 | switch_inst, |
| 12492 | zir_switch, |
| 13363 | 12493 | ); |
| 13364 | 12494 | } |
| 13365 | 12495 | |
| 13366 | | const RangeSetUnhandledIterator = struct { |
| 13367 | | pt: Zcu.PerThread, |
| 13368 | | cur: ?InternPool.Index, |
| 13369 | | max: InternPool.Index, |
| 13370 | | range_i: usize, |
| 13371 | | ranges: []const RangeSet.Range, |
| 13372 | | limbs: []math.big.Limb, |
| 12496 | const SwitchOperand = union(enum) { |
| 12497 | /// This switch will be dispatched only once, with the given operand. |
| 12498 | simple: struct { |
| 12499 | /// The raw switch operand value. Always defined. |
| 12500 | by_val: Air.Inst.Ref, |
| 12501 | /// The switch operand *pointer*. Defined only if there is a prong |
| 12502 | /// with a by-ref capture. |
| 12503 | by_ref: Air.Inst.Ref, |
| 12504 | /// The switch condition value. For unions, `operand` is the union |
| 12505 | /// and `cond` is its enum tag value. |
| 12506 | cond: Air.Inst.Ref, |
| 12507 | }, |
| 12508 | /// This switch may be dispatched multiple times with `continue` syntax. |
| 12509 | /// As such, the operand is stored in an alloc if needed. |
| 12510 | loop: struct { |
| 12511 | /// The `alloc` containing the `switch` operand for the active dispatch. |
| 12512 | /// Each prong must load from this `alloc` to get captures. |
| 12513 | /// If there are no captures, this may be undefined. |
| 12514 | operand_alloc: Air.Inst.Ref, |
| 12515 | /// Whether `operand_alloc` contains a by-val operand or a by-ref |
| 12516 | /// operand. |
| 12517 | operand_is_ref: bool, |
| 12518 | /// The switch condition value for the *initial* dispatch. For |
| 12519 | /// unions, this is the enum tag value. |
| 12520 | init_cond: Air.Inst.Ref, |
| 12521 | }, |
| 12522 | }; |
| 13373 | 12523 | |
| 13374 | | const preallocated_limbs = math.big.int.calcTwosCompLimbCount(128); |
| 12524 | const CatchAllSwitchCase = enum { none, @"else", under }; |
| 13375 | 12525 | |
| 13376 | | fn init(sema: *Sema, ty: Type, range_set: RangeSet) !RangeSetUnhandledIterator { |
| 13377 | | const pt = sema.pt; |
| 13378 | | const int_type = pt.zcu.intern_pool.indexToKey(ty.toIntern()).int_type; |
| 13379 | | const needed_limbs = math.big.int.calcTwosCompLimbCount(int_type.bits); |
| 13380 | | return .{ |
| 13381 | | .pt = pt, |
| 13382 | | .cur = (try ty.minInt(pt, ty)).toIntern(), |
| 13383 | | .max = (try ty.maxInt(pt, ty)).toIntern(), |
| 13384 | | .range_i = 0, |
| 13385 | | .ranges = range_set.ranges.items, |
| 13386 | | .limbs = if (needed_limbs > preallocated_limbs) |
| 13387 | | try sema.arena.alloc(math.big.Limb, needed_limbs) |
| 13388 | | else |
| 13389 | | &.{}, |
| 13390 | | }; |
| 13391 | | } |
| 12526 | const SwitchProngKind = union(enum) { |
| 12527 | item_refs: []const Air.Inst.Ref, |
| 12528 | has_ranges, |
| 12529 | special, |
| 12530 | }; |
| 13392 | 12531 | |
| 13393 | | fn addOne(it: *const RangeSetUnhandledIterator, val: InternPool.Index) !?InternPool.Index { |
| 13394 | | if (val == it.max) return null; |
| 13395 | | const int = it.pt.zcu.intern_pool.indexToKey(val).int; |
| 12532 | /// Resolve a switch prong which is determined at comptime to have no peers. |
| 12533 | /// Sets up captures as needed. Uses `analyzeBodyRuntimeBreak`. |
| 12534 | fn resolveSwitchProng( |
| 12535 | sema: *Sema, |
| 12536 | block: *Block, |
| 12537 | child_block: *Block, |
| 12538 | operand: SwitchOperand, |
| 12539 | raw_operand_ty: Type, |
| 12540 | prong_body: []const Zir.Inst.Index, |
| 12541 | /// Must use the `switch_capture` field in `offset`. |
| 12542 | capture_src: LazySrcLoc, |
| 12543 | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 12544 | has_tag_capture: bool, |
| 12545 | inline_case_capture: Air.Inst.Ref, |
| 12546 | kind: SwitchProngKind, |
| 12547 | else_err_ty: ?Type, |
| 12548 | merges: *Block.Merges, |
| 12549 | switch_inst: Zir.Inst.Index, |
| 12550 | zir_switch: *const Zir.UnwrappedSwitchBlock, |
| 12551 | ) CompileError!Air.Inst.Ref { |
| 12552 | const src_node_offset = zir_switch.switch_src_node_offset; |
| 12553 | const src = block.nodeOffset(src_node_offset); |
| 12554 | const operand_src = block.src(.{ .node_offset_switch_operand = src_node_offset }); |
| 13396 | 12555 | |
| 13397 | | switch (int.storage) { |
| 13398 | | inline .u64, .i64 => |val_int| { |
| 13399 | | const next_int = @addWithOverflow(val_int, 1); |
| 13400 | | if (next_int[1] == 0) |
| 13401 | | return (try it.pt.intValue(.fromInterned(int.ty), next_int[0])).toIntern(); |
| 13402 | | }, |
| 13403 | | .big_int => {}, |
| 13404 | | .lazy_align, .lazy_size => unreachable, |
| 13405 | | } |
| 12556 | // We can propagate `.cold` hints from this branch since it's comptime-known |
| 12557 | // to be taken from the parent branch. |
| 12558 | const parent_hint = sema.branch_hint; |
| 12559 | defer sema.branch_hint = parent_hint orelse if (sema.branch_hint == .cold) .cold else null; |
| 13406 | 12560 | |
| 13407 | | var val_space: InternPool.Key.Int.Storage.BigIntSpace = undefined; |
| 13408 | | const val_bigint = int.storage.toBigInt(&val_space); |
| 12561 | const payload_inst: Zir.Inst.Index = if (capture != .none) inst: { |
| 12562 | const payload_inst = zir_switch.payload_capture_placeholder.unwrap() orelse switch_inst; |
| 12563 | const payload_ref = try sema.analyzeSwitchPayloadCapture( |
| 12564 | child_block, |
| 12565 | operand, |
| 12566 | operand.simple.by_val, |
| 12567 | operand.simple.by_ref, |
| 12568 | sema.typeOf(operand.simple.by_val), |
| 12569 | operand_src, |
| 12570 | capture_src, |
| 12571 | capture == .by_ref, |
| 12572 | kind == .special, |
| 12573 | switch (kind) { |
| 12574 | .item_refs => |item_refs| item_refs, |
| 12575 | .has_ranges, .special => undefined, |
| 12576 | }, |
| 12577 | inline_case_capture, |
| 12578 | else_err_ty, |
| 12579 | ); |
| 12580 | assert(!sema.typeOf(payload_ref).isNoReturn(sema.pt.zcu)); |
| 12581 | sema.inst_map.putAssumeCapacity(payload_inst, payload_ref); |
| 12582 | break :inst payload_inst; |
| 12583 | } else undefined; |
| 12584 | defer if (capture != .none) assert(sema.inst_map.remove(payload_inst)); |
| 13409 | 12585 | |
| 13410 | | var result_limbs: [preallocated_limbs]math.big.Limb = undefined; |
| 13411 | | var result_bigint = math.big.int.Mutable.init( |
| 13412 | | if (it.limbs.len > 0) it.limbs else &result_limbs, |
| 13413 | | 0, |
| 12586 | const tag_inst: Zir.Inst.Index = if (has_tag_capture) inst: { |
| 12587 | const tag_inst = zir_switch.tag_capture_placeholder.unwrap() orelse switch_inst; |
| 12588 | const tag_ref = try sema.analyzeSwitchTagCapture( |
| 12589 | child_block, |
| 12590 | operand.simple.by_val, |
| 12591 | sema.typeOf(operand.simple.by_val), |
| 12592 | capture_src, |
| 12593 | inline_case_capture, |
| 12594 | kind, |
| 13414 | 12595 | ); |
| 12596 | sema.inst_map.putAssumeCapacity(tag_inst, tag_ref); |
| 12597 | break :inst tag_inst; |
| 12598 | } else undefined; |
| 12599 | defer if (has_tag_capture) assert(sema.inst_map.remove(tag_inst)); |
| 13415 | 12600 | |
| 13416 | | result_bigint.addScalar(val_bigint, 1); |
| 13417 | | return (try it.pt.intValue_big(.fromInterned(int.ty), result_bigint.toConst())).toIntern(); |
| 12601 | if (zir_switch.has_continue) sema.inst_map.putAssumeCapacity(switch_inst, .fromType(raw_operand_ty)); |
| 12602 | defer if (zir_switch.has_continue) assert(sema.inst_map.remove(switch_inst)); |
| 12603 | |
| 12604 | return sema.resolveBlockBody(block, src, child_block, prong_body, switch_inst, merges); |
| 12605 | } |
| 12606 | |
| 12607 | fn wantSwitchProngBodyAnalysis( |
| 12608 | sema: *Sema, |
| 12609 | block: *Block, |
| 12610 | item_ref: Air.Inst.Ref, |
| 12611 | operand_ty: Type, |
| 12612 | union_originally: bool, |
| 12613 | err_set: bool, |
| 12614 | prong_is_comptime_unreach: bool, |
| 12615 | ) bool { |
| 12616 | const zcu = sema.pt.zcu; |
| 12617 | if (union_originally) { |
| 12618 | const unresolved_item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable; |
| 12619 | const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable; |
| 12620 | const field_ty = operand_ty.unionFieldType(item_val, zcu).?; |
| 12621 | if (field_ty.isNoReturn(zcu)) return false; |
| 12622 | } |
| 12623 | if (err_set and prong_is_comptime_unreach) { |
| 12624 | const unresolved_item_val = sema.resolveConstDefinedValue(block, .unneeded, item_ref, undefined) catch unreachable; |
| 12625 | const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable; |
| 12626 | const err_name = item_val.getErrorName(zcu).unwrap().?; |
| 12627 | if (!Type.errorSetHasFieldIp(&zcu.intern_pool, operand_ty.toIntern(), err_name)) return false; |
| 13418 | 12628 | } |
| 12629 | return true; |
| 12630 | } |
| 13419 | 12631 | |
| 13420 | | fn next(it: *RangeSetUnhandledIterator) !?InternPool.Index { |
| 13421 | | var cur = it.cur orelse return null; |
| 13422 | | while (it.range_i < it.ranges.len and cur == it.ranges[it.range_i].first) { |
| 13423 | | defer it.range_i += 1; |
| 13424 | | cur = (try it.addOne(it.ranges[it.range_i].last)) orelse { |
| 13425 | | it.cur = null; |
| 13426 | | return null; |
| 13427 | | }; |
| 12632 | /// Assumes that `operand_ty` has more than one possible value. |
| 12633 | /// Sets up captures as needed. Uses `analyzeBodyRuntimeBreak`. |
| 12634 | fn analyzeSwitchProng( |
| 12635 | sema: *Sema, |
| 12636 | case_block: *Block, |
| 12637 | operand: SwitchOperand, |
| 12638 | operand_ty: Type, |
| 12639 | raw_operand_ty: Type, |
| 12640 | prong_body: []const Zir.Inst.Index, |
| 12641 | /// Must use the `switch_capture` field in `offset`. |
| 12642 | capture_src: LazySrcLoc, |
| 12643 | capture: Zir.Inst.SwitchBlock.ProngInfo.Capture, |
| 12644 | has_tag_capture: bool, |
| 12645 | inline_case_capture: Air.Inst.Ref, |
| 12646 | kind: SwitchProngKind, |
| 12647 | else_err_ty: ?Type, |
| 12648 | switch_inst: Zir.Inst.Index, |
| 12649 | zir_switch: *const Zir.UnwrappedSwitchBlock, |
| 12650 | ) CompileError!std.builtin.BranchHint { |
| 12651 | const pt = sema.pt; |
| 12652 | const zcu = pt.zcu; |
| 12653 | |
| 12654 | const operand_src = case_block.src(.{ .node_offset_switch_operand = zir_switch.switch_src_node_offset }); |
| 12655 | |
| 12656 | if (operand_ty.zigTypeTag(zcu) == .error_set) { |
| 12657 | const cond_ref = switch (operand) { |
| 12658 | .simple => |s| s.cond, |
| 12659 | .loop => |l| l.init_cond, |
| 12660 | }; |
| 12661 | if (try sema.maybeErrorUnwrap(case_block, prong_body, cond_ref, operand_src, true)) { |
| 12662 | // nothing to do here. weight against error branch |
| 12663 | return .unlikely; |
| 13428 | 12664 | } |
| 13429 | | it.cur = try it.addOne(cur); |
| 13430 | | return cur; |
| 13431 | 12665 | } |
| 13432 | | }; |
| 13433 | 12666 | |
| 13434 | | const ResolvedSwitchItem = struct { |
| 13435 | | ref: Air.Inst.Ref, |
| 13436 | | val: InternPool.Index, |
| 13437 | | }; |
| 13438 | | fn resolveSwitchItemVal( |
| 13439 | | sema: *Sema, |
| 13440 | | block: *Block, |
| 13441 | | item_ref: Zir.Inst.Ref, |
| 13442 | | /// Coerce `item_ref` to this type. |
| 13443 | | coerce_ty: Type, |
| 13444 | | item_src: LazySrcLoc, |
| 13445 | | ) CompileError!ResolvedSwitchItem { |
| 13446 | | const uncoerced_item = try sema.resolveInst(item_ref); |
| 12667 | const operand_val, const operand_ptr = load_operand: { |
| 12668 | if (capture == .none and !has_tag_capture) { |
| 12669 | // No need to load the operand for this prong! |
| 12670 | break :load_operand .{ undefined, undefined }; |
| 12671 | } |
| 12672 | if (inline_case_capture != .none and |
| 12673 | !(capture != .none and operand_ty.zigTypeTag(zcu) == .@"union")) |
| 12674 | { |
| 12675 | // We only need to load the operand if there's a union payload capture |
| 12676 | // since it's always runtime-known; only the tag is comptime-known here. |
| 12677 | break :load_operand .{ undefined, undefined }; |
| 12678 | } |
| 12679 | assert(zir_switch.any_maybe_runtime_capture); // should have caught everything else by now |
| 12680 | switch (operand) { |
| 12681 | .simple => |s| break :load_operand .{ s.by_val, s.by_ref }, |
| 12682 | .loop => |l| { |
| 12683 | const loaded = try sema.analyzeLoad(case_block, operand_src, l.operand_alloc, operand_src); |
| 12684 | if (l.operand_is_ref) { |
| 12685 | const by_val = try sema.analyzeLoad(case_block, operand_src, loaded, operand_src); |
| 12686 | break :load_operand .{ by_val, loaded }; |
| 12687 | } else { |
| 12688 | break :load_operand .{ loaded, undefined }; |
| 12689 | } |
| 12690 | }, |
| 12691 | } |
| 12692 | }; |
| 13447 | 12693 | |
| 13448 | | // Constructing a LazySrcLoc is costly because we only have the switch AST node. |
| 13449 | | // Only if we know for sure we need to report a compile error do we resolve the |
| 13450 | | // full source locations. |
| 12694 | const payload_inst: Zir.Inst.Index = if (capture != .none) inst: { |
| 12695 | const payload_inst = zir_switch.payload_capture_placeholder.unwrap() orelse switch_inst; |
| 12696 | const payload_ref = try sema.analyzeSwitchPayloadCapture( |
| 12697 | case_block, |
| 12698 | operand, |
| 12699 | operand_val, |
| 12700 | operand_ptr, |
| 12701 | operand_ty, |
| 12702 | operand_src, |
| 12703 | capture_src, |
| 12704 | capture == .by_ref, |
| 12705 | kind == .special, |
| 12706 | switch (kind) { |
| 12707 | .item_refs => |item_refs| item_refs, |
| 12708 | .has_ranges, .special => undefined, |
| 12709 | }, |
| 12710 | inline_case_capture, |
| 12711 | else_err_ty, |
| 12712 | ); |
| 12713 | assert(!sema.typeOf(payload_ref).isNoReturn(sema.pt.zcu)); |
| 12714 | sema.inst_map.putAssumeCapacity(payload_inst, payload_ref); |
| 12715 | break :inst payload_inst; |
| 12716 | } else undefined; |
| 12717 | defer if (capture != .none) assert(sema.inst_map.remove(payload_inst)); |
| 13451 | 12718 | |
| 13452 | | const item = try sema.coerce(block, coerce_ty, uncoerced_item, item_src); |
| 12719 | const tag_inst: Zir.Inst.Index = if (has_tag_capture) inst: { |
| 12720 | const tag_inst = zir_switch.tag_capture_placeholder.unwrap() orelse switch_inst; |
| 12721 | const tag_ref = try sema.analyzeSwitchTagCapture( |
| 12722 | case_block, |
| 12723 | operand_val, |
| 12724 | operand_ty, |
| 12725 | capture_src, |
| 12726 | inline_case_capture, |
| 12727 | kind, |
| 12728 | ); |
| 12729 | sema.inst_map.putAssumeCapacity(tag_inst, tag_ref); |
| 12730 | break :inst tag_inst; |
| 12731 | } else undefined; |
| 12732 | defer if (has_tag_capture) assert(sema.inst_map.remove(tag_inst)); |
| 13453 | 12733 | |
| 13454 | | const maybe_lazy = try sema.resolveConstDefinedValue(block, item_src, item, .{ .simple = .switch_item }); |
| 12734 | if (zir_switch.has_continue) sema.inst_map.putAssumeCapacity(switch_inst, .fromType(raw_operand_ty)); |
| 12735 | defer if (zir_switch.has_continue) assert(sema.inst_map.remove(switch_inst)); |
| 13455 | 12736 | |
| 13456 | | const val = try sema.resolveLazyValue(maybe_lazy); |
| 13457 | | const new_item = if (val.toIntern() != maybe_lazy.toIntern()) blk: { |
| 13458 | | break :blk Air.internedToRef(val.toIntern()); |
| 13459 | | } else item; |
| 12737 | return sema.analyzeBodyRuntimeBreak(case_block, prong_body); |
| 12738 | } |
| 12739 | |
| 12740 | fn analyzeSwitchTagCapture( |
| 12741 | sema: *Sema, |
| 12742 | case_block: *Block, |
| 12743 | /// May be `undefined` if `inline_case_capture` is not `.none`. |
| 12744 | operand_val: Air.Inst.Ref, |
| 12745 | operand_ty: Type, |
| 12746 | capture_src: LazySrcLoc, |
| 12747 | inline_case_capture: Air.Inst.Ref, |
| 12748 | kind: SwitchProngKind, |
| 12749 | ) CompileError!Air.Inst.Ref { |
| 12750 | const pt = sema.pt; |
| 12751 | const zcu = pt.zcu; |
| 12752 | |
| 12753 | const tag_capture_src: LazySrcLoc = .{ |
| 12754 | .base_node_inst = capture_src.base_node_inst, |
| 12755 | .offset = .{ .switch_tag_capture = capture_src.offset.switch_capture }, |
| 12756 | }; |
| 13460 | 12757 | |
| 13461 | | return .{ .ref = new_item, .val = val.toIntern() }; |
| 12758 | if (operand_ty.zigTypeTag(zcu) != .@"union") { |
| 12759 | return sema.fail(case_block, tag_capture_src, "cannot capture tag of non-union type '{f}'", .{ |
| 12760 | operand_ty.fmt(pt), |
| 12761 | }); |
| 12762 | } |
| 12763 | if (inline_case_capture != .none) { |
| 12764 | return inline_case_capture; // this already is the tag, it's what we're switching on! |
| 12765 | } |
| 12766 | switch (kind) { |
| 12767 | .has_ranges, .special => {}, |
| 12768 | .item_refs => |refs| if (refs.len == 1) return refs[0], |
| 12769 | } |
| 12770 | const tag_ty = operand_ty.unionTagType(zcu).?; |
| 12771 | return sema.unionToTag(case_block, tag_ty, operand_val, tag_capture_src); |
| 13462 | 12772 | } |
| 13463 | 12773 | |
| 13464 | | fn validateErrSetSwitch( |
| 12774 | fn analyzeSwitchPayloadCapture( |
| 13465 | 12775 | sema: *Sema, |
| 13466 | | block: *Block, |
| 13467 | | seen_errors: *SwitchErrorSet, |
| 13468 | | case_vals: *std.ArrayList(Air.Inst.Ref), |
| 12776 | case_block: *Block, |
| 12777 | operand: SwitchOperand, |
| 12778 | /// May be `undefined` if this is an inline capture and operand is not a union. |
| 12779 | operand_val: Air.Inst.Ref, |
| 12780 | /// May be `undefined` if `capture_by_ref` is `false` or if `operand_val` is also `undefined`. |
| 12781 | operand_ptr: Air.Inst.Ref, |
| 13469 | 12782 | operand_ty: Type, |
| 13470 | | inst_data: @FieldType(Zir.Inst.Data, "pl_node"), |
| 13471 | | scalar_cases_len: u32, |
| 13472 | | multi_cases_len: u32, |
| 13473 | | else_case: struct { body: []const Zir.Inst.Index, end: usize, src: LazySrcLoc }, |
| 13474 | | has_else: bool, |
| 13475 | | ) CompileError!?Type { |
| 13476 | | const gpa = sema.gpa; |
| 12783 | operand_src: LazySrcLoc, |
| 12784 | capture_src: LazySrcLoc, |
| 12785 | capture_by_ref: bool, |
| 12786 | is_special_prong: bool, |
| 12787 | /// May be `undefined` if `is_special_prong` is `true`. |
| 12788 | case_vals: []const Air.Inst.Ref, |
| 12789 | /// If this is not `.none`, this is an inline capture. |
| 12790 | inline_case_capture: Air.Inst.Ref, |
| 12791 | else_err_ty: ?Type, |
| 12792 | ) CompileError!Air.Inst.Ref { |
| 13477 | 12793 | const pt = sema.pt; |
| 13478 | 12794 | const zcu = pt.zcu; |
| 13479 | 12795 | const ip = &zcu.intern_pool; |
| 13480 | 12796 | |
| 13481 | | const src_node_offset = inst_data.src_node; |
| 13482 | | const src = block.nodeOffset(src_node_offset); |
| 13483 | | |
| 13484 | | var extra_index: usize = else_case.end; |
| 13485 | | { |
| 13486 | | var scalar_i: u32 = 0; |
| 13487 | | while (scalar_i < scalar_cases_len) : (scalar_i += 1) { |
| 13488 | | const item_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); |
| 13489 | | extra_index += 1; |
| 13490 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 13491 | | extra_index += 1 + info.body_len; |
| 12797 | const switch_node_offset = operand_src.offset.node_offset_switch_operand; |
| 13492 | 12798 | |
| 13493 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemError( |
| 13494 | | block, |
| 13495 | | seen_errors, |
| 13496 | | item_ref, |
| 13497 | | operand_ty, |
| 13498 | | block.src(.{ .switch_case_item = .{ |
| 13499 | | .switch_node_offset = src_node_offset, |
| 13500 | | .case_idx = .{ .kind = .scalar, .index = @intCast(scalar_i) }, |
| 13501 | | .item_idx = .{ .kind = .single, .index = 0 }, |
| 13502 | | } }), |
| 13503 | | )); |
| 12799 | if (inline_case_capture != .none) { |
| 12800 | const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, inline_case_capture, undefined) catch unreachable; |
| 12801 | if (operand_ty.zigTypeTag(zcu) == .@"union") { |
| 12802 | const field_index: u32 = @intCast(operand_ty.unionTagFieldIndex(item_val, zcu).?); |
| 12803 | const union_obj = zcu.typeToUnion(operand_ty).?; |
| 12804 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_index]); |
| 12805 | if (capture_by_ref) { |
| 12806 | const operand_ptr_info = sema.typeOf(operand_ptr).ptrInfo(zcu); |
| 12807 | const ptr_field_ty = try pt.ptrTypeSema(.{ |
| 12808 | .child = field_ty.toIntern(), |
| 12809 | .flags = .{ |
| 12810 | .is_const = operand_ptr_info.flags.is_const, |
| 12811 | .is_volatile = operand_ptr_info.flags.is_volatile, |
| 12812 | .address_space = operand_ptr_info.flags.address_space, |
| 12813 | }, |
| 12814 | }); |
| 12815 | return case_block.addStructFieldPtr(operand_ptr, field_index, ptr_field_ty); |
| 12816 | } else { |
| 12817 | if (try sema.resolveDefinedValue(case_block, operand_src, operand_val)) |union_val| { |
| 12818 | const tag_and_val = ip.indexToKey(union_val.toIntern()).un; |
| 12819 | return .fromIntern(tag_and_val.val); |
| 12820 | } |
| 12821 | return case_block.addStructFieldVal(operand_val, field_index, field_ty); |
| 12822 | } |
| 12823 | } else if (capture_by_ref) { |
| 12824 | return sema.uavRef(item_val.toIntern()); |
| 12825 | } else { |
| 12826 | return inline_case_capture; |
| 13504 | 12827 | } |
| 13505 | 12828 | } |
| 13506 | | { |
| 13507 | | var multi_i: u32 = 0; |
| 13508 | | while (multi_i < multi_cases_len) : (multi_i += 1) { |
| 13509 | | const items_len = sema.code.extra[extra_index]; |
| 13510 | | extra_index += 1; |
| 13511 | | const ranges_len = sema.code.extra[extra_index]; |
| 13512 | | extra_index += 1; |
| 13513 | | const info: Zir.Inst.SwitchBlock.ProngInfo = @bitCast(sema.code.extra[extra_index]); |
| 13514 | | extra_index += 1; |
| 13515 | | const items = sema.code.refSlice(extra_index, items_len); |
| 13516 | | extra_index += items_len + info.body_len; |
| 13517 | 12829 | |
| 13518 | | try case_vals.ensureUnusedCapacity(gpa, items.len); |
| 13519 | | for (items, 0..) |item_ref, item_i| { |
| 13520 | | case_vals.appendAssumeCapacity(try sema.validateSwitchItemError( |
| 13521 | | block, |
| 13522 | | seen_errors, |
| 13523 | | item_ref, |
| 13524 | | operand_ty, |
| 13525 | | block.src(.{ .switch_case_item = .{ |
| 13526 | | .switch_node_offset = src_node_offset, |
| 13527 | | .case_idx = .{ .kind = .multi, .index = @intCast(multi_i) }, |
| 13528 | | .item_idx = .{ .kind = .single, .index = @intCast(item_i) }, |
| 13529 | | } }), |
| 13530 | | )); |
| 12830 | const operand_ptr_ty = if (capture_by_ref) sema.typeOf(operand_ptr) else undefined; |
| 12831 | |
| 12832 | if (is_special_prong) { |
| 12833 | if (capture_by_ref) return operand_ptr; |
| 12834 | return switch (operand_ty.zigTypeTag(zcu)) { |
| 12835 | .error_set => e: { |
| 12836 | if (else_err_ty) |err_ty| { |
| 12837 | break :e sema.bitCast(case_block, err_ty, operand_val, operand_src, null); |
| 12838 | } else { |
| 12839 | try sema.analyzeUnreachable(case_block, operand_src, false); |
| 12840 | break :e .unreachable_value; |
| 12841 | } |
| 12842 | }, |
| 12843 | else => operand_val, |
| 12844 | }; |
| 12845 | } |
| 12846 | |
| 12847 | switch (operand_ty.zigTypeTag(zcu)) { |
| 12848 | .@"union" => { |
| 12849 | const union_obj = zcu.typeToUnion(operand_ty).?; |
| 12850 | const first_item_val = sema.resolveConstDefinedValue(case_block, .unneeded, case_vals[0], undefined) catch unreachable; |
| 12851 | |
| 12852 | const first_field_index: u32 = zcu.unionTagFieldIndex(union_obj, first_item_val).?; |
| 12853 | const first_field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[first_field_index]); |
| 12854 | |
| 12855 | const field_indices = try sema.arena.alloc(u32, case_vals.len); |
| 12856 | for (case_vals, field_indices) |item, *field_idx| { |
| 12857 | const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, item, undefined) catch unreachable; |
| 12858 | field_idx.* = zcu.unionTagFieldIndex(union_obj, item_val).?; |
| 12859 | } |
| 12860 | |
| 12861 | // Fast path: if all the operands are the same type already, we don't need to hit |
| 12862 | // PTR! This will also allow us to emit simpler code. |
| 12863 | const same_types = for (field_indices[1..]) |field_idx| { |
| 12864 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 12865 | if (!field_ty.eql(first_field_ty, zcu)) break false; |
| 12866 | } else true; |
| 12867 | |
| 12868 | const capture_ty: Type = capture_ty: { |
| 12869 | if (same_types) break :capture_ty first_field_ty; |
| 12870 | // We need values to run PTR on, so make a bunch of undef constants. |
| 12871 | const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len); |
| 12872 | for (dummy_captures, field_indices) |*dummy, field_idx| { |
| 12873 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 12874 | dummy.* = try pt.undefRef(field_ty); |
| 12875 | } |
| 12876 | |
| 12877 | const case_srcs = try sema.arena.alloc(?LazySrcLoc, case_vals.len); |
| 12878 | for (case_srcs, 0..) |*case_src, item_i| { |
| 12879 | case_src.* = .{ |
| 12880 | .base_node_inst = capture_src.base_node_inst, |
| 12881 | .offset = .{ .switch_case_item = .{ |
| 12882 | .switch_node_offset = switch_node_offset, |
| 12883 | .case_idx = capture_src.offset.switch_capture.case_idx, |
| 12884 | .item_idx = .{ .kind = .single, .value = @intCast(item_i) }, |
| 12885 | } }, |
| 12886 | }; |
| 12887 | } |
| 12888 | |
| 12889 | break :capture_ty sema.resolvePeerTypes( |
| 12890 | case_block, |
| 12891 | capture_src, |
| 12892 | dummy_captures, |
| 12893 | .{ .override = case_srcs }, |
| 12894 | ) catch |err| switch (err) { |
| 12895 | error.AnalysisFail => { |
| 12896 | const msg = sema.err orelse return error.AnalysisFail; |
| 12897 | try sema.reparentOwnedErrorMsg(capture_src, msg, "capture group with incompatible types", .{}); |
| 12898 | return error.AnalysisFail; |
| 12899 | }, |
| 12900 | else => |e| return e, |
| 12901 | }; |
| 12902 | }; |
| 12903 | |
| 12904 | // By-reference captures have some further restrictions which make them easier to emit |
| 12905 | if (capture_by_ref) { |
| 12906 | const operand_ptr_info = operand_ptr_ty.ptrInfo(zcu); |
| 12907 | const capture_ptr_ty = resolve: { |
| 12908 | // By-ref captures of hetereogeneous types are only allowed if all field |
| 12909 | // pointer types are peer resolvable to each other. |
| 12910 | // We need values to run PTR on, so make a bunch of undef constants. |
| 12911 | const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len); |
| 12912 | for (field_indices, dummy_captures) |field_idx, *dummy| { |
| 12913 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 12914 | const field_ptr_ty = try pt.ptrTypeSema(.{ |
| 12915 | .child = field_ty.toIntern(), |
| 12916 | .flags = .{ |
| 12917 | .is_const = operand_ptr_info.flags.is_const, |
| 12918 | .is_volatile = operand_ptr_info.flags.is_volatile, |
| 12919 | .address_space = operand_ptr_info.flags.address_space, |
| 12920 | .alignment = union_obj.fieldAlign(ip, field_idx), |
| 12921 | }, |
| 12922 | }); |
| 12923 | dummy.* = try pt.undefRef(field_ptr_ty); |
| 12924 | } |
| 12925 | const case_srcs = try sema.arena.alloc(?LazySrcLoc, case_vals.len); |
| 12926 | for (case_srcs, 0..) |*case_src, item_i| { |
| 12927 | case_src.* = .{ |
| 12928 | .base_node_inst = capture_src.base_node_inst, |
| 12929 | .offset = .{ .switch_case_item = .{ |
| 12930 | .switch_node_offset = switch_node_offset, |
| 12931 | .case_idx = capture_src.offset.switch_capture.case_idx, |
| 12932 | .item_idx = .{ .kind = .single, .value = @intCast(item_i) }, |
| 12933 | } }, |
| 12934 | }; |
| 12935 | } |
| 12936 | |
| 12937 | break :resolve sema.resolvePeerTypes( |
| 12938 | case_block, |
| 12939 | capture_src, |
| 12940 | dummy_captures, |
| 12941 | .{ .override = case_srcs }, |
| 12942 | ) catch |err| switch (err) { |
| 12943 | error.AnalysisFail => { |
| 12944 | const msg = sema.err orelse return error.AnalysisFail; |
| 12945 | try sema.errNote(capture_src, msg, "this coercion is only possible when capturing by value", .{}); |
| 12946 | try sema.reparentOwnedErrorMsg(capture_src, msg, "capture group with incompatible types", .{}); |
| 12947 | return error.AnalysisFail; |
| 12948 | }, |
| 12949 | else => |e| return e, |
| 12950 | }; |
| 12951 | }; |
| 12952 | |
| 12953 | if (try sema.resolveDefinedValue(case_block, operand_src, operand_ptr)) |op_ptr_val| { |
| 12954 | if (op_ptr_val.isUndef(zcu)) return pt.undefRef(capture_ptr_ty); |
| 12955 | const field_ptr_val = try op_ptr_val.ptrField(first_field_index, pt); |
| 12956 | return .fromValue(try pt.getCoerced(field_ptr_val, capture_ptr_ty)); |
| 12957 | } |
| 12958 | |
| 12959 | try sema.requireRuntimeBlock(case_block, operand_src, null); |
| 12960 | return case_block.addStructFieldPtr(operand_ptr, first_field_index, capture_ptr_ty); |
| 12961 | } |
| 12962 | |
| 12963 | if (try sema.resolveDefinedValue(case_block, operand_src, operand_val)) |operand_val_val| { |
| 12964 | if (operand_val_val.isUndef(zcu)) return pt.undefRef(capture_ty); |
| 12965 | const union_val = ip.indexToKey(operand_val_val.toIntern()).un; |
| 12966 | if (Value.fromInterned(union_val.tag).isUndef(zcu)) return pt.undefRef(capture_ty); |
| 12967 | const uncoerced: Air.Inst.Ref = .fromIntern(union_val.val); |
| 12968 | return sema.coerce(case_block, capture_ty, uncoerced, operand_src); |
| 12969 | } |
| 12970 | |
| 12971 | try sema.requireRuntimeBlock(case_block, operand_src, null); |
| 12972 | |
| 12973 | if (same_types) { |
| 12974 | return case_block.addStructFieldVal(operand_val, first_field_index, capture_ty); |
| 12975 | } |
| 12976 | |
| 12977 | // We may have to emit a switch block which coerces the operand to the capture type. |
| 12978 | // If we can, try to avoid that using in-memory coercions. |
| 12979 | const first_non_imc = in_mem: { |
| 12980 | for (field_indices, 0..) |field_idx, i| { |
| 12981 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 12982 | if (.ok != try sema.coerceInMemoryAllowed(case_block, capture_ty, field_ty, false, zcu.getTarget(), .unneeded, .unneeded, null)) { |
| 12983 | break :in_mem i; |
| 12984 | } |
| 12985 | } |
| 12986 | // All fields are in-memory coercible to the resolved type! |
| 12987 | // Just take the first field and bitcast the result. |
| 12988 | const uncoerced = try case_block.addStructFieldVal(operand_val, first_field_index, first_field_ty); |
| 12989 | return case_block.addBitCast(capture_ty, uncoerced); |
| 12990 | }; |
| 12991 | |
| 12992 | // By-val capture with heterogeneous types which are not all in-memory coercible to |
| 12993 | // the resolved capture type. We finally have to fall back to the ugly method. |
| 12994 | |
| 12995 | // However, let's first track which operands are in-memory coercible. There may well |
| 12996 | // be several, and we can squash all of these cases into the same switch prong using |
| 12997 | // a simple bitcast. We'll make this the 'else' prong. |
| 12998 | |
| 12999 | var in_mem_coercible: std.DynamicBitSet = try .initFull(sema.arena, field_indices.len); |
| 13000 | in_mem_coercible.unset(first_non_imc); |
| 13001 | { |
| 13002 | const next = first_non_imc + 1; |
| 13003 | for (field_indices[next..], next..) |field_idx, i| { |
| 13004 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 13005 | if (.ok != try sema.coerceInMemoryAllowed(case_block, capture_ty, field_ty, false, zcu.getTarget(), .unneeded, .unneeded, null)) { |
| 13006 | in_mem_coercible.unset(i); |
| 13007 | } |
| 13008 | } |
| 13531 | 13009 | } |
| 13532 | 13010 | |
| 13533 | | try sema.validateSwitchNoRange(block, ranges_len, operand_ty, src_node_offset); |
| 13534 | | } |
| 13535 | | } |
| 13011 | const capture_block_inst = try case_block.addInstAsIndex(.{ |
| 13012 | .tag = .block, |
| 13013 | .data = .{ |
| 13014 | .ty_pl = .{ |
| 13015 | .ty = .fromType(capture_ty), |
| 13016 | .payload = undefined, // updated below |
| 13017 | }, |
| 13018 | }, |
| 13019 | }); |
| 13536 | 13020 | |
| 13537 | | switch (try sema.resolveInferredErrorSetTy(block, src, operand_ty.toIntern())) { |
| 13538 | | .anyerror_type => { |
| 13539 | | if (!has_else) { |
| 13540 | | return sema.fail( |
| 13541 | | block, |
| 13542 | | src, |
| 13543 | | "else prong required when switching on type 'anyerror'", |
| 13544 | | .{}, |
| 13545 | | ); |
| 13021 | const prong_count = field_indices.len - in_mem_coercible.count(); |
| 13022 | |
| 13023 | const estimated_extra = prong_count * 6 + (prong_count / 10); // 2 for Case, 1 item, probably 3 insts; plus hints |
| 13024 | var cases_extra = try std.array_list.Managed(u32).initCapacity(sema.gpa, estimated_extra); |
| 13025 | defer cases_extra.deinit(); |
| 13026 | |
| 13027 | { |
| 13028 | // All branch hints are `.none`, so just add zero elems. |
| 13029 | comptime assert(@intFromEnum(std.builtin.BranchHint.none) == 0); |
| 13030 | const need_elems = std.math.divCeil(usize, prong_count + 1, 10) catch unreachable; |
| 13031 | try cases_extra.appendNTimes(0, need_elems); |
| 13546 | 13032 | } |
| 13547 | | return .anyerror; |
| 13548 | | }, |
| 13549 | | else => |err_set_ty_index| else_validation: { |
| 13550 | | const error_names = ip.indexToKey(err_set_ty_index).error_set_type.names; |
| 13551 | | var maybe_msg: ?*Zcu.ErrorMsg = null; |
| 13552 | | errdefer if (maybe_msg) |msg| msg.destroy(sema.gpa); |
| 13553 | 13033 | |
| 13554 | | for (error_names.get(ip)) |error_name| { |
| 13555 | | if (!seen_errors.contains(error_name) and !has_else) { |
| 13556 | | const msg = maybe_msg orelse blk: { |
| 13557 | | maybe_msg = try sema.errMsg( |
| 13558 | | src, |
| 13559 | | "switch must handle all possibilities", |
| 13560 | | .{}, |
| 13561 | | ); |
| 13562 | | break :blk maybe_msg.?; |
| 13034 | { |
| 13035 | // Non-bitcast cases |
| 13036 | var it = in_mem_coercible.iterator(.{ .kind = .unset }); |
| 13037 | while (it.next()) |idx| { |
| 13038 | var coerce_block = case_block.makeSubBlock(); |
| 13039 | defer coerce_block.instructions.deinit(sema.gpa); |
| 13040 | |
| 13041 | const case_src: LazySrcLoc = .{ |
| 13042 | .base_node_inst = capture_src.base_node_inst, |
| 13043 | .offset = .{ .switch_case_item = .{ |
| 13044 | .switch_node_offset = switch_node_offset, |
| 13045 | .case_idx = capture_src.offset.switch_capture.case_idx, |
| 13046 | .item_idx = .{ .kind = .single, .value = @intCast(idx) }, |
| 13047 | } }, |
| 13563 | 13048 | }; |
| 13564 | 13049 | |
| 13565 | | try sema.errNote( |
| 13566 | | src, |
| 13567 | | msg, |
| 13568 | | "unhandled error value: 'error.{f}'", |
| 13569 | | .{error_name.fmt(ip)}, |
| 13570 | | ); |
| 13050 | const field_idx = field_indices[idx]; |
| 13051 | const field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[field_idx]); |
| 13052 | const uncoerced = try coerce_block.addStructFieldVal(operand_val, field_idx, field_ty); |
| 13053 | const coerced = try sema.coerce(&coerce_block, capture_ty, uncoerced, case_src); |
| 13054 | _ = try coerce_block.addBr(capture_block_inst, coerced); |
| 13055 | |
| 13056 | try cases_extra.ensureUnusedCapacity(@typeInfo(Air.SwitchBr.Case).@"struct".fields.len + |
| 13057 | 1 + // `item`, no ranges |
| 13058 | coerce_block.instructions.items.len); |
| 13059 | cases_extra.appendSliceAssumeCapacity(&payloadToExtraItems(Air.SwitchBr.Case{ |
| 13060 | .items_len = 1, |
| 13061 | .ranges_len = 0, |
| 13062 | .body_len = @intCast(coerce_block.instructions.items.len), |
| 13063 | })); |
| 13064 | cases_extra.appendAssumeCapacity(@intFromEnum(case_vals[idx])); // item |
| 13065 | cases_extra.appendSliceAssumeCapacity(@ptrCast(coerce_block.instructions.items)); // body |
| 13571 | 13066 | } |
| 13572 | 13067 | } |
| 13068 | const else_body_len = len: { |
| 13069 | // 'else' prong uses a bitcast |
| 13070 | var coerce_block = case_block.makeSubBlock(); |
| 13071 | defer coerce_block.instructions.deinit(sema.gpa); |
| 13573 | 13072 | |
| 13574 | | if (maybe_msg) |msg| { |
| 13575 | | maybe_msg = null; |
| 13576 | | try sema.addDeclaredHereNote(msg, operand_ty); |
| 13577 | | return sema.failWithOwnedErrorMsg(block, msg); |
| 13578 | | } |
| 13073 | const first_imc_item_idx = in_mem_coercible.findFirstSet().?; |
| 13074 | const first_imc_field_idx = field_indices[first_imc_item_idx]; |
| 13075 | const first_imc_field_ty: Type = .fromInterned(union_obj.field_types.get(ip)[first_imc_field_idx]); |
| 13076 | const uncoerced = try coerce_block.addStructFieldVal(operand_val, first_imc_field_idx, first_imc_field_ty); |
| 13077 | const coerced = try coerce_block.addBitCast(capture_ty, uncoerced); |
| 13078 | _ = try coerce_block.addBr(capture_block_inst, coerced); |
| 13079 | |
| 13080 | try cases_extra.appendSlice(@ptrCast(coerce_block.instructions.items)); |
| 13081 | break :len coerce_block.instructions.items.len; |
| 13082 | }; |
| 13579 | 13083 | |
| 13580 | | if (has_else and seen_errors.count() == error_names.len) { |
| 13581 | | // In order to enable common patterns for generic code allow simple else bodies |
| 13582 | | // else => unreachable, |
| 13583 | | // else => return, |
| 13584 | | // else => |e| return e, |
| 13585 | | // even if all the possible errors were already handled. |
| 13586 | | const tags = sema.code.instructions.items(.tag); |
| 13587 | | const datas = sema.code.instructions.items(.data); |
| 13588 | | for (else_case.body) |else_inst| switch (tags[@intFromEnum(else_inst)]) { |
| 13589 | | .dbg_stmt, |
| 13590 | | .dbg_var_val, |
| 13591 | | .ret_type, |
| 13592 | | .as_node, |
| 13593 | | .ret_node, |
| 13594 | | .@"unreachable", |
| 13595 | | .@"defer", |
| 13596 | | .defer_err_code, |
| 13597 | | .err_union_code, |
| 13598 | | .ret_err_value_code, |
| 13599 | | .save_err_ret_index, |
| 13600 | | .restore_err_ret_index_unconditional, |
| 13601 | | .restore_err_ret_index_fn_entry, |
| 13602 | | .is_non_err, |
| 13603 | | .ret_is_non_err, |
| 13604 | | .condbr, |
| 13605 | | => {}, |
| 13606 | | .extended => switch (datas[@intFromEnum(else_inst)].extended.opcode) { |
| 13607 | | .restore_err_ret_index => {}, |
| 13608 | | else => break, |
| 13084 | try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.SwitchBr).@"struct".fields.len + |
| 13085 | cases_extra.items.len + |
| 13086 | @typeInfo(Air.Block).@"struct".fields.len + |
| 13087 | 1); |
| 13088 | |
| 13089 | const switch_br_inst: u32 = @intCast(sema.air_instructions.len); |
| 13090 | try sema.air_instructions.append(sema.gpa, .{ |
| 13091 | .tag = .switch_br, |
| 13092 | .data = .{ |
| 13093 | .pl_op = .{ |
| 13094 | .operand = undefined, // set by switch below |
| 13095 | .payload = sema.addExtraAssumeCapacity(Air.SwitchBr{ |
| 13096 | .cases_len = @intCast(prong_count), |
| 13097 | .else_body_len = @intCast(else_body_len), |
| 13098 | }), |
| 13609 | 13099 | }, |
| 13610 | | else => break, |
| 13611 | | } else break :else_validation; |
| 13100 | }, |
| 13101 | }); |
| 13102 | sema.air_extra.appendSliceAssumeCapacity(cases_extra.items); |
| 13103 | |
| 13104 | // Set up block body |
| 13105 | switch (operand) { |
| 13106 | .simple => |s| { |
| 13107 | const air_datas = sema.air_instructions.items(.data); |
| 13108 | air_datas[switch_br_inst].pl_op.operand = s.cond; |
| 13109 | air_datas[@intFromEnum(capture_block_inst)].ty_pl.payload = |
| 13110 | sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 }); |
| 13111 | sema.air_extra.appendAssumeCapacity(switch_br_inst); |
| 13112 | }, |
| 13113 | .loop => { |
| 13114 | // The block must first extract the tag from the loaded union. |
| 13115 | const tag_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); |
| 13116 | try sema.air_instructions.append(sema.gpa, .{ |
| 13117 | .tag = .get_union_tag, |
| 13118 | .data = .{ .ty_op = .{ |
| 13119 | .ty = .fromIntern(union_obj.enum_tag_ty), |
| 13120 | .operand = operand_val, |
| 13121 | } }, |
| 13122 | }); |
| 13123 | const air_datas = sema.air_instructions.items(.data); |
| 13124 | air_datas[switch_br_inst].pl_op.operand = tag_inst.toRef(); |
| 13125 | air_datas[@intFromEnum(capture_block_inst)].ty_pl.payload = |
| 13126 | sema.addExtraAssumeCapacity(Air.Block{ .body_len = 2 }); |
| 13127 | sema.air_extra.appendAssumeCapacity(@intFromEnum(tag_inst)); |
| 13128 | sema.air_extra.appendAssumeCapacity(switch_br_inst); |
| 13129 | }, |
| 13130 | } |
| 13612 | 13131 | |
| 13132 | return capture_block_inst.toRef(); |
| 13133 | }, |
| 13134 | .error_set => { |
| 13135 | if (capture_by_ref) { |
| 13613 | 13136 | return sema.fail( |
| 13614 | | block, |
| 13615 | | else_case.src, |
| 13616 | | "unreachable else prong; all cases already handled", |
| 13137 | case_block, |
| 13138 | capture_src, |
| 13139 | "error set cannot be captured by reference", |
| 13617 | 13140 | .{}, |
| 13618 | 13141 | ); |
| 13619 | 13142 | } |
| 13620 | 13143 | |
| 13621 | | var names: InferredErrorSet.NameMap = .{}; |
| 13622 | | try names.ensureUnusedCapacity(sema.arena, error_names.len); |
| 13623 | | for (error_names.get(ip)) |error_name| { |
| 13624 | | if (seen_errors.contains(error_name)) continue; |
| 13144 | if (case_vals.len == 1) { |
| 13145 | const item_val = sema.resolveConstDefinedValue(case_block, .unneeded, case_vals[0], undefined) catch unreachable; |
| 13146 | const item_ty = try pt.singleErrorSetType(item_val.getErrorName(zcu).unwrap().?); |
| 13147 | return sema.bitCast(case_block, item_ty, operand_val, operand_src, null); |
| 13148 | } |
| 13625 | 13149 | |
| 13626 | | names.putAssumeCapacityNoClobber(error_name, {}); |
| 13150 | var names: InferredErrorSet.NameMap = .{}; |
| 13151 | try names.ensureUnusedCapacity(sema.arena, case_vals.len); |
| 13152 | for (case_vals) |err| { |
| 13153 | const err_val = sema.resolveConstDefinedValue(case_block, .unneeded, err, undefined) catch unreachable; |
| 13154 | names.putAssumeCapacityNoClobber(err_val.getErrorName(zcu).unwrap().?, {}); |
| 13155 | } |
| 13156 | const error_ty = try pt.errorSetFromUnsortedNames(names.keys()); |
| 13157 | return sema.bitCast(case_block, error_ty, operand_val, operand_src, null); |
| 13158 | }, |
| 13159 | else => { |
| 13160 | // In this case the capture value is just the passed-through value of the |
| 13161 | // switch condition. It is comptime-known if there is only one item. |
| 13162 | if (capture_by_ref) { |
| 13163 | return operand_ptr; |
| 13164 | } else if (case_vals.len == 1) { |
| 13165 | return case_vals[0]; |
| 13166 | } else { |
| 13167 | return operand_val; |
| 13627 | 13168 | } |
| 13628 | | // No need to keep the hash map metadata correct; here we |
| 13629 | | // extract the (sorted) keys only. |
| 13630 | | return try pt.errorSetFromUnsortedNames(names.keys()); |
| 13631 | 13169 | }, |
| 13632 | 13170 | } |
| 13633 | | return null; |
| 13634 | 13171 | } |
| 13635 | 13172 | |
| 13636 | | fn validateSwitchRange( |
| 13637 | | sema: *Sema, |
| 13638 | | block: *Block, |
| 13639 | | range_set: *RangeSet, |
| 13640 | | first_ref: Zir.Inst.Ref, |
| 13641 | | last_ref: Zir.Inst.Ref, |
| 13642 | | operand_ty: Type, |
| 13643 | | item_src: LazySrcLoc, |
| 13644 | | ) CompileError![2]Air.Inst.Ref { |
| 13645 | | const first_src: LazySrcLoc = .{ |
| 13646 | | .base_node_inst = item_src.base_node_inst, |
| 13647 | | .offset = .{ .switch_case_item_range_first = item_src.offset.switch_case_item }, |
| 13648 | | }; |
| 13649 | | const last_src: LazySrcLoc = .{ |
| 13650 | | .base_node_inst = item_src.base_node_inst, |
| 13651 | | .offset = .{ .switch_case_item_range_last = item_src.offset.switch_case_item }, |
| 13652 | | }; |
| 13653 | | const first = try sema.resolveSwitchItemVal(block, first_ref, operand_ty, first_src); |
| 13654 | | const last = try sema.resolveSwitchItemVal(block, last_ref, operand_ty, last_src); |
| 13655 | | if (try Value.fromInterned(first.val).compareAll(.gt, Value.fromInterned(last.val), operand_ty, sema.pt)) { |
| 13656 | | return sema.fail(block, item_src, "range start value is greater than the end value", .{}); |
| 13657 | | } |
| 13658 | | const maybe_prev_src = try range_set.add(first.val, last.val, item_src); |
| 13659 | | try sema.validateSwitchDupe(block, maybe_prev_src, item_src); |
| 13660 | | return .{ first.ref, last.ref }; |
| 13661 | | } |
| 13173 | const ResolvedSwitchItem = struct { |
| 13174 | ref: Air.Inst.Ref, |
| 13175 | val: Value, |
| 13176 | }; |
| 13177 | const ResolvedSwitchItemAndExtraIndex = struct { ResolvedSwitchItem, usize }; |
| 13662 | 13178 | |
| 13663 | | fn validateSwitchItemInt( |
| 13179 | fn resolveSwitchItem( |
| 13664 | 13180 | sema: *Sema, |
| 13665 | 13181 | block: *Block, |
| 13666 | | range_set: *RangeSet, |
| 13667 | | item_ref: Zir.Inst.Ref, |
| 13668 | | operand_ty: Type, |
| 13669 | 13182 | item_src: LazySrcLoc, |
| 13670 | | ) CompileError!Air.Inst.Ref { |
| 13671 | | const item = try sema.resolveSwitchItemVal(block, item_ref, operand_ty, item_src); |
| 13672 | | const maybe_prev_src = try range_set.add(item.val, item.val, item_src); |
| 13673 | | try sema.validateSwitchDupe(block, maybe_prev_src, item_src); |
| 13674 | | return item.ref; |
| 13675 | | } |
| 13183 | item_ty: Type, |
| 13184 | item_info: Zir.Inst.SwitchBlock.ItemInfo, |
| 13185 | extra_index: usize, |
| 13186 | switch_inst: Zir.Inst.Index, |
| 13187 | prong_is_comptime_unreach: bool, |
| 13188 | ) CompileError!ResolvedSwitchItemAndExtraIndex { |
| 13189 | const pt = sema.pt; |
| 13190 | const zcu = pt.zcu; |
| 13191 | const ip = &zcu.intern_pool; |
| 13192 | const comp = zcu.comp; |
| 13193 | const gpa = comp.gpa; |
| 13194 | const io = comp.io; |
| 13676 | 13195 | |
| 13677 | | fn validateSwitchItemEnum( |
| 13678 | | sema: *Sema, |
| 13679 | | block: *Block, |
| 13680 | | seen_fields: []?LazySrcLoc, |
| 13681 | | range_set: *RangeSet, |
| 13682 | | item_ref: Zir.Inst.Ref, |
| 13683 | | operand_ty: Type, |
| 13684 | | item_src: LazySrcLoc, |
| 13685 | | ) CompileError!Air.Inst.Ref { |
| 13686 | | const ip = &sema.pt.zcu.intern_pool; |
| 13687 | | const item = try sema.resolveSwitchItemVal(block, item_ref, operand_ty, item_src); |
| 13688 | | const int = ip.indexToKey(item.val).enum_tag.int; |
| 13689 | | const field_index = ip.loadEnumType(ip.typeOf(item.val)).tagValueIndex(ip, int) orelse { |
| 13690 | | const maybe_prev_src = try range_set.add(int, int, item_src); |
| 13691 | | try sema.validateSwitchDupe(block, maybe_prev_src, item_src); |
| 13692 | | return item.ref; |
| 13196 | var end = extra_index; |
| 13197 | const uncoerced: Air.Inst.Ref, const uncoerced_ty: Type = uncoerced: switch (item_info.unwrap()) { |
| 13198 | .under => unreachable, // caller must check this before calling us |
| 13199 | .enum_literal => |str_index| { |
| 13200 | const zir_str = sema.code.nullTerminatedString(str_index); |
| 13201 | const name = try ip.getOrPutString(gpa, io, pt.tid, zir_str, .no_embedded_nulls); |
| 13202 | const uncoerced = try sema.analyzeDeclLiteral(block, item_src, name, item_ty, false); |
| 13203 | break :uncoerced .{ uncoerced, .enum_literal }; |
| 13204 | }, |
| 13205 | .error_value => |str_index| { |
| 13206 | const zir_str = sema.code.nullTerminatedString(str_index); |
| 13207 | const name = try ip.getOrPutString(gpa, io, pt.tid, zir_str, .no_embedded_nulls); |
| 13208 | // Make sure there's an error integer value associated with `name`. |
| 13209 | _ = try pt.getErrorValue(name); |
| 13210 | const err_set_ty = try pt.singleErrorSetType(name); |
| 13211 | const uncoerced = Air.internedToRef(try pt.intern(.{ .err = .{ |
| 13212 | .ty = err_set_ty.toIntern(), |
| 13213 | .name = name, |
| 13214 | } })); |
| 13215 | break :uncoerced .{ uncoerced, err_set_ty }; |
| 13216 | }, |
| 13217 | .body_len => |body_len| { |
| 13218 | const body = sema.code.bodySlice(extra_index, body_len); |
| 13219 | end += body.len; |
| 13220 | |
| 13221 | const uncoerced = ref: { |
| 13222 | // The result location of item bodies is `.{ .coerce_ty = switch_inst }`. |
| 13223 | sema.inst_map.putAssumeCapacity(switch_inst, .fromType(item_ty)); |
| 13224 | defer assert(sema.inst_map.remove(switch_inst)); |
| 13225 | const old_comptime_reason = block.comptime_reason; |
| 13226 | defer block.comptime_reason = old_comptime_reason; |
| 13227 | block.comptime_reason = .{ .reason = .{ |
| 13228 | .src = item_src, |
| 13229 | .r = .{ .simple = .switch_item }, |
| 13230 | } }; |
| 13231 | break :ref try sema.resolveInlineBody(block, body, switch_inst); |
| 13232 | }; |
| 13233 | break :uncoerced .{ uncoerced, sema.typeOf(uncoerced) }; |
| 13234 | }, |
| 13693 | 13235 | }; |
| 13694 | | const maybe_prev_src = seen_fields[field_index]; |
| 13695 | | seen_fields[field_index] = item_src; |
| 13696 | | try sema.validateSwitchDupe(block, maybe_prev_src, item_src); |
| 13697 | | return item.ref; |
| 13698 | | } |
| 13699 | | |
| 13700 | | fn validateSwitchItemError( |
| 13701 | | sema: *Sema, |
| 13702 | | block: *Block, |
| 13703 | | seen_errors: *SwitchErrorSet, |
| 13704 | | item_ref: Zir.Inst.Ref, |
| 13705 | | operand_ty: Type, |
| 13706 | | item_src: LazySrcLoc, |
| 13707 | | ) CompileError!Air.Inst.Ref { |
| 13708 | | const item = try sema.resolveSwitchItemVal(block, item_ref, operand_ty, item_src); |
| 13709 | | const error_name = sema.pt.zcu.intern_pool.indexToKey(item.val).err.name; |
| 13710 | | const maybe_prev_src = if (try seen_errors.fetchPut(error_name, item_src)) |prev| |
| 13711 | | prev.value |
| 13712 | | else |
| 13713 | | null; |
| 13714 | | try sema.validateSwitchDupe(block, maybe_prev_src, item_src); |
| 13715 | | return item.ref; |
| 13716 | | } |
| 13236 | const item_ref: Air.Inst.Ref = item_ref: { |
| 13237 | if (item_ty.zigTypeTag(zcu) == .error_set and |
| 13238 | uncoerced_ty.zigTypeTag(zcu) == .error_set) |
| 13239 | { |
| 13240 | // We allow prongs with errors which are not part of the error set |
| 13241 | // being switched on if their prong body is `=> comptime unreachable,`. |
| 13242 | switch (try sema.coerceInMemoryAllowedErrorSets(block, item_ty, uncoerced_ty, item_src, item_src)) { |
| 13243 | .ok => if (try sema.resolveValue(uncoerced)) |uncoerced_val| { |
| 13244 | break :item_ref try sema.coerceInMemory(uncoerced_val, item_ty); |
| 13245 | }, |
| 13246 | .missing_error => if (prong_is_comptime_unreach) { |
| 13247 | break :item_ref uncoerced; |
| 13248 | }, |
| 13249 | .from_anyerror => {}, |
| 13250 | else => unreachable, |
| 13251 | } |
| 13252 | } |
| 13253 | break :item_ref try sema.coerce(block, item_ty, uncoerced, item_src); |
| 13254 | }; |
| 13255 | const maybe_lazy = try sema.resolveConstDefinedValue(block, item_src, item_ref, .{ .simple = .switch_item }); |
| 13717 | 13256 | |
| 13718 | | fn validateSwitchDupe( |
| 13719 | | sema: *Sema, |
| 13720 | | block: *Block, |
| 13721 | | maybe_prev_src: ?LazySrcLoc, |
| 13722 | | item_src: LazySrcLoc, |
| 13723 | | ) CompileError!void { |
| 13724 | | const prev_item_src = maybe_prev_src orelse return; |
| 13725 | | return sema.failWithOwnedErrorMsg(block, msg: { |
| 13726 | | const msg = try sema.errMsg( |
| 13727 | | item_src, |
| 13728 | | "duplicate switch value", |
| 13729 | | .{}, |
| 13730 | | ); |
| 13731 | | errdefer msg.destroy(sema.gpa); |
| 13732 | | try sema.errNote( |
| 13733 | | prev_item_src, |
| 13734 | | msg, |
| 13735 | | "previous value here", |
| 13736 | | .{}, |
| 13737 | | ); |
| 13738 | | break :msg msg; |
| 13739 | | }); |
| 13740 | | } |
| 13257 | // We have to resolve lazy values here to avoid false negatives when detecting |
| 13258 | // duplicate items and comparing items to a comptime-known switch operand. |
| 13741 | 13259 | |
| 13742 | | fn validateSwitchItemBool( |
| 13743 | | sema: *Sema, |
| 13744 | | block: *Block, |
| 13745 | | true_count: *u8, |
| 13746 | | false_count: *u8, |
| 13747 | | item_ref: Zir.Inst.Ref, |
| 13748 | | item_src: LazySrcLoc, |
| 13749 | | ) CompileError!Air.Inst.Ref { |
| 13750 | | const item = try sema.resolveSwitchItemVal(block, item_ref, .bool, item_src); |
| 13751 | | if (Value.fromInterned(item.val).toBool()) { |
| 13752 | | true_count.* += 1; |
| 13753 | | } else { |
| 13754 | | false_count.* += 1; |
| 13755 | | } |
| 13756 | | if (true_count.* > 1 or false_count.* > 1) { |
| 13757 | | return sema.fail(block, item_src, "duplicate switch value", .{}); |
| 13758 | | } |
| 13759 | | return item.ref; |
| 13260 | const val = try sema.resolveLazyValue(maybe_lazy); |
| 13261 | const ref: Air.Inst.Ref = if (val.toIntern() == maybe_lazy.toIntern()) |
| 13262 | item_ref |
| 13263 | else |
| 13264 | .fromValue(val); |
| 13265 | return .{ .{ .ref = ref, .val = val }, end }; |
| 13760 | 13266 | } |
| 13761 | 13267 | |
| 13762 | | const ValueSrcMap = std.AutoHashMapUnmanaged(InternPool.Index, LazySrcLoc); |
| 13763 | | |
| 13764 | | fn validateSwitchItemSparse( |
| 13268 | fn validateSwitchItemOrRange( |
| 13765 | 13269 | sema: *Sema, |
| 13766 | 13270 | block: *Block, |
| 13767 | | seen_values: *ValueSrcMap, |
| 13768 | | item_ref: Zir.Inst.Ref, |
| 13769 | | operand_ty: Type, |
| 13770 | 13271 | item_src: LazySrcLoc, |
| 13771 | | ) CompileError!Air.Inst.Ref { |
| 13772 | | const item = try sema.resolveSwitchItemVal(block, item_ref, operand_ty, item_src); |
| 13773 | | const kv = try seen_values.fetchPut(sema.gpa, item.val, item_src) orelse return item.ref; |
| 13774 | | try sema.validateSwitchDupe(block, kv.value, item_src); |
| 13775 | | unreachable; |
| 13776 | | } |
| 13777 | | |
| 13778 | | fn validateSwitchNoRange( |
| 13779 | | sema: *Sema, |
| 13780 | | block: *Block, |
| 13781 | | ranges_len: u32, |
| 13782 | | operand_ty: Type, |
| 13783 | | src_node_offset: std.zig.Ast.Node.Offset, |
| 13272 | /// If `opt_last_val` is not `null`, this refers to the first val of a range. |
| 13273 | item_val: Value, |
| 13274 | opt_last_val: ?Value, |
| 13275 | item_ty: Type, |
| 13276 | seen_enum_fields: []?LazySrcLoc, |
| 13277 | seen_errors: *std.AutoHashMapUnmanaged(InternPool.NullTerminatedString, LazySrcLoc), |
| 13278 | seen_sparse_values: *std.AutoHashMapUnmanaged(InternPool.Index, LazySrcLoc), |
| 13279 | range_set: *RangeSet, |
| 13280 | true_src: *?LazySrcLoc, |
| 13281 | false_src: *?LazySrcLoc, |
| 13282 | void_src: *?LazySrcLoc, |
| 13784 | 13283 | ) CompileError!void { |
| 13785 | | if (ranges_len == 0) |
| 13786 | | return; |
| 13787 | | |
| 13788 | | const operand_src = block.src(.{ .node_offset_switch_operand = src_node_offset }); |
| 13789 | | const range_src = block.src(.{ .node_offset_switch_range = src_node_offset }); |
| 13790 | | |
| 13791 | | const msg = msg: { |
| 13792 | | const msg = try sema.errMsg( |
| 13793 | | operand_src, |
| 13794 | | "ranges not allowed when switching on type '{f}'", |
| 13795 | | .{operand_ty.fmt(sema.pt)}, |
| 13796 | | ); |
| 13797 | | errdefer msg.destroy(sema.gpa); |
| 13798 | | try sema.errNote( |
| 13799 | | range_src, |
| 13800 | | msg, |
| 13801 | | "range here", |
| 13802 | | .{}, |
| 13803 | | ); |
| 13804 | | break :msg msg; |
| 13284 | const pt = sema.pt; |
| 13285 | const zcu = pt.zcu; |
| 13286 | const ip = &zcu.intern_pool; |
| 13287 | const maybe_prev_src: ?LazySrcLoc = maybe_prev_src: switch (item_ty.zigTypeTag(zcu)) { |
| 13288 | .@"union" => unreachable, |
| 13289 | .@"enum" => { |
| 13290 | const int = ip.indexToKey(item_val.toIntern()).enum_tag.int; |
| 13291 | if (ip.loadEnumType(item_ty.toIntern()).tagValueIndex(ip, int)) |field_index| { |
| 13292 | const maybe_prev_src = seen_enum_fields[field_index]; |
| 13293 | seen_enum_fields[field_index] = item_src; |
| 13294 | break :maybe_prev_src maybe_prev_src; |
| 13295 | } else { |
| 13296 | break :maybe_prev_src try range_set.add(sema.arena, .{ |
| 13297 | .first = .fromInterned(int), |
| 13298 | .last = .fromInterned(int), |
| 13299 | .src = item_src, |
| 13300 | }, .fromInterned(ip.typeOf(int)), zcu); |
| 13301 | } |
| 13302 | }, |
| 13303 | .error_set => { |
| 13304 | const error_name = ip.indexToKey(item_val.toIntern()).err.name; |
| 13305 | break :maybe_prev_src if (seen_errors.fetchPutAssumeCapacity(error_name, item_src)) |prev| |
| 13306 | prev.value |
| 13307 | else |
| 13308 | null; |
| 13309 | }, |
| 13310 | .int, .comptime_int => { |
| 13311 | if (opt_last_val) |last_val| { |
| 13312 | const first_val = item_val; |
| 13313 | if (try first_val.compareAll(.gt, last_val, item_ty, pt)) { |
| 13314 | return sema.fail(block, item_src, "range start value is greater than the end value", .{}); |
| 13315 | } |
| 13316 | break :maybe_prev_src range_set.addAssumeCapacity(.{ |
| 13317 | .first = first_val, |
| 13318 | .last = last_val, |
| 13319 | .src = item_src, |
| 13320 | }, item_ty, zcu); |
| 13321 | } else { |
| 13322 | break :maybe_prev_src range_set.addAssumeCapacity(.{ |
| 13323 | .first = item_val, |
| 13324 | .last = item_val, |
| 13325 | .src = item_src, |
| 13326 | }, item_ty, zcu); |
| 13327 | } |
| 13328 | }, |
| 13329 | .enum_literal, .@"fn", .pointer, .type => { |
| 13330 | break :maybe_prev_src if (seen_sparse_values.fetchPutAssumeCapacity(item_val.toIntern(), item_src)) |prev| |
| 13331 | prev.value |
| 13332 | else |
| 13333 | null; |
| 13334 | }, |
| 13335 | .bool => { |
| 13336 | if (item_val.toBool()) { |
| 13337 | if (true_src.*) |prev_src| break :maybe_prev_src prev_src; |
| 13338 | true_src.* = item_src; |
| 13339 | } else { |
| 13340 | if (false_src.*) |prev_src| break :maybe_prev_src prev_src; |
| 13341 | false_src.* = item_src; |
| 13342 | } |
| 13343 | break :maybe_prev_src null; |
| 13344 | }, |
| 13345 | .void => { |
| 13346 | if (void_src.*) |prev_src| break :maybe_prev_src prev_src; |
| 13347 | void_src.* = item_src; |
| 13348 | break :maybe_prev_src null; |
| 13349 | }, |
| 13350 | else => unreachable, // should have already checked for invalid types |
| 13805 | 13351 | }; |
| 13806 | | return sema.failWithOwnedErrorMsg(block, msg); |
| 13352 | if (maybe_prev_src) |prev_src| { |
| 13353 | return sema.failWithOwnedErrorMsg(block, msg: { |
| 13354 | const msg = try sema.errMsg( |
| 13355 | item_src, |
| 13356 | "duplicate switch value", |
| 13357 | .{}, |
| 13358 | ); |
| 13359 | errdefer msg.destroy(sema.gpa); |
| 13360 | try sema.errNote( |
| 13361 | prev_src, |
| 13362 | msg, |
| 13363 | "previous value here", |
| 13364 | .{}, |
| 13365 | ); |
| 13366 | break :msg msg; |
| 13367 | }); |
| 13368 | } |
| 13807 | 13369 | } |
| 13808 | 13370 | |
| 13809 | 13371 | fn maybeErrorUnwrap( |
| ... | ... | @@ -18687,14 +18249,13 @@ fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError! |
| 18687 | 18249 | break :msg msg; |
| 18688 | 18250 | }); |
| 18689 | 18251 | } |
| 18690 | | const is_non_err = try sema.analyzeIsNonErrComptimeOnly(parent_block, operand_src, err_union); |
| 18691 | | if (is_non_err != .none) { |
| 18252 | if (try sema.resolveIsNonErrVal(parent_block, operand_src, err_union)) |is_non_err_val| { |
| 18692 | 18253 | // We can propagate `.cold` hints from this branch since it's comptime-known |
| 18693 | 18254 | // to be taken from the parent branch. |
| 18694 | 18255 | const parent_hint = sema.branch_hint; |
| 18695 | 18256 | defer sema.branch_hint = parent_hint orelse if (sema.branch_hint == .cold) .cold else null; |
| 18696 | 18257 | |
| 18697 | | const is_non_err_val = (try sema.resolveDefinedValue(parent_block, operand_src, is_non_err)).?; |
| 18258 | if (is_non_err_val.isUndef(zcu)) return sema.failWithUseOfUndef(parent_block, operand_src, null); |
| 18698 | 18259 | if (is_non_err_val.toBool()) { |
| 18699 | 18260 | return sema.analyzeErrUnionPayload(parent_block, src, err_union_ty, err_union, operand_src, false); |
| 18700 | 18261 | } |
| ... | ... | @@ -18751,14 +18312,13 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr |
| 18751 | 18312 | break :msg msg; |
| 18752 | 18313 | }); |
| 18753 | 18314 | } |
| 18754 | | const is_non_err = try sema.analyzeIsNonErrComptimeOnly(parent_block, operand_src, err_union); |
| 18755 | | if (is_non_err != .none) { |
| 18315 | if (try sema.resolveIsNonErrVal(parent_block, operand_src, err_union)) |is_non_err_val| { |
| 18756 | 18316 | // We can propagate `.cold` hints from this branch since it's comptime-known |
| 18757 | 18317 | // to be taken from the parent branch. |
| 18758 | 18318 | const parent_hint = sema.branch_hint; |
| 18759 | 18319 | defer sema.branch_hint = parent_hint orelse if (sema.branch_hint == .cold) .cold else null; |
| 18760 | 18320 | |
| 18761 | | const is_non_err_val = (try sema.resolveDefinedValue(parent_block, operand_src, is_non_err)).?; |
| 18321 | if (is_non_err_val.isUndef(zcu)) return sema.failWithUseOfUndef(parent_block, operand_src, null); |
| 18762 | 18322 | if (is_non_err_val.toBool()) { |
| 18763 | 18323 | return sema.analyzeErrUnionPayloadPtr(parent_block, src, operand, false, false); |
| 18764 | 18324 | } |
| ... | ... | @@ -31798,58 +31358,73 @@ fn analyzeIsNull( |
| 31798 | 31358 | return block.addUnOp(air_tag, operand); |
| 31799 | 31359 | } |
| 31800 | 31360 | |
| 31801 | | fn analyzePtrIsNonErrComptimeOnly( |
| 31361 | fn resolvePtrIsNonErrVal( |
| 31802 | 31362 | sema: *Sema, |
| 31803 | 31363 | block: *Block, |
| 31804 | 31364 | src: LazySrcLoc, |
| 31805 | 31365 | operand: Air.Inst.Ref, |
| 31806 | | ) CompileError!Air.Inst.Ref { |
| 31366 | ) CompileError!?Value { |
| 31807 | 31367 | const pt = sema.pt; |
| 31808 | 31368 | const zcu = pt.zcu; |
| 31809 | 31369 | const ptr_ty = sema.typeOf(operand); |
| 31810 | 31370 | assert(ptr_ty.zigTypeTag(zcu) == .pointer); |
| 31811 | 31371 | const child_ty = ptr_ty.childType(zcu); |
| 31812 | 31372 | |
| 31813 | | const child_tag = child_ty.zigTypeTag(zcu); |
| 31814 | | if (child_tag != .error_set and child_tag != .error_union) return .bool_true; |
| 31815 | | if (child_tag == .error_set) return .bool_false; |
| 31816 | | assert(child_tag == .error_union); |
| 31373 | if (try sema.resolveIsNonErrFromType(block, src, child_ty)) |res| { |
| 31374 | return res; |
| 31375 | } |
| 31376 | assert(child_ty.zigTypeTag(zcu) == .error_union); |
| 31817 | 31377 | |
| 31818 | | _ = block; |
| 31819 | | _ = src; |
| 31378 | if (try sema.resolveValue(operand)) |eu_ptr_val| { |
| 31379 | if (eu_ptr_val.isUndef(zcu)) return .undef_bool; |
| 31380 | if (try sema.pointerDeref(block, src, eu_ptr_val, ptr_ty)) |err_union| { |
| 31381 | if (err_union.isUndef(zcu)) return .undef_bool; |
| 31382 | return .makeBool(err_union.getErrorName(zcu) == .none); |
| 31383 | } |
| 31384 | } |
| 31820 | 31385 | |
| 31821 | | return .none; |
| 31386 | return null; |
| 31822 | 31387 | } |
| 31823 | 31388 | |
| 31824 | | fn analyzeIsNonErrComptimeOnly( |
| 31389 | fn resolveIsNonErrVal( |
| 31825 | 31390 | sema: *Sema, |
| 31826 | 31391 | block: *Block, |
| 31827 | 31392 | src: LazySrcLoc, |
| 31828 | 31393 | operand: Air.Inst.Ref, |
| 31829 | | ) CompileError!Air.Inst.Ref { |
| 31394 | ) CompileError!?Value { |
| 31395 | const zcu = sema.pt.zcu; |
| 31396 | if (try sema.resolveIsNonErrFromType(block, src, sema.typeOf(operand))) |res| { |
| 31397 | return res; |
| 31398 | } |
| 31399 | assert(sema.typeOf(operand).zigTypeTag(zcu) == .error_union); |
| 31400 | |
| 31401 | if (try sema.resolveValue(operand)) |err_union| { |
| 31402 | if (err_union.isUndef(zcu)) return .undef_bool; |
| 31403 | return .makeBool(err_union.getErrorName(zcu) == .none); |
| 31404 | } |
| 31405 | |
| 31406 | return null; |
| 31407 | } |
| 31408 | |
| 31409 | fn resolveIsNonErrFromType( |
| 31410 | sema: *Sema, |
| 31411 | block: *Block, |
| 31412 | src: LazySrcLoc, |
| 31413 | operand_ty: Type, |
| 31414 | ) CompileError!?Value { |
| 31830 | 31415 | const pt = sema.pt; |
| 31831 | 31416 | const zcu = pt.zcu; |
| 31832 | 31417 | const ip = &zcu.intern_pool; |
| 31833 | | const operand_ty = sema.typeOf(operand); |
| 31834 | 31418 | const ot = operand_ty.zigTypeTag(zcu); |
| 31835 | | if (ot != .error_set and ot != .error_union) return .bool_true; |
| 31836 | | if (ot == .error_set) return .bool_false; |
| 31419 | if (ot != .error_set and ot != .error_union) return .true; |
| 31420 | if (ot == .error_set) return .false; |
| 31837 | 31421 | assert(ot == .error_union); |
| 31838 | 31422 | |
| 31839 | 31423 | const payload_ty = operand_ty.errorUnionPayload(zcu); |
| 31840 | 31424 | if (payload_ty.zigTypeTag(zcu) == .noreturn) { |
| 31841 | | return .bool_false; |
| 31842 | | } |
| 31843 | | |
| 31844 | | if (operand == .undef) { |
| 31845 | | return .undef_bool; |
| 31846 | | } else if (@intFromEnum(operand) < InternPool.static_len) { |
| 31847 | | // None of the ref tags can be errors. |
| 31848 | | return .bool_true; |
| 31425 | return .false; |
| 31849 | 31426 | } |
| 31850 | 31427 | |
| 31851 | | const maybe_operand_val = try sema.resolveValue(operand); |
| 31852 | | |
| 31853 | 31428 | // exception if the error union error set is known to be empty, |
| 31854 | 31429 | // we allow the comparison but always make it comptime-known. |
| 31855 | 31430 | const set_ty = ip.errorUnionSet(operand_ty.toIntern()); |
| ... | ... | @@ -31865,26 +31440,23 @@ fn analyzeIsNonErrComptimeOnly( |
| 31865 | 31440 | else => |i| if (ip.indexToKey(i).error_set_type.names.len != 0) break :blk, |
| 31866 | 31441 | } |
| 31867 | 31442 | |
| 31868 | | if (maybe_operand_val != null) break :blk; |
| 31869 | | |
| 31870 | | // Try to avoid resolving inferred error set if possible. |
| 31871 | | if (ies.errors.count() != 0) return .none; |
| 31443 | if (ies.errors.count() != 0) return null; |
| 31872 | 31444 | switch (ies.resolved) { |
| 31873 | | .anyerror_type => return .none, |
| 31445 | .anyerror_type => return null, |
| 31874 | 31446 | .none => {}, |
| 31875 | 31447 | else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) { |
| 31876 | | 0 => return .bool_true, |
| 31877 | | else => return .none, |
| 31448 | 0 => return .true, |
| 31449 | else => return null, |
| 31878 | 31450 | }, |
| 31879 | 31451 | } |
| 31880 | 31452 | // We do not have a comptime answer because this inferred error |
| 31881 | 31453 | // set is not resolved, and an instruction later in this function |
| 31882 | 31454 | // body may or may not cause an error to be added to this set. |
| 31883 | | return .none; |
| 31455 | return null; |
| 31884 | 31456 | }, |
| 31885 | 31457 | else => switch (ip.indexToKey(set_ty)) { |
| 31886 | 31458 | .error_set_type => |error_set_type| { |
| 31887 | | if (error_set_type.names.len == 0) return .bool_true; |
| 31459 | if (error_set_type.names.len == 0) return .true; |
| 31888 | 31460 | }, |
| 31889 | 31461 | .inferred_error_set_type => |func_index| blk: { |
| 31890 | 31462 | // If the error set is empty, we must return a comptime true or false. |
| ... | ... | @@ -31896,39 +31468,35 @@ fn analyzeIsNonErrComptimeOnly( |
| 31896 | 31468 | .none => {}, |
| 31897 | 31469 | else => |i| if (ip.indexToKey(i).error_set_type.names.len != 0) break :blk, |
| 31898 | 31470 | } |
| 31899 | | if (maybe_operand_val != null) break :blk; |
| 31900 | 31471 | if (sema.fn_ret_ty_ies) |ies| { |
| 31901 | 31472 | if (ies.func == func_index) { |
| 31902 | 31473 | // Try to avoid resolving inferred error set if possible. |
| 31903 | | if (ies.errors.count() != 0) return .none; |
| 31474 | if (ies.errors.count() != 0) return null; |
| 31904 | 31475 | switch (ies.resolved) { |
| 31905 | | .anyerror_type => return .none, |
| 31476 | .anyerror_type => return null, |
| 31906 | 31477 | .none => {}, |
| 31907 | 31478 | else => switch (ip.indexToKey(ies.resolved).error_set_type.names.len) { |
| 31908 | | 0 => return .bool_true, |
| 31909 | | else => return .none, |
| 31479 | 0 => return .true, |
| 31480 | else => return null, |
| 31910 | 31481 | }, |
| 31911 | 31482 | } |
| 31912 | 31483 | // We do not have a comptime answer because this inferred error |
| 31913 | 31484 | // set is not resolved, and an instruction later in this function |
| 31914 | 31485 | // body may or may not cause an error to be added to this set. |
| 31915 | | return .none; |
| 31486 | return null; |
| 31916 | 31487 | } |
| 31917 | 31488 | } |
| 31918 | 31489 | const resolved_ty = try sema.resolveInferredErrorSet(block, src, set_ty); |
| 31919 | 31490 | if (resolved_ty == .anyerror_type) |
| 31920 | 31491 | break :blk; |
| 31921 | 31492 | if (ip.indexToKey(resolved_ty).error_set_type.names.len == 0) |
| 31922 | | return .bool_true; |
| 31493 | return .true; |
| 31923 | 31494 | }, |
| 31924 | 31495 | else => unreachable, |
| 31925 | 31496 | }, |
| 31926 | 31497 | } |
| 31927 | 31498 | |
| 31928 | | if (maybe_operand_val) |err_union| { |
| 31929 | | return if (err_union.isUndef(zcu)) .undef_bool else if (err_union.getErrorName(zcu) == .none) .bool_true else .bool_false; |
| 31930 | | } |
| 31931 | | return .none; |
| 31499 | return null; |
| 31932 | 31500 | } |
| 31933 | 31501 | |
| 31934 | 31502 | fn analyzeIsNonErr( |
| ... | ... | @@ -31937,12 +31505,10 @@ fn analyzeIsNonErr( |
| 31937 | 31505 | src: LazySrcLoc, |
| 31938 | 31506 | operand: Air.Inst.Ref, |
| 31939 | 31507 | ) CompileError!Air.Inst.Ref { |
| 31940 | | const result = try sema.analyzeIsNonErrComptimeOnly(block, src, operand); |
| 31941 | | if (result == .none) { |
| 31942 | | try sema.requireRuntimeBlock(block, src, null); |
| 31943 | | return block.addUnOp(.is_non_err, operand); |
| 31508 | if (try sema.resolveIsNonErrVal(block, src, operand)) |val| { |
| 31509 | return .fromValue(val); |
| 31944 | 31510 | } else { |
| 31945 | | return result; |
| 31511 | return block.addUnOp(.is_non_err, operand); |
| 31946 | 31512 | } |
| 31947 | 31513 | } |
| 31948 | 31514 | |
| ... | ... | @@ -31952,12 +31518,10 @@ fn analyzePtrIsNonErr( |
| 31952 | 31518 | src: LazySrcLoc, |
| 31953 | 31519 | operand: Air.Inst.Ref, |
| 31954 | 31520 | ) CompileError!Air.Inst.Ref { |
| 31955 | | const result = try sema.analyzePtrIsNonErrComptimeOnly(block, src, operand); |
| 31956 | | if (result == .none) { |
| 31957 | | try sema.requireRuntimeBlock(block, src, null); |
| 31958 | | return block.addUnOp(.is_non_err_ptr, operand); |
| 31521 | if (try sema.resolvePtrIsNonErrVal(block, src, operand)) |val| { |
| 31522 | return .fromValue(val); |
| 31959 | 31523 | } else { |
| 31960 | | return result; |
| 31524 | return block.addUnOp(.is_non_err_ptr, operand); |
| 31961 | 31525 | } |
| 31962 | 31526 | } |
| 31963 | 31527 | |
Matthew Lugg <mlugg@mlugg.co.uk> 2026-01-11 19:44:24+01:00
lib