Swift Package IndexBuild Information
Successful build of SwifterSockets, reference master (a1bad9), with Swift 6.0 for Linux on 27 Nov 2024 10:00:27 UTC.
Swift 6 data race errors: 2
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4609320-1":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1Build Log
========================================
RunAll
========================================
Builder version: 4.58.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/Balancingrock/SwifterSockets.git
Reference: master
Initialized empty Git repository in /host/spi-builder-workspace/.git/
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
From https://github.com/Balancingrock/SwifterSockets
* branch master -> FETCH_HEAD
* [new branch] master -> origin/master
HEAD is now at a1bad95 reduced target macos to 10.10
Cloned https://github.com/Balancingrock/SwifterSockets.git
Revision (git rev-parse @):
a1bad95095bca87756cd0f3d72d6b448ce5684a3
SUCCESS checkout https://github.com/Balancingrock/SwifterSockets.git at master
========================================
Build
========================================
Selected platform: linux
Swift version: 6.0
Building package at path: $PWD
https://github.com/Balancingrock/SwifterSockets.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4609320-1":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1
basic-6.0-latest: Pulling from finestructure/spi-images
Digest: sha256:47d26c99ca4f1ac0a332c85fd5b13ff4390e72115219984a57a68fe9d1063a05
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.0-latest
Building for debugging...
[0/2] Write sources
[1/2] Write swift-version-24593BA9C3E375BF.txt
[3/18] Emitting module SwifterSockets
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:231:24: warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
229 | /// This queue is used for usage counting and to close down a connection after inactivity.
230 |
231 | private static var uQueue: DispatchQueue = DispatchQueue(label: "Connection Usage Counting")
| |- warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'uQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'uQueue' 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
232 |
233 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:261:24: warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
259 | /// - Note: Inactactivity actions are started from this queue.
260 |
261 | private static var iQueue: DispatchQueue = DispatchQueue(label: "Inactivity handlers")
| |- warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'iQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'iQueue' 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
262 |
263 |
[4/20] Compiling SwifterSockets TransmitterProtocol.swift
[5/20] Compiling SwifterSockets WaitForSelect.swift
[6/20] Compiling SwifterSockets ReceiverProtocol.swift
[7/20] Compiling SwifterSockets ServerProtocol.swift
[8/20] Compiling SwifterSockets TipServer.swift
/host/spi-builder-workspace/Sources/SwifterSockets/TipServer.swift:275:36: warning: capture of 'self' with non-sendable type 'TipServer?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
44 | /// The server has several options with which it can be configured. At a minimum the "connectionObjectFactory" must be initialized.
45 |
46 | public class TipServer: ServerProtocol {
| `- note: class 'TipServer' does not conform to the 'Sendable' protocol
47 |
48 |
:
273 |
274 | [weak self] in
275 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'TipServer?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
276 |
277 | ACCEPT_LOOP: while !self._stop {
[9/20] Compiling SwifterSockets TipTransfer.swift
/host/spi-builder-workspace/Sources/SwifterSockets/TipServer.swift:275:36: warning: capture of 'self' with non-sendable type 'TipServer?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
44 | /// The server has several options with which it can be configured. At a minimum the "connectionObjectFactory" must be initialized.
45 |
46 | public class TipServer: ServerProtocol {
| `- note: class 'TipServer' does not conform to the 'Sendable' protocol
47 |
48 |
:
273 |
274 | [weak self] in
275 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'TipServer?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
276 |
277 | ACCEPT_LOOP: while !self._stop {
[10/20] Compiling SwifterSockets SetupTipServer.swift
[11/20] Compiling SwifterSockets SwifterSocketsResult.swift
[12/20] Compiling SwifterSockets SwifterSocketsUtils.swift
[13/20] Compiling SwifterSockets TipAccept.swift
[14/20] Compiling SwifterSockets TipInterface.swift
[15/20] Compiling SwifterSockets TipReceiverLoop.swift
[16/20] Compiling SwifterSockets FileDescriptorMacros.swift
[17/20] Compiling SwifterSockets InterfaceAccess.swift
[18/20] Compiling SwifterSockets ConnectToTipServer.swift
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:231:24: warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
229 | /// This queue is used for usage counting and to close down a connection after inactivity.
230 |
231 | private static var uQueue: DispatchQueue = DispatchQueue(label: "Connection Usage Counting")
| |- warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'uQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'uQueue' 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
232 |
233 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:261:24: warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
259 | /// - Note: Inactactivity actions are started from this queue.
260 |
261 | private static var iQueue: DispatchQueue = DispatchQueue(label: "Inactivity handlers")
| |- warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'iQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'iQueue' 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
262 |
263 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:453:48: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
451 | Connection.iQueue.asyncAfter(deadline: DispatchTime.now() + inactivityDetectionThreshold) {
452 | [weak self] in
453 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
454 |
455 | // Cancel the inactivity action if there is a pending usage or if there was another inactivity action request made.
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:528:36: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
526 |
527 | [weak self] in
528 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
529 |
530 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:544:29: warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
542 |
543 | _ = self.interface?.transfer(
544 | buffer: buffer,
| `- warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeBufferPointer:1:23: note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeBufferPointer<Element> : Copyable where Element : ~Copyable {
| `- note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
2 | public let count: Int
3 | @inlinable public init(start: UnsafePointer<Element>?, count: Int)
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:546:31: warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
544 | buffer: buffer,
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
| `- warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
547 | progress: progress ?? self.transmitterProgressMonitor)
548 |
/host/spi-builder-workspace/Sources/SwifterSockets/TransmitterProtocol.swift:42:17: note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
40 | /// A collection of methods used by a transmit operation to inform the transmitter of the events occuring on the interface.
41 |
42 | public protocol TransmitterProtocol {
| `- note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
43 |
44 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:547:31: warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') in a `@Sendable` closure; this is an error in the Swift 6 language mode
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
547 | progress: progress ?? self.transmitterProgressMonitor)
| |- warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') 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'
548 |
549 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:680:36: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
678 |
679 | [weak self] in
680 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
681 |
682 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:696:56: warning: capture of 'copy' with non-sendable type 'UnsafeMutableRawBufferPointer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
694 |
695 | _ = self.interface?.transfer(
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
| `- warning: capture of 'copy' with non-sendable type 'UnsafeMutableRawBufferPointer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeMutableRawBufferPointer:1:23: note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutableRawBufferPointer {
| `- note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
2 | @inlinable public init(start: UnsafeMutableRawPointer?, count: Int)
3 | }
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:696:118: warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
694 |
695 | _ = self.interface?.transfer(
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
| `- warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeBufferPointer:1:23: note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeBufferPointer<Element> : Copyable where Element : ~Copyable {
| `- note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
2 | public let count: Int
3 | @inlinable public init(start: UnsafePointer<Element>?, count: Int)
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:698:31: warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
| `- warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
699 | progress: progress ?? self.transmitterProgressMonitor)
700 |
/host/spi-builder-workspace/Sources/SwifterSockets/TransmitterProtocol.swift:42:17: note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
40 | /// A collection of methods used by a transmit operation to inform the transmitter of the events occuring on the interface.
41 |
42 | public protocol TransmitterProtocol {
| `- note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
43 |
44 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:699:31: warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
699 | progress: progress ?? self.transmitterProgressMonitor)
| |- warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') 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'
700 |
701 | copy.deallocate()
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:795:32: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
793 | Connection.uQueue.async {
794 | [weak self] in
795 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
796 |
797 | // If there is no usage pending, close the connection immediately. Otherwise request the close after the last usage completes.
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:836:32: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
834 |
835 | [weak self] in
836 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
837 |
838 | self.interface?.receiverLoop(
[19/20] Compiling SwifterSockets Connection.swift
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:231:24: warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
229 | /// This queue is used for usage counting and to close down a connection after inactivity.
230 |
231 | private static var uQueue: DispatchQueue = DispatchQueue(label: "Connection Usage Counting")
| |- warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'uQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'uQueue' 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
232 |
233 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:261:24: warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
259 | /// - Note: Inactactivity actions are started from this queue.
260 |
261 | private static var iQueue: DispatchQueue = DispatchQueue(label: "Inactivity handlers")
| |- warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'iQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'iQueue' 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
262 |
263 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:453:48: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
451 | Connection.iQueue.asyncAfter(deadline: DispatchTime.now() + inactivityDetectionThreshold) {
452 | [weak self] in
453 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
454 |
455 | // Cancel the inactivity action if there is a pending usage or if there was another inactivity action request made.
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:528:36: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
526 |
527 | [weak self] in
528 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
529 |
530 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:544:29: warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
542 |
543 | _ = self.interface?.transfer(
544 | buffer: buffer,
| `- warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeBufferPointer:1:23: note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeBufferPointer<Element> : Copyable where Element : ~Copyable {
| `- note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
2 | public let count: Int
3 | @inlinable public init(start: UnsafePointer<Element>?, count: Int)
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:546:31: warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
544 | buffer: buffer,
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
| `- warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
547 | progress: progress ?? self.transmitterProgressMonitor)
548 |
/host/spi-builder-workspace/Sources/SwifterSockets/TransmitterProtocol.swift:42:17: note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
40 | /// A collection of methods used by a transmit operation to inform the transmitter of the events occuring on the interface.
41 |
42 | public protocol TransmitterProtocol {
| `- note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
43 |
44 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:547:31: warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') in a `@Sendable` closure; this is an error in the Swift 6 language mode
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
547 | progress: progress ?? self.transmitterProgressMonitor)
| |- warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') 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'
548 |
549 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:680:36: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
678 |
679 | [weak self] in
680 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
681 |
682 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:696:56: warning: capture of 'copy' with non-sendable type 'UnsafeMutableRawBufferPointer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
694 |
695 | _ = self.interface?.transfer(
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
| `- warning: capture of 'copy' with non-sendable type 'UnsafeMutableRawBufferPointer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeMutableRawBufferPointer:1:23: note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutableRawBufferPointer {
| `- note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
2 | @inlinable public init(start: UnsafeMutableRawPointer?, count: Int)
3 | }
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:696:118: warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
694 |
695 | _ = self.interface?.transfer(
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
| `- warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeBufferPointer:1:23: note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeBufferPointer<Element> : Copyable where Element : ~Copyable {
| `- note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
2 | public let count: Int
3 | @inlinable public init(start: UnsafePointer<Element>?, count: Int)
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:698:31: warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
| `- warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
699 | progress: progress ?? self.transmitterProgressMonitor)
700 |
/host/spi-builder-workspace/Sources/SwifterSockets/TransmitterProtocol.swift:42:17: note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
40 | /// A collection of methods used by a transmit operation to inform the transmitter of the events occuring on the interface.
41 |
42 | public protocol TransmitterProtocol {
| `- note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
43 |
44 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:699:31: warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
699 | progress: progress ?? self.transmitterProgressMonitor)
| |- warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') 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'
700 |
701 | copy.deallocate()
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:795:32: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
793 | Connection.uQueue.async {
794 | [weak self] in
795 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
796 |
797 | // If there is no usage pending, close the connection immediately. Otherwise request the close after the last usage completes.
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:836:32: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
834 |
835 | [weak self] in
836 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
837 |
838 | self.interface?.receiverLoop(
[20/20] Compiling SwifterSockets ConnectionPool.swift
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:231:24: warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
229 | /// This queue is used for usage counting and to close down a connection after inactivity.
230 |
231 | private static var uQueue: DispatchQueue = DispatchQueue(label: "Connection Usage Counting")
| |- warning: static property 'uQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'uQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'uQueue' 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
232 |
233 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:261:24: warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
259 | /// - Note: Inactactivity actions are started from this queue.
260 |
261 | private static var iQueue: DispatchQueue = DispatchQueue(label: "Inactivity handlers")
| |- warning: static property 'iQueue' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
| |- note: convert 'iQueue' to a 'let' constant to make 'Sendable' shared state immutable
| |- note: annotate 'iQueue' 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
262 |
263 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:453:48: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
451 | Connection.iQueue.asyncAfter(deadline: DispatchTime.now() + inactivityDetectionThreshold) {
452 | [weak self] in
453 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
454 |
455 | // Cancel the inactivity action if there is a pending usage or if there was another inactivity action request made.
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:528:36: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
526 |
527 | [weak self] in
528 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
529 |
530 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:544:29: warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
542 |
543 | _ = self.interface?.transfer(
544 | buffer: buffer,
| `- warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeBufferPointer:1:23: note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeBufferPointer<Element> : Copyable where Element : ~Copyable {
| `- note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
2 | public let count: Int
3 | @inlinable public init(start: UnsafePointer<Element>?, count: Int)
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:546:31: warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
544 | buffer: buffer,
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
| `- warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
547 | progress: progress ?? self.transmitterProgressMonitor)
548 |
/host/spi-builder-workspace/Sources/SwifterSockets/TransmitterProtocol.swift:42:17: note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
40 | /// A collection of methods used by a transmit operation to inform the transmitter of the events occuring on the interface.
41 |
42 | public protocol TransmitterProtocol {
| `- note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
43 |
44 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:547:31: warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') in a `@Sendable` closure; this is an error in the Swift 6 language mode
545 | timeout: timeout ?? self.transmitterTimeoutValue,
546 | callback: callback ?? self.transmitterProtocol ?? self,
547 | progress: progress ?? self.transmitterProgressMonitor)
| |- warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') 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'
548 |
549 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:680:36: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
678 |
679 | [weak self] in
680 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
681 |
682 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:696:56: warning: capture of 'copy' with non-sendable type 'UnsafeMutableRawBufferPointer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
694 |
695 | _ = self.interface?.transfer(
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
| `- warning: capture of 'copy' with non-sendable type 'UnsafeMutableRawBufferPointer' in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeMutableRawBufferPointer:1:23: note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutableRawBufferPointer {
| `- note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
2 | @inlinable public init(start: UnsafeMutableRawPointer?, count: Int)
3 | }
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:696:118: warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
694 |
695 | _ = self.interface?.transfer(
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
| `- warning: capture of 'buffer' with non-sendable type 'UnsafeBufferPointer<UInt8>' in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
Swift.UnsafeBufferPointer:1:23: note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeBufferPointer<Element> : Copyable where Element : ~Copyable {
| `- note: generic struct 'UnsafeBufferPointer' does not conform to the 'Sendable' protocol
2 | public let count: Int
3 | @inlinable public init(start: UnsafePointer<Element>?, count: Int)
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:698:31: warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
696 | buffer: UnsafeBufferPointer(start: copy.baseAddress!.assumingMemoryBound(to: UInt8.self), count: buffer.count),
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
| `- warning: capture of 'callback' with non-sendable type '(any TransmitterProtocol)?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
699 | progress: progress ?? self.transmitterProgressMonitor)
700 |
/host/spi-builder-workspace/Sources/SwifterSockets/TransmitterProtocol.swift:42:17: note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
40 | /// A collection of methods used by a transmit operation to inform the transmitter of the events occuring on the interface.
41 |
42 | public protocol TransmitterProtocol {
| `- note: protocol 'TransmitterProtocol' does not conform to the 'Sendable' protocol
43 |
44 |
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:699:31: warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') in a `@Sendable` closure; this is an error in the Swift 6 language mode
697 | timeout: timeout ?? self.transmitterTimeoutValue,
698 | callback: callback ?? self.transmitterProtocol ?? self,
699 | progress: progress ?? self.transmitterProgressMonitor)
| |- warning: capture of 'progress' with non-sendable type 'TransmitterProgressMonitor?' (aka 'Optional<(Int, Int) -> Bool>') 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'
700 |
701 | copy.deallocate()
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:795:32: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
793 | Connection.uQueue.async {
794 | [weak self] in
795 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
796 |
797 | // If there is no usage pending, close the connection immediately. Otherwise request the close after the last usage completes.
/host/spi-builder-workspace/Sources/SwifterSockets/Connection.swift:836:32: warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
63 | /// - Note: By default a connection stays open until the peer closes it. This is normally __unacceptable for a server!__. For a servers it is recommened to use an inactivity detector that takes appropriate action when the connection is no longer used.
64 |
65 | open class Connection: ReceiverProtocol, TransmitterProtocol {
| `- note: class 'Connection' does not conform to the 'Sendable' protocol
66 |
67 | // For maximum performance the connection objects use two dispatch queues, one for the transmitter and one for the receiver. Transmitter closures run only when something needs to be transmitted. The receiver loop is event driven. Closing the underlying connection is easy for the transmitter queue: schedule the closing on the transmitter queue, and it is ensured that the closing will not not run concurrently with a transmission. However the receiver loop poses a problem. Since it is event driven the arrival of new data could coincide with the closing of the connection. A third queue and a handshake mechanism have been introduced to prevent collisions of this kind.
:
834 |
835 | [weak self] in
836 | guard let `self` = self else { return }
| `- warning: capture of 'self' with non-sendable type 'Connection?' in a `@Sendable` closure; this is an error in the Swift 6 language mode
837 |
838 | self.interface?.receiverLoop(
Build complete! (10.43s)
Build complete.
{
"dependencies" : [
],
"manifest_display_name" : "SwifterSockets",
"name" : "SwifterSockets",
"path" : "/host/spi-builder-workspace",
"platforms" : [
{
"name" : "macos",
"version" : "10.10"
},
{
"name" : "ios",
"version" : "8.0"
}
],
"products" : [
{
"name" : "SwifterSockets",
"targets" : [
"SwifterSockets"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"swift_languages_versions" : [
"4",
"4.2",
"5"
],
"targets" : [
{
"c99name" : "SwifterSockets",
"module_type" : "SwiftTarget",
"name" : "SwifterSockets",
"path" : "Sources/SwifterSockets",
"product_memberships" : [
"SwifterSockets"
],
"sources" : [
"ConnectToTipServer.swift",
"Connection.swift",
"ConnectionPool.swift",
"FileDescriptorMacros.swift",
"InterfaceAccess.swift",
"ReceiverProtocol.swift",
"ServerProtocol.swift",
"SetupTipServer.swift",
"SwifterSocketsResult.swift",
"SwifterSocketsUtils.swift",
"TipAccept.swift",
"TipInterface.swift",
"TipReceiverLoop.swift",
"TipServer.swift",
"TipTransfer.swift",
"TransmitterProtocol.swift",
"WaitForSelect.swift"
],
"type" : "library"
}
],
"tools_version" : "5.0"
}
basic-6.0-latest: Pulling from finestructure/spi-images
Digest: sha256:47d26c99ca4f1ac0a332c85fd5b13ff4390e72115219984a57a68fe9d1063a05
Status: Image is up to date for registry.gitlab.com/finestructure/spi-images:basic-6.0-latest
Done.