It builds again! With some horrible hacks

Sources/System/AsyncFileDescriptor.swift

@@ -1,13 +1,12 @@
 @_implementationOnly import CSystem
 
-
-public final class AsyncFileDescriptor {    
+public struct AsyncFileDescriptor: ~Copyable {
     @usableFromInline var open: Bool = true
     @usableFromInline let fileSlot: IORingFileSlot
     @usableFromInline let ring: ManagedIORing
-    
+
     public static func openat(
-        atDirectory: FileDescriptor = FileDescriptor(rawValue: -100), 
+        atDirectory: FileDescriptor = FileDescriptor(rawValue: -100),
         path: FilePath,
         _ mode: FileDescriptor.AccessMode,
         options: FileDescriptor.OpenOptions = FileDescriptor.OpenOptions(),
@@ -19,35 +18,37 @@ public final class AsyncFileDescriptor {
             throw IORingError.missingRequiredFeatures
         }
         let cstr = path.withCString {
-            return $0 // bad
+            return $0  // bad
         }
-        let res = await ring.submitAndWait(.openat(
-            atDirectory: atDirectory, 
-            path: cstr,
-            mode,
-            options: options,
-            permissions: permissions,
-            intoSlot: fileSlot
-        ))
+        let res = await ring.submitAndWait(
+            .openat(
+                atDirectory: atDirectory,
+                path: cstr,
+                mode,
+                options: options,
+                permissions: permissions,
+                intoSlot: fileSlot.borrow()
+            ))
         if res.result < 0 {
             throw Errno(rawValue: -res.result)
         }
-        
+
         return AsyncFileDescriptor(
             fileSlot, ring: ring
         )
     }
 
-    internal init(_ fileSlot: IORingFileSlot, ring: ManagedIORing) {
-        self.fileSlot = fileSlot
+    internal init(_ fileSlot: consuming IORingFileSlot, ring: ManagedIORing) {
+        self.fileSlot = consume fileSlot
         self.ring = ring
     }
 
     @inlinable @inline(__always) @_unsafeInheritExecutor
-    public func close() async throws {
-        let res = await ring.submitAndWait(.close(
-            .registered(self.fileSlot)
-        ))
+    public consuming func close() async throws {
+        let res = await ring.submitAndWait(
+            .close(
+                .registered(self.fileSlot)
+            ))
         if res.result < 0 {
             throw Errno(rawValue: -res.result)
         }
@@ -56,67 +57,99 @@ public final class AsyncFileDescriptor {
 
     @inlinable @inline(__always) @_unsafeInheritExecutor
     public func read(
-        into buffer: IORequest.Buffer,
+        into buffer: inout UnsafeMutableRawBufferPointer,
         atAbsoluteOffset offset: UInt64 = UInt64.max
     ) async throws -> UInt32 {
-        let res = await ring.submitAndWait(.read(
-            file: .registered(self.fileSlot),
-            buffer: buffer,
-            offset: offset
-        ))
+        let file = fileSlot.borrow()
+        let res = await ring.submitAndWait(
+            .readUnregistered(
+                file: .registered(file),
+                buffer: buffer,
+                offset: offset
+            ))
         if res.result < 0 {
             throw Errno(rawValue: -res.result)
         } else {
             return UInt32(bitPattern: res.result)
         }
     }
 
-    deinit {
-        if (self.open) {
-            // TODO: close or error? TBD
+    @inlinable @inline(__always) @_unsafeInheritExecutor
+    public func read(
+        into buffer: borrowing IORingBuffer, //TODO: should be inout?
+        atAbsoluteOffset offset: UInt64 = UInt64.max
+    ) async throws -> UInt32 {
+        let res = await ring.submitAndWait(
+            .read(
+                file: .registered(self.fileSlot.borrow()),
+                buffer: buffer.borrow(),
+                offset: offset
+            ))
+        if res.result < 0 {
+            throw Errno(rawValue: -res.result)
+        } else {
+            return UInt32(bitPattern: res.result)
         }
     }
+
+    //TODO: temporary workaround until AsyncSequence supports ~Copyable
+    public consuming func toBytes() -> AsyncFileDescriptorSequence {
+        AsyncFileDescriptorSequence(self)
+    }
+
+    //TODO: can we do the linear types thing and error if they don't consume it manually?
+  //  deinit {
+  //      if self.open {
+            // TODO: close or error? TBD
+  //      }
+  //  }
 }
 
-extension AsyncFileDescriptor: AsyncSequence {
+public class AsyncFileDescriptorSequence: AsyncSequence {
+    var descriptor: AsyncFileDescriptor?
+
     public func makeAsyncIterator() -> FileIterator {
-        return .init(self)
+        return .init(descriptor.take()!)
+    }
+
+    internal init(_ descriptor: consuming AsyncFileDescriptor) {
+        self.descriptor = consume descriptor
     }
 
     public typealias AsyncIterator = FileIterator
     public typealias Element = UInt8
 }
 
-public struct FileIterator: AsyncIteratorProtocol {
+//TODO: only a class due to ~Copyable limitations
+public class FileIterator: AsyncIteratorProtocol {
     @usableFromInline let file: AsyncFileDescriptor
     @usableFromInline var buffer: IORingBuffer
     @usableFromInline var done: Bool
 
     @usableFromInline internal var currentByte: UnsafeRawPointer?
     @usableFromInline internal var lastByte: UnsafeRawPointer?
 
-    init(_ file: AsyncFileDescriptor) {
-        self.file = file
+    init(_ file: consuming AsyncFileDescriptor) {
         self.buffer = file.ring.getBuffer()!
+        self.file = file
         self.done = false
     }
 
     @inlinable @inline(__always)
-    public mutating func nextBuffer() async throws {
-        let buffer = self.buffer
-
-        let bytesRead = try await file.read(into: .registered(buffer))
+    public func nextBuffer() async throws {
+        let bytesRead = Int(try await file.read(into: buffer))
         if _fastPath(bytesRead != 0) {
-            let bufPointer = buffer.unsafeBuffer.baseAddress.unsafelyUnwrapped
+            let unsafeBuffer = buffer.unsafeBuffer
+            let bufPointer = unsafeBuffer.baseAddress.unsafelyUnwrapped
             self.currentByte = UnsafeRawPointer(bufPointer)
-            self.lastByte = UnsafeRawPointer(bufPointer.advanced(by: Int(bytesRead)))
+            self.lastByte = UnsafeRawPointer(bufPointer.advanced(by: bytesRead))
         } else {
-            self.done = true
+            done = true
         }
     }
 
     @inlinable @inline(__always) @_unsafeInheritExecutor
-    public mutating func next() async throws -> UInt8? {
+    public func next() async throws -> UInt8? {
         if _fastPath(currentByte != lastByte) {
             // SAFETY: both pointers should be non-nil if they're not equal
             let byte = currentByte.unsafelyUnwrapped.load(as: UInt8.self)

Sources/System/IOCompletion.swift

@@ -1,5 +1,6 @@
 @_implementationOnly import CSystem
 
+//TODO: should be ~Copyable, but requires UnsafeContinuation add ~Copyable support
 public struct IOCompletion {
     let rawValue: io_uring_cqe
 }

Sources/System/IORequest.swift

@@ -1,7 +1,7 @@
 import struct CSystem.io_uring_sqe
 
 public enum IORequest: ~Copyable {
-    case nop // nothing here
+    case nop  // nothing here
     case openat(
         atDirectory: FileDescriptor,
         path: UnsafePointer<CChar>,
@@ -12,21 +12,26 @@ public enum IORequest: ~Copyable {
     )
     case read(
         file: File,
-        buffer: Buffer,
+        buffer: IORingBuffer,
+        offset: UInt64 = 0
+    )
+    case readUnregistered(
+        file: File,
+        buffer: UnsafeMutableRawBufferPointer,
         offset: UInt64 = 0
     )
     case write(
         file: File,
-        buffer: Buffer,
+        buffer: IORingBuffer,
+        offset: UInt64 = 0
+    )
+    case writeUnregistered(
+        file: File,
+        buffer: UnsafeMutableRawBufferPointer,
         offset: UInt64 = 0
     )
     case close(File)
 
-    public enum Buffer: ~Copyable {
-        case registered(IORingBuffer)
-        case unregistered(UnsafeMutableRawBufferPointer)
-    }
-
     public enum File: ~Copyable {
         case registered(IORingFileSlot)
         case unregistered(FileDescriptor)
@@ -90,30 +95,21 @@ extension IORequest {
                 request.rawValue.file_index = UInt32(fileSlot.index + 1)
             }
         case .write(let file, let buffer, let offset):
-            switch consume buffer {
-            case .registered(let buffer):
-                request.operation = .writeFixed
-                return makeRawRequest_readWrite_registered(
-                    file: file, buffer: buffer, offset: offset, request: request)
-
-            case .unregistered(let buffer):
-                request.operation = .write
-                return makeRawRequest_readWrite_unregistered(
-                    file: file, buffer: buffer, offset: offset, request: request)
-            }
+            request.operation = .writeFixed
+            return makeRawRequest_readWrite_registered(
+                file: file, buffer: buffer, offset: offset, request: request)
+        case .writeUnregistered(let file, let buffer, let offset):
+            request.operation = .write
+            return makeRawRequest_readWrite_unregistered(
+                file: file, buffer: buffer, offset: offset, request: request)
         case .read(let file, let buffer, let offset):
-
-            switch consume buffer {
-            case .registered(let buffer):
-                request.operation = .readFixed
-                return makeRawRequest_readWrite_registered(
-                    file: file, buffer: buffer, offset: offset, request: request)
-
-            case .unregistered(let buffer):
-                request.operation = .read
-                return makeRawRequest_readWrite_unregistered(
-                    file: file, buffer: buffer, offset: offset, request: request)
-            }
+            request.operation = .readFixed
+            return makeRawRequest_readWrite_registered(
+                file: file, buffer: buffer, offset: offset, request: request)
+        case .readUnregistered(let file, let buffer, let offset):
+            request.operation = .read
+            return makeRawRequest_readWrite_unregistered(
+                file: file, buffer: buffer, offset: offset, request: request)
         case .close(let file):
             request.operation = .close
             switch file {

Sources/System/IORing.swift

@@ -51,7 +51,7 @@ internal class ResourceManager<T>: @unchecked Sendable {
 
     struct Resources {
         let resourceList: UnsafeMutableBufferPointer<T>
-        var freeList: [Int]
+        var freeList: [Int] //TODO: bitvector?
     }
 
     let mutex: Mutex<Resources>
@@ -90,23 +90,33 @@ public struct IOResource<T>: ~Copyable {
     @usableFromInline let resource: T
     @usableFromInline let index: Int
     let manager: ResourceManager<T>
+    let isBorrow: Bool //TODO: this is a workaround for lifetime issues and should be removed
 
     internal init(
         resource: T,
         index: Int,
-        manager: ResourceManager<T>
+        manager: ResourceManager<T>,
+        isBorrow: Bool = false
     ) {
         self.resource = resource
         self.index = index
         self.manager = manager
+        self.isBorrow = isBorrow
     }
 
     func withResource() {
 
     }
 
+    //TODO: this is a workaround for lifetime issues and should be removed
+    @usableFromInline func borrow() -> IOResource<T> {
+        IOResource(resource: resource, index: index, manager: manager, isBorrow: true)
+    }
+
     deinit {
-        self.manager.releaseResource(index: self.index)
+        if !isBorrow {
+            manager.releaseResource(index: self.index)
+        }
     }
 }
 
@@ -204,8 +214,6 @@ internal func _getSubmissionEntry(ring: inout SQRing, submissionQueueEntries: Un
     return nil
 }
 
-// XXX: This should be a non-copyable type (?)
-// demo only runs on Swift 5.8.1
 public struct IORing: @unchecked Sendable, ~Copyable {
     let ringFlags: UInt32
     let ringDescriptor: Int32
@@ -455,9 +463,9 @@ public struct IORing: @unchecked Sendable, ~Copyable {
 
     @inlinable @inline(__always)
     public mutating func writeRequest(_ request: __owned IORequest) -> Bool {
-        let raw = request.makeRawRequest()
+        var raw: RawIORequest? = request.makeRawRequest()
         return submissionMutex.withLock { ring in
-            return _writeRequest(raw, ring: &ring, submissionQueueEntries: submissionQueueEntries)
+            return _writeRequest(raw.take()!, ring: &ring, submissionQueueEntries: submissionQueueEntries)
         }
     }
 

Sources/System/ManagedIORing.swift

@@ -37,11 +37,11 @@ final public class ManagedIORing: @unchecked Sendable {
     }
 
     internal func getFileSlot() -> IORingFileSlot? {
-        self.internalRing.getFile()
+        internalRing.getFile()
     }
 
     internal func getBuffer() -> IORingBuffer? {
-        self.internalRing.getBuffer()
+        internalRing.getBuffer()
     }
 
 }

Sources/System/RawIORequest.swift

@@ -2,7 +2,7 @@
 @_implementationOnly import CSystem
 import struct CSystem.io_uring_sqe
 
-public struct RawIORequest {
+public struct RawIORequest: ~Copyable {
     @usableFromInline var rawValue: io_uring_sqe 
 
     public init() {

Tests/SystemTests/AsyncFileDescriptorTests.swift

@@ -33,7 +33,7 @@ final class AsyncFileDescriptorTests: XCTestCase {
             .readOnly,
             onRing: ring
         )
-        for try await _ in file {
+        for try await _ in file.toBytes() {
             XCTFail("/dev/null should be empty")
         }
     }

Tests/SystemTests/IORequestTests.swift

@@ -6,7 +6,7 @@ import XCTest
 import System
 #endif
 
-func requestBytes(_ request: RawIORequest) -> [UInt8] {
+func requestBytes(_ request: consuming RawIORequest) -> [UInt8] {
     return withUnsafePointer(to: request) {
         let requestBuf = UnsafeBufferPointer(start: $0, count: 1)
         let rawBytes = UnsafeRawBufferPointer(requestBuf)
@@ -40,7 +40,7 @@ final class IORequestTests: XCTestCase {
             .readOnly,
             options: [],
             permissions: nil,
-            intoSlot: fileSlot
+            intoSlot: fileSlot.borrow()
         )
 
         let expectedRequest: [UInt8] = {