Add missing availability annotations (#9)

gjcairo · web-flow · commit 5ffc0fe0b9f0 · 2025-08-06T16:11:22.000+01:00
This PR adds missing availability annotations after removing platform
requirements from the package manifest.
It also re-enables missing availability warnings in Xcode (which had
been turned off). This was hiding a Sendability issue for some reason,
but I'll fix that up in a follow-up PR since it's quite complex.
diff --git a/Package.swift b/Package.swift
@@ -10,11 +10,7 @@ let extraSettings: [SwiftSetting] = [
     .enableUpcomingFeature("InferIsolatedConformances"),
     .enableUpcomingFeature("ExistentialAny"),
     .enableUpcomingFeature("MemberImportVisibility"),
-    .enableUpcomingFeature("InternalImportsByDefault"),
-    .unsafeFlags([
-        "-Xfrontend",
-        "-disable-availability-checking",
-    ]),
+    .enableUpcomingFeature("InternalImportsByDefault")
 ]
 
 let package = Package(
diff --git a/Sources/Example/Example.swift b/Sources/Example/Example.swift
@@ -8,6 +8,7 @@ import Middleware
 import X509
 
 @main
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct Example {
     static func main() async throws {
         try await serve()
@@ -68,6 +69,7 @@ struct Example {
 
 // MARK: - Server Extensions
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 extension Server {
     /// Serve HTTP requests using a middleware chain built with the provided builder
     /// This method handles the type inference for HTTP middleware components
diff --git a/Sources/Example/Middlewares/HTTPRequestLoggingMiddleware.swift b/Sources/Example/Middlewares/HTTPRequestLoggingMiddleware.swift
@@ -3,6 +3,7 @@ import HTTPTypes
 import Logging
 import Middleware
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct HTTPRequestLoggingMiddleware<
     RequestConludingAsyncReader: ConcludingAsyncReader,
     ResponseConcludingAsyncWriter: ConcludingAsyncWriter & ~Copyable
@@ -62,6 +63,7 @@ where
     }
 }
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct HTTPRequestLoggingConcludingAsyncReader<
     Base: ConcludingAsyncReader
 >: ConcludingAsyncReader
@@ -123,6 +125,7 @@ where
     }
 }
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct HTTPResponseLoggingConcludingAsyncWriter<
     Base: ConcludingAsyncWriter & ~Copyable
 >: ConcludingAsyncWriter, ~Copyable
diff --git a/Sources/Example/Middlewares/RouteHandlerMiddleware.swift b/Sources/Example/Middlewares/RouteHandlerMiddleware.swift
@@ -2,6 +2,7 @@ import HTTPServer
 import HTTPTypes
 import Middleware
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct RouteHandlerMiddleware<
     RequestConcludingAsyncReader: ConcludingAsyncReader & Copyable,
     ResponseConcludingAsyncWriter: ConcludingAsyncWriter & ~Copyable,
diff --git a/Sources/Example/Middlewares/TimeoutMiddleware.swift b/Sources/Example/Middlewares/TimeoutMiddleware.swift
@@ -1,5 +1,6 @@
 import Middleware
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct TimeoutMiddleware<Input>: Middleware {
     func intercept(input: Input, next: (Input) async throws -> Void) async throws {
         try await withoutActuallyEscaping(next) { next in
@@ -21,6 +22,7 @@ package struct TimeOutError: Error {
     var underlying: any Error
 }
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public func withTimeout<T: Sendable, Clock: _Concurrency.Clock>(
     in timeout: Clock.Duration,
     clock: Clock,
diff --git a/Sources/Example/Middlewares/TracingMiddleware.swift b/Sources/Example/Middlewares/TracingMiddleware.swift
@@ -2,6 +2,7 @@ import HTTPTypes
 import Middleware
 import Tracing
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 struct TracingMiddleware<Input>: Middleware {
     func intercept(
         input: Input,
diff --git a/Sources/HTTPServer/AsyncPrimitives/AsyncReader.swift b/Sources/HTTPServer/AsyncPrimitives/AsyncReader.swift
@@ -2,6 +2,7 @@
 ///
 /// ``AsyncReader`` defines an interface for types that can asynchronously read elements
 /// of a specified type from a source.
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public protocol AsyncReader<ReadElement, ReadFailure> {
     /// The type of elements that can be read by this reader.
     associatedtype ReadElement: ~Copyable, ~Escapable
@@ -44,6 +45,7 @@ public protocol AsyncReader<ReadElement, ReadFailure> {
     ) async throws(ReadFailure) -> Return
 }
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 extension AsyncReader {
     /// Collects elements from the reader up to a specified limit and processes them with a body function.
     ///
diff --git a/Sources/HTTPServer/AsyncPrimitives/ConcludingAsyncReader.swift b/Sources/HTTPServer/AsyncPrimitives/ConcludingAsyncReader.swift
@@ -4,6 +4,7 @@
 /// provide a conclusive element after all reads are completed. This is particularly useful
 /// for streams that have meaningful completion states beyond just terminating, such as
 /// HTTP responses that include headers after the body is fully read.
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public protocol ConcludingAsyncReader<Underlying, FinalElement> {
     /// The underlying asynchronous reader type that produces elements.
     associatedtype Underlying: AsyncReader, ~Copyable, ~Escapable
@@ -37,6 +38,7 @@ public protocol ConcludingAsyncReader<Underlying, FinalElement> {
     ) async throws -> (Return, FinalElement)
 }
 
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 extension ConcludingAsyncReader {
     /// Processes the underlying async reader until completion and returns only the final element.
     ///
diff --git a/Sources/HTTPServer/HTTPRequestConcludingAsyncReader.swift b/Sources/HTTPServer/HTTPRequestConcludingAsyncReader.swift
@@ -9,6 +9,7 @@ import NIOHTTPTypes
 /// and concluding with the HTTP trailer fields received at the end of the request. This type
 /// follows the ``ConcludingAsyncReader`` pattern, which allows for asynchronous consumption of
 /// a stream with a conclusive final element.
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public struct HTTPRequestConcludingAsyncReader: ConcludingAsyncReader {
     /// A reader for HTTP request body chunks that implements the ``AsyncReader`` protocol.
     ///
diff --git a/Sources/HTTPServer/HTTPResponseConcludingAsyncWriter.swift b/Sources/HTTPServer/HTTPResponseConcludingAsyncWriter.swift
@@ -11,6 +11,7 @@ import NIOHTTPTypes
 ///
 /// This writer is designed to work with HTTP responses where the body is streamed in chunks
 /// and potentially followed by trailer fields.
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public struct HTTPResponseConcludingAsyncWriter: ConcludingAsyncWriter, ~Copyable {
     /// A writer for HTTP response body chunks that implements the ``AsyncWriter`` protocol.
     ///
diff --git a/Sources/HTTPServer/HTTPServer.swift b/Sources/HTTPServer/HTTPServer.swift
@@ -59,6 +59,7 @@ import SwiftASN1
 ///     }
 /// }
 /// ```
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public final class Server<RequestHandler: HTTPServerRequestHandler> {
     /// Starts an HTTP server with a closure-based request handler.
     ///
diff --git a/Sources/HTTPServer/HTTPServerClosureRequestHandler.swift b/Sources/HTTPServer/HTTPServerClosureRequestHandler.swift
@@ -23,6 +23,7 @@ public import HTTPTypes
 ///     }
 /// }
 /// ```
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public struct HTTPServerClosureRequestHandler: HTTPServerRequestHandler {
     /// The underlying closure that handles HTTP requests
     private let _handler:
diff --git a/Sources/HTTPServer/HTTPServerConfiguration.swift b/Sources/HTTPServer/HTTPServerConfiguration.swift
@@ -4,6 +4,7 @@ public import X509
 ///
 /// This structure contains all the necessary configuration options for setting up
 /// and running an HTTP server, including network binding and TLS settings.
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public struct HTTPServerConfiguration: Sendable {
     /// Specifies where the server should bind and listen for incoming connections.
     ///
diff --git a/Sources/HTTPServer/HTTPServerRequestHandler.swift b/Sources/HTTPServer/HTTPServerRequestHandler.swift
@@ -53,6 +53,7 @@ public import HTTPTypes
 ///     }
 /// }
 /// ```
+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
 public protocol HTTPServerRequestHandler: Sendable {
     /// Handles an incoming HTTP request and generates a response.
     ///
diff --git a/Tests/HTTPServerTests/HTTPServerTests.swift b/Tests/HTTPServerTests/HTTPServerTests.swift
@@ -6,7 +6,7 @@ import Testing
 @Suite
 struct HTTPServerTests {
     @Test
-    @available(macOS 26.0, *)
+    @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
     func testSimpleAPI() async throws {
         try await HTTPServer.Server
             .serve(

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ import HTTPTypes`
`3`	`3`	`import Logging`
`4`	`4`	`import Middleware`
`5`	`5`
	`6`	`+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)`
`6`	`7`	`struct HTTPRequestLoggingMiddleware<`
`7`	`8`	`RequestConludingAsyncReader: ConcludingAsyncReader,`
`8`	`9`	`ResponseConcludingAsyncWriter: ConcludingAsyncWriter & ~Copyable`
`@@ -62,6 +63,7 @@ where`
`62`	`63`	`}`
`63`	`64`	`}`
`64`	`65`
	`66`	`+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)`
`65`	`67`	`struct HTTPRequestLoggingConcludingAsyncReader<`
`66`	`68`	`Base: ConcludingAsyncReader`
`67`	`69`	`>: ConcludingAsyncReader`
`@@ -123,6 +125,7 @@ where`
`123`	`125`	`}`
`124`	`126`	`}`
`125`	`127`
	`128`	`+@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)`
`126`	`129`	`struct HTTPResponseLoggingConcludingAsyncWriter<`
`127`	`130`	`Base: ConcludingAsyncWriter & ~Copyable`
`128`	`131`	`>: ConcludingAsyncWriter, ~Copyable`