Swift Package IndexBuild Information
Successful build of RediStack, reference 2.0.0-gamma.1.1 (8ac2d7), with Swift 6.1 for macOS (SPM) on 27 Apr 2025 20:12:56 UTC.
Swift 6 data race errors: 19
Build Command
env DEVELOPER_DIR=/Applications/Xcode-16.3.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCapturesBuild Log
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:478:68: warning: implicit capture of 'target' requires that 'RedisSubscriptionTarget' conforms to 'Sendable'; this is an error in the Swift 6 language mode
476 | logger.debug("subscription removed, but still have active subscription count", metadata: [
477 | RedisLogging.MetadataKeys.subscriptionCount: "\($0)",
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
| `- warning: implicit capture of 'target' requires that 'RedisSubscriptionTarget' conforms to 'Sendable'; this is an error in the Swift 6 language mode
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:487:25: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
485 | .removeRedisPubSubHandler(handler)
486 | .map {
487 | self.state = .open
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
488 | logger.debug("connection is now open to all commands")
489 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:135:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
133 | public func activate(logger: Logger? = nil) {
134 | self.loop.execute {
135 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
136 | }
137 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:149:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
147 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
148 | self.loop.execute {
149 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
150 |
151 | self.pubsubConnection = nil
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:208:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
206 |
207 | return operation(connection)
208 | .always { _ in returnConnection(connection, logger) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
209 | },
210 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:208:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
206 |
207 | return operation(connection)
208 | .always { _ in returnConnection(connection, logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
209 | },
210 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:240:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
238 |
239 | for request in unbufferedRequests {
240 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
241 | }
242 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:233:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
231 |
232 | self.loop.execute {
233 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
234 |
235 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:301:26: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
299 | ) where Discovery.Instance == SocketAddress {
300 | self.loop.execute {
301 | let logger = self.prepareLoggerForUse(logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
302 |
303 | self.cancellationToken = discovery.subscribe(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:307:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
305 | onNext: { result in
306 | // This closure may execute on any thread.
307 | self.loop.execute {
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
308 | switch result {
309 | case .success(let targets):
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:310:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
308 | switch result {
309 | case .success(let targets):
310 | self.updateConnectionAddresses(targets, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
311 | case .failure(let error):
312 | logger.error("Service discovery error", metadata: [RedisLogging.MetadataKeys.error: "\(error)"])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:318:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
316 | onComplete: { (_: CompletionReason) in
317 | // We don't really care about the reason, we just want to brick this client.
318 | self.close(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
319 | }
320 | )
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:347:10: warning: type 'CommandResult' does not conform to the 'Sendable' protocol
327 | public var eventLoop: EventLoop { self.loop }
328 |
329 | public func send<CommandResult>(
| `- note: consider making generic parameter 'CommandResult' conform to the 'Sendable' protocol
330 | _ command: RedisCommand<CommandResult>,
331 | eventLoop: EventLoop? = nil,
:
345 | taskLogger: logger
346 | )
347 | .hop(to: eventLoop ?? self.eventLoop)
| `- warning: type 'CommandResult' does not conform to the 'Sendable' protocol
348 | }
349 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:341:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
339 | return connection
340 | .send(command, eventLoop: eventLoop, logger: logger)
341 | .always { _ in returnConnection(connection, logger) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
342 | },
343 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:341:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
339 | return connection
340 | .send(command, eventLoop: eventLoop, logger: logger)
341 | .always { _ in returnConnection(connection, logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
342 | },
343 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:481:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
479 | // a "no-op" unsub, so we need to return this connection
480 | guard
481 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:484:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
484 | returnConnection(connection, logger)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
485 | }
486 | },
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:484:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
484 | returnConnection(connection, logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
485 | }
486 | },
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:512:30: warning: type 'T' does not conform to the 'Sendable' protocol
502 | */
503 | @usableFromInline
504 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
505 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
506 | preferredConnection: RedisConnection?,
:
510 | // Establish event loop context then jump to the in-loop version.
511 | guard self.loop.inEventLoop else {
512 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
513 | return self.forwardOperationToConnection(
514 | operation,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:18: warning: type 'T' does not conform to the 'Sendable' protocol
502 | */
503 | @usableFromInline
504 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
505 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
506 | preferredConnection: RedisConnection?,
:
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:513:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
511 | guard self.loop.inEventLoop else {
512 | return self.loop.flatSubmit {
513 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
514 | operation,
515 | preferredConnection: preferredConnection,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:514:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
512 | return self.loop.flatSubmit {
513 | return self.forwardOperationToConnection(
514 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
515 | preferredConnection: preferredConnection,
516 | eventLoop: eventLoop,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:515:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
513 | return self.forwardOperationToConnection(
514 | operation,
515 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
516 | eventLoop: eventLoop,
517 | taskLogger: taskLogger
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[274/275] Compiling RediStack RedisConnectionPool+Configuration.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:66:29: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
64 | // if a password is specified, use it to authenticate before further operations happen
65 | if let password = config.password {
66 | future = future.flatMap { connection in
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
67 | return connection.authorize(with: password).map { connection }
68 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:73:29: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
71 | // if a database index is specified, use it to switch the selected database before further operations happen
72 | if let database = config.initialDatabase {
73 | future = future.flatMap { connection in
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
74 | return connection.select(database: database).map { connection }
75 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:62:85: warning: capture of 'config' with non-sendable type 'RedisConnection.Configuration' in a '@Sendable' closure
60 | var future = client
61 | .connect(to: config.address)
62 | .map { return RedisConnection(configuredRESPChannel: $0, defaultLogger: config.defaultLogger) }
| `- warning: capture of 'config' with non-sendable type 'RedisConnection.Configuration' in a '@Sendable' closure
63 |
64 | // if a password is specified, use it to authenticate before further operations happen
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection+Configuration.swift:64:19: note: consider making struct 'Configuration' conform to the 'Sendable' protocol
62 | extension RedisConnection {
63 | /// A configuration object for creating a single connection to Redis.
64 | public struct Configuration {
| `- note: consider making struct 'Configuration' conform to the 'Sendable' protocol
65 | /// The default port that Redis uses.
66 | ///
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:67:67: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
65 | if let password = config.password {
66 | future = future.flatMap { connection in
67 | return connection.authorize(with: password).map { connection }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
68 | }
69 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:74:68: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
72 | if let database = config.initialDatabase {
73 | future = future.flatMap { connection in
74 | return connection.select(database: database).map { connection }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
75 | }
76 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:187:28: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
185 | // if our state is still open, that means we didn't cause the closeFuture to resolve.
186 | // update state, metrics, and logging
187 | let oldState = self.state
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
188 | self.state = .closed
189 | RedisMetrics.activeConnectionCount.decrement()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:269:28: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
267 | let outboundData: RedisCommandHandler.OutboundCommandPayload = (command.serialized(), promise)
268 | let writeFuture: EventLoopFuture<Void> = self.sendCommandsImmediately
269 | ? self.channel.writeAndFlush(outboundData)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
270 | : self.channel.write(outboundData)
271 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:270:28: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
268 | let writeFuture: EventLoopFuture<Void> = self.sendCommandsImmediately
269 | ? self.channel.writeAndFlush(outboundData)
270 | : self.channel.write(outboundData)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
271 |
272 | return writeFuture
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:273:14: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
271 |
272 | return writeFuture
273 | .flatMap { promise.futureResult }
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
274 | .flatMapThrowing { try command.transform($0) }
275 | .hop(to: finalEventLoop)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:275:14: warning: type 'CommandResult' does not conform to the 'Sendable' protocol
223 |
224 | extension RedisConnection {
225 | public func send<CommandResult>(
| `- note: consider making generic parameter 'CommandResult' conform to the 'Sendable' protocol
226 | _ command: RedisCommand<CommandResult>,
227 | eventLoop: EventLoop? = nil,
:
273 | .flatMap { promise.futureResult }
274 | .flatMapThrowing { try command.transform($0) }
275 | .hop(to: finalEventLoop)
| `- warning: type 'CommandResult' does not conform to the 'Sendable' protocol
276 | }
277 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:274:36: warning: capture of 'command' with non-sendable type 'RedisCommand<CommandResult>' in a '@Sendable' closure
272 | return writeFuture
273 | .flatMap { promise.futureResult }
274 | .flatMapThrowing { try command.transform($0) }
| `- warning: capture of 'command' with non-sendable type 'RedisCommand<CommandResult>' in a '@Sendable' closure
275 | .hop(to: finalEventLoop)
276 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:15: note: consider making generic struct 'RedisCommand' conform to the 'Sendable' protocol
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: consider making generic struct 'RedisCommand' conform to the 'Sendable' protocol
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:312:47: warning: type 'RedisGracefulConnectionCloseEvent' does not conform to the 'Sendable' protocol
310 | let promise = finalEventLoop.makePromise(of: Void.self)
311 | let notification = promise.futureResult
312 | self.channel.triggerUserOutboundEvent(RedisGracefulConnectionCloseEvent(), promise: promise)
| `- warning: type 'RedisGracefulConnectionCloseEvent' does not conform to the 'Sendable' protocol
313 |
314 | notification.whenFailure {
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:181:15: note: consider making struct 'RedisGracefulConnectionCloseEvent' conform to the 'Sendable' protocol
179 |
180 | /// A channel event that informs the ``RedisCommandHandler`` that it should close the channel gracefully
181 | public struct RedisGracefulConnectionCloseEvent {
| `- note: consider making struct 'RedisGracefulConnectionCloseEvent' conform to the 'Sendable' protocol
182 | /// Creates a ``RedisGracefulConnectionCloseEvent``
183 | public init() {}
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:387:18: warning: type 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
385 | return self.channel.pipeline
386 | .addRedisPubSubHandler()
387 | .flatMap { handler in
| `- warning: type 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
388 | logger.trace("handler added, adding subscription")
389 | return handler
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:390:47: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
388 | logger.trace("handler added, adding subscription")
389 | return handler
390 | .addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
391 | .flatMapError { error in
392 | logger.debug(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:390:65: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
388 | logger.trace("handler added, adding subscription")
389 | return handler
390 | .addSubscription(for: target, receiver: receiver)
| |- warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
391 | .flatMapError { error in
392 | logger.debug(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:400:36: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
398 | // if there was an error, no subscriptions were made
399 | // so remove the handler and propogate the error to the caller by rethrowing it
400 | return self.channel.pipeline.removeRedisPubSubHandler(handler)
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
401 | .flatMapThrowing { throw error }
402 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:400:36: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
398 | // if there was an error, no subscriptions were made
399 | // so remove the handler and propogate the error to the caller by rethrowing it
400 | return self.channel.pipeline.removeRedisPubSubHandler(handler)
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
401 | .flatMapThrowing { throw error }
402 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:400:83: warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
398 | // if there was an error, no subscriptions were made
399 | // so remove the handler and propogate the error to the caller by rethrowing it
400 | return self.channel.pipeline.removeRedisPubSubHandler(handler)
| `- warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
401 | .flatMapThrowing { throw error }
402 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:406:36: warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
404 | .map { _ in
405 | logger.trace("successfully entered pubsub mode")
406 | return handler
| `- warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
407 | }
408 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:411:21: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
409 | // success, update our state
410 | .map { (handler: RedisPubSubHandler) in
411 | self.state = .pubsub(handler)
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
412 | logger.debug("the connection is now in pubsub mode")
413 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:478:68: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
476 | logger.debug("subscription removed, but still have active subscription count", metadata: [
477 | RedisLogging.MetadataKeys.subscriptionCount: "\($0)",
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:480:28: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
481 | }
482 | logger.debug("subscription removed, with no current active subscriptions. leaving pubsub mode")
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:485:47: warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
483 | // otherwise, remove the handler and update our state
484 | return self.channel.pipeline
485 | .removeRedisPubSubHandler(handler)
| `- warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
486 | .map {
487 | self.state = .open
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:478:68: warning: implicit capture of 'target' requires that 'RedisSubscriptionTarget' conforms to 'Sendable'; this is an error in the Swift 6 language mode
476 | logger.debug("subscription removed, but still have active subscription count", metadata: [
477 | RedisLogging.MetadataKeys.subscriptionCount: "\($0)",
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
| `- warning: implicit capture of 'target' requires that 'RedisSubscriptionTarget' conforms to 'Sendable'; this is an error in the Swift 6 language mode
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:487:25: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
485 | .removeRedisPubSubHandler(handler)
486 | .map {
487 | self.state = .open
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
488 | logger.debug("connection is now open to all commands")
489 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:135:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
133 | public func activate(logger: Logger? = nil) {
134 | self.loop.execute {
135 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
136 | }
137 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:149:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
147 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
148 | self.loop.execute {
149 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
150 |
151 | self.pubsubConnection = nil
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:208:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
206 |
207 | return operation(connection)
208 | .always { _ in returnConnection(connection, logger) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
209 | },
210 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:208:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
206 |
207 | return operation(connection)
208 | .always { _ in returnConnection(connection, logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
209 | },
210 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:240:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
238 |
239 | for request in unbufferedRequests {
240 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
241 | }
242 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:233:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
231 |
232 | self.loop.execute {
233 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
234 |
235 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:301:26: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
299 | ) where Discovery.Instance == SocketAddress {
300 | self.loop.execute {
301 | let logger = self.prepareLoggerForUse(logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
302 |
303 | self.cancellationToken = discovery.subscribe(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:307:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
305 | onNext: { result in
306 | // This closure may execute on any thread.
307 | self.loop.execute {
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
308 | switch result {
309 | case .success(let targets):
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:310:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
308 | switch result {
309 | case .success(let targets):
310 | self.updateConnectionAddresses(targets, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
311 | case .failure(let error):
312 | logger.error("Service discovery error", metadata: [RedisLogging.MetadataKeys.error: "\(error)"])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:318:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
316 | onComplete: { (_: CompletionReason) in
317 | // We don't really care about the reason, we just want to brick this client.
318 | self.close(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
319 | }
320 | )
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:347:10: warning: type 'CommandResult' does not conform to the 'Sendable' protocol
327 | public var eventLoop: EventLoop { self.loop }
328 |
329 | public func send<CommandResult>(
| `- note: consider making generic parameter 'CommandResult' conform to the 'Sendable' protocol
330 | _ command: RedisCommand<CommandResult>,
331 | eventLoop: EventLoop? = nil,
:
345 | taskLogger: logger
346 | )
347 | .hop(to: eventLoop ?? self.eventLoop)
| `- warning: type 'CommandResult' does not conform to the 'Sendable' protocol
348 | }
349 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:341:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
339 | return connection
340 | .send(command, eventLoop: eventLoop, logger: logger)
341 | .always { _ in returnConnection(connection, logger) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
342 | },
343 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:341:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
339 | return connection
340 | .send(command, eventLoop: eventLoop, logger: logger)
341 | .always { _ in returnConnection(connection, logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
342 | },
343 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:481:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
479 | // a "no-op" unsub, so we need to return this connection
480 | guard
481 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:484:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
484 | returnConnection(connection, logger)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
485 | }
486 | },
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:484:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
484 | returnConnection(connection, logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
485 | }
486 | },
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:512:30: warning: type 'T' does not conform to the 'Sendable' protocol
502 | */
503 | @usableFromInline
504 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
505 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
506 | preferredConnection: RedisConnection?,
:
510 | // Establish event loop context then jump to the in-loop version.
511 | guard self.loop.inEventLoop else {
512 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
513 | return self.forwardOperationToConnection(
514 | operation,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:18: warning: type 'T' does not conform to the 'Sendable' protocol
502 | */
503 | @usableFromInline
504 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
505 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
506 | preferredConnection: RedisConnection?,
:
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:513:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
511 | guard self.loop.inEventLoop else {
512 | return self.loop.flatSubmit {
513 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
514 | operation,
515 | preferredConnection: preferredConnection,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:514:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
512 | return self.loop.flatSubmit {
513 | return self.forwardOperationToConnection(
514 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
515 | preferredConnection: preferredConnection,
516 | eventLoop: eventLoop,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:515:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
513 | return self.forwardOperationToConnection(
514 | operation,
515 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
516 | eventLoop: eventLoop,
517 | taskLogger: taskLogger
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[275/275] Compiling RediStack RedisConnectionPool.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:66:29: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
64 | // if a password is specified, use it to authenticate before further operations happen
65 | if let password = config.password {
66 | future = future.flatMap { connection in
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
67 | return connection.authorize(with: password).map { connection }
68 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:73:29: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
71 | // if a database index is specified, use it to switch the selected database before further operations happen
72 | if let database = config.initialDatabase {
73 | future = future.flatMap { connection in
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
74 | return connection.select(database: database).map { connection }
75 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:62:85: warning: capture of 'config' with non-sendable type 'RedisConnection.Configuration' in a '@Sendable' closure
60 | var future = client
61 | .connect(to: config.address)
62 | .map { return RedisConnection(configuredRESPChannel: $0, defaultLogger: config.defaultLogger) }
| `- warning: capture of 'config' with non-sendable type 'RedisConnection.Configuration' in a '@Sendable' closure
63 |
64 | // if a password is specified, use it to authenticate before further operations happen
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection+Configuration.swift:64:19: note: consider making struct 'Configuration' conform to the 'Sendable' protocol
62 | extension RedisConnection {
63 | /// A configuration object for creating a single connection to Redis.
64 | public struct Configuration {
| `- note: consider making struct 'Configuration' conform to the 'Sendable' protocol
65 | /// The default port that Redis uses.
66 | ///
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:67:67: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
65 | if let password = config.password {
66 | future = future.flatMap { connection in
67 | return connection.authorize(with: password).map { connection }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
68 | }
69 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:74:68: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
72 | if let database = config.initialDatabase {
73 | future = future.flatMap { connection in
74 | return connection.select(database: database).map { connection }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
75 | }
76 | }
:
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:187:28: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
185 | // if our state is still open, that means we didn't cause the closeFuture to resolve.
186 | // update state, metrics, and logging
187 | let oldState = self.state
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
188 | self.state = .closed
189 | RedisMetrics.activeConnectionCount.decrement()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:269:28: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
267 | let outboundData: RedisCommandHandler.OutboundCommandPayload = (command.serialized(), promise)
268 | let writeFuture: EventLoopFuture<Void> = self.sendCommandsImmediately
269 | ? self.channel.writeAndFlush(outboundData)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
270 | : self.channel.write(outboundData)
271 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:270:28: warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
268 | let writeFuture: EventLoopFuture<Void> = self.sendCommandsImmediately
269 | ? self.channel.writeAndFlush(outboundData)
270 | : self.channel.write(outboundData)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
271 |
272 | return writeFuture
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:273:14: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
271 |
272 | return writeFuture
273 | .flatMap { promise.futureResult }
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
274 | .flatMapThrowing { try command.transform($0) }
275 | .hop(to: finalEventLoop)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: consider making enum 'RESPValue' conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:275:14: warning: type 'CommandResult' does not conform to the 'Sendable' protocol
223 |
224 | extension RedisConnection {
225 | public func send<CommandResult>(
| `- note: consider making generic parameter 'CommandResult' conform to the 'Sendable' protocol
226 | _ command: RedisCommand<CommandResult>,
227 | eventLoop: EventLoop? = nil,
:
273 | .flatMap { promise.futureResult }
274 | .flatMapThrowing { try command.transform($0) }
275 | .hop(to: finalEventLoop)
| `- warning: type 'CommandResult' does not conform to the 'Sendable' protocol
276 | }
277 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:274:36: warning: capture of 'command' with non-sendable type 'RedisCommand<CommandResult>' in a '@Sendable' closure
272 | return writeFuture
273 | .flatMap { promise.futureResult }
274 | .flatMapThrowing { try command.transform($0) }
| `- warning: capture of 'command' with non-sendable type 'RedisCommand<CommandResult>' in a '@Sendable' closure
275 | .hop(to: finalEventLoop)
276 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:15: note: consider making generic struct 'RedisCommand' conform to the 'Sendable' protocol
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: consider making generic struct 'RedisCommand' conform to the 'Sendable' protocol
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:312:47: warning: type 'RedisGracefulConnectionCloseEvent' does not conform to the 'Sendable' protocol
310 | let promise = finalEventLoop.makePromise(of: Void.self)
311 | let notification = promise.futureResult
312 | self.channel.triggerUserOutboundEvent(RedisGracefulConnectionCloseEvent(), promise: promise)
| `- warning: type 'RedisGracefulConnectionCloseEvent' does not conform to the 'Sendable' protocol
313 |
314 | notification.whenFailure {
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:181:15: note: consider making struct 'RedisGracefulConnectionCloseEvent' conform to the 'Sendable' protocol
179 |
180 | /// A channel event that informs the ``RedisCommandHandler`` that it should close the channel gracefully
181 | public struct RedisGracefulConnectionCloseEvent {
| `- note: consider making struct 'RedisGracefulConnectionCloseEvent' conform to the 'Sendable' protocol
182 | /// Creates a ``RedisGracefulConnectionCloseEvent``
183 | public init() {}
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:387:18: warning: type 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
385 | return self.channel.pipeline
386 | .addRedisPubSubHandler()
387 | .flatMap { handler in
| `- warning: type 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
388 | logger.trace("handler added, adding subscription")
389 | return handler
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:390:47: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
388 | logger.trace("handler added, adding subscription")
389 | return handler
390 | .addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
391 | .flatMapError { error in
392 | logger.debug(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:390:65: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
388 | logger.trace("handler added, adding subscription")
389 | return handler
390 | .addSubscription(for: target, receiver: receiver)
| |- warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
391 | .flatMapError { error in
392 | logger.debug(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:400:36: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
398 | // if there was an error, no subscriptions were made
399 | // so remove the handler and propogate the error to the caller by rethrowing it
400 | return self.channel.pipeline.removeRedisPubSubHandler(handler)
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
401 | .flatMapThrowing { throw error }
402 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:400:36: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
398 | // if there was an error, no subscriptions were made
399 | // so remove the handler and propogate the error to the caller by rethrowing it
400 | return self.channel.pipeline.removeRedisPubSubHandler(handler)
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
401 | .flatMapThrowing { throw error }
402 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:400:83: warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
398 | // if there was an error, no subscriptions were made
399 | // so remove the handler and propogate the error to the caller by rethrowing it
400 | return self.channel.pipeline.removeRedisPubSubHandler(handler)
| `- warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
401 | .flatMapThrowing { throw error }
402 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:406:36: warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
404 | .map { _ in
405 | logger.trace("successfully entered pubsub mode")
406 | return handler
| `- warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
407 | }
408 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:411:21: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
409 | // success, update our state
410 | .map { (handler: RedisPubSubHandler) in
411 | self.state = .pubsub(handler)
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
412 | logger.debug("the connection is now in pubsub mode")
413 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:478:68: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
476 | logger.debug("subscription removed, but still have active subscription count", metadata: [
477 | RedisLogging.MetadataKeys.subscriptionCount: "\($0)",
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:480:28: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
481 | }
482 | logger.debug("subscription removed, with no current active subscriptions. leaving pubsub mode")
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:485:47: warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
483 | // otherwise, remove the handler and update our state
484 | return self.channel.pipeline
485 | .removeRedisPubSubHandler(handler)
| `- warning: capture of 'handler' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
486 | .map {
487 | self.state = .open
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:94:20: note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
92 |
93 | /// A channel handler that stores a map of closures and channel or pattern names subscribed to in Redis using Pub/Sub.
94 | public final class RedisPubSubHandler {
| `- note: class 'RedisPubSubHandler' does not conform to the 'Sendable' protocol
95 | private var state: State = .default
96 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:478:68: warning: implicit capture of 'target' requires that 'RedisSubscriptionTarget' conforms to 'Sendable'; this is an error in the Swift 6 language mode
476 | logger.debug("subscription removed, but still have active subscription count", metadata: [
477 | RedisLogging.MetadataKeys.subscriptionCount: "\($0)",
478 | RedisLogging.MetadataKeys.pubsubTarget: "\(target.debugDescription)"
| `- warning: implicit capture of 'target' requires that 'RedisSubscriptionTarget' conforms to 'Sendable'; this is an error in the Swift 6 language mode
479 | ])
480 | return self.eventLoop.makeSucceededFuture(())
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:65:13: note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
63 | ///
64 | /// Use the `values` property to quickly access the underlying list of the target for any purpose that requires a the `String` values.
65 | public enum RedisSubscriptionTarget: Equatable, CustomDebugStringConvertible {
| `- note: consider making enum 'RedisSubscriptionTarget' conform to the 'Sendable' protocol
66 | case channels([RedisChannelName])
67 | case patterns([String])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:487:25: warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
:
485 | .removeRedisPubSubHandler(handler)
486 | .map {
487 | self.state = .open
| `- warning: capture of 'self' with non-sendable type 'RedisConnection' in a '@Sendable' closure
488 | logger.debug("connection is now open to all commands")
489 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:135:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
133 | public func activate(logger: Logger? = nil) {
134 | self.loop.execute {
135 | self.pool?.activate(logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
136 | }
137 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:149:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
147 | public func close(promise: EventLoopPromise<Void>? = nil, logger: Logger? = nil) {
148 | self.loop.execute {
149 | self.pool?.close(promise: promise, logger: self.prepareLoggerForUse(logger))
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
150 |
151 | self.pubsubConnection = nil
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:208:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
206 |
207 | return operation(connection)
208 | .always { _ in returnConnection(connection, logger) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
209 | },
210 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:208:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
206 |
207 | return operation(connection)
208 | .always { _ in returnConnection(connection, logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
209 | },
210 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:240:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
238 |
239 | for request in unbufferedRequests {
240 | request.completeWith(self.connectionFactory(self.loop))
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
241 | }
242 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:233:13: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
231 |
232 | self.loop.execute {
233 | self.serverConnectionAddresses.update(newAddresses)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
234 |
235 | // Shiny, we can unbuffer any pending connections and pass them on as they now have somewhere to go.
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:301:26: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
299 | ) where Discovery.Instance == SocketAddress {
300 | self.loop.execute {
301 | let logger = self.prepareLoggerForUse(logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
302 |
303 | self.cancellationToken = discovery.subscribe(
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:307:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
305 | onNext: { result in
306 | // This closure may execute on any thread.
307 | self.loop.execute {
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
308 | switch result {
309 | case .success(let targets):
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:310:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
308 | switch result {
309 | case .success(let targets):
310 | self.updateConnectionAddresses(targets, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
311 | case .failure(let error):
312 | logger.error("Service discovery error", metadata: [RedisLogging.MetadataKeys.error: "\(error)"])
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:318:21: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
316 | onComplete: { (_: CompletionReason) in
317 | // We don't really care about the reason, we just want to brick this client.
318 | self.close(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
319 | }
320 | )
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:347:10: warning: type 'CommandResult' does not conform to the 'Sendable' protocol
327 | public var eventLoop: EventLoop { self.loop }
328 |
329 | public func send<CommandResult>(
| `- note: consider making generic parameter 'CommandResult' conform to the 'Sendable' protocol
330 | _ command: RedisCommand<CommandResult>,
331 | eventLoop: EventLoop? = nil,
:
345 | taskLogger: logger
346 | )
347 | .hop(to: eventLoop ?? self.eventLoop)
| `- warning: type 'CommandResult' does not conform to the 'Sendable' protocol
348 | }
349 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:341:36: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
339 | return connection
340 | .send(command, eventLoop: eventLoop, logger: logger)
341 | .always { _ in returnConnection(connection, logger) }
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
342 | },
343 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:341:53: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
339 | return connection
340 | .send(command, eventLoop: eventLoop, logger: logger)
341 | .always { _ in returnConnection(connection, logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
342 | },
343 | preferredConnection: nil,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:481:29: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
479 | // a "no-op" unsub, so we need to return this connection
480 | guard
481 | self.pubsubConnection == nil,
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:484:25: warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
484 | returnConnection(connection, logger)
| |- warning: capture of 'returnConnection' with non-sendable type '(RedisConnection, Logger) -> Void' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
485 | }
486 | },
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:484:42: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
482 | self.leasedConnectionCount > 0
483 | else { return }
484 | returnConnection(connection, logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
485 | }
486 | },
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:512:30: warning: type 'T' does not conform to the 'Sendable' protocol
502 | */
503 | @usableFromInline
504 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
505 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
506 | preferredConnection: RedisConnection?,
:
510 | // Establish event loop context then jump to the in-loop version.
511 | guard self.loop.inEventLoop else {
512 | return self.loop.flatSubmit {
| `- warning: type 'T' does not conform to the 'Sendable' protocol
513 | return self.forwardOperationToConnection(
514 | operation,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:18: warning: type 'T' does not conform to the 'Sendable' protocol
502 | */
503 | @usableFromInline
504 | internal func forwardOperationToConnection<T>(
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
505 | _ operation: @escaping (RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>,
506 | preferredConnection: RedisConnection?,
:
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: type 'T' does not conform to the 'Sendable' protocol
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:513:24: warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
28 | /// single `EventLoop`: if callers call the API from a different `EventLoop` (or from no `EventLoop` at all)
29 | /// `RedisConnectionPool` will ensure that the call is dispatched to the correct loop.
30 | public class RedisConnectionPool {
| `- note: class 'RedisConnectionPool' does not conform to the 'Sendable' protocol
31 | /// A unique identifer to represent this connection.
32 | public let id = UUID()
:
511 | guard self.loop.inEventLoop else {
512 | return self.loop.flatSubmit {
513 | return self.forwardOperationToConnection(
| `- warning: capture of 'self' with non-sendable type 'RedisConnectionPool' in a '@Sendable' closure
514 | operation,
515 | preferredConnection: preferredConnection,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:514:21: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
512 | return self.loop.flatSubmit {
513 | return self.forwardOperationToConnection(
514 | operation,
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
515 | preferredConnection: preferredConnection,
516 | eventLoop: eventLoop,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:515:42: warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
513 | return self.forwardOperationToConnection(
514 | operation,
515 | preferredConnection: preferredConnection,
| `- warning: capture of 'preferredConnection' with non-sendable type 'RedisConnection?' in a '@Sendable' closure
516 | eventLoop: eventLoop,
517 | taskLogger: taskLogger
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:28: warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| |- warning: capture of 'operation' with non-sendable type '(RedisConnection, @escaping (RedisConnection, Logger) -> Void, Logger) -> EventLoopFuture<T>' in a '@Sendable' closure
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnectionPool.swift:534:42: warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
532 | return pool
533 | .leaseConnection(logger: logger)
534 | .flatMap { operation($0, pool.returnConnection(_:logger:), logger) }
| `- warning: capture of 'pool' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
535 | }
536 |
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:38:22: note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
36 | /// and being used, at the cost of incurring more reconnects under low load. Of course, when we're under low load we don't
37 | /// really care how many reconnects there are.
38 | internal final class ConnectionPool {
| `- note: class 'ConnectionPool' does not conform to the 'Sendable' protocol
39 | /// A function used to create Redis connections.
40 | private let connectionFactory: (EventLoop) -> EventLoopFuture<RedisConnection>
[276/284] Emitting module RedisTypes
[277/284] Compiling RedisTypes RedisSet.swift
/Users/admin/builder/spi-builder-workspace/Sources/RedisTypes/RedisSet.swift:210:55: warning: type 'Element' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
58 | ///
59 | /// See [https://redis.io/topics/data-types-intro#sets](https://redis.io/topics/data-types-intro#sets)
60 | public struct RedisSet<Element> where Element: RESPValueConvertible {
| `- note: consider making generic parameter 'Element' conform to the 'Sendable' protocol
61 | /// The key in Redis that this instance is a reference to.
62 | public var identifier: RedisKey { return self.id }
:
208 | public func popRandomElements(max count: Int) -> EventLoopFuture<[Element]> {
209 | guard count >= 0 else { return self.eventLoop.makeFailedFuture(RedisError.indexOutOfRange) }
210 | guard count >= 1 else { return self.eventLoop.makeSucceededFuture([]) }
| `- warning: type 'Element' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
211 | return self.send(.spop(from: self.id, max: count))
212 | .map { return $0.compactMap(Element.init) }
[278/284] Compiling RediStackTestUtils RedisIntegrationTestCase.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStackTestUtils/RedisIntegrationTestCase.swift:69:37: warning: capture of 'self' with non-sendable type 'RedisIntegrationTestCase' in a '@Sendable' closure
21 | ///
22 | /// See `RedisConnection.make(configuration:boundEventLoop:)` to understand how connections are made.
23 | open class RedisIntegrationTestCase: XCTestCase {
| `- note: class 'RedisIntegrationTestCase' does not conform to the 'Sendable' protocol
24 | /// An overridable value of the Redis instance's hostname to connect to for the test suite(s).
25 | ///
:
67 | if self.connection.isConnected {
68 | _ = try self.connection.send(.flushall)
69 | .flatMap { _ in self.connection.close() }
| `- warning: capture of 'self' with non-sendable type 'RedisIntegrationTestCase' in a '@Sendable' closure
70 | .wait()
71 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStackTestUtils/RedisIntegrationTestCase.swift:91:11: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
89 | ),
90 | boundEventLoop: eventLoopGroup.next()
91 | ).wait()
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
92 | }
93 | }
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RedisConnection.swift:99:20: note: class 'RedisConnection' does not conform to the 'Sendable' protocol
97 | ///
98 | /// Note: `wait()` is used in the example for simplicity. Never call `wait()` on an event loop.
99 | public final class RedisConnection: RedisClient {
| `- note: class 'RedisConnection' does not conform to the 'Sendable' protocol
100 | /// A unique identifer to represent this connection.
101 | public let id = UUID()
/Users/admin/builder/spi-builder-workspace/Sources/RediStackTestUtils/RedisIntegrationTestCase.swift:17:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
15 | import NIOCore
16 | import NIOPosix
17 | import RediStack
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
18 | import XCTest
19 |
[279/284] Compiling RediStackTestUtils General.swift
[280/284] Compiling RediStackTestUtils _Deprecations.swift
[281/284] Compiling RediStackTestUtils RedisConnectionPoolIntegrationTestCase.swift
[282/284] Compiling RediStackTestUtils RediStack.swift
[283/284] Emitting module RediStackTestUtils
[284/284] Compiling RediStackTestUtils EmbeddedMockRedisServer.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStackTestUtils/EmbeddedMockRedisServer.swift:62:34: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
60 | // We always allow this.
61 | let response = RESPValue.simpleString("OK".byteBuffer)
62 | data.responsePromise.succeed(response)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
63 |
64 | default:
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/RESP/RESPValue.swift:29:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
27 | ///
28 | /// See: [https://redis.io/topics/protocol](https://redis.io/topics/protocol)
29 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
30 | case null
31 | case simpleString(ByteBuffer)
/Users/admin/builder/spi-builder-workspace/Sources/RediStackTestUtils/EmbeddedMockRedisServer.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
13 | //===----------------------------------------------------------------------===//
14 |
15 | import RediStack
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'RediStack'
16 | import XCTest
17 | import NIOCore
/Users/admin/builder/spi-builder-workspace/Sources/RediStackTestUtils/EmbeddedMockRedisServer.swift:73:13: warning: capture of 'self' with non-sendable type 'EmbeddedMockRedisServer' in a '@Sendable' closure
26 | /// This is not really a Redis server: it's just something that lets us stub out the connection management in order to let
27 | /// us test the connection pool.
28 | internal final class EmbeddedMockRedisServer {
| `- note: class 'EmbeddedMockRedisServer' does not conform to the 'Sendable' protocol
29 | var channels: ArraySlice<EmbeddedChannel> = []
30 | var loop: EmbeddedEventLoop = EmbeddedEventLoop()
:
71 | let channel = EmbeddedChannel(handler: GracefulShutdownToCloseHandler(), loop: self.loop)
72 | channel.closeFuture.whenComplete { _ in
73 | self.channels.removeAll(where: { $0 === channel })
| `- warning: capture of 'self' with non-sendable type 'EmbeddedMockRedisServer' in a '@Sendable' closure
74 | }
75 |
Build complete! (18.96s)
Build complete.
{
"dependencies" : [
{
"identity" : "swift-log",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.0",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-log.git"
},
{
"identity" : "swift-metrics",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.0",
"upper_bound" : "3.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-metrics.git"
},
{
"identity" : "swift-nio",
"requirement" : {
"range" : [
{
"lower_bound" : "2.43.0",
"upper_bound" : "3.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-nio.git"
},
{
"identity" : "swift-atomics",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.2",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-atomics.git"
},
{
"identity" : "swift-service-discovery",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.0",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-service-discovery"
}
],
"manifest_display_name" : "RediStack",
"name" : "RediStack",
"path" : "/Users/admin/builder/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "RediStack",
"targets" : [
"RediStack"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "RediStackTestUtils",
"targets" : [
"RediStackTestUtils"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "RedisTypes",
"targets" : [
"RedisTypes"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"targets" : [
{
"c99name" : "RedisTypesTests",
"module_type" : "SwiftTarget",
"name" : "RedisTypesTests",
"path" : "Tests/RedisTypesTests",
"product_dependencies" : [
"NIOCore"
],
"sources" : [
"RedisSetTests.swift",
"RedisTypesIntegrationTestCase.swift"
],
"target_dependencies" : [
"RediStack",
"RedisTypes",
"RediStackTestUtils"
],
"type" : "test"
},
{
"c99name" : "RedisTypes",
"module_type" : "SwiftTarget",
"name" : "RedisTypes",
"path" : "Sources/RedisTypes",
"product_memberships" : [
"RedisTypes"
],
"sources" : [
"RedisSet.swift"
],
"target_dependencies" : [
"RediStack"
],
"type" : "library"
},
{
"c99name" : "RediStackTests",
"module_type" : "SwiftTarget",
"name" : "RediStackTests",
"path" : "Tests/RediStackTests",
"product_dependencies" : [
"NIOCore",
"NIOPosix",
"NIOEmbedded",
"NIOTestUtils"
],
"sources" : [
"ChannelHandlers/RedisByteDecoderTests.swift",
"ChannelHandlers/RedisCommandHandlerTests.swift",
"ChannelHandlers/RedisMessageEncoderTests.swift",
"ConfigurationTests.swift",
"ConnectionPoolTests.swift",
"RESPTranslatorTests.swift",
"RESPValueTests.swift",
"RedisCommandTests.swift",
"RedisConnectionTests.swift",
"RedisKeyLifetime.swift"
],
"target_dependencies" : [
"RediStack",
"RediStackTestUtils"
],
"type" : "test"
},
{
"c99name" : "RediStackTestUtils",
"module_type" : "SwiftTarget",
"name" : "RediStackTestUtils",
"path" : "Sources/RediStackTestUtils",
"product_dependencies" : [
"NIOCore",
"NIOPosix",
"NIOEmbedded"
],
"product_memberships" : [
"RediStackTestUtils"
],
"sources" : [
"EmbeddedMockRedisServer.swift",
"Extensions/General.swift",
"Extensions/RediStack.swift",
"RedisConnectionPoolIntegrationTestCase.swift",
"RedisIntegrationTestCase.swift",
"_Deprecations.swift"
],
"target_dependencies" : [
"RediStack"
],
"type" : "library"
},
{
"c99name" : "RediStackIntegrationTests",
"module_type" : "SwiftTarget",
"name" : "RediStackIntegrationTests",
"path" : "Tests/RediStackIntegrationTests",
"product_dependencies" : [
"NIO",
"ServiceDiscovery"
],
"sources" : [
"Commands/ConnectionCommandsTests.swift",
"Commands/HashCommandsTests.swift",
"Commands/KeyCommandsTests.swift",
"Commands/ListCommandsTests.swift",
"Commands/PubSubCommandsTests.swift",
"Commands/ServerCommandsTests.swift",
"Commands/SetCommandsTests.swift",
"Commands/SortedSetCommandsTests.swift",
"Commands/StringCommandsTests.swift",
"RediStackIntegrationTestCase.swift",
"RedisConnectionPoolTests.swift",
"RedisConnectionTests.swift",
"RedisLoggingTests.swift",
"RedisServiceDiscoveryTests.swift"
],
"target_dependencies" : [
"RediStack",
"RediStackTestUtils"
],
"type" : "test"
},
{
"c99name" : "RediStack",
"module_type" : "SwiftTarget",
"name" : "RediStack",
"path" : "Sources/RediStack",
"product_dependencies" : [
"Atomics",
"NIOCore",
"NIOPosix",
"Logging",
"Metrics",
"ServiceDiscovery"
],
"product_memberships" : [
"RediStack",
"RediStackTestUtils",
"RedisTypes"
],
"sources" : [
"ChannelHandlers/RedisByteDecoder.swift",
"ChannelHandlers/RedisCommandHandler.swift",
"ChannelHandlers/RedisMessageEncoder.swift",
"ChannelHandlers/RedisPubSubHandler.swift",
"Commands/ConnectionCommands.swift",
"Commands/HashCommands.swift",
"Commands/KeyCommands.swift",
"Commands/ListCommands.swift",
"Commands/PubSubCommands.swift",
"Commands/RedisCommand.swift",
"Commands/ServerCommands.swift",
"Commands/SetCommands.swift",
"Commands/SortedSetCommands.swift",
"Commands/StringCommands.swift",
"ConnectionPool/ConnectionPool.swift",
"ConnectionPool/ConnectionPoolErrors.swift",
"Extensions/StandardLibrary.swift",
"Extensions/SwiftNIO.swift",
"RESP/RESPTranslator.swift",
"RESP/RESPValue.swift",
"RESP/RESPValueConvertible.swift",
"RedisChannelName.swift",
"RedisClient.swift",
"RedisConnection+Configuration.swift",
"RedisConnection.swift",
"RedisConnectionPool+Configuration.swift",
"RedisConnectionPool.swift",
"RedisError.swift",
"RedisKey+TTL.swift",
"RedisKey.swift",
"RedisLogging.swift",
"RedisMetrics.swift",
"_Deprecations.swift"
],
"type" : "library"
}
],
"tools_version" : "5.5"
}
✅ Doc result (pending) reported
========================================
GenerateDocs
========================================
Generating docs at path: $PWD/.docs/swift-server/redistack/2.0.0-gamma.1.1
Repository: swift-server/RediStack
Swift version used: 6.1
Target: RediStack
Extracting symbol information for 'RediStack'...
Finished extracting symbol information for 'RediStack'. (9.08s)
Building documentation for 'RediStack'...
warning: Parameter 'key' not found in type method declaration
--> ../Commands/ListCommands.swift:82:15-82:18
80 | /// It is **highly** recommended to set a reasonable `timeout` or to use the non-blocking `rpop` method where possible.
81 | /// - Parameters:
82 + /// - key: The key of the list to pop from.
| ╰─suggestion: Replace 'key' with 'keys'
83 | /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
84 | /// - Returns: The popped value and the key of its source list, otherwise `nil`.
warning: Parameter 'keys' is missing documentation
--> ../Commands/ListCommands.swift:83:103-83:103
81 | /// - Parameters:
82 | /// - key: The key of the list to pop from.
83 + /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
| ╰─suggestion: Document 'keys' parameter
84 | /// - Returns: The popped value and the key of its source list, otherwise `nil`.
85 | public static func brpop(from keys: [RedisKey], timeout: TimeAmount = .seconds(0)) -> RedisCommand<(RedisKey, RESPValue)?> {
warning: Parameter 'key' not found in type method declaration
--> ../Commands/ListCommands.swift:95:15-95:18
93 | /// It is **highly** recommended to set a reasonable `timeout` or to use the non-blocking `rpop` method where possible.
94 | /// - Parameters:
95 + /// - key: The key of the list to pop from.
| ╰─suggestion: Replace 'key' with 'keys'
96 | /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
97 | /// - Returns: The popped value and the key of its source list, otherwise `nil`.
warning: Parameter 'keys' is missing documentation
--> ../Commands/ListCommands.swift:96:103-96:103
94 | /// - Parameters:
95 | /// - key: The key of the list to pop from.
96 + /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
| ╰─suggestion: Document 'keys' parameter
97 | /// - Returns: The popped value and the key of its source list, otherwise `nil`.
98 | public static func brpop(
warning: External name 'sources' used to document parameter
--> ../Commands/SetCommands.swift:68:15-68:22
66 | /// - Parameters:
67 | /// - destination: The key of the new set from the result.
68 + /// - sources: The list of source sets to calculate the difference of.
| ╰─suggestion: Replace 'sources' with 'keys'
69 | public static func sdiffstore(as destination: RedisKey, sources keys: [RedisKey]) -> RedisCommand<Int> {
70 | assert(!keys.isEmpty, "at least 1 key should be provided")
warning: External name 'sources' used to document parameter
--> ../Commands/SetCommands.swift:95:15-95:22
93 | /// - Parameters:
94 | /// - destination: The key of the new set from the result.
95 + /// - sources: A list of source sets to calculate the intersection of.
| ╰─suggestion: Replace 'sources' with 'keys'
96 | public static func sinterstore(as destination: RedisKey, sources keys: [RedisKey]) -> RedisCommand<Int> {
97 | assert(!keys.isEmpty, "at least 1 key should be provided")
warning: External name 'sources' used to document parameter
--> ../Commands/SetCommands.swift:221:15-221:22
219 | /// - Parameters:
220 | /// - destination: The key of the new set from the result.
221 + /// - sources: A list of source sets to calculate the union of.
| ╰─suggestion: Replace 'sources' with 'keys'
222 | public static func sunionstore(as destination: RedisKey, sources keys: [RedisKey]) -> RedisCommand<Int> {
223 | assert(!keys.isEmpty, "at least 1 key should be provided")
warning: Parameter 'key' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:87:15-87:18
85 | /// It is **highly** recommended to set a reasonable `timeout` or to use the non-blocking `zpopmax` method where possible.
86 | /// - Parameters:
87 + /// - key: The key identifying the sorted set in Redis.
| ╰─suggestion: Replace 'key' with 'keys'
88 | /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
89 | public static func bzpopmax(
warning: Parameter 'keys' is missing documentation
--> ../Commands/SortedSetCommands.swift:88:103-88:103
86 | /// - Parameters:
87 | /// - key: The key identifying the sorted set in Redis.
88 + /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
| ╰─suggestion: Document 'keys' parameter
89 | public static func bzpopmax(
90 | from keys: [RedisKey],
warning: Parameter 'key' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:100:15-100:18
98 | /// It is **highly** recommended to set a reasonable `timeout` or to use the non-blocking `zpopmax` method where possible.
99 | /// - Parameters:
100 + /// - key: The key identifying the sorted set in Redis.
| ╰─suggestion: Replace 'key' with 'keys'
101 | /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
102 | public static func bzpopmax(
warning: Parameter 'keys' is missing documentation
--> ../Commands/SortedSetCommands.swift:101:103-101:103
99 | /// - Parameters:
100 | /// - key: The key identifying the sorted set in Redis.
101 + /// - timeout: The max time to wait for a value to use. `0`seconds means to wait indefinitely.
| ╰─suggestion: Document 'keys' parameter
102 | public static func bzpopmax(
103 | from keys: RedisKey...,
warning: External name 'aggregateMethod' used to document parameter
--> ../Commands/SortedSetCommands.swift:266:15-266:30
264 | /// - sources: The list of sorted set keys to treat as the source of the intersection.
265 | /// - weights: The multiplying factor to apply to the corresponding `sources` key based on index of the two parameters.
266 + /// - aggregateMethod: The method of aggregating the values of the intersection. If one isn't specified, Redis will default to `.sum`.
| ╰─suggestion: Replace 'aggregateMethod' with 'aggregate'
267 | public static func zinterstore(
268 | as destination: RedisKey,
warning: 'zrange(from:firstIndex:lastIndex:resultOption:)' doesn't exist at '/RediStack/RedisCommand/zrange(from:indices:returning:)'
--> ../Commands/SortedSetCommands.swift:371:45-371:92
369 | /// `ClosedRange` will trigger a precondition failure.
370 | ///
371 + /// If you need such a range, use ``zrange(from:firstIndex:lastIndex:resultOption:)`` instead.
372 | /// - Important: This treats the SortedSet as ordered from **low** to **high**.
373 | ///
warning: 'zrange(from:firstIndex:lastIndex:)' doesn't exist at '/RediStack/RedisCommand/zrange(from:indices:returning:)'
--> ../Commands/SortedSetCommands.swift:392:45-392:79
390 | /// `Range` will trigger a precondition failure.
391 | ///
392 + /// If you need such a range, use ``zrange(from:firstIndex:lastIndex:)`` instead.
393 | /// - Important: This treats the SortedSet as ordered from **low** to **high**.
394 | ///
warning: External name 'limitBy' used to document parameter
--> ../Commands/SortedSetCommands.swift:468:15-468:22
466 | /// - key: The key of the SortedSet that will be counted.
467 | /// - range: The min and max value bounds for filtering elements by.
468 + /// - limitBy: The optional offset and count of elements to query.
| ╰─suggestion: Replace 'limitBy' with 'limit'
469 | @inlinable
470 | public static func zrangebylex<Value: CustomStringConvertible>(
warning: Parameter 'minValue' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:503:15-503:23
501 | /// - Parameters:
502 | /// - key: The key of the SortedSet.
503 + /// - minValue: The maximum lexiographical value an element in the SortedSet should have to be included in the result set.
| ╰─suggestion: Replace 'minValue' with 'maxValue'
504 | /// - limit: The optional offset and count of elements to query
505 | @inlinable
warning: Parameter 'maxValue' is missing documentation
--> ../Commands/SortedSetCommands.swift:504:72-504:72
502 | /// - key: The key of the SortedSet.
503 | /// - minValue: The maximum lexiographical value an element in the SortedSet should have to be included in the result set.
504 + /// - limit: The optional offset and count of elements to query
| ╰─suggestion: Document 'maxValue' parameter
505 | @inlinable
506 | public static func zrangebylex<Value: CustomStringConvertible>(
warning: External name 'limitBy' used to document parameter
--> ../Commands/SortedSetCommands.swift:522:15-522:22
520 | /// - key: The key of the SortedSet that will be counted.
521 | /// - range: The min and max value bounds for filtering elements by.
522 + /// - limitBy: The optional offset and count of elements to query.
| ╰─suggestion: Replace 'limitBy' with 'limit'
523 | @inlinable
524 | public static func zrevrangebylex<Value: CustomStringConvertible>(
warning: Parameter 'minValue' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:557:15-557:23
555 | /// - Parameters:
556 | /// - key: The key of the SortedSet.
557 + /// - minValue: The maximum lexiographical value an element in the SortedSet should have to be included in the result set.
| ╰─suggestion: Replace 'minValue' with 'maxValue'
558 | /// - limit: The optional offset and count of elements to query
559 | @inlinable
warning: Parameter 'maxValue' is missing documentation
--> ../Commands/SortedSetCommands.swift:558:72-558:72
556 | /// - key: The key of the SortedSet.
557 | /// - minValue: The maximum lexiographical value an element in the SortedSet should have to be included in the result set.
558 + /// - limit: The optional offset and count of elements to query
| ╰─suggestion: Document 'maxValue' parameter
559 | @inlinable
560 | public static func zrevrangebylex<Value: CustomStringConvertible>(
warning: Parameter 'range' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:641:13-641:117
639 | /// - Parameters:
640 | /// - key: The key of the SortedSet.
641 + /// - range: The minimum score bound an element in the SortedSet should have to be included in the response.
| ╰─suggestion: Remove 'range' parameter documentation
642 | /// - limit: The optional offset and count of elements to query.
643 | /// - resultOption: What information should be returned in the result?
warning: Parameter 'minScore' is missing documentation
--> ../Commands/SortedSetCommands.swift:643:79-643:79
641 | /// - range: The minimum score bound an element in the SortedSet should have to be included in the response.
642 | /// - limit: The optional offset and count of elements to query.
| ╰─suggestion: Document 'minScore' parameter
643 + /// - resultOption: What information should be returned in the result?
644 | @inlinable
645 | public static func zrangebyscore<T>(
warning: Parameter 'range' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:665:13-665:117
663 | /// - Parameters:
664 | /// - key: The key of the SortedSet.
665 + /// - range: The maximum score bound an element in the SortedSet should have to be included in the response.
| ╰─suggestion: Remove 'range' parameter documentation
666 | /// - limit: The optional offset and count of elements to query.
667 | /// - resultOption: What information should be returned in the result?
warning: Parameter 'maxScore' is missing documentation
--> ../Commands/SortedSetCommands.swift:667:79-667:79
665 | /// - range: The maximum score bound an element in the SortedSet should have to be included in the response.
666 | /// - limit: The optional offset and count of elements to query.
| ╰─suggestion: Document 'maxScore' parameter
667 + /// - resultOption: What information should be returned in the result?
668 | @inlinable
669 | public static func zrangebyscore<T>(
warning: Parameter 'minScore' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:865:15-865:23
863 | /// - Parameters:
864 | /// - key: The key of the SortedSet to remove elements from.
865 + /// - minScore: The maximum score bound an element in the SortedSet should have to be removed.
| ╰─suggestion: Replace 'minScore' with 'maxScore'
866 | public static func zremrangebyscore(from key: RedisKey, withMaximumScoreOf maxScore: RedisZScoreBound) -> RedisCommand<Int> {
867 | return .zremrangebyscore(from: key, withScoresBetween: (.inclusive(-.infinity), maxScore))
warning: Parameter 'maxScore' is missing documentation
--> ../Commands/SortedSetCommands.swift:865:103-865:103
863 | /// - Parameters:
864 | /// - key: The key of the SortedSet to remove elements from.
865 + /// - minScore: The maximum score bound an element in the SortedSet should have to be removed.
| ╰─suggestion: Document 'maxScore' parameter
866 | public static func zremrangebyscore(from key: RedisKey, withMaximumScoreOf maxScore: RedisZScoreBound) -> RedisCommand<Int> {
867 | return .zremrangebyscore(from: key, withScoresBetween: (.inclusive(-.infinity), maxScore))
warning: 'zrevrange(from:firstIndex:lastIndex:)' doesn't exist at '/RediStack/RedisCommand/zrevrange(from:indices:returning:)'
--> ../Commands/SortedSetCommands.swift:891:45-891:82
889 | /// `ClosedRange` will trigger a precondition failure.
890 | ///
891 + /// If you need such a range, use ``zrevrange(from:firstIndex:lastIndex:)`` instead.
892 | /// - Important: This treats the SortedSet as ordered from **high** to **low**.
893 | ///
warning: 'zrevrange(from:firstIndex:lastIndex:)' doesn't exist at '/RediStack/RedisCommand/zrevrange(from:indices:returning:)'
--> ../Commands/SortedSetCommands.swift:910:45-910:82
908 | /// `Range` will trigger a precondition failure.
909 | ///
910 + /// If you need such a range, use ``zrevrange(from:firstIndex:lastIndex:)`` instead.
911 | /// - Important: This treats the SortedSet as ordered from **high** to **low**.
912 | ///
warning: Parameter 'range' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:1043:13-1043:117
1041 | /// - Parameters:
1042 | /// - key: The key of the SortedSet.
1043 + /// - range: The minimum score bound an element in the SortedSet should have to be included in the response.
| ╰─suggestion: Remove 'range' parameter documentation
1044 | /// - limit: The optional offset and count of elements to query.
1045 | /// - resultOption: What information should be returned in the result?
warning: Parameter 'minScore' is missing documentation
--> ../Commands/SortedSetCommands.swift:1045:79-1045:79
1043 | /// - range: The minimum score bound an element in the SortedSet should have to be included in the response.
1044 | /// - limit: The optional offset and count of elements to query.
| ╰─suggestion: Document 'minScore' parameter
1045 + /// - resultOption: What information should be returned in the result?
1046 | @inlinable
1047 | public static func zrevrangebyscore<T>(
warning: Parameter 'range' not found in type method declaration
--> ../Commands/SortedSetCommands.swift:1067:13-1067:117
1065 | /// - Parameters:
1066 | /// - key: The key of the SortedSet.
1067 + /// - range: The maximum score bound an element in the SortedSet should have to be included in the response.
| ╰─suggestion: Remove 'range' parameter documentation
1068 | /// - limit: The optional offset and count of elements to query.
1069 | /// - resultOption: What information should be returned in the result?
warning: Parameter 'maxScore' is missing documentation
--> ../Commands/SortedSetCommands.swift:1069:79-1069:79
1067 | /// - range: The maximum score bound an element in the SortedSet should have to be included in the response.
1068 | /// - limit: The optional offset and count of elements to query.
| ╰─suggestion: Document 'maxScore' parameter
1069 + /// - resultOption: What information should be returned in the result?
1070 | @inlinable
1071 | public static func zrevrangebyscore<T>(
warning: External name 'aggregateMethod' used to document parameter
--> ../Commands/SortedSetCommands.swift:1120:15-1120:30
1118 | /// - sources: The list of sorted set keys to treat as the source of the union.
1119 | /// - weights: The multiplying factor to apply to the corresponding `sources` key based on index of the two parameters.
1120 + /// - aggregateMethod: The method of aggregating the values of the union. If one isn't specified, Redis will default to `.sum`.
| ╰─suggestion: Replace 'aggregateMethod' with 'aggregate'
1121 | public static func zunionstore(
1122 | as destination: RedisKey,
warning: Parameter 'encoder' is missing documentation
--> ../Commands/StringCommands.swift:381:95-381:95
379 | /// - expiration: The expiration to set on the `key` when setting the value. If `nil`, no expiration will be set.
380 | /// - eventLoop: An optional event loop to hop to for any further chaining on the returned event loop future.
| ╰─suggestion: Document 'encoder' parameter
381 + /// - logger: An optional logger instance to use for logs generated from this command.
382 | /// - Returns: A `NIO.EventLoopFuture` indicating the result of the operation; `.ok` if successful and `.conditionNotMet` if the given `condition` was not meth.
383 | ///
warning: Parameter 'encoder' is missing documentation
--> ../Commands/StringCommands.swift:381:95-381:95
379 | /// - expiration: The expiration to set on the `key` when setting the value. If `nil`, no expiration will be set.
380 | /// - eventLoop: An optional event loop to hop to for any further chaining on the returned event loop future.
| ╰─suggestion: Document 'encoder' parameter
381 + /// - logger: An optional logger instance to use for logs generated from this command.
382 | /// - Returns: A `NIO.EventLoopFuture` indicating the result of the operation; `.ok` if successful and `.conditionNotMet` if the given `condition` was not meth.
383 | ///
warning: Parameter 'encoder' is missing documentation
--> ../Commands/StringCommands.swift:381:95-381:95
379 | /// - expiration: The expiration to set on the `key` when setting the value. If `nil`, no expiration will be set.
380 | /// - eventLoop: An optional event loop to hop to for any further chaining on the returned event loop future.
| ╰─suggestion: Document 'encoder' parameter
381 + /// - logger: An optional logger instance to use for logs generated from this command.
382 | /// - Returns: A `NIO.EventLoopFuture` indicating the result of the operation; `.ok` if successful and `.conditionNotMet` if the given `condition` was not meth.
383 | ///
warning: 'DocumentationExtension' doesn't change default configuration and has no effect
--> Symbol Extensions/RedisCommand.md:4:5-4:51
2 |
3 | @Metadata {
4 + @DocumentationExtension(mergeBehavior: append)
| ╰─suggestion: Remove this 'DocumentationExtension' directive.
5 | }
6 |
warning: 'DocumentationExtension' doesn't change default configuration and has no effect
--> Symbol Extensions/RedisCommand.md:4:5-4:51
2 |
3 | @Metadata {
4 + @DocumentationExtension(mergeBehavior: append)
| ╰─suggestion: Remove this 'DocumentationExtension' directive.
5 | }
6 |
warning: Parameter 'eventLoop' is missing documentation
--> ../RedisConnection.swift:290:82-290:82
288 | /// - logger: An optional logger instance to use while trying to close the connection.
| ╰─suggestion: Document 'eventLoop' parameter
289 | ///
290 + /// If one is not provided, the connection will use its default logger.
291 | /// - Returns: A `NIO.EventLoopFuture` that resolves when the connection has been closed.
292 | @discardableResult
Finished building documentation for 'RediStack' (0.56s)
Generated documentation archive at:
/Users/admin/builder/spi-builder-workspace/.docs/swift-server/redistack/2.0.0-gamma.1.1
Updating https://github.com/apple/swift-atomics.git
Updating https://github.com/apple/swift-nio.git
Updating https://github.com/apple/swift-collections.git
Updating https://github.com/apple/swift-system.git
Updating https://github.com/apple/swift-log.git
Updating https://github.com/apple/swift-service-discovery
Updating https://github.com/apple/swift-metrics.git
Updated https://github.com/apple/swift-atomics.git (0.48s)
Fetching https://github.com/swiftlang/swift-docc-plugin from cache
Updated https://github.com/apple/swift-system.git (0.53s)
Updated https://github.com/apple/swift-log.git (0.54s)
Updated https://github.com/apple/swift-collections.git (0.54s)
Updated https://github.com/apple/swift-metrics.git (0.73s)
Updated https://github.com/apple/swift-nio.git (0.73s)
Updated https://github.com/apple/swift-service-discovery (0.73s)
Fetched https://github.com/swiftlang/swift-docc-plugin from cache (0.48s)
Computing version for https://github.com/apple/swift-service-discovery
Computed https://github.com/apple/swift-service-discovery at 1.4.0 (1.47s)
Computing version for https://github.com/apple/swift-atomics.git
Computed https://github.com/apple/swift-atomics.git at 1.2.0 (0.47s)
Computing version for https://github.com/apple/swift-nio.git
Computed https://github.com/apple/swift-nio.git at 2.82.0 (0.66s)
Computing version for https://github.com/apple/swift-metrics.git
Computed https://github.com/apple/swift-metrics.git at 2.6.1 (0.46s)
Computing version for https://github.com/apple/swift-log.git
Computed https://github.com/apple/swift-log.git at 1.6.3 (0.46s)
Computing version for https://github.com/apple/swift-system.git
Computed https://github.com/apple/swift-system.git at 1.4.2 (0.45s)
Computing version for https://github.com/apple/swift-collections.git
Computed https://github.com/apple/swift-collections.git at 1.1.4 (0.64s)
Computing version for https://github.com/swiftlang/swift-docc-plugin
Computed https://github.com/swiftlang/swift-docc-plugin at 1.4.3 (0.55s)
Fetching https://github.com/swiftlang/swift-docc-symbolkit from cache
Fetched https://github.com/swiftlang/swift-docc-symbolkit from cache (0.77s)
Computing version for https://github.com/swiftlang/swift-docc-symbolkit
Computed https://github.com/swiftlang/swift-docc-symbolkit at 1.0.0 (1.39s)
Creating working copy for https://github.com/swiftlang/swift-docc-symbolkit
Working copy of https://github.com/swiftlang/swift-docc-symbolkit resolved at 1.0.0
Creating working copy for https://github.com/swiftlang/swift-docc-plugin
Working copy of https://github.com/swiftlang/swift-docc-plugin resolved at 1.4.3
Building for debugging...
[0/8] Write sources
[1/8] Write snippet-extract-tool-entitlement.plist
[4/8] Write swift-version-2F0A5646E1D333AE.txt
[6/53] Compiling SymbolKit GenericConstraint.swift
[7/53] Compiling SymbolKit GenericParameter.swift
[8/53] Compiling SymbolKit Generics.swift
[9/53] Compiling SymbolKit Namespace.swift
[10/57] Compiling SymbolKit DeclarationFragments.swift
[11/57] Compiling SymbolKit Fragment.swift
[12/57] Compiling SymbolKit FragmentKind.swift
[13/57] Compiling SymbolKit FunctionParameter.swift
[14/57] Compiling SymbolKit FunctionSignature.swift
[15/57] Emitting module SymbolKit
[16/57] Compiling SymbolKit Mixin+Equals.swift
[17/57] Compiling SymbolKit Mixin+Hash.swift
[18/57] Compiling SymbolKit Mixin.swift
[19/57] Compiling SymbolKit LineList.swift
[20/57] Compiling SymbolKit Position.swift
[21/57] Compiling SymbolKit Names.swift
[22/57] Compiling SymbolKit SPI.swift
[23/57] Compiling SymbolKit Snippet.swift
[24/57] Compiling SymbolKit Extension.swift
[25/57] Compiling SymbolKit SourceRange.swift
[26/57] Compiling SymbolKit Metadata.swift
[27/57] Compiling SymbolKit Module.swift
[28/57] Compiling SymbolKit OperatingSystem.swift
[29/57] Compiling SymbolKit Platform.swift
[30/57] Compiling SymbolKit SemanticVersion.swift
[31/57] Compiling SymbolKit AccessControl.swift
[32/57] Compiling SymbolKit Availability.swift
[33/57] Compiling SymbolKit AvailabilityItem.swift
[34/57] Compiling SymbolKit Domain.swift
[35/57] Compiling SymbolKit Relationship.swift
[36/57] Compiling SymbolKit RelationshipKind.swift
[37/57] Compiling SymbolKit SourceOrigin.swift
[38/57] Compiling SymbolKit GenericConstraints.swift
[39/57] Compiling SymbolKit Swift.swift
[40/57] Compiling SymbolKit Identifier.swift
[41/57] Compiling SymbolKit KindIdentifier.swift
[42/57] Compiling SymbolKit Location.swift
[43/57] Compiling SymbolKit Mutability.swift
[44/57] Compiling SymbolKit Symbol.swift
[45/57] Compiling SymbolKit SymbolKind.swift
[46/57] Compiling SymbolKit SymbolGraph.swift
[47/57] Compiling SymbolKit GraphCollector.swift
[48/57] Compiling SymbolKit UnifiedSymbol+Encodable.swift
[49/57] Compiling SymbolKit UnifiedSymbol.swift
[50/57] Compiling SymbolKit UnifiedSymbolGraph+Encodable.swift
[51/57] Compiling SymbolKit UnifiedSymbolGraph.swift
[52/57] Compiling Snippets Snippet.swift
[53/57] Compiling Snippets SnippetParser.swift
[54/57] Emitting module Snippets
[55/61] Compiling snippet_extract URL+Status.swift
[56/61] Compiling snippet_extract SymbolGraph+Snippet.swift
[57/61] Emitting module snippet_extract
[58/61] Compiling snippet_extract SnippetBuildCommand.swift
[58/61] Write Objects.LinkFileList
[59/61] Linking snippet-extract-tool
[60/61] Applying snippet-extract-tool
Build of product 'snippet-extract' complete! (3.73s)
Building for debugging...
[0/1] Write swift-version-2F0A5646E1D333AE.txt
[2/58] Compiling Atomics OptionalRawRepresentable.swift
[3/58] Compiling Atomics RawRepresentable.swift
[4/59] Compiling Atomics ManagedAtomic.swift
[5/59] Compiling Atomics ManagedAtomicLazyReference.swift
[6/59] Compiling InternalCollectionsUtilities UnsafeBufferPointer+Extras.swift
[7/59] Compiling Atomics AtomicStorage.swift
[8/59] Compiling Atomics AtomicValue.swift
[9/59] Compiling Atomics AtomicMemoryOrderings.swift
[10/59] Compiling Atomics DoubleWord.swift
[11/59] Compiling Logging MetadataProvider.swift
[14/61] Compiling _NIODataStructures PriorityQueue.swift
[15/61] Compiling Atomics UnsafeAtomic.swift
[16/61] Compiling Atomics UnsafeAtomicLazyReference.swift
[21/61] Compiling InternalCollectionsUtilities UnsafeMutableBufferPointer+Extras.swift
[22/61] Compiling NIOConcurrencyHelpers NIOLock.swift
[23/61] Emitting module _NIOBase64
[24/61] Compiling _NIOBase64 Base64.swift
[25/61] Compiling _NIODataStructures Heap.swift
[26/61] Compiling _NIODataStructures _TinyArray.swift
[27/61] Compiling NIOConcurrencyHelpers lock.swift
[28/61] Compiling Atomics IntegerOperations.swift
[29/61] Compiling Atomics Unmanaged extensions.swift
[30/61] Compiling NIOConcurrencyHelpers NIOAtomic.swift
[31/61] Emitting module _NIODataStructures
[32/61] Compiling Atomics AtomicOptionalWrappable.swift
[33/61] Compiling Atomics AtomicReference.swift
[34/61] Compiling Atomics Primitives.shims.swift
[35/61] Compiling Atomics AtomicInteger.swift
[36/61] Compiling NIOConcurrencyHelpers NIOLockedValueBox.swift
[37/61] Compiling NIOConcurrencyHelpers atomics.swift
[38/61] Emitting module NIOConcurrencyHelpers
[39/61] Emitting module InternalCollectionsUtilities
[42/61] Emitting module CoreMetrics
[43/61] Compiling CoreMetrics Locks.swift
[44/61] Compiling CoreMetrics Metrics.swift
[47/61] Compiling Atomics PointerConformances.swift
[48/61] Compiling Atomics Primitives.native.swift
[49/61] Compiling Atomics AtomicBool.swift
[50/61] Compiling Atomics IntegerConformances.swift
[55/63] Compiling Logging LogHandler.swift
[58/63] Compiling Logging Locks.swift
[59/63] Emitting module Logging
[60/63] Compiling Logging Logging.swift
[61/79] Compiling DequeModule _DequeSlot.swift
[62/80] Emitting module Metrics
[63/80] Compiling Metrics Metrics.swift
[64/80] Compiling DequeModule _DequeBufferHeader.swift
[65/80] Compiling DequeModule Deque+Testing.swift
[66/80] Compiling DequeModule Deque._Storage.swift
[67/80] Compiling DequeModule _DequeBuffer.swift
[68/80] Compiling DequeModule _UnsafeWrappedBuffer.swift
[69/80] Emitting module Atomics
[70/80] Compiling DequeModule Deque+Extras.swift
[71/80] Compiling DequeModule Deque+Hashable.swift
[72/80] Compiling DequeModule Deque._UnsafeHandle.swift
[73/80] Compiling DequeModule Deque.swift
[74/80] Compiling DequeModule Deque+CustomReflectable.swift
[75/80] Compiling DequeModule Deque+Descriptions.swift
[76/80] Compiling DequeModule Deque+Equatable.swift
[77/80] Compiling DequeModule Deque+ExpressibleByArrayLiteral.swift
[78/80] Compiling DequeModule Deque+Codable.swift
[79/80] Compiling DequeModule Deque+Collection.swift
[80/80] Emitting module DequeModule
[81/91] Emitting module ServiceDiscovery
[82/151] Compiling ServiceDiscovery ServiceDiscovery+Combinators.swift
[83/151] Compiling ServiceDiscovery ServiceDiscovery.swift
[84/151] Compiling ServiceDiscovery MapServiceServiceDiscovery.swift
[85/151] Compiling ServiceDiscovery ServiceDiscovery+TypeErased.swift
[86/151] Compiling ServiceDiscovery ServiceDiscovery+AsyncAwait.swift
[87/151] Compiling ServiceDiscovery MapInstanceServiceDiscovery.swift
[88/151] Compiling ServiceDiscovery InMemoryServiceDiscovery.swift
[89/151] Compiling ServiceDiscovery FilterInstanceServiceDiscovery.swift
[90/151] Compiling ServiceDiscovery HostPort.swift
[91/151] Compiling NIOCore GlobalSingletons.swift
[92/151] Compiling NIOCore IO.swift
[93/151] Compiling NIOCore IOData.swift
[94/151] Compiling NIOCore IPProtocol.swift
[95/151] Compiling NIOCore IntegerBitPacking.swift
[96/151] Compiling NIOCore IntegerTypes.swift
[97/157] Compiling NIOCore Interfaces.swift
[98/157] Compiling NIOCore Linux.swift
[99/157] Compiling NIOCore MarkedCircularBuffer.swift
[100/157] Compiling NIOCore MulticastChannel.swift
[101/157] Compiling NIOCore NIOAny.swift
[102/157] Compiling NIOCore NIOCloseOnErrorHandler.swift
[103/157] Compiling NIOCore EventLoopFuture+AssumeIsolated.swift
[104/157] Compiling NIOCore EventLoopFuture+Deprecated.swift
[105/157] Compiling NIOCore EventLoopFuture+WithEventLoop.swift
[106/157] Compiling NIOCore EventLoopFuture.swift
[107/157] Compiling NIOCore FileDescriptor.swift
[108/157] Compiling NIOCore FileHandle.swift
[109/157] Compiling NIOCore FileRegion.swift
[110/157] Compiling NIOCore NIOLoopBound.swift
[111/157] Compiling NIOCore NIOScheduledCallback.swift
[112/157] Compiling NIOCore NIOSendable.swift
[113/157] Compiling NIOCore RecvByteBufferAllocator.swift
[114/157] Compiling NIOCore SingleStepByteToMessageDecoder.swift
[115/157] Compiling NIOCore SocketAddresses.swift
[116/157] Compiling NIOCore Codec.swift
[117/157] Compiling NIOCore ConvenienceOptionSupport.swift
[118/157] Compiling NIOCore DeadChannel.swift
[119/157] Compiling NIOCore DispatchQueue+WithFuture.swift
[120/157] Compiling NIOCore EventLoop+Deprecated.swift
[121/157] Compiling NIOCore EventLoop+SerialExecutor.swift
[122/157] Compiling NIOCore EventLoop.swift
[123/157] Compiling NIOCore SocketOptionProvider.swift
[124/157] Compiling NIOCore SystemCallHelpers.swift
[125/157] Compiling NIOCore TimeAmount+Duration.swift
[126/157] Compiling NIOCore TypeAssistedChannelHandler.swift
[127/157] Compiling NIOCore UniversalBootstrapSupport.swift
[128/157] Compiling NIOCore Utilities.swift
[129/157] Compiling NIOCore NIOAsyncSequenceProducerStrategies.swift
[130/157] Compiling NIOCore NIOAsyncWriter.swift
[131/157] Compiling NIOCore NIOThrowingAsyncSequenceProducer.swift
[132/157] Compiling NIOCore BSDSocketAPI.swift
[133/157] Compiling NIOCore ByteBuffer-aux.swift
[134/157] Compiling NIOCore ByteBuffer-binaryEncodedLengthPrefix.swift
[135/157] Compiling NIOCore ByteBuffer-conversions.swift
[136/157] Compiling NIOCore Channel.swift
[137/157] Compiling NIOCore ChannelHandler.swift
[138/157] Compiling NIOCore ChannelHandlers.swift
[139/157] Compiling NIOCore ChannelInvoker.swift
[140/157] Compiling NIOCore ChannelOption.swift
[141/157] Compiling NIOCore ChannelPipeline.swift
[142/157] Compiling NIOCore CircularBuffer.swift
[143/157] Compiling NIOCore AddressedEnvelope.swift
[144/157] Compiling NIOCore AsyncAwaitSupport.swift
[145/157] Compiling NIOCore AsyncChannel.swift
[146/157] Compiling NIOCore AsyncChannelHandler.swift
[147/157] Compiling NIOCore AsyncChannelInboundStream.swift
[148/157] Compiling NIOCore AsyncChannelOutboundWriter.swift
[149/157] Compiling NIOCore NIOAsyncSequenceProducer.swift
[150/157] Compiling NIOCore ByteBuffer-core.swift
[151/157] Compiling NIOCore ByteBuffer-hex.swift
[152/157] Compiling NIOCore ByteBuffer-int.swift
[153/157] Compiling NIOCore ByteBuffer-lengthPrefix.swift
[154/157] Compiling NIOCore ByteBuffer-multi-int.swift
[155/157] Compiling NIOCore ByteBuffer-quicBinaryEncodingStrategy.swift
[156/157] Compiling NIOCore ByteBuffer-views.swift
[157/157] Emitting module NIOCore
[158/206] Compiling NIOPosix SocketProtocols.swift
[159/206] Compiling NIOPosix System.swift
[160/206] Compiling NIOPosix Thread.swift
[161/206] Compiling NIOPosix ThreadPosix.swift
[162/206] Compiling NIOPosix ThreadWindows.swift
[163/211] Compiling NIOPosix LinuxCPUSet.swift
[164/211] Compiling NIOPosix LinuxUring.swift
[165/211] Compiling NIOPosix MultiThreadedEventLoopGroup.swift
[166/211] Compiling NIOPosix NIOThreadPool.swift
[167/211] Compiling NIOPosix NonBlockingFileIO.swift
[168/211] Compiling NIOPosix BSDSocketAPICommon.swift
[169/211] Compiling NIOPosix BSDSocketAPIPosix.swift
[170/211] Compiling NIOPosix BSDSocketAPIWindows.swift
[171/211] Compiling NIOPosix BaseSocket.swift
[172/211] Compiling NIOPosix BaseSocketChannel+SocketOptionProvider.swift
[173/211] Compiling NIOPosix BaseSocketChannel.swift
[174/211] Compiling NIOPosix SelectorKqueue.swift
[175/211] Compiling NIOPosix SelectorUring.swift
[176/211] Compiling NIOPosix ServerSocket.swift
[177/211] Compiling NIOPosix Socket.swift
[178/211] Compiling NIOPosix SocketChannel.swift
[179/211] Compiling NIOPosix Selectable.swift
[180/211] Compiling NIOPosix SelectableChannel.swift
[181/211] Compiling NIOPosix SelectableEventLoop.swift
[182/211] Compiling NIOPosix SelectorEpoll.swift
[183/211] Compiling NIOPosix SelectorGeneric.swift
[184/211] Compiling NIOPosix PendingDatagramWritesManager.swift
[185/211] Compiling NIOPosix PendingWritesManager.swift
[186/211] Compiling NIOPosix PipeChannel.swift
[187/211] Compiling NIOPosix PipePair.swift
[188/211] Compiling NIOPosix Pool.swift
[189/211] Compiling NIOPosix PooledRecvBufferAllocator.swift
[190/211] Compiling NIOPosix PosixSingletons+ConcurrencyTakeOver.swift
[191/211] Compiling NIOPosix PosixSingletons.swift
[192/211] Compiling NIOPosix RawSocketBootstrap.swift
[193/211] Compiling NIOPosix Resolver.swift
[194/211] Compiling NIOPosix UnsafeTransfer.swift
[195/211] Compiling NIOPosix Utilities.swift
[196/211] Compiling NIOPosix VsockAddress.swift
[197/211] Compiling NIOPosix VsockChannelEvents.swift
[198/211] Compiling NIOPosix resource_bundle_accessor.swift
[199/211] Emitting module NIOPosix
[200/211] Compiling NIOPosix BaseStreamSocketChannel.swift
[201/211] Compiling NIOPosix Bootstrap.swift
[202/211] Compiling NIOPosix ControlMessage.swift
[203/211] Compiling NIOPosix DatagramVectorReadManager.swift
[204/211] Compiling NIOPosix Errors+Any.swift
[205/211] Compiling NIOPosix FileDescriptor.swift
[206/211] Compiling NIOPosix GetaddrinfoResolver.swift
[207/211] Compiling NIOPosix HappyEyeballs.swift
[208/211] Compiling NIOPosix IO.swift
[209/211] Compiling NIOPosix IntegerBitPacking.swift
[210/211] Compiling NIOPosix IntegerTypes.swift
[211/211] Compiling NIOPosix Linux.swift
[212/242] Compiling RediStack ConnectionPoolErrors.swift
[213/242] Compiling RediStack StandardLibrary.swift
[214/242] Compiling RediStack SwiftNIO.swift
[215/245] Compiling RediStack PubSubCommands.swift
[216/245] Compiling RediStack RedisCommand.swift
[217/245] Compiling RediStack ServerCommands.swift
[218/245] Compiling RediStack SetCommands.swift
[219/245] Compiling RediStack RedisByteDecoder.swift
[220/245] Compiling RediStack RedisCommandHandler.swift
[221/245] Compiling RediStack RedisMessageEncoder.swift
[222/245] Compiling RediStack RedisPubSubHandler.swift
[223/245] Compiling RediStack RESPTranslator.swift
[224/245] Compiling RediStack RESPValue.swift
[225/245] Compiling RediStack RESPValueConvertible.swift
[226/245] Compiling RediStack RedisLogging.swift
[227/245] Compiling RediStack RedisMetrics.swift
[228/245] Compiling RediStack _Deprecations.swift
[229/245] Emitting module RediStack
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/ListCommands.swift:546:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
544 | // MARK: - Shared implementations
545 | extension RedisCommand {
546 | fileprivate static func _bpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
547 | keyword: String,
548 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1347:36: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1345 | // MARK: - Shared implementations
1346 | extension RedisCommand {
1347 | fileprivate static func _bzpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1348 | keyword: String,
1349 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1401:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1399 | }
1400 |
1401 | fileprivate static func _zpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1402 | keyword: String,
1403 | _ count: Int?,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:503:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
501 |
502 | extension RedisCommand {
503 | fileprivate static func _mset<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
504 | keyword: String,
505 | _ operations: [RedisKey: RESPValueConvertible],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[230/245] Compiling RediStack ConnectionCommands.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/ListCommands.swift:546:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
544 | // MARK: - Shared implementations
545 | extension RedisCommand {
546 | fileprivate static func _bpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
547 | keyword: String,
548 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[231/245] Compiling RediStack HashCommands.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/ListCommands.swift:546:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
544 | // MARK: - Shared implementations
545 | extension RedisCommand {
546 | fileprivate static func _bpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
547 | keyword: String,
548 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[232/245] Compiling RediStack KeyCommands.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/ListCommands.swift:546:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
544 | // MARK: - Shared implementations
545 | extension RedisCommand {
546 | fileprivate static func _bpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
547 | keyword: String,
548 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[233/245] Compiling RediStack ListCommands.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/ListCommands.swift:546:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
544 | // MARK: - Shared implementations
545 | extension RedisCommand {
546 | fileprivate static func _bpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
547 | keyword: String,
548 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[234/245] Compiling RediStack RedisConnection.swift
[235/245] Compiling RediStack RedisConnectionPool+Configuration.swift
[236/245] Compiling RediStack RedisConnectionPool.swift
[237/245] Compiling RediStack RedisChannelName.swift
[238/245] Compiling RediStack RedisClient.swift
[239/245] Compiling RediStack RedisConnection+Configuration.swift
[240/245] Compiling RediStack RedisError.swift
[241/245] Compiling RediStack RedisKey+TTL.swift
[242/245] Compiling RediStack RedisKey.swift
[243/245] Compiling RediStack SortedSetCommands.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1347:36: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1345 | // MARK: - Shared implementations
1346 | extension RedisCommand {
1347 | fileprivate static func _bzpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1348 | keyword: String,
1349 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1401:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1399 | }
1400 |
1401 | fileprivate static func _zpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1402 | keyword: String,
1403 | _ count: Int?,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:503:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
501 |
502 | extension RedisCommand {
503 | fileprivate static func _mset<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
504 | keyword: String,
505 | _ operations: [RedisKey: RESPValueConvertible],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[244/245] Compiling RediStack StringCommands.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1347:36: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1345 | // MARK: - Shared implementations
1346 | extension RedisCommand {
1347 | fileprivate static func _bzpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1348 | keyword: String,
1349 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1401:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1399 | }
1400 |
1401 | fileprivate static func _zpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1402 | keyword: String,
1403 | _ count: Int?,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:503:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
501 |
502 | extension RedisCommand {
503 | fileprivate static func _mset<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
504 | keyword: String,
505 | _ operations: [RedisKey: RESPValueConvertible],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
[245/245] Compiling RediStack ConnectionPool.swift
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1347:36: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1345 | // MARK: - Shared implementations
1346 | extension RedisCommand {
1347 | fileprivate static func _bzpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1348 | keyword: String,
1349 | _ keys: [RedisKey],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1401:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1399 | }
1400 |
1401 | fileprivate static func _zpop<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
1402 | keyword: String,
1403 | _ count: Int?,
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:503:35: warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
501 |
502 | extension RedisCommand {
503 | fileprivate static func _mset<ResultType>(
| `- warning: generic parameter 'ResultType' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
504 | keyword: String,
505 | _ operations: [RedisKey: RESPValueConvertible],
/Users/admin/builder/spi-builder-workspace/Sources/RediStack/Commands/RedisCommand.swift:24:28: note: 'ResultType' previously declared here
22 | ///
23 | /// When creating a `RedisCommand`, a closure is provided for transforming an arbitrary `RESPValue` instance into the `ResultType`.
24 | public struct RedisCommand<ResultType> {
| `- note: 'ResultType' previously declared here
25 | public let keyword: String
26 | public let arguments: [RESPValue]
Build of target: 'RediStack' complete! (6.56s)
Target: RedisTypes
Extracting symbol information for 'RedisTypes'...
Finished extracting symbol information for 'RedisTypes'. (1.20s)
Building documentation for 'RedisTypes'...
warning: Parameter 'members' not found in instance method declaration
--> Sources/RedisTypes/RedisSet.swift:154:21-154:28
152 | ///
153 | /// See `RediStack.RedisClient.srem(_:from:)`
154 + /// - Parameter members: The element in the set to remove.
| ╰─suggestion: Replace 'members' with 'member'
155 | /// - Returns: A `NIO.EventLoopFuture<Bool>` resolving `true` if `member` was removed from the set; otherwise, `false`.
156 | public func remove(_ member: Element) -> EventLoopFuture<Bool> {
warning: Parameter 'member' is missing documentation
--> Sources/RedisTypes/RedisSet.swift:154:63-154:63
152 | ///
153 | /// See `RediStack.RedisClient.srem(_:from:)`
154 + /// - Parameter members: The element in the set to remove.
| ╰─suggestion: Document 'member' parameter
155 | /// - Returns: A `NIO.EventLoopFuture<Bool>` resolving `true` if `member` was removed from the set; otherwise, `false`.
156 | public func remove(_ member: Element) -> EventLoopFuture<Bool> {
Finished building documentation for 'RedisTypes' (0.08s)
Generated documentation archive at:
/Users/admin/builder/spi-builder-workspace/.docs/swift-server/redistack/2.0.0-gamma.1.1
Building for debugging...
[0/3] Write swift-version-2F0A5646E1D333AE.txt
Build of product 'snippet-extract' complete! (0.45s)
Building for debugging...
[0/1] Write swift-version-2F0A5646E1D333AE.txt
[2/3] Emitting module RedisTypes
[3/3] Compiling RedisTypes RedisSet.swift
Build of target: 'RedisTypes' complete! (1.00s)
Successfully merged into /Users/admin/builder/spi-builder-workspace/.docs-staging/swift-server/redistack/2.0.0-gamma.1.1/index/index.json
Successfully merged into /Users/admin/builder/spi-builder-workspace/.docs-staging/swift-server/redistack/2.0.0-gamma.1.1/linkable-paths.json
Target: RediStackTestUtils
Extracting symbol information for 'RediStackTestUtils'...
Finished extracting symbol information for 'RediStackTestUtils'. (3.29s)
Building documentation for 'RediStackTestUtils'...
Finished building documentation for 'RediStackTestUtils' (0.06s)
Generated documentation archive at:
/Users/admin/builder/spi-builder-workspace/.docs/swift-server/redistack/2.0.0-gamma.1.1
Building for debugging...
[0/3] Write swift-version-2F0A5646E1D333AE.txt
Build of product 'snippet-extract' complete! (0.60s)
Building for debugging...
[0/1] Write swift-version-2F0A5646E1D333AE.txt
[2/5] Compiling NIOEmbedded AsyncTestingChannel.swift
[3/5] Compiling NIOEmbedded Embedded.swift
[4/5] Emitting module NIOEmbedded
[5/5] Compiling NIOEmbedded AsyncTestingEventLoop.swift
[6/12] Compiling RediStackTestUtils _Deprecations.swift
[7/12] Emitting module RediStackTestUtils
[8/12] Compiling RediStackTestUtils General.swift
[9/12] Compiling RediStackTestUtils RedisConnectionPoolIntegrationTestCase.swift
[10/12] Compiling RediStackTestUtils RedisIntegrationTestCase.swift
[11/12] Compiling RediStackTestUtils RediStack.swift
[12/12] Compiling RediStackTestUtils EmbeddedMockRedisServer.swift
Build of target: 'RediStackTestUtils' complete! (1.46s)
Successfully merged into /Users/admin/builder/spi-builder-workspace/.docs-staging/swift-server/redistack/2.0.0-gamma.1.1/index/index.json
Successfully merged into /Users/admin/builder/spi-builder-workspace/.docs-staging/swift-server/redistack/2.0.0-gamma.1.1/linkable-paths.json
1794
16 /Users/admin/builder/spi-builder-workspace/.docs/swift-server/redistack/2.0.0-gamma.1.1
✅ Doc result (uploading) reported
========================================
SyncDocs
========================================
Doc archive source directory: $PWD/.docs/swift-server/redistack/2.0.0-gamma.1.1
File count: 1794
Doc size: 16.0MB
Preparing doc bundle ...
Uploading prod-swift-server-redistack-2.0.0-gamma.1.1-ee07d9b1.zip to s3://spi-docs-inbox/prod-swift-server-redistack-2.0.0-gamma.1.1-ee07d9b1.zip
Copying... [11%]
Copying... [20%]
Copying... [32%]
Copying... [41%]
Copying... [52%]
Copying... [61%]
Copying... [70%]
Copying... [81%]
Copying... [91%]
Copying... [100%]
Done.