Swift Package IndexBuild Information
Successful build of redi-s, reference develop (24dacc), with Swift 6.0 for Linux on 4 Nov 2024 06:43:39 UTC.
Swift 6 data race errors: 18
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete 2>&1Build Log
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:17:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
15 | import Dispatch
16 | import NIO
17 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
18 | import struct Foundation.Data
19 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:45:13: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
43 | pubsub.Q.async {
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:46:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
47 | pubsub.subscribe(key, handler: ctx.handler)
48 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:51:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 |
50 | ctx.eventLoop.execute {
51 | if ctx.handler.subscribedChannels == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
52 | ctx.handler.subscribedChannels = Set()
53 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:76:12: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
74 | pubsub.Q.async {
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:77:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
78 | pubsub.unsubscribe(key, handler: ctx.handler)
79 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:82:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
80 |
81 | ctx.eventLoop.execute {
82 | ctx.handler.subscribedChannels?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:108:13: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
106 | pubsub.Q.async {
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:109:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
110 | pubsub.subscribe(key, handler: ctx.handler)
111 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:114:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 |
113 | ctx.eventLoop.execute {
114 | if ctx.handler.subscribedPatterns == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
115 | ctx.handler.subscribedPatterns = Set()
116 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:143:12: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
141 | pubsub.Q.async {
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:144:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
145 | pubsub.unsubscribe(key, handler: ctx.handler)
146 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:149:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
147 |
148 | ctx.eventLoop.execute {
149 | ctx.handler.subscribedPatterns?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:21: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:218:30: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
216 |
217 | for channel in channels {
218 | guard let loop2Sub = pubSub.channelToEventLoopToSubscribers[channel],
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | !loop2Sub.isEmpty else {
220 | channelCountPairs.append(RESPValue(bulkString: channel))
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:230:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | }
229 |
230 | ctx.write(.array(channelCountPairs))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
231 | }
232 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:241:36: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
239 | var channels = ContiguousArray<RESPValue>()
240 |
241 | for ( channel, loop2Sub ) in pubSub.channelToEventLoopToSubscribers {
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
242 | guard !loop2Sub.isEmpty else { continue }
243 | if let pattern = pattern {
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:257:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
255 | }
256 |
257 | ctx.write(.array(channels))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
258 | }
259 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
[275/287] Compiling RedisServer KeyCommands.swift
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:21:14: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
19 |
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
| `- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
13 | //===----------------------------------------------------------------------===//
14 |
15 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
16 | import struct NIORedis.RESPError
17 | import struct NIO.ByteBuffer
:
19 |
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
| |- note: annotate 'none' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:22:14: warning: static property 'string' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
22 | static let string = RESPValue(simpleString: "string")
| |- warning: static property 'string' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'string' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:23:14: warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
21 | static let none = RESPValue(simpleString: "none")
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
| |- warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'list' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
24 | static let set = RESPValue(simpleString: "set")
25 | static let hash = RESPValue(simpleString: "hash")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:24:14: warning: static property 'set' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
| |- warning: static property 'set' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'set' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
25 | static let hash = RESPValue(simpleString: "hash")
26 | }
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:25:14: warning: static property 'hash' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
25 | static let hash = RESPValue(simpleString: "hash")
| |- warning: static property 'hash' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hash' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 | }
27 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:67:47: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
65 | ctx.get(key) { value in
66 | ctx.eventLoop.execute {
67 | guard let value = value else { return ctx.write(TypeValues.none) }
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
68 |
69 | switch value {
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:28:19: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
26 | let pubsub = ctx.handler.server.pubSub
27 | pubsub.Q.async {
28 | let count = pubsub.publish(channel, message)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
29 | ctx.write(count)
30 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:29:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
27 | pubsub.Q.async {
28 | let count = pubsub.publish(channel, message)
29 | ctx.write(count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
30 | }
31 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:47:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:47:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:17:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
15 | import Dispatch
16 | import NIO
17 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
18 | import struct Foundation.Data
19 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:45:13: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
43 | pubsub.Q.async {
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:46:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
47 | pubsub.subscribe(key, handler: ctx.handler)
48 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:51:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 |
50 | ctx.eventLoop.execute {
51 | if ctx.handler.subscribedChannels == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
52 | ctx.handler.subscribedChannels = Set()
53 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:76:12: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
74 | pubsub.Q.async {
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:77:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
78 | pubsub.unsubscribe(key, handler: ctx.handler)
79 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:82:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
80 |
81 | ctx.eventLoop.execute {
82 | ctx.handler.subscribedChannels?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:108:13: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
106 | pubsub.Q.async {
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:109:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
110 | pubsub.subscribe(key, handler: ctx.handler)
111 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:114:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 |
113 | ctx.eventLoop.execute {
114 | if ctx.handler.subscribedPatterns == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
115 | ctx.handler.subscribedPatterns = Set()
116 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:143:12: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
141 | pubsub.Q.async {
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:144:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
145 | pubsub.unsubscribe(key, handler: ctx.handler)
146 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:149:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
147 |
148 | ctx.eventLoop.execute {
149 | ctx.handler.subscribedPatterns?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:21: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:218:30: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
216 |
217 | for channel in channels {
218 | guard let loop2Sub = pubSub.channelToEventLoopToSubscribers[channel],
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | !loop2Sub.isEmpty else {
220 | channelCountPairs.append(RESPValue(bulkString: channel))
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:230:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | }
229 |
230 | ctx.write(.array(channelCountPairs))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
231 | }
232 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:241:36: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
239 | var channels = ContiguousArray<RESPValue>()
240 |
241 | for ( channel, loop2Sub ) in pubSub.channelToEventLoopToSubscribers {
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
242 | guard !loop2Sub.isEmpty else { continue }
243 | if let pattern = pattern {
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:257:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
255 | }
256 |
257 | ctx.write(.array(channels))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
258 | }
259 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
[276/287] Compiling RedisServer ListCommands.swift
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:21:14: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
19 |
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
| `- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
13 | //===----------------------------------------------------------------------===//
14 |
15 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
16 | import struct NIORedis.RESPError
17 | import struct NIO.ByteBuffer
:
19 |
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
| |- note: annotate 'none' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:22:14: warning: static property 'string' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
22 | static let string = RESPValue(simpleString: "string")
| |- warning: static property 'string' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'string' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:23:14: warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
21 | static let none = RESPValue(simpleString: "none")
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
| |- warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'list' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
24 | static let set = RESPValue(simpleString: "set")
25 | static let hash = RESPValue(simpleString: "hash")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:24:14: warning: static property 'set' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
| |- warning: static property 'set' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'set' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
25 | static let hash = RESPValue(simpleString: "hash")
26 | }
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:25:14: warning: static property 'hash' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
25 | static let hash = RESPValue(simpleString: "hash")
| |- warning: static property 'hash' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hash' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 | }
27 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:67:47: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
65 | ctx.get(key) { value in
66 | ctx.eventLoop.execute {
67 | guard let value = value else { return ctx.write(TypeValues.none) }
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
68 |
69 | switch value {
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:28:19: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
26 | let pubsub = ctx.handler.server.pubSub
27 | pubsub.Q.async {
28 | let count = pubsub.publish(channel, message)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
29 | ctx.write(count)
30 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:29:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
27 | pubsub.Q.async {
28 | let count = pubsub.publish(channel, message)
29 | ctx.write(count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
30 | }
31 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:47:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:47:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:17:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
15 | import Dispatch
16 | import NIO
17 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
18 | import struct Foundation.Data
19 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:45:13: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
43 | pubsub.Q.async {
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:46:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
47 | pubsub.subscribe(key, handler: ctx.handler)
48 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:51:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 |
50 | ctx.eventLoop.execute {
51 | if ctx.handler.subscribedChannels == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
52 | ctx.handler.subscribedChannels = Set()
53 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:76:12: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
74 | pubsub.Q.async {
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:77:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
78 | pubsub.unsubscribe(key, handler: ctx.handler)
79 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:82:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
80 |
81 | ctx.eventLoop.execute {
82 | ctx.handler.subscribedChannels?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:108:13: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
106 | pubsub.Q.async {
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:109:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
110 | pubsub.subscribe(key, handler: ctx.handler)
111 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:114:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 |
113 | ctx.eventLoop.execute {
114 | if ctx.handler.subscribedPatterns == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
115 | ctx.handler.subscribedPatterns = Set()
116 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:143:12: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
141 | pubsub.Q.async {
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:144:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
145 | pubsub.unsubscribe(key, handler: ctx.handler)
146 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:149:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
147 |
148 | ctx.eventLoop.execute {
149 | ctx.handler.subscribedPatterns?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:21: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:218:30: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
216 |
217 | for channel in channels {
218 | guard let loop2Sub = pubSub.channelToEventLoopToSubscribers[channel],
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | !loop2Sub.isEmpty else {
220 | channelCountPairs.append(RESPValue(bulkString: channel))
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:230:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | }
229 |
230 | ctx.write(.array(channelCountPairs))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
231 | }
232 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:241:36: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
239 | var channels = ContiguousArray<RESPValue>()
240 |
241 | for ( channel, loop2Sub ) in pubSub.channelToEventLoopToSubscribers {
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
242 | guard !loop2Sub.isEmpty else { continue }
243 | if let pattern = pattern {
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:257:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
255 | }
256 |
257 | ctx.write(.array(channels))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
258 | }
259 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
[277/287] Compiling RedisServer PubSubCommands.swift
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:21:14: warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
19 |
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
| `- warning: static property 'none' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:15:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
13 | //===----------------------------------------------------------------------===//
14 |
15 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
16 | import struct NIORedis.RESPError
17 | import struct NIO.ByteBuffer
:
19 |
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
| |- note: annotate 'none' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:22:14: warning: static property 'string' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
20 | fileprivate enum TypeValues {
21 | static let none = RESPValue(simpleString: "none")
22 | static let string = RESPValue(simpleString: "string")
| |- warning: static property 'string' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'string' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:23:14: warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
21 | static let none = RESPValue(simpleString: "none")
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
| |- warning: static property 'list' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'list' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
24 | static let set = RESPValue(simpleString: "set")
25 | static let hash = RESPValue(simpleString: "hash")
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:24:14: warning: static property 'set' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
22 | static let string = RESPValue(simpleString: "string")
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
| |- warning: static property 'set' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'set' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
25 | static let hash = RESPValue(simpleString: "hash")
26 | }
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:25:14: warning: static property 'hash' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
23 | static let list = RESPValue(simpleString: "list")
24 | static let set = RESPValue(simpleString: "set")
25 | static let hash = RESPValue(simpleString: "hash")
| |- warning: static property 'hash' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'hash' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
26 | }
27 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/KeyCommands.swift:67:47: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
65 | ctx.get(key) { value in
66 | ctx.eventLoop.execute {
67 | guard let value = value else { return ctx.write(TypeValues.none) }
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
68 |
69 | switch value {
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:28:19: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
26 | let pubsub = ctx.handler.server.pubSub
27 | pubsub.Q.async {
28 | let count = pubsub.publish(channel, message)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
29 | ctx.write(count)
30 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:29:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
27 | pubsub.Q.async {
28 | let count = pubsub.publish(channel, message)
29 | ctx.write(count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
30 | }
31 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:47:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:47:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
48 | }
49 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:17:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
15 | import Dispatch
16 | import NIO
17 | import enum NIORedis.RESPValue
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
18 | import struct Foundation.Data
19 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:45:13: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
43 | pubsub.Q.async {
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
46 | subscribedChannels.insert(key)
47 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:46:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
44 | for key in channelKeys {
45 | if !subscribedChannels.contains(key) {
46 | subscribedChannels.insert(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
47 | pubsub.subscribe(key, handler: ctx.handler)
48 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:51:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 |
50 | ctx.eventLoop.execute {
51 | if ctx.handler.subscribedChannels == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
52 | ctx.handler.subscribedChannels = Set()
53 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:56:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
54 | ctx.handler.subscribedChannels!.insert(key)
55 | let count = ctx.handler.subscribedChannels!.count
56 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 | RESPValue(bulkString: key),
58 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:78:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | }
80 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:76:12: warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
74 | pubsub.Q.async {
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
| `- warning: reference to captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
77 | subscribedChannels.remove(key)
78 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:77:11: warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
75 | for key in channelKeys {
76 | if subscribedChannels.contains(key) {
77 | subscribedChannels.remove(key)
| `- warning: mutation of captured var 'subscribedChannels' in concurrently-executing code; this is an error in the Swift 6 language mode
78 | pubsub.unsubscribe(key, handler: ctx.handler)
79 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:82:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
80 |
81 | ctx.eventLoop.execute {
82 | ctx.handler.subscribedChannels?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:84:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | ctx.handler.subscribedChannels?.remove(key)
83 | let count = ctx.handler.subscribedChannels?.count ?? 0
84 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
85 | RESPValue(bulkString: key),
86 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:110:42: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
111 | }
112 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:108:13: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
106 | pubsub.Q.async {
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
109 | subscribedPatterns.insert(key)
110 | pubsub.subscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:109:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
107 | for ( bb, key ) in patterns {
108 | if !subscribedPatterns.contains(key) {
109 | subscribedPatterns.insert(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
110 | pubsub.subscribe(key, handler: ctx.handler)
111 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:114:14: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 |
113 | ctx.eventLoop.execute {
114 | if ctx.handler.subscribedPatterns == nil {
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
115 | ctx.handler.subscribedPatterns = Set()
116 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:119:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
117 | ctx.handler.subscribedPatterns!.insert(key)
118 | let count = ctx.handler.subscribedPatterns!.count
119 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | RESPValue.bulkString(bb),
121 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:11: warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'pubsub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:145:44: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
146 | }
147 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:143:12: warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
141 | pubsub.Q.async {
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
| `- warning: reference to captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
144 | subscribedPatterns.remove(key)
145 | pubsub.unsubscribe(key, handler: ctx.handler)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:144:11: warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
142 | for ( bb, key ) in patterns {
143 | if subscribedPatterns.contains(key) {
144 | subscribedPatterns.remove(key)
| `- warning: mutation of captured var 'subscribedPatterns' in concurrently-executing code; this is an error in the Swift 6 language mode
145 | pubsub.unsubscribe(key, handler: ctx.handler)
146 | }
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:149:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
147 |
148 | ctx.eventLoop.execute {
149 | ctx.handler.subscribedPatterns?.remove(key)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:151:23: warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
149 | ctx.handler.subscribedPatterns?.remove(key)
150 | let count = ctx.handler.subscribedPatterns?.count ?? 0
151 | ctx.write([ subscribeCmd,
| `- warning: capture of 'subscribeCmd' with non-sendable type 'RESPValue' in a `@Sendable` closure; this is an error in the Swift 6 language mode
152 | RESPValue.bulkString(bb),
153 | RESPValue.integer(count) ].toRESPValue())
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:11: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:202:21: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
200 | let pubSub = ctx.handler.server.pubSub
201 | pubSub.Q.async {
202 | ctx.write(pubSub.patternToEventLoopToSubscribers.count)
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
203 | }
204 |
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:218:30: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
216 |
217 | for channel in channels {
218 | guard let loop2Sub = pubSub.channelToEventLoopToSubscribers[channel],
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | !loop2Sub.isEmpty else {
220 | channelCountPairs.append(RESPValue(bulkString: channel))
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:230:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | }
229 |
230 | ctx.write(.array(channelCountPairs))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
231 | }
232 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:241:36: warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
239 | var channels = ContiguousArray<RESPValue>()
240 |
241 | for ( channel, loop2Sub ) in pubSub.channelToEventLoopToSubscribers {
| `- warning: capture of 'pubSub' with non-sendable type 'PubSub' in a `@Sendable` closure; this is an error in the Swift 6 language mode
242 | guard !loop2Sub.isEmpty else { continue }
243 | if let pattern = pattern {
/host/spi-builder-workspace/Sources/RedisServer/Server/PubSub.swift:20:7: note: class 'PubSub' does not conform to the 'Sendable' protocol
18 | import enum NIORedis.RESPValue
19 |
20 | class PubSub {
| `- note: class 'PubSub' does not conform to the 'Sendable' protocol
21 |
22 | typealias SubscriberList = ContiguousArray<RedisCommandHandler>
/host/spi-builder-workspace/Sources/RedisServer/Commands/PubSubCommands.swift:257:7: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
255 | }
256 |
257 | ctx.write(.array(channels))
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
258 | }
259 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
[278/287] Compiling RedisServer StringCommands.swift
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/StringCommands.swift:227:47: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
225 |
226 | ctx.eventLoop.execute {
227 | guard let value = value else { return ctx.write(.bulkString(nil)) }
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | ctx.write(value)
229 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:122:7: warning: capture of 'cb' with non-sendable type '(Date, TimeInterval) -> Void' (aka '(Date, Double) -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | func getLastSave(_ cb: @escaping ( Date, TimeInterval ) -> Void) {
121 | Q.async {
122 | cb(self.lastSave, self.lastSaveDuration)
| |- warning: capture of 'cb' with non-sendable type '(Date, TimeInterval) -> Void' (aka '(Date, Double) -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
123 | }
124 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:122:10: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
120 | func getLastSave(_ cb: @escaping ( Date, TimeInterval ) -> Void) {
121 | Q.async {
122 | cb(self.lastSave, self.lastSaveDuration)
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
123 | }
124 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:132:9: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
130 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
131 | Q.async {
132 | self.lastSave = lastSave
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | self.lastSaveDuration = diff
134 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:139:40: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
137 | Q.async {
138 | do {
139 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 | self.lastSave = lastSave
141 | self.lastSaveDuration = diff
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:139:59: warning: capture of 'databases' with non-sendable type 'Databases' in a `@Sendable` closure; this is an error in the Swift 6 language mode
137 | Q.async {
138 | do {
139 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
| `- warning: capture of 'databases' with non-sendable type 'Databases' in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 | self.lastSave = lastSave
141 | self.lastSaveDuration = diff
/host/spi-builder-workspace/Sources/RedisServer/Database/Database.swift:50:13: note: class 'Databases' does not conform to the 'Sendable' protocol
48 | * Hashable etc.
49 | */
50 | final class Databases : Codable {
| `- note: class 'Databases' does not conform to the 'Sendable' protocol
51 |
52 | typealias SavePoints = ContiguousArray<SavePoint>
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:185:29: warning: capture of 'me' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
183 | // Careful: running in DB thread
184 | me.Q.async {
185 | me._scheduleSave(in: savePoint.delay)
| `- warning: capture of 'me' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
186 | }
187 | })
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:185:50: warning: capture of 'savePoint' with non-sendable type 'Databases.SavePoint' (aka 'RedisServer.Configuration.SavePoint') in a `@Sendable` closure; this is an error in the Swift 6 language mode
183 | // Careful: running in DB thread
184 | me.Q.async {
185 | me._scheduleSave(in: savePoint.delay)
| `- warning: capture of 'savePoint' with non-sendable type 'Databases.SavePoint' (aka 'RedisServer.Configuration.SavePoint') in a `@Sendable` closure; this is an error in the Swift 6 language mode
186 | }
187 | })
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisServer.swift:32:19: note: consider making struct 'SavePoint' conform to the 'Sendable' protocol
30 | open class Configuration {
31 |
32 | public struct SavePoint {
| `- note: consider making struct 'SavePoint' conform to the 'Sendable' protocol
33 | public let delay : TimeInterval
34 | public let changeCount : Int
[279/287] Compiling RedisServer Database.swift
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/StringCommands.swift:227:47: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
225 |
226 | ctx.eventLoop.execute {
227 | guard let value = value else { return ctx.write(.bulkString(nil)) }
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | ctx.write(value)
229 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:122:7: warning: capture of 'cb' with non-sendable type '(Date, TimeInterval) -> Void' (aka '(Date, Double) -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | func getLastSave(_ cb: @escaping ( Date, TimeInterval ) -> Void) {
121 | Q.async {
122 | cb(self.lastSave, self.lastSaveDuration)
| |- warning: capture of 'cb' with non-sendable type '(Date, TimeInterval) -> Void' (aka '(Date, Double) -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
123 | }
124 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:122:10: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
120 | func getLastSave(_ cb: @escaping ( Date, TimeInterval ) -> Void) {
121 | Q.async {
122 | cb(self.lastSave, self.lastSaveDuration)
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
123 | }
124 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:132:9: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
130 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
131 | Q.async {
132 | self.lastSave = lastSave
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | self.lastSaveDuration = diff
134 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:139:40: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
137 | Q.async {
138 | do {
139 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 | self.lastSave = lastSave
141 | self.lastSaveDuration = diff
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:139:59: warning: capture of 'databases' with non-sendable type 'Databases' in a `@Sendable` closure; this is an error in the Swift 6 language mode
137 | Q.async {
138 | do {
139 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
| `- warning: capture of 'databases' with non-sendable type 'Databases' in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 | self.lastSave = lastSave
141 | self.lastSaveDuration = diff
/host/spi-builder-workspace/Sources/RedisServer/Database/Database.swift:50:13: note: class 'Databases' does not conform to the 'Sendable' protocol
48 | * Hashable etc.
49 | */
50 | final class Databases : Codable {
| `- note: class 'Databases' does not conform to the 'Sendable' protocol
51 |
52 | typealias SavePoints = ContiguousArray<SavePoint>
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:185:29: warning: capture of 'me' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
183 | // Careful: running in DB thread
184 | me.Q.async {
185 | me._scheduleSave(in: savePoint.delay)
| `- warning: capture of 'me' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
186 | }
187 | })
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:185:50: warning: capture of 'savePoint' with non-sendable type 'Databases.SavePoint' (aka 'RedisServer.Configuration.SavePoint') in a `@Sendable` closure; this is an error in the Swift 6 language mode
183 | // Careful: running in DB thread
184 | me.Q.async {
185 | me._scheduleSave(in: savePoint.delay)
| `- warning: capture of 'savePoint' with non-sendable type 'Databases.SavePoint' (aka 'RedisServer.Configuration.SavePoint') in a `@Sendable` closure; this is an error in the Swift 6 language mode
186 | }
187 | })
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisServer.swift:32:19: note: consider making struct 'SavePoint' conform to the 'Sendable' protocol
30 | open class Configuration {
31 |
32 | public struct SavePoint {
| `- note: consider making struct 'SavePoint' conform to the 'Sendable' protocol
33 | public let delay : TimeInterval
34 | public let changeCount : Int
[280/287] Compiling RedisServer DumpManager.swift
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
/host/spi-builder-workspace/Sources/RedisServer/Commands/StringCommands.swift:227:47: warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
225 |
226 | ctx.eventLoop.execute {
227 | guard let value = value else { return ctx.write(.bulkString(nil)) }
| `- warning: capture of 'ctx' with non-sendable type 'Commands.CommandContext' (aka 'RedisCommandContext') in a `@Sendable` closure; this is an error in the Swift 6 language mode
228 | ctx.write(value)
229 | }
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisCommandContext.swift:22:15: note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
20 | * The environment commands need to run.
21 | */
22 | public struct RedisCommandContext {
| `- note: consider making struct 'RedisCommandContext' conform to the 'Sendable' protocol
23 |
24 | let command : RedisCommand
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:122:7: warning: capture of 'cb' with non-sendable type '(Date, TimeInterval) -> Void' (aka '(Date, Double) -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
120 | func getLastSave(_ cb: @escaping ( Date, TimeInterval ) -> Void) {
121 | Q.async {
122 | cb(self.lastSave, self.lastSaveDuration)
| |- warning: capture of 'cb' with non-sendable type '(Date, TimeInterval) -> Void' (aka '(Date, Double) -> ()') in a `@Sendable` closure; this is an error in the Swift 6 language mode
| `- note: a function type must be marked '@Sendable' to conform to 'Sendable'
123 | }
124 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:122:10: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
120 | func getLastSave(_ cb: @escaping ( Date, TimeInterval ) -> Void) {
121 | Q.async {
122 | cb(self.lastSave, self.lastSaveDuration)
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
123 | }
124 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:132:9: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
130 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
131 | Q.async {
132 | self.lastSave = lastSave
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
133 | self.lastSaveDuration = diff
134 | }
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:139:40: warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
137 | Q.async {
138 | do {
139 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
| `- warning: capture of 'self' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 | self.lastSave = lastSave
141 | self.lastSaveDuration = diff
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:139:59: warning: capture of 'databases' with non-sendable type 'Databases' in a `@Sendable` closure; this is an error in the Swift 6 language mode
137 | Q.async {
138 | do {
139 | let ( lastSave, diff ) = try self._saveDump(of: databases, to: url)
| `- warning: capture of 'databases' with non-sendable type 'Databases' in a `@Sendable` closure; this is an error in the Swift 6 language mode
140 | self.lastSave = lastSave
141 | self.lastSaveDuration = diff
/host/spi-builder-workspace/Sources/RedisServer/Database/Database.swift:50:13: note: class 'Databases' does not conform to the 'Sendable' protocol
48 | * Hashable etc.
49 | */
50 | final class Databases : Codable {
| `- note: class 'Databases' does not conform to the 'Sendable' protocol
51 |
52 | typealias SavePoints = ContiguousArray<SavePoint>
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:185:29: warning: capture of 'me' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
50 | }
51 |
52 | class SimpleJSONDumpManager : DumpManager {
| `- note: class 'SimpleJSONDumpManager' does not conform to the 'Sendable' protocol
53 |
54 | let Q = DispatchQueue(label: "de.zeezide.nio.redisd.dump")
:
183 | // Careful: running in DB thread
184 | me.Q.async {
185 | me._scheduleSave(in: savePoint.delay)
| `- warning: capture of 'me' with non-sendable type 'SimpleJSONDumpManager' in a `@Sendable` closure; this is an error in the Swift 6 language mode
186 | }
187 | })
/host/spi-builder-workspace/Sources/RedisServer/Database/DumpManager.swift:185:50: warning: capture of 'savePoint' with non-sendable type 'Databases.SavePoint' (aka 'RedisServer.Configuration.SavePoint') in a `@Sendable` closure; this is an error in the Swift 6 language mode
183 | // Careful: running in DB thread
184 | me.Q.async {
185 | me._scheduleSave(in: savePoint.delay)
| `- warning: capture of 'savePoint' with non-sendable type 'Databases.SavePoint' (aka 'RedisServer.Configuration.SavePoint') in a `@Sendable` closure; this is an error in the Swift 6 language mode
186 | }
187 | })
/host/spi-builder-workspace/Sources/RedisServer/Server/RedisServer.swift:32:19: note: consider making struct 'SavePoint' conform to the 'Sendable' protocol
30 | open class Configuration {
31 |
32 | public struct SavePoint {
| `- note: consider making struct 'SavePoint' conform to the 'Sendable' protocol
33 | public let delay : TimeInterval
34 | public let changeCount : Int
[281/287] Compiling RedisServer RedisList.swift
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
[282/287] Compiling RedisServer RedisValue.swift
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
[283/287] Compiling RedisServer RedisValueCoding.swift
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:279:14: warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| `- warning: static property 'ok' is not concurrency-safe because non-'Sendable' type 'RESPValue' may have shared mutable state; this is an error in the Swift 6 language mode
280 | }
281 |
/host/spi-builder-workspace/.build/checkouts/swift-nio-redis/Sources/NIORedis/RESPValue.swift:18:13: note: enum 'RESPValue' does not conform to the 'Sendable' protocol
16 | import Foundation
17 |
18 | public enum RESPValue {
| `- note: enum 'RESPValue' does not conform to the 'Sendable' protocol
19 | case simpleString(ByteBuffer)
20 | case bulkString (ByteBuffer?)
/host/spi-builder-workspace/Sources/RedisServer/Values/RedisValue.swift:16:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
14 |
15 | import NIO
16 | import NIORedis
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'NIORedis'
17 | import Foundation
18 |
:
277 |
278 | extension RESPValue {
279 | static let ok = RESPValue(simpleString: "OK")
| |- note: annotate 'ok' with '@MainActor' if property should only be accessed from the main actor
| `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
280 | }
281 |
[284/288] Wrapping AST for RedisServer for debugging
[286/291] Compiling redi_s ConfigFile.swift
[287/291] Emitting module redi_s
[288/291] Compiling redi_s main.swift
[289/292] Wrapping AST for redi-s for debugging
[290/292] Write Objects.LinkFileList
[291/292] Linking redi-s
Build complete! (96.73s)
Build complete.
{
"dependencies" : [
{
"identity" : "swift-nio-redis",
"requirement" : {
"range" : [
{
"lower_bound" : "0.11.0",
"upper_bound" : "1.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/SwiftNIOExtras/swift-nio-redis.git"
},
{
"identity" : "swift-atomics",
"requirement" : {
"range" : [
{
"lower_bound" : "1.0.0",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/apple/swift-atomics"
}
],
"manifest_display_name" : "redi-s",
"name" : "redi-s",
"path" : "/host/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "RedisServer",
"targets" : [
"RedisServer"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "redi-s",
"targets" : [
"redi-s"
],
"type" : {
"executable" : null
}
}
],
"targets" : [
{
"c99name" : "redi_s",
"module_type" : "SwiftTarget",
"name" : "redi-s",
"path" : "Sources/redi-s",
"product_memberships" : [
"redi-s"
],
"sources" : [
"ConfigFile.swift",
"main.swift"
],
"target_dependencies" : [
"RedisServer"
],
"type" : "executable"
},
{
"c99name" : "RedisServer",
"module_type" : "SwiftTarget",
"name" : "RedisServer",
"path" : "Sources/RedisServer",
"product_dependencies" : [
"NIORedis",
"Atomics"
],
"product_memberships" : [
"RedisServer",
"redi-s"
],
"sources" : [
"Commands/CommandTable.swift",
"Commands/CommandType.swift",
"Commands/ExpirationCommands.swift",
"Commands/HashCommands.swift",
"Commands/IntCommands.swift",
"Commands/KeyCommands.swift",
"Commands/ListCommands.swift",
"Commands/PubSubCommands.swift",
"Commands/RedisCommand.swift",
"Commands/ServerCommands.swift",
"Commands/SetCommands.swift",
"Commands/StringCommands.swift",
"Database/Database.swift",
"Database/DumpManager.swift",
"Helpers/RedisLogger.swift",
"Helpers/RedisPattern.swift",
"Helpers/Utilities.swift",
"Server/Monitor.swift",
"Server/PubSub.swift",
"Server/RedisCommandContext.swift",
"Server/RedisCommandHandler.swift",
"Server/RedisServer.swift",
"Values/RedisError.swift",
"Values/RedisList.swift",
"Values/RedisValue.swift",
"Values/RedisValueCoding.swift"
],
"type" : "library"
}
],
"tools_version" : "5.0"
}
basic-6.0-latest: Pulling from finestructure/spi-images
Digest: sha256:47d26c99ca4f1ac0a332c85fd5b13ff4390e72115219984a57a68fe9d1063a05
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.0-latest
Done.