Swift Package IndexBuild Information
Successful build of RediStack, reference 2.0.0-gamma.1.1 (8ac2d7), with Swift 6.1 for Linux on 27 Apr 2025 20:08:07 UTC.
Swift 6 data race errors: 19
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4606859-1":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.1-latest swift build --triple x86_64-unknown-linux-gnu -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 InferSendableFromCaptures 2>&1Build Log
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],
/host/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]
/host/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,
/host/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,
/host/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()
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:47:23: warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
45 |
46 | /// The wrapped `Metrics.Gauge` maintaining the current number of connections this library has active.
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
| |- warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeConnectionCount' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeConnectionCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:49:23: warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
| |- warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeChannelSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeChannelSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:51:23: warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
| |- warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activePatternSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activePatternSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | /// The `Metrics.Counter` that retains the number of connections made since application startup.
53 | public static let totalConnectionCount = Counter(label: .totalConnectionCount)
[266/286] Compiling RediStack HashCommands.swift
/host/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],
/host/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]
[267/286] Compiling RediStack KeyCommands.swift
/host/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],
/host/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]
[268/286] Compiling RediStack ListCommands.swift
/host/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],
/host/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]
[269/286] Compiling RediStack PubSubCommands.swift
/host/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],
/host/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]
[270/286] Compiling RediStack StringCommands.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:410:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
411 |
412 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:415:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
413 | ///
414 | /// Redis documentation refers to this as the option "XX".
415 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
416 |
417 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:420:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
418 | ///
419 | /// Redis documentation refers to this as the option "NX".
420 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
421 |
422 | private enum Condition: String, Hashable {
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:447:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
440 | ///
441 | /// See [SET](https://redis.io/commands/set)
442 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
443 | /// Retain the existing expiration associated with the key, if one exists.
444 | ///
445 | /// Redis documentation refers to this as "KEEPTTL".
446 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
447 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
448 |
449 | /// Expire the key after the given number of seconds.
/host/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],
/host/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]
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:127:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
125 | } else {
126 | self.loop.execute {
127 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
128 | }
129 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:139:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
137 | } else {
138 | self.loop.execute {
139 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
140 | }
141 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:149:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
147 | return self._leaseConnection(logger: logger, deadline: deadline)
148 | } else {
149 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
150 | return self._leaseConnection(logger: logger, deadline: deadline)
151 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:150:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
148 | } else {
149 | return self.loop.flatSubmit {
150 | return self._leaseConnection(logger: logger, deadline: deadline)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
151 | }
152 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
161 | }
162 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
161 | }
162 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:196:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
194 |
195 | self.loop.scheduleTask(in: delay) {
196 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:198:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
196 | self.connectionFactory(self.loop)
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
199 |
200 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:493:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
489 | }
490 |
491 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
492 | assert(self.timeoutTask == nil)
493 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
494 | }
495 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:498:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
496 | func succeed(_ connection: RedisConnection) {
497 | self.timeoutTask?.cancel()
498 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
499 | }
500 |
/host/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()
[271/286] Compiling RediStack ConnectionPool.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:410:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
411 |
412 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:415:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
413 | ///
414 | /// Redis documentation refers to this as the option "XX".
415 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
416 |
417 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:420:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
418 | ///
419 | /// Redis documentation refers to this as the option "NX".
420 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
421 |
422 | private enum Condition: String, Hashable {
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:447:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
440 | ///
441 | /// See [SET](https://redis.io/commands/set)
442 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
443 | /// Retain the existing expiration associated with the key, if one exists.
444 | ///
445 | /// Redis documentation refers to this as "KEEPTTL".
446 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
447 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
448 |
449 | /// Expire the key after the given number of seconds.
/host/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],
/host/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]
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:127:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
125 | } else {
126 | self.loop.execute {
127 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
128 | }
129 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:139:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
137 | } else {
138 | self.loop.execute {
139 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
140 | }
141 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:149:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
147 | return self._leaseConnection(logger: logger, deadline: deadline)
148 | } else {
149 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
150 | return self._leaseConnection(logger: logger, deadline: deadline)
151 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:150:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
148 | } else {
149 | return self.loop.flatSubmit {
150 | return self._leaseConnection(logger: logger, deadline: deadline)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
151 | }
152 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
161 | }
162 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
161 | }
162 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:196:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
194 |
195 | self.loop.scheduleTask(in: delay) {
196 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:198:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
196 | self.connectionFactory(self.loop)
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
199 |
200 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:493:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
489 | }
490 |
491 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
492 | assert(self.timeoutTask == nil)
493 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
494 | }
495 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:498:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
496 | func succeed(_ connection: RedisConnection) {
497 | self.timeoutTask?.cancel()
498 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
499 | }
500 |
/host/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()
[272/286] Compiling RediStack ConnectionPoolErrors.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:410:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
411 |
412 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:415:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
413 | ///
414 | /// Redis documentation refers to this as the option "XX".
415 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
416 |
417 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:420:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
418 | ///
419 | /// Redis documentation refers to this as the option "NX".
420 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
421 |
422 | private enum Condition: String, Hashable {
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:447:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
440 | ///
441 | /// See [SET](https://redis.io/commands/set)
442 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
443 | /// Retain the existing expiration associated with the key, if one exists.
444 | ///
445 | /// Redis documentation refers to this as "KEEPTTL".
446 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
447 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
448 |
449 | /// Expire the key after the given number of seconds.
/host/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],
/host/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]
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:127:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
125 | } else {
126 | self.loop.execute {
127 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
128 | }
129 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:139:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
137 | } else {
138 | self.loop.execute {
139 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
140 | }
141 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:149:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
147 | return self._leaseConnection(logger: logger, deadline: deadline)
148 | } else {
149 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
150 | return self._leaseConnection(logger: logger, deadline: deadline)
151 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:150:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
148 | } else {
149 | return self.loop.flatSubmit {
150 | return self._leaseConnection(logger: logger, deadline: deadline)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
151 | }
152 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
161 | }
162 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
161 | }
162 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:196:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
194 |
195 | self.loop.scheduleTask(in: delay) {
196 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:198:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
196 | self.connectionFactory(self.loop)
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
199 |
200 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:493:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
489 | }
490 |
491 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
492 | assert(self.timeoutTask == nil)
493 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
494 | }
495 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:498:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
496 | func succeed(_ connection: RedisConnection) {
497 | self.timeoutTask?.cancel()
498 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
499 | }
500 |
/host/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()
[273/286] Compiling RediStack StandardLibrary.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:410:23: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
| |- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'none' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
411 |
412 | /// Only set the key if it already exists.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:415:23: warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
413 | ///
414 | /// Redis documentation refers to this as the option "XX".
415 | public static let keyExists = RedisSetCommandCondition(.keyExists)
| |- warning: static property 'keyExists' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyExists' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
416 |
417 | /// Only set the key if it does not already exist.
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:420:23: warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
406 | ///
407 | /// See [SET](https://redis.io/commands/set)
408 | public struct RedisSetCommandCondition: Hashable {
| `- note: consider making struct 'RedisSetCommandCondition' conform to the 'Sendable' protocol
409 | /// No condition is required to be met in order to set the key's value.
410 | public static let none = RedisSetCommandCondition(.none)
:
418 | ///
419 | /// Redis documentation refers to this as the option "NX".
420 | public static let keyDoesNotExist = RedisSetCommandCondition(.keyDoesNotExist)
| |- warning: static property 'keyDoesNotExist' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandCondition' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keyDoesNotExist' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
421 |
422 | private enum Condition: String, Hashable {
/host/spi-builder-workspace/Sources/RediStack/Commands/StringCommands.swift:447:23: warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
440 | ///
441 | /// See [SET](https://redis.io/commands/set)
442 | public struct RedisSetCommandExpiration: Hashable {
| `- note: consider making struct 'RedisSetCommandExpiration' conform to the 'Sendable' protocol
443 | /// Retain the existing expiration associated with the key, if one exists.
444 | ///
445 | /// Redis documentation refers to this as "KEEPTTL".
446 | /// - Important: This is option is only available in Redis 6.0+. An error will be returned if this value is sent in lower versions of Redis.
447 | public static let keepExisting = RedisSetCommandExpiration(.keepExisting)
| |- warning: static property 'keepExisting' is not concurrency-safe because non-'Sendable' type 'RedisSetCommandExpiration' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'keepExisting' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
448 |
449 | /// Expire the key after the given number of seconds.
/host/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],
/host/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]
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:127:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
125 | } else {
126 | self.loop.execute {
127 | self.refillConnections(logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
128 | }
129 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:139:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
137 | } else {
138 | self.loop.execute {
139 | self.closePool(promise: promise, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
140 | }
141 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:149:30: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
147 | return self._leaseConnection(logger: logger, deadline: deadline)
148 | } else {
149 | return self.loop.flatSubmit {
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
150 | return self._leaseConnection(logger: logger, deadline: deadline)
151 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:150:24: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
148 | } else {
149 | return self.loop.flatSubmit {
150 | return self._leaseConnection(logger: logger, deadline: deadline)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
151 | }
152 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:17: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
161 | }
162 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:160:46: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
158 | } else {
159 | return self.loop.execute {
160 | self._returnLeasedConnection(connection, logger: logger)
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
161 | }
162 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:196:13: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
194 |
195 | self.loop.scheduleTask(in: delay) {
196 | self.connectionFactory(self.loop)
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:198:21: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
196 | self.connectionFactory(self.loop)
197 | .whenComplete { result in
198 | self.loop.preconditionInEventLoop()
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
199 |
200 | self.pendingConnectionCount -= 1
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:64: warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
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>
:
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'self' with non-sendable type 'ConnectionPool' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:233:90: warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
231 | // Great, we want this. We'll be "returning" it to the pool. First,
232 | // attach the close callback to it.
233 | connection.channel.closeFuture.whenComplete { _ in self.poolConnectionClosed(connection, logger: logger) }
| `- warning: capture of 'connection' with non-sendable type 'RedisConnection' in a '@Sendable' closure
234 | self._returnConnection(connection, logger: logger)
235 | }
/host/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()
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:493:70: warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
489 | }
490 |
491 | mutating func scheduleDeadline(loop: EventLoop, deadline: NIODeadline, _ onTimeout: @escaping () -> Void) {
| `- note: parameter 'onTimeout' is implicitly non-sendable
492 | assert(self.timeoutTask == nil)
493 | self.timeoutTask = loop.scheduleTask(deadline: deadline, onTimeout)
| `- warning: passing non-sendable parameter 'onTimeout' to function expecting a @Sendable closure
494 | }
495 |
/host/spi-builder-workspace/Sources/RediStack/ConnectionPool/ConnectionPool.swift:498:25: warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
496 | func succeed(_ connection: RedisConnection) {
497 | self.timeoutTask?.cancel()
498 | self.result.succeed(connection)
| `- warning: type 'RedisConnection' does not conform to the 'Sendable' protocol
499 | }
500 |
/host/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()
[274/286] Compiling RediStack RedisByteDecoder.swift
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:103:25: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
101 |
102 | default:
103 | leadPromise.succeed(value)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
104 | RedisMetrics.commandSuccessCount.increment()
105 | }
/host/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)
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:24: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:50: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:68: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.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'
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:48: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
251 | }
252 |
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:77: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
251 | }
252 |
[275/286] Compiling RediStack RedisCommandHandler.swift
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:103:25: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
101 |
102 | default:
103 | leadPromise.succeed(value)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
104 | RedisMetrics.commandSuccessCount.increment()
105 | }
/host/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)
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:24: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:50: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:68: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.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'
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:48: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
251 | }
252 |
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:77: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
251 | }
252 |
[276/286] Compiling RediStack RedisMessageEncoder.swift
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:103:25: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
101 |
102 | default:
103 | leadPromise.succeed(value)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
104 | RedisMetrics.commandSuccessCount.increment()
105 | }
/host/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)
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:24: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:50: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:68: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.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'
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:48: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
251 | }
252 |
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:77: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
251 | }
252 |
[277/286] Compiling RediStack RedisPubSubHandler.swift
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:103:25: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
101 |
102 | default:
103 | leadPromise.succeed(value)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
104 | RedisMetrics.commandSuccessCount.increment()
105 | }
/host/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)
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:24: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:50: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:68: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.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'
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:48: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
251 | }
252 |
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:77: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
251 | }
252 |
[278/286] Compiling RediStack ConnectionCommands.swift
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisCommandHandler.swift:103:25: warning: type 'RESPValue' does not conform to the 'Sendable' protocol
101 |
102 | default:
103 | leadPromise.succeed(value)
| `- warning: type 'RESPValue' does not conform to the 'Sendable' protocol
104 | RedisMetrics.commandSuccessCount.increment()
105 | }
/host/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)
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:24: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:50: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.addSubscription(for: target, receiver: receiver)
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:208:68: warning: capture of 'receiver' with non-sendable type 'RedisPubSubEventReceiver' (aka '(RedisPubSubEvent) -> ()') in a '@Sendable' closure
206 | guard self.eventLoop.inEventLoop else {
207 | return self.eventLoop.flatSubmit {
208 | return self.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'
209 | }
210 | }
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:48: warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
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 |
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'self' with non-sendable type 'RedisPubSubHandler' in a '@Sendable' closure
251 | }
252 |
/host/spi-builder-workspace/Sources/RediStack/ChannelHandlers/RedisPubSubHandler.swift:250:77: warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
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])
:
248 | public func removeSubscription(for target: RedisSubscriptionTarget) -> EventLoopFuture<Int> {
249 | guard self.eventLoop.inEventLoop else {
250 | return self.eventLoop.flatSubmit { self.removeSubscription(for: target) }
| `- warning: capture of 'target' with non-sendable type 'RedisSubscriptionTarget' in a '@Sendable' closure
251 | }
252 |
[279/286] Compiling RediStack RedisCommand.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1183:23: warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
| |- warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'allElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1185:23: warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
| |- warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyNewElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1187:23: warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
:
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
| |- warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyExistingElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1188 |
1189 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1212:23: warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
| |- warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'changedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1214:23: warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
| |- warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'insertedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1215 |
1216 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1268:23: warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
| |- warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'sum' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1270:23: warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
| |- warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'min' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1272:23: warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
:
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
| |- warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'max' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1273 |
1274 | internal var string: String { self.option.rawValue }
/host/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],
/host/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]
/host/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?,
/host/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]
[280/286] Compiling RediStack ServerCommands.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1183:23: warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
| |- warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'allElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1185:23: warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
| |- warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyNewElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1187:23: warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
:
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
| |- warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyExistingElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1188 |
1189 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1212:23: warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
| |- warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'changedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1214:23: warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
| |- warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'insertedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1215 |
1216 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1268:23: warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
| |- warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'sum' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1270:23: warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
| |- warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'min' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1272:23: warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
:
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
| |- warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'max' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1273 |
1274 | internal var string: String { self.option.rawValue }
/host/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],
/host/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]
/host/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?,
/host/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]
[281/286] Compiling RediStack SetCommands.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1183:23: warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
| |- warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'allElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1185:23: warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
| |- warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyNewElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1187:23: warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
:
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
| |- warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyExistingElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1188 |
1189 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1212:23: warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
| |- warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'changedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1214:23: warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
| |- warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'insertedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1215 |
1216 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1268:23: warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
| |- warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'sum' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1270:23: warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
| |- warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'min' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1272:23: warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
:
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
| |- warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'max' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1273 |
1274 | internal var string: String { self.option.rawValue }
/host/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],
/host/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]
/host/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?,
/host/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]
[282/286] Compiling RediStack SortedSetCommands.swift
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1183:23: warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
| |- warning: static property 'allElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'allElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1185:23: warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
1184 | /// Only insert new elements; do not update the score of existing elements.
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
| |- warning: static property 'onlyNewElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyNewElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1187:23: warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1179 | ///
1180 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options).
1181 | public struct RedisZaddInsertBehavior {
| `- note: consider making struct 'RedisZaddInsertBehavior' conform to the 'Sendable' protocol
1182 | /// Insert new elements and update the score of existing elements.
1183 | public static let allElements = RedisZaddInsertBehavior(nil)
:
1185 | public static let onlyNewElements = RedisZaddInsertBehavior(.nx)
1186 | /// Only update the score of existing elements; do not insert new elements.
1187 | public static let onlyExistingElements = RedisZaddInsertBehavior(.xx)
| |- warning: static property 'onlyExistingElements' is not concurrency-safe because non-'Sendable' type 'RedisZaddInsertBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'onlyExistingElements' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1188 |
1189 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1212:23: warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
| |- warning: static property 'changedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'changedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1214:23: warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
1208 | ///
1209 | /// See [ZADD Options](https://redis.io/commands/zadd#zadd-options)
1210 | public struct RedisZaddReturnBehavior {
| `- note: consider making struct 'RedisZaddReturnBehavior' conform to the 'Sendable' protocol
1211 | /// Count both new elements that were inserted into the SortedSet and existing elements that had their score updated.
1212 | public static let changedElementsCount = RedisZaddReturnBehavior(.ch)
1213 | /// Count only new elements that were inserted into the SortedSet.
1214 | public static let insertedElementsCount = RedisZaddReturnBehavior(nil)
| |- warning: static property 'insertedElementsCount' is not concurrency-safe because non-'Sendable' type 'RedisZaddReturnBehavior' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'insertedElementsCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1215 |
1216 | @usableFromInline
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1268:23: warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
| |- warning: static property 'sum' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'sum' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1270:23: warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
1269 | /// Use the minimum score of the matching elements in the source SortedSets.
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
| |- warning: static property 'min' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'min' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
/host/spi-builder-workspace/Sources/RediStack/Commands/SortedSetCommands.swift:1272:23: warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
1264 | ///
1265 | /// See the documentation for each individual command that uses this object for more details.
1266 | public struct RedisSortedSetAggregateMethod {
| `- note: consider making struct 'RedisSortedSetAggregateMethod' conform to the 'Sendable' protocol
1267 | /// Add the score of all matching elements in the source SortedSets.
1268 | public static let sum = RedisSortedSetAggregateMethod(.sum)
:
1270 | public static let min = RedisSortedSetAggregateMethod(.min)
1271 | /// Use the maximum score of the matching elements in the source SortedSets.
1272 | public static let max = RedisSortedSetAggregateMethod(.max)
| |- warning: static property 'max' is not concurrency-safe because non-'Sendable' type 'RedisSortedSetAggregateMethod' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: add '@MainActor' to make static property 'max' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
1273 |
1274 | internal var string: String { self.option.rawValue }
/host/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],
/host/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]
/host/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?,
/host/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]
[283/286] Compiling RediStack RedisKey.swift
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:47:23: warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
45 |
46 | /// The wrapped `Metrics.Gauge` maintaining the current number of connections this library has active.
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
| |- warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeConnectionCount' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeConnectionCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:49:23: warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
| |- warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeChannelSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeChannelSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:51:23: warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
| |- warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activePatternSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activePatternSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | /// The `Metrics.Counter` that retains the number of connections made since application startup.
53 | public static let totalConnectionCount = Counter(label: .totalConnectionCount)
[284/286] Compiling RediStack RedisLogging.swift
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:47:23: warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
45 |
46 | /// The wrapped `Metrics.Gauge` maintaining the current number of connections this library has active.
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
| |- warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeConnectionCount' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeConnectionCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:49:23: warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
| |- warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeChannelSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeChannelSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:51:23: warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
| |- warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activePatternSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activePatternSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | /// The `Metrics.Counter` that retains the number of connections made since application startup.
53 | public static let totalConnectionCount = Counter(label: .totalConnectionCount)
[285/286] Compiling RediStack RedisMetrics.swift
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:47:23: warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
45 |
46 | /// The wrapped `Metrics.Gauge` maintaining the current number of connections this library has active.
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
| |- warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeConnectionCount' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeConnectionCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:49:23: warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
| |- warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeChannelSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeChannelSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:51:23: warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
| |- warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activePatternSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activePatternSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | /// The `Metrics.Counter` that retains the number of connections made since application startup.
53 | public static let totalConnectionCount = Counter(label: .totalConnectionCount)
[286/286] Compiling RediStack _Deprecations.swift
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:47:23: warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
45 |
46 | /// The wrapped `Metrics.Gauge` maintaining the current number of connections this library has active.
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
| |- warning: static property 'activeConnectionCount' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeConnectionCount' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeConnectionCount' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:49:23: warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
47 | public static var activeConnectionCount = IncrementalGauge(.activeConnectionCount)
48 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channels.
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
| |- warning: static property 'activeChannelSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activeChannelSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activeChannelSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
/host/spi-builder-workspace/Sources/RediStack/RedisMetrics.swift:51:23: warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
49 | public static var activeChannelSubscriptions = IncrementalGauge(.activeChannelSubscriptions)
50 | /// The wrapped `Metrics.Gauge` maintaining the current number of subscriptions to channel patterns.
51 | public static var activePatternSubscriptions = IncrementalGauge(.activePatternSubscriptions)
| |- warning: static property 'activePatternSubscriptions' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'activePatternSubscriptions' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: add '@MainActor' to make static property 'activePatternSubscriptions' part of global actor 'MainActor'
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
52 | /// The `Metrics.Counter` that retains the number of connections made since application startup.
53 | public static let totalConnectionCount = Counter(label: .totalConnectionCount)
[288/296] Compiling RediStackTestUtils RediStack.swift
[289/296] Compiling RediStackTestUtils _Deprecations.swift
[290/296] Compiling RediStackTestUtils General.swift
[291/296] Emitting module RedisTypes
[292/296] Compiling RedisTypes RedisSet.swift
/host/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) }
[293/297] Compiling RediStackTestUtils RedisConnectionPoolIntegrationTestCase.swift
[294/297] Compiling RediStackTestUtils RedisIntegrationTestCase.swift
/host/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 | }
/host/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 | }
/host/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()
/host/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 |
[295/297] Compiling RediStackTestUtils EmbeddedMockRedisServer.swift
/host/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:
/host/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)
/host/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
/host/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 |
[296/297] Emitting module RediStackTestUtils
Build complete! (53.44s)
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" : "/host/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"
}
basic-6.1-latest: Pulling from finestructure/spi-images
Digest: sha256:3bdcac04179f4ed3e5b8e9dbd6e74bbf5ebc0f4fde48bbaad7d1e5c757e65bcb
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.1-latest
Done.