Merge branch 'handle-builtin-issue1296' of https://github.com/kristate/zig into kristate-handle-builtin-issue1296

7 files changed, 28 insertions, 28 deletions

diff --git a/std/event/channel.zig b/std/event/channel.zig
index 03a036042b..71e97f6e78 100644
--- a/std/event/channel.zig
+++ b/std/event/channel.zig
@@ -71,10 +71,10 @@ pub fn Channel(comptime T: type) type {
         /// puts a data item in the channel. The promise completes when the value has been added to the
         /// buffer, or in the case of a zero size buffer, when the item has been retrieved by a getter.
         pub async fn put(self: *SelfChannel, data: T) void {
-            suspend |handle| {
+            suspend {
                 var my_tick_node = Loop.NextTickNode{
                     .next = undefined,
-                    .data = handle,
+                    .data = @handle(),
                 };
                 var queue_node = std.atomic.Queue(PutNode).Node{
                     .data = PutNode{
@@ -96,10 +96,10 @@ pub fn Channel(comptime T: type) type {
             // TODO integrate this function with named return values
             // so we can get rid of this extra result copy
             var result: T = undefined;
-            suspend |handle| {
+            suspend {
                 var my_tick_node = Loop.NextTickNode{
                     .next = undefined,
-                    .data = handle,
+                    .data = @handle(),
                 };
                 var queue_node = std.atomic.Queue(GetNode).Node{
                     .data = GetNode{
diff --git a/std/event/future.zig b/std/event/future.zig
index f5d14d1ca6..8abdce7d02 100644
--- a/std/event/future.zig
+++ b/std/event/future.zig
@@ -100,8 +100,8 @@ test "std.event.Future" {
 }
 
 async fn testFuture(loop: *Loop) void {
-    suspend |p| {
-        resume p;
+    suspend {
+        resume @handle();
     }
     var future = Future(i32).init(loop);
 
@@ -115,15 +115,15 @@ async fn testFuture(loop: *Loop) void {
 }
 
 async fn waitOnFuture(future: *Future(i32)) i32 {
-    suspend |p| {
-        resume p;
+    suspend {
+        resume @handle();
     }
     return (await (async future.get() catch @panic("memory"))).*;
 }
 
 async fn resolveFuture(future: *Future(i32)) void {
-    suspend |p| {
-        resume p;
+    suspend {
+        resume @handle();
     }
     future.data = 6;
     future.resolve();
diff --git a/std/event/group.zig b/std/event/group.zig
index 26c098399e..6c7fc63699 100644
--- a/std/event/group.zig
+++ b/std/event/group.zig
@@ -54,10 +54,10 @@ pub fn Group(comptime ReturnType: type) type {
             const S = struct {
                 async fn asyncFunc(node: **Stack.Node, args2: ...) ReturnType {
                     // TODO this is a hack to make the memory following be inside the coro frame
-                    suspend |p| {
+                    suspend {
                         var my_node: Stack.Node = undefined;
                         node.* = &my_node;
-                        resume p;
+                        resume @handle();
                     }
 
                     // TODO this allocation elision should be guaranteed because we await it in
diff --git a/std/event/lock.zig b/std/event/lock.zig
index 0bd7183db2..c4cb1a3f0e 100644
--- a/std/event/lock.zig
+++ b/std/event/lock.zig
@@ -90,10 +90,10 @@ pub const Lock = struct {
     }
 
     pub async fn acquire(self: *Lock) Held {
-        suspend |handle| {
+        suspend {
             // TODO explicitly put this memory in the coroutine frame #1194
             var my_tick_node = Loop.NextTickNode{
-                .data = handle,
+                .data = @handle(),
                 .next = undefined,
             };
 
@@ -141,8 +141,8 @@ test "std.event.Lock" {
 
 async fn testLock(loop: *Loop, lock: *Lock) void {
     // TODO explicitly put next tick node memory in the coroutine frame #1194
-    suspend |p| {
-        resume p;
+    suspend {
+        resume @handle();
     }
     const handle1 = async lockRunner(lock) catch @panic("out of memory");
     var tick_node1 = Loop.NextTickNode{
diff --git a/std/event/loop.zig b/std/event/loop.zig
index 4e219653be..8b1b2e53db 100644
--- a/std/event/loop.zig
+++ b/std/event/loop.zig
@@ -331,11 +331,11 @@ pub const Loop = struct {
 
     pub async fn waitFd(self: *Loop, fd: i32) !void {
         defer self.removeFd(fd);
-        suspend |p| {
+        suspend {
             // TODO explicitly put this memory in the coroutine frame #1194
             var resume_node = ResumeNode{
                 .id = ResumeNode.Id.Basic,
-                .handle = p,
+                .handle = @handle(),
             };
             try self.addFd(fd, &resume_node);
         }
@@ -417,11 +417,11 @@ pub const Loop = struct {
     pub fn call(self: *Loop, comptime func: var, args: ...) !(promise->@typeOf(func).ReturnType) {
         const S = struct {
             async fn asyncFunc(loop: *Loop, handle: *promise->@typeOf(func).ReturnType, args2: ...) @typeOf(func).ReturnType {
-                suspend |p| {
-                    handle.* = p;
+                suspend {
+                    handle.* = @handle();
                     var my_tick_node = Loop.NextTickNode{
                         .next = undefined,
-                        .data = p,
+                        .data = @handle(),
                     };
                     loop.onNextTick(&my_tick_node);
                 }
@@ -439,10 +439,10 @@ pub const Loop = struct {
     /// CPU bound tasks would be waiting in the event loop but never get started because no async I/O
     /// is performed.
     pub async fn yield(self: *Loop) void {
-        suspend |p| {
+        suspend {
             var my_tick_node = Loop.NextTickNode{
                 .next = undefined,
-                .data = p,
+                .data = @handle(),
             };
             self.onNextTick(&my_tick_node);
         }
diff --git a/std/event/tcp.zig b/std/event/tcp.zig
index 416a8c07dc..ea803a9322 100644
--- a/std/event/tcp.zig
+++ b/std/event/tcp.zig
@@ -88,8 +88,8 @@ pub const Server = struct {
                 },
                 error.ProcessFdQuotaExceeded => {
                     errdefer std.os.emfile_promise_queue.remove(&self.waiting_for_emfile_node);
-                    suspend |p| {
-                        self.waiting_for_emfile_node = PromiseNode.init(p);
+                    suspend {
+                        self.waiting_for_emfile_node = PromiseNode.init( @handle() );
                         std.os.emfile_promise_queue.append(&self.waiting_for_emfile_node);
                     }
                     continue;
@@ -141,8 +141,8 @@ test "listen on a port, send bytes, receive bytes" {
             (await next_handler) catch |err| {
                 std.debug.panic("unable to handle connection: {}\n", err);
             };
-            suspend |p| {
-                cancel p;
+            suspend {
+                cancel @handle();
             }
         }
         async fn errorableHandler(self: *Self, _addr: *const std.net.Address, _socket: *const std.os.File) !void {
diff --git a/std/zig/parser_test.zig b/std/zig/parser_test.zig
index 21259bec3c..32cdc8121f 100644
--- a/std/zig/parser_test.zig
+++ b/std/zig/parser_test.zig
@@ -1784,7 +1784,7 @@ test "zig fmt: coroutines" {
         \\    x += 1;
         \\    suspend;
         \\    x += 1;
-        \\    suspend |p| {}
+        \\    suspend;
         \\    const p: promise->void = async simpleAsyncFn() catch unreachable;
         \\    await p;
         \\}