Swift Package IndexBuild Information
Successful build of AllCache, reference 3.8.1 (9153c5), with Swift 6.0 for macOS (SPM) on 1 Nov 2024 06:57:57 UTC.
Swift 6 data race errors: 2
Build Command
env DEVELOPER_DIR=/Applications/Xcode-16.1.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=completeBuild Log
========================================
RunAll
========================================
Builder version: 4.56.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/JuanjoArreola/AllCache.git
Reference: 3.8.1
Initialized empty Git repository in /Users/admin/builder/spi-builder-workspace/.git/
From https://github.com/JuanjoArreola/AllCache
* tag 3.8.1 -> FETCH_HEAD
HEAD is now at 9153c55 Fix log warn
Cloned https://github.com/JuanjoArreola/AllCache.git
Revision (git rev-parse @):
9153c553d51b85b0b49fef18464b54f417668b8c
SUCCESS checkout https://github.com/JuanjoArreola/AllCache.git at 3.8.1
Fetching https://github.com/JuanjoArreola/Logg.git
Fetching https://github.com/JuanjoArreola/AsyncRequest.git
[1/137] Fetching asyncrequest
[138/296] Fetching asyncrequest, logg
Fetched https://github.com/JuanjoArreola/AsyncRequest.git from cache (0.66s)
Fetched https://github.com/JuanjoArreola/Logg.git from cache (0.66s)
Computing version for https://github.com/JuanjoArreola/AsyncRequest.git
Computed https://github.com/JuanjoArreola/AsyncRequest.git at 2.3.0 (0.67s)
Computing version for https://github.com/JuanjoArreola/Logg.git
Computed https://github.com/JuanjoArreola/Logg.git at 2.4.0 (0.64s)
Creating working copy for https://github.com/JuanjoArreola/Logg.git
Working copy of https://github.com/JuanjoArreola/Logg.git resolved at 2.4.0
Creating working copy for https://github.com/JuanjoArreola/AsyncRequest.git
Working copy of https://github.com/JuanjoArreola/AsyncRequest.git resolved at 2.3.0
========================================
ResolveProductDependencies
========================================
Resolving dependencies ...
{
"identity": ".resolve-product-dependencies",
"name": "resolve-dependencies",
"url": "/Users/admin/builder/spi-builder-workspace/.resolve-product-dependencies",
"version": "unspecified",
"path": "/Users/admin/builder/spi-builder-workspace/.resolve-product-dependencies",
"dependencies": [
{
"identity": "allcache",
"name": "AllCache",
"url": "https://github.com/JuanjoArreola/AllCache.git",
"version": "unspecified",
"path": "/Users/admin/builder/spi-builder-workspace/.resolve-product-dependencies/.build/checkouts/AllCache",
"dependencies": [
{
"identity": "logg",
"name": "Logg",
"url": "https://github.com/JuanjoArreola/Logg.git",
"version": "2.4.1",
"path": "/Users/admin/builder/spi-builder-workspace/.resolve-product-dependencies/.build/checkouts/Logg",
"dependencies": [
]
},
{
"identity": "asyncrequest",
"name": "AsyncRequest",
"url": "https://github.com/JuanjoArreola/AsyncRequest.git",
"version": "2.3.0",
"path": "/Users/admin/builder/spi-builder-workspace/.resolve-product-dependencies/.build/checkouts/AsyncRequest",
"dependencies": [
]
}
]
}
]
}
Fetching https://github.com/JuanjoArreola/AllCache.git
[1/969] Fetching allcache
Fetched https://github.com/JuanjoArreola/AllCache.git from cache (0.87s)
Fetching https://github.com/JuanjoArreola/Logg.git from cache
Fetching https://github.com/JuanjoArreola/AsyncRequest.git from cache
Fetched https://github.com/JuanjoArreola/Logg.git from cache (0.49s)
Fetched https://github.com/JuanjoArreola/AsyncRequest.git from cache (0.49s)
Computing version for https://github.com/JuanjoArreola/AsyncRequest.git
Computed https://github.com/JuanjoArreola/AsyncRequest.git at 2.3.0 (0.02s)
Computing version for https://github.com/JuanjoArreola/Logg.git
Computed https://github.com/JuanjoArreola/Logg.git at 2.4.1 (0.02s)
Creating working copy for https://github.com/JuanjoArreola/AllCache.git
Working copy of https://github.com/JuanjoArreola/AllCache.git resolved at 3.8.1 (9153c55)
Creating working copy for https://github.com/JuanjoArreola/AsyncRequest.git
Working copy of https://github.com/JuanjoArreola/AsyncRequest.git resolved at 2.3.0
Creating working copy for https://github.com/JuanjoArreola/Logg.git
Working copy of https://github.com/JuanjoArreola/Logg.git resolved at 2.4.1
warning: '.resolve-product-dependencies': dependency 'allcache' is not used by any target
Found 2 product dependencies
- Logg
- AsyncRequest
========================================
Build
========================================
Selected platform: macosSpm
Swift version: 6.0
Building package at path: $PWD
https://github.com/JuanjoArreola/AllCache.git
Running build ...
env DEVELOPER_DIR=/Applications/Xcode-16.1.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete
Building for debugging...
[0/4] Write sources
[3/4] Write swift-version--7754E27361AE5C74.txt
[5/24] Compiling Logg LogLevel.swift
[6/24] Compiling AsyncRequest Cancellable.swift
[7/24] Compiling AsyncRequest RequestError.swift
[8/24] Compiling AsyncRequest RequestHandlers.swift
[9/24] Compiling AsyncRequest URLSessionRequest.swift
[10/24] Compiling AsyncRequest RequestGroup.swift
[11/24] Compiling AsyncRequest Request.swift
[12/24] Emitting module AsyncRequest
[13/24] Compiling AsyncRequest GroupRequestHandlers.swift
[14/24] Compiling AsyncRequest UUIDTimeoutRequest.swift
[15/24] Compiling AsyncRequest TimeoutRequest.swift
[16/24] Compiling Logg LogFormatter.swift
[17/24] Compiling Logg LogContext.swift
[18/24] Compiling Logg ConsoleFormatter.swift
[19/24] Compiling Logg FileLogger.swift
[20/24] Compiling Logg Logger.swift
[21/24] Emitting module Logg
[22/24] Compiling Logg ConsoleLogger.swift
[23/24] Compiling Logg DefaultFormatter.swift
[24/24] Compiling Logg CompositeLogger.swift
[25/46] Emitting module AllCache
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/ImageCache.swift:30:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
23 | import AsyncRequest
24 |
25 | open class ImageCache: Cache<Image> {
| `- note: class 'ImageCache' does not conform to the 'Sendable' protocol
26 |
27 | #if os(iOS) || os(tvOS) || os(watchOS)
28 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: PNGImageSerializer())
29 | #else
30 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: ImageSerializer())
| |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shared' 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
31 | #endif
32 |
[26/48] Compiling AllCache AllCacheFormatter.swift
[27/48] Compiling AllCache CGSize+Util.swift
[28/48] Compiling AllCache CachableDescriptor.swift
[29/48] Compiling AllCache MemoryCache.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/MemoryCache.swift:32:13: warning: capture of 'self' with non-sendable type 'MemoryCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
9 | import Foundation
10 |
11 | public final class MemoryCache<T: AnyObject> {
| `- note: generic class 'MemoryCache' does not conform to the 'Sendable' protocol
12 |
13 | private let cache = NSCache<NSString, T>()
:
30 | guard let object = object else { return }
31 | queue.async {
32 | self.cache.setObject(object, forKey: key as NSString)
| `- warning: capture of 'self' with non-sendable type 'MemoryCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
33 | }
34 | }
/Users/admin/builder/spi-builder-workspace/Sources/MemoryCache.swift:32:34: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
9 | import Foundation
10 |
11 | public final class MemoryCache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
12 |
13 | private let cache = NSCache<NSString, T>()
:
30 | guard let object = object else { return }
31 | queue.async {
32 | self.cache.setObject(object, forKey: key as NSString)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
33 | }
34 | }
/Users/admin/builder/spi-builder-workspace/Sources/Networking.swift:22:77: warning: passing non-sendable parameter 'completion' to function expecting a @Sendable closure
15 | }
16 |
17 | func request(url: URL, method: HTTPMethod = .GET, completion: @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask {
| `- note: parameter 'completion' is implicitly non-sendable
18 |
19 | var request = URLRequest(url: url)
20 | request.httpMethod = method.rawValue
21 |
22 | let task = URLSession.shared.dataTask(with: request, completionHandler: completion)
| `- warning: passing non-sendable parameter 'completion' to function expecting a @Sendable closure
23 | task.resume()
24 | return task
[30/48] Compiling AllCache Networking.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/MemoryCache.swift:32:13: warning: capture of 'self' with non-sendable type 'MemoryCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
9 | import Foundation
10 |
11 | public final class MemoryCache<T: AnyObject> {
| `- note: generic class 'MemoryCache' does not conform to the 'Sendable' protocol
12 |
13 | private let cache = NSCache<NSString, T>()
:
30 | guard let object = object else { return }
31 | queue.async {
32 | self.cache.setObject(object, forKey: key as NSString)
| `- warning: capture of 'self' with non-sendable type 'MemoryCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
33 | }
34 | }
/Users/admin/builder/spi-builder-workspace/Sources/MemoryCache.swift:32:34: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
9 | import Foundation
10 |
11 | public final class MemoryCache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
12 |
13 | private let cache = NSCache<NSString, T>()
:
30 | guard let object = object else { return }
31 | queue.async {
32 | self.cache.setObject(object, forKey: key as NSString)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
33 | }
34 | }
/Users/admin/builder/spi-builder-workspace/Sources/Networking.swift:22:77: warning: passing non-sendable parameter 'completion' to function expecting a @Sendable closure
15 | }
16 |
17 | func request(url: URL, method: HTTPMethod = .GET, completion: @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask {
| `- note: parameter 'completion' is implicitly non-sendable
18 |
19 | var request = URLRequest(url: url)
20 | request.httpMethod = method.rawValue
21 |
22 | let task = URLSession.shared.dataTask(with: request, completionHandler: completion)
| `- warning: passing non-sendable parameter 'completion' to function expecting a @Sendable closure
23 | task.resume()
24 | return task
[31/48] Compiling AllCache String+Range.swift
[32/48] Compiling AllCache UIButton+ImageCache.swift
[33/48] Compiling AllCache JPEGImageSerializer.swift
[34/48] Compiling AllCache LowMemoryHandler.swift
[35/48] Compiling AllCache PNGImageSerializer.swift
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:48:13: warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
12 | internal let syncQueue = DispatchQueue(label: "com.allcache.SyncQueue", attributes: .concurrent)
13 |
14 | class RequestingCache<T> {
| `- note: generic class 'RequestingCache' does not conform to the 'Sendable' protocol
15 |
16 | var fetching: [String: Request<FetcherResult<T>>] = [:]
:
46 | func setCached(request: Request<T>?, forIdentifier identifier: String) {
47 | syncQueue.async(flags: .barrier, execute: {
48 | self.requesting[identifier] = request
| `- warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 | })
50 | }
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:48:43: warning: capture of 'request' with non-sendable type 'Request<T>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
46 | func setCached(request: Request<T>?, forIdentifier identifier: String) {
47 | syncQueue.async(flags: .barrier, execute: {
48 | self.requesting[identifier] = request
| `- warning: capture of 'request' with non-sendable type 'Request<T>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 | })
50 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
8 |
9 | import Foundation
10 | import AsyncRequest
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
11 |
12 | internal let syncQueue = DispatchQueue(label: "com.allcache.SyncQueue", attributes: .concurrent)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:81:13: warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
12 | internal let syncQueue = DispatchQueue(label: "com.allcache.SyncQueue", attributes: .concurrent)
13 |
14 | class RequestingCache<T> {
| `- note: generic class 'RequestingCache' does not conform to the 'Sendable' protocol
15 |
16 | var fetching: [String: Request<FetcherResult<T>>] = [:]
:
79 | func setCached(fetching: Request<FetcherResult<T>>?, forIdentifier identifier: String) {
80 | syncQueue.async(flags: .barrier, execute: {
81 | self.fetching[identifier] = fetching
| `- warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | })
83 | }
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:81:41: warning: capture of 'fetching' with non-sendable type 'Request<FetcherResult<T>>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | func setCached(fetching: Request<FetcherResult<T>>?, forIdentifier identifier: String) {
80 | syncQueue.async(flags: .barrier, execute: {
81 | self.fetching[identifier] = fetching
| `- warning: capture of 'fetching' with non-sendable type 'Request<FetcherResult<T>>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | })
83 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
[36/48] Compiling AllCache RequestingCache.swift
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:48:13: warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
12 | internal let syncQueue = DispatchQueue(label: "com.allcache.SyncQueue", attributes: .concurrent)
13 |
14 | class RequestingCache<T> {
| `- note: generic class 'RequestingCache' does not conform to the 'Sendable' protocol
15 |
16 | var fetching: [String: Request<FetcherResult<T>>] = [:]
:
46 | func setCached(request: Request<T>?, forIdentifier identifier: String) {
47 | syncQueue.async(flags: .barrier, execute: {
48 | self.requesting[identifier] = request
| `- warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 | })
50 | }
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:48:43: warning: capture of 'request' with non-sendable type 'Request<T>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
46 | func setCached(request: Request<T>?, forIdentifier identifier: String) {
47 | syncQueue.async(flags: .barrier, execute: {
48 | self.requesting[identifier] = request
| `- warning: capture of 'request' with non-sendable type 'Request<T>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
49 | })
50 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
8 |
9 | import Foundation
10 | import AsyncRequest
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
11 |
12 | internal let syncQueue = DispatchQueue(label: "com.allcache.SyncQueue", attributes: .concurrent)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:81:13: warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
12 | internal let syncQueue = DispatchQueue(label: "com.allcache.SyncQueue", attributes: .concurrent)
13 |
14 | class RequestingCache<T> {
| `- note: generic class 'RequestingCache' does not conform to the 'Sendable' protocol
15 |
16 | var fetching: [String: Request<FetcherResult<T>>] = [:]
:
79 | func setCached(fetching: Request<FetcherResult<T>>?, forIdentifier identifier: String) {
80 | syncQueue.async(flags: .barrier, execute: {
81 | self.fetching[identifier] = fetching
| `- warning: capture of 'self' with non-sendable type 'RequestingCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | })
83 | }
/Users/admin/builder/spi-builder-workspace/Sources/RequestingCache.swift:81:41: warning: capture of 'fetching' with non-sendable type 'Request<FetcherResult<T>>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
79 | func setCached(fetching: Request<FetcherResult<T>>?, forIdentifier identifier: String) {
80 | syncQueue.async(flags: .barrier, execute: {
81 | self.fetching[identifier] = fetching
| `- warning: capture of 'fetching' with non-sendable type 'Request<FetcherResult<T>>?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
82 | })
83 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
[37/48] Compiling AllCache Cache.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:13: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:36: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:91: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:11:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
9 | import Foundation
10 | import Logg
11 | import AsyncRequest
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
12 |
13 | internal let diskQueue = DispatchQueue(label: "com.allcache.DiskQueue", attributes: .concurrent)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:98:21: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
96 | if let object = try diskCache.object(forKey: key) {
97 | responseQueue.async {
98 | request.complete(with: object)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
99 | self.memoryCache.set(object: object, forKey: key)
100 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:98:44: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
96 | if let object = try diskCache.object(forKey: key) {
97 | responseQueue.async {
98 | request.complete(with: object)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
99 | self.memoryCache.set(object: object, forKey: key)
100 | }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:99:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
97 | responseQueue.async {
98 | request.complete(with: object)
99 | self.memoryCache.set(object: object, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
100 | }
101 | } else if let _ = descriptor.processor {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:46: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:95: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:120:40: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
118 | diskQueue.async {
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
122 | self.saveToMemory(original: rawObject, forKey: key)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:121:62: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
122 | self.saveToMemory(original: rawObject, forKey: key)
123 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:121:83: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
122 | self.saveToMemory(original: rawObject, forKey: key)
123 | } else {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:162:38: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
160 |
161 | processQueue.async {
162 | log.debug("processing (\(descriptor.resultKey))")
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
163 | do {
164 | let object = try processor.process(object: rawObject)
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:164:34: warning: capture of 'processor' with non-sendable type 'Processor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
162 | log.debug("processing (\(descriptor.resultKey))")
163 | do {
164 | let object = try processor.process(object: rawObject)
| `- warning: capture of 'processor' with non-sendable type 'Processor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
/Users/admin/builder/spi-builder-workspace/Sources/ObjectProcessor.swift:11:12: note: generic class 'Processor' does not conform to the 'Sendable' protocol
9 | import Foundation
10 |
11 | open class Processor<T> {
| `- note: generic class 'Processor' does not conform to the 'Sendable' protocol
12 |
13 | public let identifier: String
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:164:60: warning: capture of 'rawObject' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
162 | log.debug("processing (\(descriptor.resultKey))")
163 | do {
164 | let object = try processor.process(object: rawObject)
| `- warning: capture of 'rawObject' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:165:17: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
163 | do {
164 | let object = try processor.process(object: rawObject)
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
166 | request.complete(with: object, in: self.responseQueue)
167 | self.persist(object: object, data: nil, key: descriptor.resultKey)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:166:17: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
164 | let object = try processor.process(object: rawObject)
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
167 | self.persist(object: object, data: nil, key: descriptor.resultKey)
168 | } catch {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:162:38: warning: implicit capture of 'descriptor' requires that 'CachableDescriptor<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
160 |
161 | processQueue.async {
162 | log.debug("processing (\(descriptor.resultKey))")
| `- warning: implicit capture of 'descriptor' requires that 'CachableDescriptor<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
163 | do {
164 | let object = try processor.process(object: rawObject)
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:179:25: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
177 | do {
178 | if let data = data {
179 | try self.diskCache.set(data: data, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
180 | } else if let object = object {
181 | try self.diskCache.set(object: object, forKey: key)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:180:40: warning: capture of 'object' with non-sendable type 'T?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
178 | if let data = data {
179 | try self.diskCache.set(data: data, forKey: key)
180 | } else if let object = object {
| `- warning: capture of 'object' with non-sendable type 'T?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
181 | try self.diskCache.set(object: object, forKey: key)
182 | }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:195:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
193 | diskQueue.async(flags: .barrier, execute: {
194 | do {
195 | try self.diskCache.set(object: object, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:195:48: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
193 | diskQueue.async(flags: .barrier, execute: {
194 | do {
195 | try self.diskCache.set(object: object, forKey: key)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:197:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
195 | try self.diskCache.set(object: object, forKey: key)
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
198 | }
199 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:197:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
195 | try self.diskCache.set(object: object, forKey: key)
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
198 | }
199 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:208:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
206 | diskQueue.async(flags: .barrier, execute: {
207 | do {
208 | try self.diskCache.removeObject(forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:210:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
208 | try self.diskCache.removeObject(forKey: key)
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
211 | }
212 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:210:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
208 | try self.diskCache.removeObject(forKey: key)
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
211 | }
212 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:218:13: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
216 | memoryCache.clear()
217 | diskQueue.async {
218 | self.diskCache.clear()
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | }
220 | }
[38/48] Compiling AllCache CodableSerializer.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:13: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:36: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:91: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:11:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
9 | import Foundation
10 | import Logg
11 | import AsyncRequest
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
12 |
13 | internal let diskQueue = DispatchQueue(label: "com.allcache.DiskQueue", attributes: .concurrent)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:98:21: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
96 | if let object = try diskCache.object(forKey: key) {
97 | responseQueue.async {
98 | request.complete(with: object)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
99 | self.memoryCache.set(object: object, forKey: key)
100 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:98:44: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
96 | if let object = try diskCache.object(forKey: key) {
97 | responseQueue.async {
98 | request.complete(with: object)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
99 | self.memoryCache.set(object: object, forKey: key)
100 | }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:99:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
97 | responseQueue.async {
98 | request.complete(with: object)
99 | self.memoryCache.set(object: object, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
100 | }
101 | } else if let _ = descriptor.processor {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:46: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:95: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:120:40: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
118 | diskQueue.async {
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
122 | self.saveToMemory(original: rawObject, forKey: key)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:121:62: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
122 | self.saveToMemory(original: rawObject, forKey: key)
123 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:121:83: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
122 | self.saveToMemory(original: rawObject, forKey: key)
123 | } else {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:162:38: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
160 |
161 | processQueue.async {
162 | log.debug("processing (\(descriptor.resultKey))")
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
163 | do {
164 | let object = try processor.process(object: rawObject)
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:164:34: warning: capture of 'processor' with non-sendable type 'Processor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
162 | log.debug("processing (\(descriptor.resultKey))")
163 | do {
164 | let object = try processor.process(object: rawObject)
| `- warning: capture of 'processor' with non-sendable type 'Processor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
/Users/admin/builder/spi-builder-workspace/Sources/ObjectProcessor.swift:11:12: note: generic class 'Processor' does not conform to the 'Sendable' protocol
9 | import Foundation
10 |
11 | open class Processor<T> {
| `- note: generic class 'Processor' does not conform to the 'Sendable' protocol
12 |
13 | public let identifier: String
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:164:60: warning: capture of 'rawObject' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
162 | log.debug("processing (\(descriptor.resultKey))")
163 | do {
164 | let object = try processor.process(object: rawObject)
| `- warning: capture of 'rawObject' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:165:17: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
163 | do {
164 | let object = try processor.process(object: rawObject)
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
166 | request.complete(with: object, in: self.responseQueue)
167 | self.persist(object: object, data: nil, key: descriptor.resultKey)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:166:17: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
164 | let object = try processor.process(object: rawObject)
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
167 | self.persist(object: object, data: nil, key: descriptor.resultKey)
168 | } catch {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:162:38: warning: implicit capture of 'descriptor' requires that 'CachableDescriptor<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
160 |
161 | processQueue.async {
162 | log.debug("processing (\(descriptor.resultKey))")
| `- warning: implicit capture of 'descriptor' requires that 'CachableDescriptor<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
163 | do {
164 | let object = try processor.process(object: rawObject)
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:179:25: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
177 | do {
178 | if let data = data {
179 | try self.diskCache.set(data: data, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
180 | } else if let object = object {
181 | try self.diskCache.set(object: object, forKey: key)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:180:40: warning: capture of 'object' with non-sendable type 'T?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
178 | if let data = data {
179 | try self.diskCache.set(data: data, forKey: key)
180 | } else if let object = object {
| `- warning: capture of 'object' with non-sendable type 'T?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
181 | try self.diskCache.set(object: object, forKey: key)
182 | }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:195:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
193 | diskQueue.async(flags: .barrier, execute: {
194 | do {
195 | try self.diskCache.set(object: object, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:195:48: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
193 | diskQueue.async(flags: .barrier, execute: {
194 | do {
195 | try self.diskCache.set(object: object, forKey: key)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:197:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
195 | try self.diskCache.set(object: object, forKey: key)
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
198 | }
199 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:197:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
195 | try self.diskCache.set(object: object, forKey: key)
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
198 | }
199 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:208:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
206 | diskQueue.async(flags: .barrier, execute: {
207 | do {
208 | try self.diskCache.removeObject(forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:210:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
208 | try self.diskCache.removeObject(forKey: key)
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
211 | }
212 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:210:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
208 | try self.diskCache.removeObject(forKey: key)
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
211 | }
212 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:218:13: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
216 | memoryCache.clear()
217 | diskQueue.async {
218 | self.diskCache.clear()
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | }
220 | }
[39/48] Compiling AllCache DataSerializer.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:13: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:36: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:89:91: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
87 | }
88 | diskQueue.async {
89 | self.searchOnDisk(key: descriptor.resultKey, descriptor: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
90 | }
91 | return proxy
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:11:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
9 | import Foundation
10 | import Logg
11 | import AsyncRequest
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'AsyncRequest'
12 |
13 | internal let diskQueue = DispatchQueue(label: "com.allcache.DiskQueue", attributes: .concurrent)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:98:21: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
96 | if let object = try diskCache.object(forKey: key) {
97 | responseQueue.async {
98 | request.complete(with: object)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
99 | self.memoryCache.set(object: object, forKey: key)
100 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:98:44: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
96 | if let object = try diskCache.object(forKey: key) {
97 | responseQueue.async {
98 | request.complete(with: object)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
99 | self.memoryCache.set(object: object, forKey: key)
100 | }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:99:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
97 | responseQueue.async {
98 | request.complete(with: object)
99 | self.memoryCache.set(object: object, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
100 | }
101 | } else if let _ = descriptor.processor {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:46: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:103:95: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
101 | } else if let _ = descriptor.processor {
102 | responseQueue.async {
103 | self.searchOriginal(key: descriptor.key, descriptor: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
104 | }
105 | } else {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:120:40: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
118 | diskQueue.async {
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
122 | self.saveToMemory(original: rawObject, forKey: key)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:121:62: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
122 | self.saveToMemory(original: rawObject, forKey: key)
123 | } else {
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:121:83: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
119 | do {
120 | if let rawObject = try self.diskCache.object(forKey: key) {
121 | self.process(rawObject: rawObject, with: descriptor, request: request)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
122 | self.saveToMemory(original: rawObject, forKey: key)
123 | } else {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:162:38: warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
160 |
161 | processQueue.async {
162 | log.debug("processing (\(descriptor.resultKey))")
| `- warning: capture of 'descriptor' with non-sendable type 'CachableDescriptor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
163 | do {
164 | let object = try processor.process(object: rawObject)
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:164:34: warning: capture of 'processor' with non-sendable type 'Processor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
162 | log.debug("processing (\(descriptor.resultKey))")
163 | do {
164 | let object = try processor.process(object: rawObject)
| `- warning: capture of 'processor' with non-sendable type 'Processor<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
/Users/admin/builder/spi-builder-workspace/Sources/ObjectProcessor.swift:11:12: note: generic class 'Processor' does not conform to the 'Sendable' protocol
9 | import Foundation
10 |
11 | open class Processor<T> {
| `- note: generic class 'Processor' does not conform to the 'Sendable' protocol
12 |
13 | public let identifier: String
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:164:60: warning: capture of 'rawObject' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
162 | log.debug("processing (\(descriptor.resultKey))")
163 | do {
164 | let object = try processor.process(object: rawObject)
| `- warning: capture of 'rawObject' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:165:17: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
163 | do {
164 | let object = try processor.process(object: rawObject)
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
166 | request.complete(with: object, in: self.responseQueue)
167 | self.persist(object: object, data: nil, key: descriptor.resultKey)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:166:17: warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
164 | let object = try processor.process(object: rawObject)
165 | self.memoryCache.set(object: object, forKey: descriptor.resultKey, in: self.responseQueue)
166 | request.complete(with: object, in: self.responseQueue)
| `- warning: capture of 'request' with non-sendable type 'Request<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
167 | self.persist(object: object, data: nil, key: descriptor.resultKey)
168 | } catch {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/AsyncRequest/Sources/Request.swift:3:12: note: generic class 'Request' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | open class Request<T>: Cancellable {
| `- note: generic class 'Request' does not conform to the 'Sendable' protocol
4 |
5 | private var handlers: RequestHandlers<T>? = RequestHandlers<T>()
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:162:38: warning: implicit capture of 'descriptor' requires that 'CachableDescriptor<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
160 |
161 | processQueue.async {
162 | log.debug("processing (\(descriptor.resultKey))")
| `- warning: implicit capture of 'descriptor' requires that 'CachableDescriptor<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
163 | do {
164 | let object = try processor.process(object: rawObject)
/Users/admin/builder/spi-builder-workspace/Sources/CachableDescriptor.swift:12:12: note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
10 |
11 | /// Abstract class that provides all the information that a cache requires to search, fetch and process an object
12 | open class CachableDescriptor<T: Any> {
| `- note: generic class 'CachableDescriptor' does not conform to the 'Sendable' protocol
13 | public let key: String
14 |
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:179:25: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
177 | do {
178 | if let data = data {
179 | try self.diskCache.set(data: data, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
180 | } else if let object = object {
181 | try self.diskCache.set(object: object, forKey: key)
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:180:40: warning: capture of 'object' with non-sendable type 'T?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
178 | if let data = data {
179 | try self.diskCache.set(data: data, forKey: key)
180 | } else if let object = object {
| `- warning: capture of 'object' with non-sendable type 'T?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
181 | try self.diskCache.set(object: object, forKey: key)
182 | }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:195:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
193 | diskQueue.async(flags: .barrier, execute: {
194 | do {
195 | try self.diskCache.set(object: object, forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:195:48: warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: consider making generic parameter 'T' conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
193 | diskQueue.async(flags: .barrier, execute: {
194 | do {
195 | try self.diskCache.set(object: object, forKey: key)
| `- warning: capture of 'object' with non-sendable type 'T' in a `@Sendable` closure; this is an error in the Swift 6 language mode
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:197:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
195 | try self.diskCache.set(object: object, forKey: key)
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
198 | }
199 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:197:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
195 | try self.diskCache.set(object: object, forKey: key)
196 | } catch {
197 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
198 | }
199 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:208:21: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
206 | diskQueue.async(flags: .barrier, execute: {
207 | do {
208 | try self.diskCache.removeObject(forKey: key)
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:210:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
208 | try self.diskCache.removeObject(forKey: key)
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
211 | }
212 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:210:44: warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
208 | try self.diskCache.removeObject(forKey: key)
209 | } catch {
210 | self.responseQueue.async { errorHandler?(error) }
| |- warning: capture of 'errorHandler' with non-sendable type '((any Error) -> Void)?' 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'
211 | }
212 | })
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:218:13: warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
21 | /// The Cache class is a generic container that stores key-value pairs,
22 | /// internally has a memory cache and a disk cache
23 | open class Cache<T: AnyObject> {
| `- note: generic class 'Cache' does not conform to the 'Sendable' protocol
24 |
25 | private let requestCache = RequestingCache<T>()
:
216 | memoryCache.clear()
217 | diskQueue.async {
218 | self.diskCache.clear()
| `- warning: capture of 'self' with non-sendable type 'Cache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
219 | }
220 | }
[40/48] Compiling AllCache UIImageView+ImageCache.swift
[41/48] Compiling AllCache URL+Util.swift
[42/48] Compiling AllCache ImageResizer.swift
[43/48] Compiling AllCache ImageSerializer.swift
[44/48] Compiling AllCache ObjectFetcher.swift
[45/48] Compiling AllCache ObjectProcessor.swift
[46/48] Compiling AllCache DiskCache.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:56:27: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
54 | }
55 | log.debug("🔑(\(key)) found on disk")
56 | diskQueue.async { self.updateLastAccess(ofKey: key) }
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 |
58 | return try serializer.deserialize(data: Data(contentsOf: url))
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:111:36: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
109 | diskQueue.async {
110 | let resourceKeys: [URLResourceKey] = [.contentAccessDateKey, .totalFileAllocatedSizeKey]
111 | guard let enumerator = self.cacheDirectory.enumerator(includingPropertiesForKeys: resourceKeys) else {
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 | log.error(DiskCacheError.enumeratorError)
113 | return
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:116:28: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in an isolated closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
114 | }
115 | let urls = enumerator.compactMap({ $0 as? URL }).filter({ ($0.contentAccessDate ?? limit) < limit })
116 | urls.forEach({ self.removeIfPossible(url: $0) })
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in an isolated closure; this is an error in the Swift 6 language mode
117 | }
118 | }
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:143:16: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
141 | if size < maxCapacity { return }
142 | diskQueue.async {
143 | if self.shrinking { return }
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
144 | self.shrinking = true
145 | do {
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:146:50: warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
144 | self.shrinking = true
145 | do {
146 | log.debug("💽 Original size: \(self.size)")
| `- warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
147 | try self.restrictSize(percent: 0.8)
148 | log.debug("💽 Final size: \(self.size)")
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:148:47: warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
146 | log.debug("💽 Original size: \(self.size)")
147 | try self.restrictSize(percent: 0.8)
148 | log.debug("💽 Final size: \(self.size)")
| `- warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
149 | self.shrinking = false
150 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/ImageCache.swift:30:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
23 | import AsyncRequest
24 |
25 | open class ImageCache: Cache<Image> {
| `- note: class 'ImageCache' does not conform to the 'Sendable' protocol
26 |
27 | #if os(iOS) || os(tvOS) || os(watchOS)
28 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: PNGImageSerializer())
29 | #else
30 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: ImageSerializer())
| |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shared' 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
31 | #endif
32 |
[47/48] Compiling AllCache ImageCache.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:56:27: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
54 | }
55 | log.debug("🔑(\(key)) found on disk")
56 | diskQueue.async { self.updateLastAccess(ofKey: key) }
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 |
58 | return try serializer.deserialize(data: Data(contentsOf: url))
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:111:36: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
109 | diskQueue.async {
110 | let resourceKeys: [URLResourceKey] = [.contentAccessDateKey, .totalFileAllocatedSizeKey]
111 | guard let enumerator = self.cacheDirectory.enumerator(includingPropertiesForKeys: resourceKeys) else {
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 | log.error(DiskCacheError.enumeratorError)
113 | return
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:116:28: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in an isolated closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
114 | }
115 | let urls = enumerator.compactMap({ $0 as? URL }).filter({ ($0.contentAccessDate ?? limit) < limit })
116 | urls.forEach({ self.removeIfPossible(url: $0) })
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in an isolated closure; this is an error in the Swift 6 language mode
117 | }
118 | }
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:143:16: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
141 | if size < maxCapacity { return }
142 | diskQueue.async {
143 | if self.shrinking { return }
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
144 | self.shrinking = true
145 | do {
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:146:50: warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
144 | self.shrinking = true
145 | do {
146 | log.debug("💽 Original size: \(self.size)")
| `- warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
147 | try self.restrictSize(percent: 0.8)
148 | log.debug("💽 Final size: \(self.size)")
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:148:47: warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
146 | log.debug("💽 Original size: \(self.size)")
147 | try self.restrictSize(percent: 0.8)
148 | log.debug("💽 Final size: \(self.size)")
| `- warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
149 | self.shrinking = false
150 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/ImageCache.swift:30:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
23 | import AsyncRequest
24 |
25 | open class ImageCache: Cache<Image> {
| `- note: class 'ImageCache' does not conform to the 'Sendable' protocol
26 |
27 | #if os(iOS) || os(tvOS) || os(watchOS)
28 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: PNGImageSerializer())
29 | #else
30 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: ImageSerializer())
| |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shared' 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
31 | #endif
32 |
[48/48] Compiling AllCache ImageFetcher.swift
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:19:12: warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| `- warning: let 'log' is not concurrency-safe because non-'Sendable' type 'CompositeLogger' may have shared mutable state; this is an error in the Swift 6 language mode
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/Logg/Sources/Logg/CompositeLogger.swift:3:14: note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
1 | import Foundation
2 |
3 | public class CompositeLogger {
| `- note: class 'CompositeLogger' does not conform to the 'Sendable' protocol
4 |
5 | public convenience init() {
/Users/admin/builder/spi-builder-workspace/Sources/Cache.swift:10:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
8 |
9 | import Foundation
10 | import Logg
| `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'Logg'
11 | import AsyncRequest
12 |
:
17 | private let processQueue = DispatchQueue(label: "com.allcache.ProcessQueue", attributes: .concurrent)
18 |
19 | public let log = CompositeLogger(loggers: [ConsoleLogger(formatter: AllCacheFormatter(), level: [.error, .fault])])
| |- note: annotate 'log' 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
20 |
21 | /// The Cache class is a generic container that stores key-value pairs,
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:56:27: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
54 | }
55 | log.debug("🔑(\(key)) found on disk")
56 | diskQueue.async { self.updateLastAccess(ofKey: key) }
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
57 |
58 | return try serializer.deserialize(data: Data(contentsOf: url))
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:111:36: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
109 | diskQueue.async {
110 | let resourceKeys: [URLResourceKey] = [.contentAccessDateKey, .totalFileAllocatedSizeKey]
111 | guard let enumerator = self.cacheDirectory.enumerator(includingPropertiesForKeys: resourceKeys) else {
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
112 | log.error(DiskCacheError.enumeratorError)
113 | return
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:116:28: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in an isolated closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
114 | }
115 | let urls = enumerator.compactMap({ $0 as? URL }).filter({ ($0.contentAccessDate ?? limit) < limit })
116 | urls.forEach({ self.removeIfPossible(url: $0) })
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in an isolated closure; this is an error in the Swift 6 language mode
117 | }
118 | }
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:143:16: warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
141 | if size < maxCapacity { return }
142 | diskQueue.async {
143 | if self.shrinking { return }
| `- warning: capture of 'self' with non-sendable type 'DiskCache<T>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
144 | self.shrinking = true
145 | do {
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:146:50: warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
144 | self.shrinking = true
145 | do {
146 | log.debug("💽 Original size: \(self.size)")
| `- warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
147 | try self.restrictSize(percent: 0.8)
148 | log.debug("💽 Final size: \(self.size)")
/Users/admin/builder/spi-builder-workspace/Sources/DiskCache.swift:148:47: warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
15 | }
16 |
17 | public final class DiskCache<T> {
| `- note: generic class 'DiskCache' does not conform to the 'Sendable' protocol
18 |
19 | public let identifier: String
:
146 | log.debug("💽 Original size: \(self.size)")
147 | try self.restrictSize(percent: 0.8)
148 | log.debug("💽 Final size: \(self.size)")
| `- warning: implicit capture of 'self' requires that 'DiskCache<T>' conforms to `Sendable`; this is an error in the Swift 6 language mode
149 | self.shrinking = false
150 | } catch {
/Users/admin/builder/spi-builder-workspace/Sources/ImageCache.swift:30:23: warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
23 | import AsyncRequest
24 |
25 | open class ImageCache: Cache<Image> {
| `- note: class 'ImageCache' does not conform to the 'Sendable' protocol
26 |
27 | #if os(iOS) || os(tvOS) || os(watchOS)
28 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: PNGImageSerializer())
29 | #else
30 | public static let shared = try! ImageCache(identifier: "sharedImage", serializer: ImageSerializer())
| |- warning: static property 'shared' is not concurrency-safe because non-'Sendable' type 'ImageCache' may have shared mutable state; this is an error in the Swift 6 language mode
| |- note: annotate 'shared' 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
31 | #endif
32 |
Build complete! (33.80s)
Build complete.
{
"dependencies" : [
{
"identity" : "logg",
"requirement" : {
"range" : [
{
"lower_bound" : "2.4.0",
"upper_bound" : "2.5.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/JuanjoArreola/Logg.git"
},
{
"identity" : "asyncrequest",
"requirement" : {
"range" : [
{
"lower_bound" : "2.3.0",
"upper_bound" : "3.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/JuanjoArreola/AsyncRequest.git"
}
],
"manifest_display_name" : "AllCache",
"name" : "AllCache",
"path" : "/Users/admin/builder/spi-builder-workspace",
"platforms" : [
],
"products" : [
{
"name" : "AllCache",
"targets" : [
"AllCache"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"targets" : [
{
"c99name" : "AllCacheTests",
"module_type" : "SwiftTarget",
"name" : "AllCacheTests",
"path" : "Tests",
"sources" : [
"AllCacheTests/DiskTests.swift",
"AllCacheTests/Icecream.swift",
"AllCacheTests/ImageCacheTests.swift",
"AllCacheTests/MemoryTests.swift",
"AllCacheTests/RequestingCacheTests.swift",
"LinuxMain.swift"
],
"target_dependencies" : [
"AllCache"
],
"type" : "test"
},
{
"c99name" : "AllCache",
"module_type" : "SwiftTarget",
"name" : "AllCache",
"path" : "Sources",
"product_dependencies" : [
"Logg",
"AsyncRequest"
],
"product_memberships" : [
"AllCache"
],
"sources" : [
"AllCacheFormatter.swift",
"CGSize+Util.swift",
"CachableDescriptor.swift",
"Cache.swift",
"CodableSerializer.swift",
"DataSerializer.swift",
"DiskCache.swift",
"ImageCache.swift",
"ImageFetcher.swift",
"ImageResizer.swift",
"ImageSerializer.swift",
"JPEGImageSerializer.swift",
"LowMemoryHandler.swift",
"MemoryCache.swift",
"Networking.swift",
"ObjectFetcher.swift",
"ObjectProcessor.swift",
"PNGImageSerializer.swift",
"RequestingCache.swift",
"String+Range.swift",
"UIButton+ImageCache.swift",
"UIImageView+ImageCache.swift",
"URL+Util.swift"
],
"type" : "library"
}
],
"tools_version" : "5.2"
}
Done.