Drop Swift 5.10 (#3393)

This PR drops Swift 5.10 and enables Swift 6 language mode.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>

Author: fabianfett

Package.swift

@@ -86,7 +86,8 @@ SwiftNIO            | Minimum Swift Version
 `2.60.0 ..< 2.65.0` | 5.7
 `2.65.0 ..< 2.76.0` | 5.8
 `2.76.0 ..< 2.83.0` | 5.9
-`2.83.0 ...`        | 5.10
+`2.83.0 ..< 2.87.0` | 5.10
+`2.87.0 ...       ` | 6.0
 
 ### SwiftNIO 1
 SwiftNIO 1 is considered end of life - it is strongly recommended that you move to a newer version.  The Core NIO team does not actively work on this version.  No new features will be added to this version but PRs which fix bugs or security vulnerabilities will be accepted until the end of May 2022.

README.md

@@ -19,7 +19,6 @@ import CNIOAtomics
 /// **Do not add conformance to this protocol for arbitrary types**. Only a small range
 /// of types have appropriate atomic operations supported by the CPU, and those types
 /// already have conformances implemented.
-#if compiler(>=6.0)
 @preconcurrency
 public protocol NIOAtomicPrimitive {
     associatedtype AtomicWrapper
@@ -35,18 +34,6 @@ public protocol NIOAtomicPrimitive {
     static var nio_atomic_load: @Sendable (UnsafeMutablePointer<AtomicWrapper>) -> Self { get }
     static var nio_atomic_store: @Sendable (UnsafeMutablePointer<AtomicWrapper>, Self) -> Void { get }
 }
-#else
-public protocol NIOAtomicPrimitive {
-    associatedtype AtomicWrapper
-    static var nio_atomic_create_with_existing_storage: (UnsafeMutablePointer<AtomicWrapper>, Self) -> Void { get }
-    static var nio_atomic_compare_and_exchange: (UnsafeMutablePointer<AtomicWrapper>, Self, Self) -> Bool { get }
-    static var nio_atomic_add: (UnsafeMutablePointer<AtomicWrapper>, Self) -> Self { get }
-    static var nio_atomic_sub: (UnsafeMutablePointer<AtomicWrapper>, Self) -> Self { get }
-    static var nio_atomic_exchange: (UnsafeMutablePointer<AtomicWrapper>, Self) -> Self { get }
-    static var nio_atomic_load: (UnsafeMutablePointer<AtomicWrapper>) -> Self { get }
-    static var nio_atomic_store: (UnsafeMutablePointer<AtomicWrapper>, Self) -> Void { get }
-}
-#endif
 
 extension Bool: NIOAtomicPrimitive {
     public typealias AtomicWrapper = catmc_nio_atomic__Bool

Sources/NIOConcurrencyHelpers/NIOAtomic.swift

@@ -297,7 +297,6 @@ extension Atomic: @unchecked Sendable where T: Sendable {}
 /// **Do not add conformance to this protocol for arbitrary types**. Only a small range
 /// of types have appropriate atomic operations supported by the CPU, and those types
 /// already have conformances implemented.
-#if compiler(>=6.0)
 @preconcurrency
 public protocol AtomicPrimitive {
     static var atomic_create: @Sendable (Self) -> OpaquePointer { get }
@@ -309,18 +308,6 @@ public protocol AtomicPrimitive {
     static var atomic_load: @Sendable (OpaquePointer) -> Self { get }
     static var atomic_store: @Sendable (OpaquePointer, Self) -> Void { get }
 }
-#else
-public protocol AtomicPrimitive {
-    static var atomic_create: (Self) -> OpaquePointer { get }
-    static var atomic_destroy: (OpaquePointer) -> Void { get }
-    static var atomic_compare_and_exchange: (OpaquePointer, Self, Self) -> Bool { get }
-    static var atomic_add: (OpaquePointer, Self) -> Self { get }
-    static var atomic_sub: (OpaquePointer, Self) -> Self { get }
-    static var atomic_exchange: (OpaquePointer, Self) -> Self { get }
-    static var atomic_load: (OpaquePointer) -> Self { get }
-    static var atomic_store: (OpaquePointer, Self) -> Void { get }
-}
-#endif
 
 extension Bool: AtomicPrimitive {
     public static let atomic_create = catmc_atomic__Bool_create

Sources/NIOConcurrencyHelpers/atomics.swift

@@ -323,19 +323,18 @@ public struct NIOAsyncChannel<Inbound: Sendable, Outbound: Sendable>: Sendable {
         return result
     }
 
-    #if compiler(>=6.0)
-    // Note: Whitespace changes are used to workaround compiler bug
-    // Remove when compiler version 5.10 is no longer supported.
-    // https://github.com/swiftlang/swift/issues/79285
-    // swift-format-ignore
     /// Provides scoped access to the inbound and outbound side of the underlying ``Channel``.
     ///
     /// - Important: After this method returned the underlying ``Channel`` will be closed.
     ///
     /// - Parameters:
     ///     - actor: actor where this function should be isolated to
     ///     - body: A closure that gets scoped access to the inbound and outbound.
-    public func executeThenClose<Result>(isolation actor: isolated (any Actor)? = #isolation, _ body: (_ inbound: NIOAsyncChannelInboundStream<Inbound>, _ outbound: NIOAsyncChannelOutboundWriter<Outbound>) async throws -> sending Result) async throws -> sending Result {
+    public func executeThenClose<Result>(
+        isolation actor: isolated (any Actor)? = #isolation,
+        _ body: (_ inbound: NIOAsyncChannelInboundStream<Inbound>, _ outbound: NIOAsyncChannelOutboundWriter<Outbound>)
+            async throws -> sending Result
+    ) async throws -> sending Result {
         let result: Result
         do {
             result = try await body(self._inbound, self._outbound)
@@ -370,7 +369,6 @@ public struct NIOAsyncChannel<Inbound: Sendable, Outbound: Sendable>: Sendable {
 
         return result
     }
-    #endif
 }
 
 // swift-format-ignore: AmbiguousTrailingClosureOverload
@@ -419,19 +417,17 @@ extension NIOAsyncChannel {
         return result
     }
 
-    #if compiler(>=6.0)
-    // Note: Whitespace changes are used to workaround compiler bug
-    // Remove when compiler version 5.10 is no longer supported.
-    // https://github.com/swiftlang/swift/issues/79285
-    // swift-format-ignore
     /// Provides scoped access to the inbound side of the underlying ``Channel``.
     ///
     /// - Important: After this method returned the underlying ``Channel`` will be closed.
     ///
     /// - Parameters:
     ///     - actor: actor where this function should be isolated to
     ///     - body: A closure that gets scoped access to the inbound.
-    public func executeThenClose<Result>(isolation actor: isolated (any Actor)? = #isolation, _ body: (_ inbound: NIOAsyncChannelInboundStream<Inbound>) async throws -> sending Result) async throws -> sending Result where Outbound == Never {
+    public func executeThenClose<Result>(
+        isolation actor: isolated (any Actor)? = #isolation,
+        _ body: (_ inbound: NIOAsyncChannelInboundStream<Inbound>) async throws -> sending Result
+    ) async throws -> sending Result where Outbound == Never {
         let result: Result
         do {
             result = try await body(self._inbound)
@@ -466,7 +462,6 @@ extension NIOAsyncChannel {
 
         return result
     }
-    #endif
 }
 
 extension Channel {

Sources/NIOCore/AsyncChannel/AsyncChannel.swift

@@ -102,15 +102,9 @@ private let sysInet_pton: @convention(c) (CInt, UnsafePointer<CChar>?, UnsafeMut
 #endif
 
 #if os(Android)
-#if compiler(>=6.0)
 @usableFromInline let IFF_BROADCAST: CUnsignedInt = numericCast(Android.IFF_BROADCAST.rawValue)
 @usableFromInline let IFF_POINTOPOINT: CUnsignedInt = numericCast(Android.IFF_POINTOPOINT.rawValue)
 @usableFromInline let IFF_MULTICAST: CUnsignedInt = numericCast(Android.IFF_MULTICAST.rawValue)
-#else
-@usableFromInline let IFF_BROADCAST: CUnsignedInt = numericCast(SwiftGlibc.IFF_BROADCAST.rawValue)
-@usableFromInline let IFF_POINTOPOINT: CUnsignedInt = numericCast(SwiftGlibc.IFF_POINTOPOINT.rawValue)
-@usableFromInline let IFF_MULTICAST: CUnsignedInt = numericCast(SwiftGlibc.IFF_MULTICAST.rawValue)
-#endif
 #if arch(arm)
 @usableFromInline let SO_RCVTIMEO = SO_RCVTIMEO_OLD
 @usableFromInline let SO_TIMESTAMP = SO_TIMESTAMP_OLD

Sources/NIOCore/BSDSocketAPI.swift

@@ -1003,7 +1003,6 @@ extension Optional where Wrapped == ByteBuffer {
     }
 }
 
-#if compiler(>=6)
 extension ByteBuffer {
     /// Get the string at `index` from this `ByteBuffer` decoding using the UTF-8 encoding. Does not move the reader index.
     /// The selected bytes must be readable or else `nil` will be returned.
@@ -1077,4 +1076,3 @@ extension ByteBuffer {
         try self.getUTF8ValidatedString(at: self.readerIndex, length: length)
     }
 }
-#endif  // compiler(>=6)

Sources/NIOCore/ByteBuffer-aux.swift

@@ -139,17 +139,16 @@ public final class NIOLoopBoundBox<Value>: @unchecked Sendable {
         .init(_value: value, uncheckedEventLoop: eventLoop)
     }
 
-    #if compiler(>=6.0)
-    // Note: Whitespace changes are used to workaround compiler bug
-    // Remove when compiler version 5.10 is no longer supported.
-    // https://github.com/swiftlang/swift/issues/79285
-    // swift-format-ignore
     /// Initialise a ``NIOLoopBoundBox`` by sending a  value, validly callable off `eventLoop`.
     ///
     /// Contrary to ``init(_:eventLoop:)``, this method can be called off `eventLoop` because `value` is moved into the box and can no longer be accessed outside the box.
     /// So we don't need to protect `value` itself, we just need to protect the ``NIOLoopBoundBox`` against mutations which we do because the ``value``
     /// accessors are checking that we're on `eventLoop`.
-    public static func makeBoxSendingValue(_ value: sending Value, as: Value.Type = Value.self, eventLoop: EventLoop) -> NIOLoopBoundBox<Value> {
+    public static func makeBoxSendingValue(
+        _ value: sending Value,
+        as: Value.Type = Value.self,
+        eventLoop: EventLoop
+    ) -> NIOLoopBoundBox<Value> {
         // Here, we -- possibly surprisingly -- do not precondition being on the EventLoop. This is okay for a few
         // reasons:
         // - This function takes its value as `sending` so we don't need to worry about somebody
@@ -159,7 +158,6 @@ public final class NIOLoopBoundBox<Value>: @unchecked Sendable {
         // - The only way to ever write (or read indeed) `self._value` is by proving to be inside the `EventLoop`.
         .init(_value: value, uncheckedEventLoop: eventLoop)
     }
-    #endif
 
     /// Access the `value` with the precondition that the code is running on `eventLoop`.
     ///

Sources/NIOCore/NIOLoopBound.swift

@@ -180,7 +180,7 @@ struct EventLoopCrashTests {
         NIOSingletons.groupLoopCountSuggestion = -1
     }
 
-    #if compiler(>=5.9) && swift(<6.2)  // We only support Concurrency executor take-over on those Swift versions, as versions greater than that have not been properly tested.
+    #if swift(<6.2)  // We only support Concurrency executor take-over on those Swift versions, as versions greater than that have not been properly tested.
     let testInstallingSingletonMTELGAsConcurrencyExecutorWorksButOnlyOnce = CrashTest(
         regex: #"Fatal error: Must be called only once"#
     ) {
@@ -207,6 +207,6 @@ struct EventLoopCrashTests {
         // This should crash
         _ = NIOSingletons.unsafeTryInstallSingletonPosixEventLoopGroupAsConcurrencyGlobalExecutor()
     }
-    #endif  // compiler(>=5.9) && swift(<6.2)
+    #endif  // swift(<6.2)
 }
 #endif  // !canImport(Darwin) || os(macOS)

Sources/NIOCrashTester/CrashTests+EventLoop.swift

@@ -207,18 +207,20 @@ extension FileDescriptor {
             }
 
             // Read and decode.
-            var buffer = [CChar](repeating: 0, count: capacity)
+            var buffer = [UInt8](repeating: 0, count: capacity)
             return buffer.withUnsafeMutableBufferPointer { pointer in
-                self.listExtendedAttributes(pointer)
+                pointer.withMemoryRebound(to: CChar.self) { pointer in
+                    self.listExtendedAttributes(pointer)
+                }
             }.map { size in
                 // The buffer contains null terminated C-strings.
                 var attributes = [String]()
                 var slice = buffer.prefix(size)
                 while let index = slice.firstIndex(of: 0) {
                     // TODO: can we do this more cheaply?
-                    let prefix = slice[...index]
-                    attributes.append(String(cString: Array(prefix)))
-                    slice = slice.dropFirst(prefix.count)
+                    let prefix = slice[..<index]
+                    attributes.append(String(decoding: Array(prefix), as: Unicode.UTF8.self))
+                    slice = slice.dropFirst(prefix.count + 1)
                 }
 
                 return attributes