Drop Swift 5.5 (#686)

Author: dnadoba

Package@swift-5.5.swift

@@ -323,11 +323,12 @@ Please have a look at [SECURITY.md](SECURITY.md) for AsyncHTTPClient's security
 
 ## Supported Versions
 
-The most recent versions of AsyncHTTPClient support Swift 5.5.2 and newer. The minimum Swift version supported by AsyncHTTPClient releases are detailed below:
+The most recent versions of AsyncHTTPClient support Swift 5.6 and newer. The minimum Swift version supported by AsyncHTTPClient releases are detailed below:
 
 AsyncHTTPClient     | Minimum Swift Version
 --------------------|----------------------
 `1.0.0 ..< 1.5.0`   | 5.0
 `1.5.0 ..< 1.10.0`  | 5.2
 `1.10.0 ..< 1.13.0` | 5.4
-`1.13.0 ...`        | 5.5.2
+`1.13.0 ..< 1.18.0` | 5.5.2
+`1.18.0 ...`        | 5.6

README.md

@@ -91,7 +91,6 @@ extension HTTPClientRequest.Body {
         self.init(.byteBuffer(byteBuffer))
     }
 
-    #if swift(>=5.6)
     /// Create an ``HTTPClientRequest/Body-swift.struct`` from a `RandomAccessCollection` of bytes.
     ///
     /// This construction will flatten the bytes into a `ByteBuffer`. As a result, the peak memory
@@ -106,21 +105,6 @@ extension HTTPClientRequest.Body {
     ) -> Self where Bytes.Element == UInt8 {
         Self._bytes(bytes)
     }
-    #else
-    /// Create an ``HTTPClientRequest/Body-swift.struct`` from a `RandomAccessCollection` of bytes.
-    ///
-    /// This construction will flatten the bytes into a `ByteBuffer`. As a result, the peak memory
-    /// usage of this construction will be double the size of the original collection. The construction
-    /// of the `ByteBuffer` will be delayed until it's needed.
-    ///
-    /// - parameter bytes: The bytes of the request body.
-    @inlinable
-    public static func bytes<Bytes: RandomAccessCollection>(
-        _ bytes: Bytes
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._bytes(bytes)
-    }
-    #endif
 
     @inlinable
     static func _bytes<Bytes: RandomAccessCollection>(
@@ -139,7 +123,6 @@ extension HTTPClientRequest.Body {
         })
     }
 
-    #if swift(>=5.6)
     /// Create an ``HTTPClientRequest/Body-swift.struct`` from a `Sequence` of bytes.
     ///
     /// This construction will flatten the bytes into a `ByteBuffer`. As a result, the peak memory
@@ -165,32 +148,6 @@ extension HTTPClientRequest.Body {
     ) -> Self where Bytes.Element == UInt8 {
         Self._bytes(bytes, length: length)
     }
-    #else
-    /// Create an ``HTTPClientRequest/Body-swift.struct`` from a `Sequence` of bytes.
-    ///
-    /// This construction will flatten the bytes into a `ByteBuffer`. As a result, the peak memory
-    /// usage of this construction will be double the size of the original collection. The construction
-    /// of the `ByteBuffer` will be delayed until it's needed.
-    ///
-    /// Unlike ``bytes(_:)-1uns7``, this construction does not assume that the body can be replayed. As a result,
-    /// if a redirect is encountered that would need us to replay the request body, the redirect will instead
-    /// not be followed. Prefer ``bytes(_:)-1uns7`` wherever possible.
-    ///
-    /// Caution should be taken with this method to ensure that the `length` is correct. Incorrect lengths
-    /// will cause unnecessary runtime failures. Setting `length` to ``Length/unknown`` will trigger the upload
-    /// to use `chunked` `Transfer-Encoding`, while using ``Length/known(_:)`` will use `Content-Length`.
-    ///
-    /// - parameters:
-    ///     - bytes: The bytes of the request body.
-    ///     - length: The length of the request body.
-    @inlinable
-    public static func bytes<Bytes: Sequence>(
-        _ bytes: Bytes,
-        length: Length
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._bytes(bytes, length: length)
-    }
-    #endif
 
     @inlinable
     static func _bytes<Bytes: Sequence>(
@@ -210,7 +167,6 @@ extension HTTPClientRequest.Body {
         })
     }
 
-    #if swift(>=5.6)
     /// Create an ``HTTPClientRequest/Body-swift.struct`` from a `Collection` of bytes.
     ///
     /// This construction will flatten the bytes into a `ByteBuffer`. As a result, the peak memory
@@ -232,28 +188,6 @@ extension HTTPClientRequest.Body {
     ) -> Self where Bytes.Element == UInt8 {
         Self._bytes(bytes, length: length)
     }
-    #else
-    /// Create an ``HTTPClientRequest/Body-swift.struct`` from a `Collection` of bytes.
-    ///
-    /// This construction will flatten the bytes into a `ByteBuffer`. As a result, the peak memory
-    /// usage of this construction will be double the size of the original collection. The construction
-    /// of the `ByteBuffer` will be delayed until it's needed.
-    ///
-    /// Caution should be taken with this method to ensure that the `length` is correct. Incorrect lengths
-    /// will cause unnecessary runtime failures. Setting `length` to ``Length/unknown`` will trigger the upload
-    /// to use `chunked` `Transfer-Encoding`, while using ``Length/known(_:)`` will use `Content-Length`.
-    ///
-    /// - parameters:
-    ///     - bytes: The bytes of the request body.
-    ///     - length: The length of the request body.
-    @inlinable
-    public static func bytes<Bytes: Collection>(
-        _ bytes: Bytes,
-        length: Length
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._bytes(bytes, length: length)
-    }
-    #endif
 
     @inlinable
     static func _bytes<Bytes: Collection>(
@@ -273,7 +207,6 @@ extension HTTPClientRequest.Body {
         })
     }
 
-    #if swift(>=5.6)
     /// Create an ``HTTPClientRequest/Body-swift.struct`` from an `AsyncSequence` of `ByteBuffer`s.
     ///
     /// This construction will stream the upload one `ByteBuffer` at a time.
@@ -293,26 +226,6 @@ extension HTTPClientRequest.Body {
     ) -> Self where SequenceOfBytes.Element == ByteBuffer {
         Self._stream(sequenceOfBytes, length: length)
     }
-    #else
-    /// Create an ``HTTPClientRequest/Body-swift.struct`` from an `AsyncSequence` of `ByteBuffer`s.
-    ///
-    /// This construction will stream the upload one `ByteBuffer` at a time.
-    ///
-    /// Caution should be taken with this method to ensure that the `length` is correct. Incorrect lengths
-    /// will cause unnecessary runtime failures. Setting `length` to ``Length/unknown`` will trigger the upload
-    /// to use `chunked` `Transfer-Encoding`, while using ``Length/known(_:)`` will use `Content-Length`.
-    ///
-    /// - parameters:
-    ///     - sequenceOfBytes: The bytes of the request body.
-    ///     - length: The length of the request body.
-    @inlinable
-    public static func stream<SequenceOfBytes: AsyncSequence>(
-        _ sequenceOfBytes: SequenceOfBytes,
-        length: Length
-    ) -> Self where SequenceOfBytes.Element == ByteBuffer {
-        Self._stream(sequenceOfBytes, length: length)
-    }
-    #endif
 
     @inlinable
     static func _stream<SequenceOfBytes: AsyncSequence>(
@@ -328,7 +241,6 @@ extension HTTPClientRequest.Body {
         return body
     }
 
-    #if swift(>=5.6)
     /// Create an ``HTTPClientRequest/Body-swift.struct`` from an `AsyncSequence` of bytes.
     ///
     /// This construction will consume 1kB chunks from the `Bytes` and send them at once. This optimizes for
@@ -350,28 +262,6 @@ extension HTTPClientRequest.Body {
     ) -> Self where Bytes.Element == UInt8 {
         Self._stream(bytes, length: length)
     }
-    #else
-    /// Create an ``HTTPClientRequest/Body-swift.struct`` from an `AsyncSequence` of bytes.
-    ///
-    /// This construction will consume 1kB chunks from the `Bytes` and send them at once. This optimizes for
-    /// `AsyncSequence`s where larger chunks are buffered up and available without actually suspending, such
-    /// as those provided by `FileHandle`.
-    ///
-    /// Caution should be taken with this method to ensure that the `length` is correct. Incorrect lengths
-    /// will cause unnecessary runtime failures. Setting `length` to ``Length/unknown`` will trigger the upload
-    /// to use `chunked` `Transfer-Encoding`, while using ``Length/known(_:)`` will use `Content-Length`.
-    ///
-    /// - parameters:
-    ///     - bytes: The bytes of the request body.
-    ///     - length: The length of the request body.
-    @inlinable
-    public static func stream<Bytes: AsyncSequence>(
-        _ bytes: Bytes,
-        length: Length
-    ) -> Self where Bytes.Element == UInt8 {
-        Self._stream(bytes, length: length)
-    }
-    #endif
 
     @inlinable
     static func _stream<Bytes: AsyncSequence>(

Sources/AsyncHTTPClient/AsyncAwait/HTTPClientRequest.swift

@@ -433,10 +433,8 @@ final class HTTP1ClientChannelHandler: ChannelDuplexHandler {
     }
 }
 
-#if swift(>=5.6)
 @available(*, unavailable)
 extension HTTP1ClientChannelHandler: Sendable {}
-#endif
 
 extension HTTP1ClientChannelHandler: HTTPRequestExecutor {
     func writeRequestBodyPart(_ data: IOData, request: HTTPExecutableRequest, promise: EventLoopPromise<Void>?) {

Sources/AsyncHTTPClient/ConnectionPool/HTTP1/HTTP1ClientChannelHandler.swift

@@ -13,12 +13,6 @@ This library provides the following:
 - Automatic HTTP/2 over HTTPS (since version 1.7.0)
 - Cookie parsing (but not storage)
 
----
-
-**NOTE**: You will need [Xcode 13.2](https://apps.apple.com/gb/app/xcode/id497799835?mt=12) or [Swift 5.5.2](https://swift.org/download/#swift-552) to try out `AsyncHTTPClient`s new async/await APIs.
-
----
-
 ### Getting Started
 
 #### Adding the dependency

Sources/AsyncHTTPClient/Docs.docc/index.md

@@ -200,7 +200,6 @@ public class HTTPClient {
         }
     }
 
-    #if swift(>=5.6)
     /// Shuts down the client and event loop gracefully.
     ///
     /// This function is clearly an outlier in that it uses a completion
@@ -213,17 +212,6 @@ public class HTTPClient {
     ) {
         self.shutdown(requiresCleanClose: false, queue: queue, callback)
     }
-    #else
-    /// Shuts down the client and event loop gracefully.
-    ///
-    /// This function is clearly an outlier in that it uses a completion
-    /// callback instead of an EventLoopFuture. The reason for that is that NIO's EventLoopFutures will call back on an event loop.
-    /// The virtue of this function is to shut the event loop down. To work around that we call back on a DispatchQueue
-    /// instead.
-    public func shutdown(queue: DispatchQueue = .global(), _ callback: @escaping (Error?) -> Void) {
-        self.shutdown(requiresCleanClose: false, queue: queue, callback)
-    }
-    #endif
 
     /// Shuts down the ``HTTPClient`` and releases its resources.
     ///
@@ -917,11 +905,7 @@ public class HTTPClient {
         case enabled(limit: NIOHTTPDecompression.DecompressionLimit)
     }
 
-    #if swift(>=5.6)
     typealias ShutdownCallback = @Sendable (Error?) -> Void
-    #else
-    typealias ShutdownCallback = (Error?) -> Void
-    #endif
 
     enum State {
         case upAndRunning
@@ -934,10 +918,8 @@ public class HTTPClient {
 extension HTTPClient.Configuration: Sendable {}
 #endif
 
-#if swift(>=5.6)
 extension HTTPClient.EventLoopGroupProvider: Sendable {}
 extension HTTPClient.EventLoopPreference: Sendable {}
-#endif
 
 // HTTPClient is thread-safe because its shared mutable state is protected through a lock
 extension HTTPClient: @unchecked Sendable {}