change how completions get attached

src/async/io_uring.zig

@@ -126,7 +126,6 @@ pub const AsyncIoUring = struct {
     pub fn to_async(self: *AsyncIoUring) Async {
         return Async{
             .runner = self.runner,
-            .completions = undefined,
             ._queue_accept = queue_accept,
             ._queue_recv = queue_recv,
             ._queue_send = queue_send,

src/async/lib.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const assert = std.debug.assert;
 const builtin = @import("builtin");
 const Socket = @import("../core/socket.zig").Socket;
 const Completion = @import("completion.zig").Completion;
@@ -27,7 +28,8 @@ pub const AsyncError = error{
 
 pub const Async = struct {
     runner: *anyopaque,
-    completions: []Completion,
+    attached: bool = false,
+    completions: []Completion = undefined,
 
     _queue_accept: *const fn (
         self: *Async,
@@ -58,15 +60,20 @@ pub const Async = struct {
     _reap: *const fn (self: *Async) AsyncError![]Completion,
     _submit: *const fn (self: *Async) AsyncError!void,
 
-    pub fn attach_completions(self: *Async, completions: []Completion) void {
+    /// This provides the completions that the backend will utilize when
+    /// submitting and reaping. This MUST be called before any other
+    /// methods on this Async instance.
+    pub fn attach(self: *Async, completions: []Completion) void {
         self.completions = completions;
+        self.attached = true;
     }
 
     pub fn queue_accept(
         self: *Async,
         context: *anyopaque,
         socket: Socket,
     ) AsyncError!void {
+        assert(self.attached);
         try @call(.auto, self._queue_accept, .{ self, context, socket });
     }
 
@@ -76,6 +83,7 @@ pub const Async = struct {
         socket: Socket,
         buffer: []u8,
     ) AsyncError!void {
+        assert(self.attached);
         try @call(.auto, self._queue_recv, .{ self, context, socket, buffer });
     }
 
@@ -85,6 +93,7 @@ pub const Async = struct {
         socket: Socket,
         buffer: []const u8,
     ) AsyncError!void {
+        assert(self.attached);
         try @call(.auto, self._queue_send, .{ self, context, socket, buffer });
     }
 
@@ -93,14 +102,17 @@ pub const Async = struct {
         context: *anyopaque,
         socket: Socket,
     ) AsyncError!void {
+        assert(self.attached);
         try @call(.auto, self._queue_close, .{ self, context, socket });
     }
 
     pub fn reap(self: *Async) AsyncError![]Completion {
+        assert(self.attached);
         return try @call(.auto, self._reap, .{self});
     }
 
     pub fn submit(self: *Async) AsyncError!void {
+        assert(self.attached);
         try @call(.auto, self._submit, .{self});
     }
 };

src/core/server.zig

@@ -657,7 +657,7 @@ pub fn Server(
                     self.config.size_completions_reap_max,
                 );
 
-                backend.attach_completions(completions);
+                backend.attach(completions);
             }
 
             defer {
@@ -741,7 +741,7 @@ pub fn Server(
                                             z_config.size_completions_reap_max,
                                         ) catch unreachable;
 
-                                        thread_backend.attach_completions(completions);
+                                        thread_backend.attach(completions);
                                     }
 
                                     defer {

src/examples/custom/main.zig

@@ -127,7 +127,6 @@ pub const CustomAsync = struct {
     pub fn to_async(self: *CustomAsync) Async {
         return Async{
             .runner = self.inner,
-            .completions = undefined,
             ._queue_accept = queue_accept,
             ._queue_recv = queue_recv,
             ._queue_send = queue_send,