add behavior tests for cancel semantics

test/behavior.zig

@@ -16,6 +16,7 @@ comptime {
     _ = @import("cases/bugs/828.zig");
     _ = @import("cases/bugs/920.zig");
     _ = @import("cases/byval_arg_var.zig");
+    _ = @import("cases/cancel.zig");
     _ = @import("cases/cast.zig");
     _ = @import("cases/const_slice_child.zig");
     _ = @import("cases/coroutine_await_struct.zig");

test/cases/cancel.zig

@@ -0,0 +1,92 @@
+const std = @import("std");
+
+var defer_f1: bool = false;
+var defer_f2: bool = false;
+var defer_f3: bool = false;
+
+test "cancel forwards" {
+    var da = std.heap.DirectAllocator.init();
+    defer da.deinit();
+
+    const p = async<&da.allocator> f1() catch unreachable;
+    cancel p;
+    std.debug.assert(defer_f1);
+    std.debug.assert(defer_f2);
+    std.debug.assert(defer_f3);
+}
+
+async fn f1() void {
+    defer {
+        defer_f1 = true;
+    }
+    await (async f2() catch unreachable);
+}
+
+async fn f2() void {
+    defer {
+        defer_f2 = true;
+    }
+    await (async f3() catch unreachable);
+}
+
+async fn f3() void {
+    defer {
+        defer_f3 = true;
+    }
+    suspend;
+}
+
+var defer_b1: bool = false;
+var defer_b2: bool = false;
+var defer_b3: bool = false;
+var defer_b4: bool = false;
+
+test "cancel backwards" {
+    var da = std.heap.DirectAllocator.init();
+    defer da.deinit();
+
+    const p = async<&da.allocator> b1() catch unreachable;
+    cancel p;
+    std.debug.assert(defer_b1);
+    std.debug.assert(defer_b2);
+    std.debug.assert(defer_b3);
+    std.debug.assert(defer_b4);
+}
+
+async fn b1() void {
+    defer {
+        defer_b1 = true;
+    }
+    await (async b2() catch unreachable);
+}
+
+var b4_handle: promise = undefined;
+
+async fn b2() void {
+    const b3_handle = async b3() catch unreachable;
+    resume b4_handle;
+    cancel b4_handle;
+    defer {
+        defer_b2 = true;
+    }
+    const value = await b3_handle;
+    @panic("unreachable");
+}
+
+async fn b3() i32 {
+    defer {
+        defer_b3 = true;
+    }
+    await (async b4() catch unreachable);
+    return 1234;
+}
+
+async fn b4() void {
+    defer {
+        defer_b4 = true;
+    }
+    suspend |p| {
+        b4_handle = p;
+    }
+    suspend;
+}