Adopt strict concurrency

ra1028 · ra1028 · commit c29a790e66f7 · 2024-10-02T20:17:38.000+09:00
diff --git a/Benchmarks/Test.xcodeproj/project.pbxproj b/Benchmarks/Test.xcodeproj/project.pbxproj
@@ -251,6 +251,7 @@
 				SDKROOT = iphoneos;
 				SWIFT_COMPILATION_MODE = wholemodule;
 				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				SWIFT_STRICT_CONCURRENCY = complete;
 				SWIFT_VERSION = 5.0;
 			};
 			name = Release;
@@ -366,6 +367,7 @@
 				SDKROOT = iphoneos;
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_STRICT_CONCURRENCY = complete;
 				SWIFT_VERSION = 5.0;
 			};
 			name = Debug;
diff --git a/Benchmarks/project.yml b/Benchmarks/project.yml
@@ -8,6 +8,7 @@ settings:
   CODE_SIGNING_REQUIRED: NO
   CODE_SIGN_IDENTITY: "-"
   CODE_SIGN_STYLE: Manual
+  SWIFT_STRICT_CONCURRENCY: complete
 
 packages:
   swiftui-atom-properties:
diff --git a/Examples/App.xcodeproj/project.pbxproj b/Examples/App.xcodeproj/project.pbxproj
@@ -324,6 +324,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_COMPILATION_MODE = wholemodule;
 				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				SWIFT_STRICT_CONCURRENCY = complete;
 				SWIFT_VERSION = 5.0;
 				TVOS_DEPLOYMENT_TARGET = 16.0;
 			};
@@ -441,6 +442,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_STRICT_CONCURRENCY = complete;
 				SWIFT_VERSION = 5.0;
 				TVOS_DEPLOYMENT_TARGET = 16.0;
 			};
diff --git a/Examples/project.yml b/Examples/project.yml
@@ -12,6 +12,7 @@ settings:
   CODE_SIGNING_REQUIRED: NO
   CODE_SIGN_IDENTITY: "-"
   CODE_SIGN_STYLE: Manual
+  SWIFT_STRICT_CONCURRENCY: complete
 
 targetTemplates:
   App:
diff --git a/Sources/Atoms/Atom/PublisherAtom.swift b/Sources/Atoms/Atom/PublisherAtom.swift
@@ -1,4 +1,4 @@
-import Combine
+@preconcurrency import Combine
 
 /// An atom type that provides a sequence of values of the given `Publisher` as an ``AsyncPhase`` value.
 ///
diff --git a/Sources/Atoms/Context/AtomTestContext.swift b/Sources/Atoms/Context/AtomTestContext.swift
@@ -1,4 +1,4 @@
-import Combine
+@preconcurrency import Combine
 
 /// A context structure to read, watch, and otherwise interact with atoms in testing.
 ///
diff --git a/Sources/Atoms/Core/Atom/Atom.swift b/Sources/Atoms/Core/Atom/Atom.swift
@@ -2,7 +2,7 @@
 ///
 /// The value produced by an atom is created only when the atom is watched from somewhere,
 /// and is immediately released when no longer watched.
-public protocol Atom<Produced> {
+public protocol Atom<Produced>: Sendable {
     /// A type representing the stable identity of this atom.
     associatedtype Key: Hashable
 
diff --git a/Sources/Atoms/Core/Modifier/AtomModifier.swift b/Sources/Atoms/Core/Modifier/AtomModifier.swift
@@ -9,7 +9,7 @@ public extension Atom {
 }
 
 /// A modifier that you apply to an atom, producing a new value modified from the original value.
-public protocol AtomModifier {
+public protocol AtomModifier: Sendable {
     /// A type representing the stable identity of this modifier.
     associatedtype Key: Hashable
 
diff --git a/Sources/Atoms/Core/StoreState.swift b/Sources/Atoms/Core/StoreState.swift
@@ -3,4 +3,6 @@ internal final class StoreState {
     var caches = [AtomKey: any AtomCacheProtocol]()
     var states = [AtomKey: any AtomStateProtocol]()
     var subscriptions = [AtomKey: [SubscriberKey: Subscription]]()
+
+    nonisolated init() {}
 }
diff --git a/Sources/Atoms/Core/Subscriber.swift b/Sources/Atoms/Core/Subscriber.swift
@@ -11,12 +11,12 @@ internal struct Subscriber {
     }
 
     var subscribing: Set<AtomKey> {
-        get { state?.subscribing ?? [] }
-        nonmutating set { state?.subscribing = newValue }
+        get { state?.subscribing.value ?? [] }
+        nonmutating set { state?.subscribing.value = newValue }
     }
 
     var unsubscribe: ((Set<AtomKey>) -> Void)? {
-        get { state?.unsubscribe }
-        nonmutating set { state?.unsubscribe = newValue }
+        get { state?.unsubscribe.value }
+        nonmutating set { state?.unsubscribe.value = newValue }
     }
 }
diff --git a/Sources/Atoms/Core/SubscriberState.swift b/Sources/Atoms/Core/SubscriberState.swift
@@ -3,18 +3,18 @@ import Foundation
 @MainActor
 internal final class SubscriberState {
     let token = SubscriberKey.Token()
-    var subscribing = Set<AtomKey>()
-    var unsubscribe: ((Set<AtomKey>) -> Void)?
+    var subscribing = UnsafeUncheckedSendable(Set<AtomKey>())
+    var unsubscribe = UnsafeUncheckedSendable<((Set<AtomKey>) -> Void)?>(nil)
 
     // TODO: Use isolated synchronous deinit once it's available.
     // 0371-isolated-synchronous-deinit
     deinit {
         if Thread.isMainThread {
-            unsubscribe?(subscribing)
+            unsubscribe.value?(subscribing.value)
         }
         else {
-            Task(priority: .high) { @MainActor [unsubscribe, subscribing] in
-                unsubscribe?(subscribing)
+            Task { @MainActor [unsubscribe, subscribing] in
+                unsubscribe.value?(subscribing.value)
             }
         }
     }
diff --git a/Sources/Atoms/Core/UnsafeUncheckedSendable.swift b/Sources/Atoms/Core/UnsafeUncheckedSendable.swift
@@ -0,0 +1,9 @@
+import os
+
+internal struct UnsafeUncheckedSendable<Value>: @unchecked Sendable {
+    var value: Value
+
+    init(_ value: Value) {
+        self.value = value
+    }
+}
diff --git a/Sources/Atoms/Deprecated.swift b/Sources/Atoms/Deprecated.swift
@@ -6,7 +6,7 @@ public extension Atom {
 
     @available(*, deprecated, renamed: "changes(of:)")
     func select<Selected: Equatable>(
-        _ keyPath: KeyPath<Produced, Selected>
+        _ keyPath: KeyPath<Produced, Selected> & Sendable
     ) -> ModifiedAtom<Self, ChangesOfModifier<Produced, Selected>> {
         changes(of: keyPath)
     }
diff --git a/Sources/Atoms/Modifier/ChangesOfModifier.swift b/Sources/Atoms/Modifier/ChangesOfModifier.swift
@@ -49,22 +49,22 @@ public struct ChangesOfModifier<Base, Produced: Equatable>: AtomModifier {
         }
     }
 
-    private let keyPath: KeyPath<Base, Produced>
+    private let keyPath: UnsafeUncheckedSendable<KeyPath<Base, Produced>>
 
     internal init(keyPath: KeyPath<Base, Produced>) {
-        self.keyPath = keyPath
+        self.keyPath = UnsafeUncheckedSendable(keyPath)
     }
 
     /// A unique value used to identify the modifier internally.
     public var key: Key {
-        Key(keyPath: keyPath)
+        Key(keyPath: keyPath.value)
     }
 
     /// A producer that produces the value of this atom.
     public func producer(atom: some Atom<Base>) -> AtomProducer<Produced> {
         AtomProducer { context in
             let value = context.transaction { $0.watch(atom) }
-            return value[keyPath: keyPath]
+            return value[keyPath: keyPath.value]
         } shouldUpdate: { oldValue, newValue in
             oldValue != newValue
         }
diff --git a/Tests/AtomsTests/Attribute/KeepAliveTests.swift b/Tests/AtomsTests/Attribute/KeepAliveTests.swift
@@ -5,15 +5,15 @@ import XCTest
 final class KeepAliveTests: XCTestCase {
     @MainActor
     func testKeepAliveAtoms() {
-        struct KeepAliveAtom<T: Hashable>: ValueAtom, KeepAlive, Hashable {
+        struct KeepAliveAtom<T: Hashable>: ValueAtom, KeepAlive, Hashable, @unchecked Sendable {
             let value: T
 
             func value(context: Context) -> T {
                 value
             }
         }
 
-        struct ScopedKeepAliveAtom<T: Hashable>: ValueAtom, KeepAlive, Scoped, Hashable {
+        struct ScopedKeepAliveAtom<T: Hashable>: ValueAtom, KeepAlive, Scoped, Hashable, @unchecked Sendable {
             let value: T
 
             func value(context: Context) -> T {
diff --git a/Tests/AtomsTests/Attribute/ScopedTests.swift b/Tests/AtomsTests/Attribute/ScopedTests.swift
@@ -5,7 +5,7 @@ import XCTest
 final class ScopedTests: XCTestCase {
     @MainActor
     func testScopedAtoms() {
-        struct ScopedAtom<ID: Hashable, T: Hashable>: ValueAtom, Scoped, Equatable {
+        struct ScopedAtom<ID: Hashable, T: Hashable>: ValueAtom, Scoped, Equatable, @unchecked Sendable {
             let key = UniqueKey()
             let scopeID: ID
             let value: T
diff --git a/Tests/AtomsTests/Core/StoreContextTests.swift b/Tests/AtomsTests/Core/StoreContextTests.swift
@@ -1379,7 +1379,7 @@ final class StoreContextTests: XCTestCase {
             }
         }
 
-        final class SubscriberHost {
+        final class SubscriberHost: @unchecked Sendable {
             var subscriberState: SubscriberState?
         }
 
diff --git a/Tests/AtomsTests/Core/SubscriberStateTests.swift b/Tests/AtomsTests/Core/SubscriberStateTests.swift
@@ -8,7 +8,7 @@ final class SubscriberStateTests: XCTestCase {
         var subscriberState: SubscriberState? = SubscriberState()
         var unsubscribedCount = 0
 
-        subscriberState!.unsubscribe = { _ in
+        subscriberState!.unsubscribe.value = { _ in
             unsubscribedCount += 1
         }
 
diff --git a/Tests/AtomsTests/Core/SubscriberTestsTests.swift b/Tests/AtomsTests/Core/SubscriberTestsTests.swift
@@ -35,7 +35,7 @@ final class SubscriberTests: XCTestCase {
 
         subscriber.subscribing = expected
 
-        XCTAssertEqual(state?.subscribing, expected)
+        XCTAssertEqual(state?.subscribing.value, expected)
 
         state = nil
 
@@ -52,7 +52,7 @@ final class SubscriberTests: XCTestCase {
             isUnsubscribed = true
         }
 
-        state?.unsubscribe?([])
+        state?.unsubscribe.value?([])
 
         XCTAssertTrue(isUnsubscribed)
 
diff --git a/Tests/AtomsTests/Utilities/TestAtom.swift b/Tests/AtomsTests/Utilities/TestAtom.swift
@@ -2,15 +2,15 @@ import Combine
 
 @testable import Atoms
 
-struct TestAtom<T: Hashable>: ValueAtom, Hashable {
+struct TestAtom<T: Hashable>: ValueAtom, Hashable, @unchecked Sendable {
     var value: T
 
     func value(context: Context) -> T {
         value
     }
 }
 
-struct TestValueAtom<T>: ValueAtom {
+struct TestValueAtom<T>: ValueAtom, @unchecked Sendable {
     var value: T
     var effect: TestEffect?
 
@@ -27,7 +27,7 @@ struct TestValueAtom<T>: ValueAtom {
     }
 }
 
-struct TestStateAtom<T>: StateAtom {
+struct TestStateAtom<T>: StateAtom, @unchecked Sendable {
     var defaultValue: T
     var effect: TestEffect?
 
@@ -44,7 +44,7 @@ struct TestStateAtom<T>: StateAtom {
     }
 }
 
-struct TestTaskAtom<T: Sendable>: TaskAtom {
+struct TestTaskAtom<T: Sendable>: TaskAtom, @unchecked Sendable {
     var effect: TestEffect?
     var getValue: () -> T
 
@@ -61,7 +61,7 @@ struct TestTaskAtom<T: Sendable>: TaskAtom {
     }
 }
 
-struct TestThrowingTaskAtom<Success: Sendable>: ThrowingTaskAtom {
+struct TestThrowingTaskAtom<Success: Sendable>: ThrowingTaskAtom, @unchecked Sendable {
     var effect: TestEffect?
     var getResult: () -> Result<Success, Error>
 
@@ -78,7 +78,7 @@ struct TestThrowingTaskAtom<Success: Sendable>: ThrowingTaskAtom {
     }
 }
 
-struct TestCustomRefreshableAtom<T: Sendable>: ValueAtom, Refreshable {
+struct TestCustomRefreshableAtom<T: Sendable>: ValueAtom, Refreshable, @unchecked Sendable {
     var getValue: (Context) -> T
     var refresh: (CurrentContext) async -> T
 
@@ -95,7 +95,7 @@ struct TestCustomRefreshableAtom<T: Sendable>: ValueAtom, Refreshable {
     }
 }
 
-struct TestCustomResettableAtom<T>: StateAtom, Resettable {
+struct TestCustomResettableAtom<T>: StateAtom, Resettable, @unchecked Sendable {
     var defaultValue: (Context) -> T
     var reset: (CurrentContext) -> Void
 
@@ -112,7 +112,7 @@ struct TestCustomResettableAtom<T>: StateAtom, Resettable {
     }
 }
 
-struct TestPublisherAtom<Publisher: Combine.Publisher>: PublisherAtom where Publisher.Output: Sendable {
+struct TestPublisherAtom<Publisher: Combine.Publisher>: PublisherAtom, @unchecked Sendable where Publisher.Output: Sendable {
     var effect: TestEffect?
     var makePublisher: () -> Publisher
 
@@ -129,7 +129,7 @@ struct TestPublisherAtom<Publisher: Combine.Publisher>: PublisherAtom where Publ
     }
 }
 
-struct TestAsyncSequenceAtom<Sequence: AsyncSequence>: AsyncSequenceAtom where Sequence.Element: Sendable {
+struct TestAsyncSequenceAtom<Sequence: AsyncSequence>: AsyncSequenceAtom, @unchecked Sendable where Sequence.Element: Sendable {
     var effect: TestEffect?
     var makeSequence: () -> Sequence
 
@@ -146,7 +146,7 @@ struct TestAsyncSequenceAtom<Sequence: AsyncSequence>: AsyncSequenceAtom where S
     }
 }
 
-struct TestObservableObjectAtom: ObservableObjectAtom {
+struct TestObservableObjectAtom: ObservableObjectAtom, @unchecked Sendable {
     var effect: TestEffect?
 
     var key: UniqueKey {
diff --git a/Tests/AtomsTests/Utilities/Utilities.swift b/Tests/AtomsTests/Utilities/Utilities.swift
@@ -33,7 +33,7 @@ final class TestObservableObject: ObservableObject, @unchecked Sendable {
     }
 }
 
-final class AsyncThrowingStreamPipe<Element> {
+final class AsyncThrowingStreamPipe<Element>: @unchecked Sendable {
     private(set) var stream: AsyncThrowingStream<Element, Error>
     private(set) var continuation: AsyncThrowingStream<Element, Error>.Continuation
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import Combine`
	`1`	`+@preconcurrency import Combine`
`2`	`2`
`3`	`3`	/// An atom type that provides a sequence of values of the given `Publisher` as an ``AsyncPhase`` value.
`4`	`4`	`///`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public extension Atom {`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`/// A modifier that you apply to an atom, producing a new value modified from the original value.`
`12`		`-public protocol AtomModifier {`
	`12`	`+public protocol AtomModifier: Sendable {`
`13`	`13`	`/// A type representing the stable identity of this modifier.`
`14`	`14`	`associatedtype Key: Hashable`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -3,4 +3,6 @@ internal final class StoreState {`
`3`	`3`	`var caches = [AtomKey: any AtomCacheProtocol]()`
`4`	`4`	`var states = [AtomKey: any AtomStateProtocol]()`
`5`	`5`	`var subscriptions = [AtomKey: [SubscriberKey: Subscription]]()`
	`6`	`+`
	`7`	`+ nonisolated init() {}`
`6`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ internal struct Subscriber {`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`var subscribing: Set<AtomKey> {`
`14`		`- get { state?.subscribing ?? [] }`
`15`		`- nonmutating set { state?.subscribing = newValue }`
	`14`	`+ get { state?.subscribing.value ?? [] }`
	`15`	`+ nonmutating set { state?.subscribing.value = newValue }`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`var unsubscribe: ((Set<AtomKey>) -> Void)? {`
`19`		`- get { state?.unsubscribe }`
`20`		`- nonmutating set { state?.unsubscribe = newValue }`
	`19`	`+ get { state?.unsubscribe.value }`
	`20`	`+ nonmutating set { state?.unsubscribe.value = newValue }`
`21`	`21`	`}`
`22`	`22`	`}`