[core] Remove swift 6 concurrency errors (WIP do not merge)

Examples/APIGateway+LambdaAuthorizer/Sources/AuthorizerLambda/main.swift

@@ -22,56 +22,58 @@ import AWSLambdaRuntime
 // This code is shown for the example only and is not used in this demo.
 // This code doesn't perform any type of token validation. It should be used as a reference only.
 let policyAuthorizerHandler:
-    (APIGatewayLambdaAuthorizerRequest, LambdaContext) async throws -> APIGatewayLambdaAuthorizerPolicyResponse = {
-        (request: APIGatewayLambdaAuthorizerRequest, context: LambdaContext) in
+    @Sendable (APIGatewayLambdaAuthorizerRequest, LambdaContext) async throws ->
+        APIGatewayLambdaAuthorizerPolicyResponse = {
+            (request: APIGatewayLambdaAuthorizerRequest, context: LambdaContext) in
 
-        context.logger.debug("+++ Policy Authorizer called +++")
+            context.logger.debug("+++ Policy Authorizer called +++")
 
-        // typically, this function will check the validity of the incoming token received in the request
+            // typically, this function will check the validity of the incoming token received in the request
 
-        // then it creates and returns a response
-        return APIGatewayLambdaAuthorizerPolicyResponse(
-            principalId: "John Appleseed",
+            // then it creates and returns a response
+            return APIGatewayLambdaAuthorizerPolicyResponse(
+                principalId: "John Appleseed",
 
-            // this policy allows the caller to invoke any API Gateway endpoint
-            policyDocument: .init(statement: [
-                .init(
-                    action: "execute-api:Invoke",
-                    effect: .allow,
-                    resource: "*"
-                )
+                // this policy allows the caller to invoke any API Gateway endpoint
+                policyDocument: .init(statement: [
+                    .init(
+                        action: "execute-api:Invoke",
+                        effect: .allow,
+                        resource: "*"
+                    )
 
-            ]),
+                ]),
 
-            // this is additional context we want to return to the caller
-            context: [
-                "abc1": "xyz1",
-                "abc2": "xyz2",
-            ]
-        )
-    }
+                // this is additional context we want to return to the caller
+                context: [
+                    "abc1": "xyz1",
+                    "abc2": "xyz2",
+                ]
+            )
+        }
 
 //
 // This is an example of a simple authorizer that always authorizes the request.
 // A simple authorizer returns a yes/no decision and optional context key-value pairs
 //
 // This code doesn't perform any type of token validation. It should be used as a reference only.
 let simpleAuthorizerHandler:
-    (APIGatewayLambdaAuthorizerRequest, LambdaContext) async throws -> APIGatewayLambdaAuthorizerSimpleResponse = {
-        (_: APIGatewayLambdaAuthorizerRequest, context: LambdaContext) in
+    @Sendable (APIGatewayLambdaAuthorizerRequest, LambdaContext) async throws ->
+        APIGatewayLambdaAuthorizerSimpleResponse = {
+            (_: APIGatewayLambdaAuthorizerRequest, context: LambdaContext) in
 
-        context.logger.debug("+++ Simple Authorizer called +++")
+            context.logger.debug("+++ Simple Authorizer called +++")
 
-        // typically, this function will check the validity of the incoming token received in the request
+            // typically, this function will check the validity of the incoming token received in the request
 
-        return APIGatewayLambdaAuthorizerSimpleResponse(
-            // this is the authorization decision: yes or no
-            isAuthorized: true,
+            return APIGatewayLambdaAuthorizerSimpleResponse(
+                // this is the authorization decision: yes or no
+                isAuthorized: true,
 
-            // this is additional context we want to return to the caller
-            context: ["abc1": "xyz1"]
-        )
-    }
+                // this is additional context we want to return to the caller
+                context: ["abc1": "xyz1"]
+            )
+        }
 
 // create the runtime and start polling for new events.
 // in this demo we use the simple authorizer handler

Package.swift

@@ -17,7 +17,7 @@ let package = Package(
         .library(name: "AWSLambdaTesting", targets: ["AWSLambdaTesting"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/apple/swift-nio.git", from: "2.76.0"),
+        .package(url: "https://github.com/apple/swift-nio.git", from: "2.77.0"),
         .package(url: "https://github.com/apple/swift-log.git", from: "1.5.4"),
     ],
     targets: [
@@ -36,8 +36,8 @@ let package = Package(
                 .product(name: "NIOCore", package: "swift-nio"),
                 .product(name: "NIOConcurrencyHelpers", package: "swift-nio"),
                 .product(name: "NIOPosix", package: "swift-nio"),
-            ],
-            swiftSettings: [.swiftLanguageMode(.v5)]
+            ]
+            // swiftSettings: [.swiftLanguageMode(.v5)]
         ),
         .plugin(
             name: "AWSLambdaPackager",
@@ -89,11 +89,11 @@ let package = Package(
         .executableTarget(
             name: "MockServer",
             dependencies: [
+                .product(name: "Logging", package: "swift-log"),
                 .product(name: "NIOHTTP1", package: "swift-nio"),
                 .product(name: "NIOCore", package: "swift-nio"),
                 .product(name: "NIOPosix", package: "swift-nio"),
-            ],
-            swiftSettings: [.swiftLanguageMode(.v5)]
+            ]
         ),
     ]
 )

Sources/AWSLambdaRuntime/Lambda+Codable.swift

@@ -91,7 +91,7 @@ extension LambdaRuntime {
     public convenience init<Event: Decodable, Output>(
         decoder: JSONDecoder = JSONDecoder(),
         encoder: JSONEncoder = JSONEncoder(),
-        body: sending @escaping (Event, LambdaContext) async throws -> Output
+        body: @Sendable @escaping (Event, LambdaContext) async throws -> Output
     )
     where
         Handler == LambdaCodableAdapter<
@@ -116,7 +116,7 @@ extension LambdaRuntime {
     /// - Parameter decoder: The decoder object that will be used to decode the incoming `ByteBuffer` event into the generic `Event` type. `JSONDecoder()` used as default.
     public convenience init<Event: Decodable>(
         decoder: JSONDecoder = JSONDecoder(),
-        body: sending @escaping (Event, LambdaContext) async throws -> Void
+        body: @Sendable @escaping (Event, LambdaContext) async throws -> Void
     )
     where
         Handler == LambdaCodableAdapter<

Sources/AWSLambdaRuntimeCore/Lambda+Codable.swift

@@ -16,7 +16,7 @@ import NIOCore
 
 /// The protocol a decoder must conform to so that it can be used with ``LambdaCodableAdapter`` to decode incoming
 /// `ByteBuffer` events.
-public protocol LambdaEventDecoder {
+public protocol LambdaEventDecoder: Sendable {
     /// Decode the `ByteBuffer` representing the received event into the generic `Event` type
     /// the handler will receive.
     /// - Parameters:
@@ -28,7 +28,7 @@ public protocol LambdaEventDecoder {
 
 /// The protocol an encoder must conform to so that it can be used with ``LambdaCodableAdapter`` to encode the generic
 /// ``LambdaOutputEncoder/Output`` object into a `ByteBuffer`.
-public protocol LambdaOutputEncoder {
+public protocol LambdaOutputEncoder: Sendable {
     associatedtype Output
 
     /// Encode the generic type `Output` the handler has returned into a `ByteBuffer`.
@@ -52,7 +52,7 @@ public struct LambdaHandlerAdapter<
     Event: Decodable,
     Output,
     Handler: LambdaHandler
->: LambdaWithBackgroundProcessingHandler where Handler.Event == Event, Handler.Output == Output {
+>: Sendable, LambdaWithBackgroundProcessingHandler where Handler.Event == Event, Handler.Output == Output {
     @usableFromInline let handler: Handler
 
     /// Initializes an instance given a concrete handler.
@@ -86,7 +86,8 @@ public struct LambdaCodableAdapter<
     Output,
     Decoder: LambdaEventDecoder,
     Encoder: LambdaOutputEncoder
->: StreamingLambdaHandler where Handler.Event == Event, Handler.Output == Output, Encoder.Output == Output {
+>: Sendable, StreamingLambdaHandler
+where Handler.Event == Event, Handler.Output == Output, Encoder.Output == Output, Encoder: Sendable, Decoder: Sendable {
     @usableFromInline let handler: Handler
     @usableFromInline let encoder: Encoder
     @usableFromInline let decoder: Decoder
@@ -139,7 +140,7 @@ public struct LambdaCodableAdapter<
 /// A ``LambdaResponseStreamWriter`` wrapper that conforms to ``LambdaResponseWriter``.
 public struct LambdaCodableResponseWriter<Output, Encoder: LambdaOutputEncoder, Base: LambdaResponseStreamWriter>:
     LambdaResponseWriter
-where Output == Encoder.Output {
+where Output == Encoder.Output, Encoder: Sendable {
     @usableFromInline let underlyingStreamWriter: Base
     @usableFromInline let encoder: Encoder