compiler assertion failure when unwrapping `?@Frame()`

[tgschultz]

fn frameFunc() void {
    suspend;
    suspend;
}

test "unwrap @Frame()" {
    var frame: ?@Frame(frameFunc) = null;
    frame = async frameFunc();
    if(frame) |f| resume f;
    resume frame.?;
}

Code Generation [1/708] when analyzing /root/testing/test.zig:134:13 in compiler source at /deps/zig/src/codegen.cpp:1811: assertion failed. This is a bug in the Zig compiler.
Unable to dump stack trace: debug info stripped
Aborted

Note: the line in question is the assignment to frame, however this also fails when unwrapping with an if statement or the unconditional unwrap.

[cristobal-montecino]

I tried with (click to expand)

fn frameFunc() void {
    suspend;
    @import("std").debug.print("first resume\n", .{});
    suspend;
    @import("std").debug.print("last resume\n", .{});
}

pub fn main() !void {
    var frame: ?@Frame(frameFunc) = null;
    
    frame = async frameFunc();

    if(frame) |*f| resume f;
    resume frame.?;
}

when analyzing <source>:11:13 in compiler source at /deps/zig/src/codegen.cpp:1811: assertion failed. This is a bug in the Zig compiler.

Try this code

---

The assert was in zig/src/codegen.cpp:1811.

In the function, ir_llvm_value

static LLVMValueRef ir_llvm_value(CodeGen *g, IrInstGen *instruction)

Details

static LLVMValueRef ir_llvm_value(CodeGen *g, IrInstGen *instruction) {
    Error err;

    bool value_has_bits;
    if ((err = type_has_bits2(g, instruction->value->type, &value_has_bits)))
        codegen_report_errors_and_exit(g);

    if (!value_has_bits)
        return nullptr;

    if (!instruction->llvm_value) {
        if (instruction->id == IrInstGenIdAwait) {
            IrInstGenAwait *await = reinterpret_cast<IrInstGenAwait*>(instruction);
            if (await->result_loc != nullptr) {
                return get_handle_value(g, ir_llvm_value(g, await->result_loc),
                    await->result_loc->value->type->data.pointer.child_type, await->result_loc->value->type);
            }
        }
        if (instruction->spill != nullptr) {
            ZigType *ptr_type = instruction->spill->value->type;
            ir_assert(ptr_type->id == ZigTypeIdPointer, instruction);
            return get_handle_value(g, ir_llvm_value(g, instruction->spill),
                ptr_type->data.pointer.child_type, instruction->spill->value->type);
        }

        ir_assert(instruction->value->special != ConstValSpecialRuntime, instruction); // <-- Here

        assert(instruction->value->type);
        render_const_val(g, instruction->value, "");
        // we might have to do some pointer casting here due to the way union
        // values are rendered with a type other than the one we expect
        if (handle_is_ptr(g, instruction->value->type)) {
            render_const_val_global(g, instruction->value, "");
            ZigType *ptr_type = get_pointer_to_type(g, instruction->value->type, true);
            instruction->llvm_value = LLVMBuildBitCast(g->builder, instruction->value->llvm_global, get_llvm_type(g, ptr_type), "");
        } else {
            instruction->llvm_value = LLVMBuildBitCast(g->builder, instruction->value->llvm_value,
                    get_llvm_type(g, instruction->value->type), "");
        }
        assert(instruction->llvm_value);
    }
    return instruction->llvm_value;
}

---

I suspect that cast from a temporal value for the frame doesn't have a implementation.

If you avoid the temporal casting declaring a manually temporal, works:

fn frameFunc() void {
    suspend;
    @import("std").debug.print("first resume\n", .{});
    suspend;
    @import("std").debug.print("last resume\n", .{});
}

pub fn main() void {
    var frame: ?@Frame(frameFunc) = null;
    
    var tmp: @Frame(frameFunc) = async frameFunc();
    frame = tmp;

    if(frame) |*f| resume f;
    resume frame.?;
}

first resume
last resume

Try this code

---

The test for temporal frame casting to optional

fn trivialAsyncFunc() void {
    suspend;
}

test "casting temporal @Frame to ?@Frame" {
    var frame: ?@Frame(trivialAsyncFunc) = null;
    frame = async trivialAsyncFunc();
}