fix #91; retroactive conformances to Sendable (#99)

* fix #91; retroactive conformances to Sendable

* Typos

Author: mattmassicotte

Guide.docc/CommonProblems.md

@@ -656,6 +656,31 @@ it `Sendable` should not be your first approach.
 It is often easier to try other techniques first, falling back to
 manual synchronization only when truly necessary.
 
+#### Retroactive Sendable Conformance
+
+Your dependencies may also expose types that are using manual synchronization.
+This is usually visible only via documentation.
+It is possible to add an `@unchecked Sendable` conformance in this case as well.
+
+```swift
+extension ColorComponents: @retroactive @unchecked Sendable {
+}
+```
+
+Because `Sendable` is a marker protocol, a retroactive conformance
+does not have direct binary compatibility issues.
+However, it should still be used with extreme caution.
+Types that use manual synchronization can come with conditions or
+exceptions to their safety that may not completely match the semantics of
+`Sendable`.
+Further, you should be _particularly_ careful about using this technique
+for types that are part of your system's public API.
+
+> Note: To learn more about retroactive conformances,
+see the associated [Swift evolution proposal][SE-0364].
+
+[SE-0364]: https://github.com/swiftlang/swift-evolution/blob/main/proposals/0364-retroactive-conformance-warning.md
+
 #### Sendable Reference Types
 
 It is possible for reference types to be validated as `Sendable` without

Sources/Examples/Boundaries.swift

@@ -8,7 +8,7 @@ func applyBackground(_ color: ColorComponents) {
 }
 
 #if swift(<6.0)
-/// A non-isolated function  that accepts non-`Sendable` parameters.
+/// A non-isolated function that accepts non-`Sendable` parameters.
 func updateStyle(backgroundColor: ColorComponents) async {
     // the `backgroundColor` parameter is being moved from the
     // non-isolated domain to the `MainActor` here.
@@ -19,6 +19,13 @@ func updateStyle(backgroundColor: ColorComponents) async {
 }
 #endif
 
+#if swift(>=6.0)
+/// A non-isolated function that accepts non-`Sendable` parameters which must be safe to use at callsites.
+func sending_updateStyle(backgroundColor: sending ColorComponents) async {
+    await applyBackground(backgroundColor)
+}
+#endif
+
 // MARK: Latent Isolation
 
 /// MainActor-isolated function that accepts non-`Sendable` parameters.
@@ -96,13 +103,35 @@ actor Style {
     }
 }
 
+// MARK: Manual Synchronization
+
+extension RetroactiveColorComponents: @retroactive @unchecked Sendable {
+}
+
+/// An overload used by `retroactive_updateStyle` to match types.
+@MainActor
+func applyBackground(_ color: RetroactiveColorComponents	) {
+}
+
+/// A non-isolated function that accepts retroactively-`Sendable` parameters.
+func retroactive_updateStyle(backgroundColor: RetroactiveColorComponents) async {
+    await applyBackground(backgroundColor)
+}
+
 func exerciseBoundaryCrossingExamples() async {
     print("Isolation Boundary Crossing Examples")
 
 #if swift(<6.0)
     print("  - updateStyle(backgroundColor:) passing its argument unsafely")
 #endif
 
+#if swift(>=6.0)
+    print("  - using sending to allow safe usage of ColorComponents")
+    let nonSendableComponents = ColorComponents()
+
+    await sending_updateStyle(backgroundColor: nonSendableComponents)
+#endif
+
     print("  - using ColorComponents only from the main actor")
     let t1 = Task { @MainActor in
         let components = ColorComponents()
@@ -137,4 +166,9 @@ func exerciseBoundaryCrossingExamples() async {
     let actor = Style(background: actorComponents)
 
     await actor.applyBackground()
+
+    print("  - using a retroactive unchecked Sendable argument")
+    let retroactiveComponents = RetroactiveColorComponents()
+
+    await retroactive_updateStyle(backgroundColor: retroactiveComponents)
 }

Sources/Library/Library.swift

@@ -21,6 +21,15 @@ public struct ColorComponents {
     }
 }
 
+/// A variant of `ColorComponents` that could be marked as Sendable
+public struct RetroactiveColorComponents {
+    public let red: Float = 1.0
+    public let green: Float = 1.0
+    public let blue: Float = 1.0
+
+    public init() {}
+}
+
 /// Explicitly-Sendable variant of `ColorComponents`.
 public struct SendableColorComponents : Sendable {
     public let red: Float = 1.0