async/await support

Motivation:

The async/await proposal has entered the review phase, so we may want to
start looking into NIO with async/await.

Modifications:

- Add `EventLoopFuture.get() throws await`
- Add `ChannelOutboundInvoker` `async` methods

Result:

If async/await were actually implemented, you could use NIO together
with async/wait. So far, you can only compile your projects.

Author: weissi

Package.swift

@@ -15,6 +15,14 @@
 
 import PackageDescription
 
+let nioSwiftSettings: [SwiftSetting]
+
+#if compiler(>=5.4)
+nioSwiftSettings = [.unsafeFlags(["-Xfrontend", "-enable-experimental-concurrency"])]
+#else
+nioSwiftSettings = []
+#endif
+
 var targets: [PackageDescription.Target] = [
     .target(name: "_NIO1APIShims",
             dependencies: ["NIO", "NIOHTTP1", "NIOTLS", "NIOFoundationCompat", "NIOWebSocket"]),
@@ -24,7 +32,8 @@ var targets: [PackageDescription.Target] = [
                            "CNIOWindows",
                            "NIOConcurrencyHelpers",
                            "CNIOAtomics",
-                           "CNIOSHA1"]),
+                           "CNIOSHA1"],
+            swiftSettings: nioSwiftSettings),
     .target(name: "NIOFoundationCompat", dependencies: ["NIO"]),
     .target(name: "CNIOAtomics", dependencies: []),
     .target(name: "CNIOSHA1", dependencies: []),

Sources/NIO/AsyncAwaitSupport.swift

@@ -0,0 +1,84 @@
+#if compiler(>=5.4)
+extension EventLoopFuture {
+    public func get() async throws -> Value {
+        return await try Task.withUnsafeThrowingContinuation { cont in
+            self.whenComplete { result in
+                switch result {
+                case .success(let value):
+                    cont.resume(returning: value)
+                case .failure(let error):
+                    cont.resume(throwing: error)
+                }
+            }
+        }
+    }
+}
+
+extension Channel {
+    public func writeAndFlush<T>(_ any: T) async throws {
+        await try self.writeAndFlush(any).get()
+    }
+
+    /// Set `option` to `value` on this `Channel`.
+    public func setOption<Option: ChannelOption>(_ option: Option, value: Option.Value) async throws {
+        await try self.setOption(option, value: value).get()
+    }
+
+    /// Get the value of `option` for this `Channel`.
+    public func getOption<Option: ChannelOption>(_ option: Option) async throws -> Option.Value {
+        return await try self.getOption(option).get()
+    }
+}
+
+extension ChannelOutboundInvoker {
+    /// Register on an `EventLoop` and so have all its IO handled.
+    ///
+    /// - returns: the future which will be notified once the operation completes.
+    public func register(file: StaticString = #file, line: UInt = #line) async throws {
+        await try self.register(file: file, line: line)
+    }
+
+    /// Bind to a `SocketAddress`.
+    /// - parameters:
+    ///     - to: the `SocketAddress` to which we should bind the `Channel`.
+    /// - returns: the future which will be notified once the operation completes.
+    public func bind(to address: SocketAddress, file: StaticString = #file, line: UInt = #line) async throws {
+        await try self.bind(to: address, file: file, line: line)
+    }
+
+    /// Connect to a `SocketAddress`.
+    /// - parameters:
+    ///     - to: the `SocketAddress` to which we should connect the `Channel`.
+    /// - returns: the future which will be notified once the operation completes.
+    public func connect(to address: SocketAddress, file: StaticString = #file, line: UInt = #line) async throws {
+        await try self.connect(to: address, file: file, line: line)
+    }
+
+    /// Shortcut for calling `write` and `flush`.
+    ///
+    /// - parameters:
+    ///     - data: the data to write
+    /// - returns: the future which will be notified once the `write` operation completes.
+    public func writeAndFlush(_ data: NIOAny, file: StaticString = #file, line: UInt = #line) async throws {
+        await try self.writeAndFlush(data, file: file, line: line)
+    }
+
+    /// Close the `Channel` and so the connection if one exists.
+    ///
+    /// - parameters:
+    ///     - mode: the `CloseMode` that is used
+    /// - returns: the future which will be notified once the operation completes.
+    public func close(mode: CloseMode = .all, file: StaticString = #file, line: UInt = #line) async throws {
+        await try self.close(mode: mode, file: file, line: line)
+    }
+
+    /// Trigger a custom user outbound event which will flow through the `ChannelPipeline`.
+    ///
+    /// - parameters:
+    ///     - event: the event itself.
+    /// - returns: the future which will be notified once the operation completes.
+    public func triggerUserOutboundEvent(_ event: Any, file: StaticString = #file, line: UInt = #line) async throws {
+        await try self.triggerUserOutboundEvent(event, file: file, line: line).get()
+    }
+}
+#endif