more Sendable conformances & Sendable Context (#381)

weissi · web-flow · commit add9e1518ac3 · 2023-02-08T08:05:08.000-08:00
diff --git a/Sources/TSCBasic/CodableResult.swift b/Sources/TSCBasic/CodableResult.swift
@@ -49,6 +49,8 @@ public struct CodableResult<Success, Failure>: Codable where Success: Codable, F
     }
 }
 
+extension CodableResult: Sendable where Success: Sendable, Failure: Sendable {}
+
 extension CodableResult where Failure == StringError {
     public init(body: () throws -> Success) {
         do {
diff --git a/Sources/TSCBasic/Condition.swift b/Sources/TSCBasic/Condition.swift
@@ -50,3 +50,7 @@ public struct Condition {
         return try body()
     }
 }
+
+#if compiler(>=5.7)
+extension Condition: Sendable {}
+#endif
diff --git a/Sources/TSCBasic/DeltaAlgorithm.swift b/Sources/TSCBasic/DeltaAlgorithm.swift
@@ -27,7 +27,7 @@
 /// It is not an error to provide a predicate that does not satisfy these
 /// requirements, and the algorithm will generally produce reasonable results.
 /// However, it may run substantially more tests than with a good predicate.
-public struct DeltaAlgorithm<Change: Hashable> {
+public struct DeltaAlgorithm<Change: Hashable>: Sendable {
 
     public init() {}
 
diff --git a/Sources/TSCBasic/DiagnosticsEngine.swift b/Sources/TSCBasic/DiagnosticsEngine.swift
@@ -21,9 +21,9 @@ extension DiagnosticData {
 public protocol DiagnosticLocation: Sendable, CustomStringConvertible {
 }
 
-public struct Diagnostic: CustomStringConvertible {
+public struct Diagnostic: CustomStringConvertible, Sendable {
     /// The behavior associated with this diagnostic.
-    public enum Behavior {
+    public enum Behavior: Sendable {
         /// An error which will halt the operation.
         case error
 
@@ -38,7 +38,7 @@ public struct Diagnostic: CustomStringConvertible {
         case ignored
     }
 
-    public struct Message {
+    public struct Message: Sendable {
         /// The diagnostic's behavior.
         public let behavior: Behavior
 
@@ -191,7 +191,7 @@ extension Diagnostic.Message {
     }
 }
 
-public struct StringDiagnostic: DiagnosticData {
+public struct StringDiagnostic: DiagnosticData, Sendable {
     /// The diagnostic description.
     public let description: String
 
diff --git a/Sources/TSCBasic/FileSystem.swift b/Sources/TSCBasic/FileSystem.swift
@@ -13,8 +13,8 @@ import Foundation
 import Dispatch
 import SystemPackage
 
-public struct FileSystemError: Error, Equatable {
-    public enum Kind: Equatable {
+public struct FileSystemError: Error, Equatable, Sendable {
+    public enum Kind: Equatable, Sendable {
         /// Access to the path is denied.
         ///
         /// This is used when an operation cannot be completed because a component of
diff --git a/Sources/TSCBasic/HashAlgorithms.swift b/Sources/TSCBasic/HashAlgorithms.swift
@@ -12,7 +12,7 @@
 import CryptoKit
 #endif
 
-public protocol HashAlgorithm {
+public protocol HashAlgorithm: Sendable {
 
     /// Hashes the input bytes, returning the digest.
     ///
@@ -31,7 +31,7 @@ extension HashAlgorithm {
 /// SHA-256 implementation from Secure Hash Algorithm 2 (SHA-2) set of
 /// cryptographic hash functions (FIPS PUB 180-2).
 ///  Uses CryptoKit where available
-public struct SHA256: HashAlgorithm {
+public struct SHA256: HashAlgorithm, Sendable {
     private let underlying: HashAlgorithm
 
     public init() {
@@ -197,7 +197,7 @@ struct InternalSHA256: HashAlgorithm {
 #if canImport(CryptoKit)
 @available(*, deprecated, message: "use SHA256 which abstract over platform differences")
 @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
-public struct CryptoKitSHA256: HashAlgorithm {
+public struct CryptoKitSHA256: HashAlgorithm, Sendable {
     let underlying = _CryptoKitSHA256()
     public init() {}
     public func hash(_ bytes: ByteString) -> ByteString {
diff --git a/Sources/TSCBasic/KeyedPair.swift b/Sources/TSCBasic/KeyedPair.swift
@@ -50,3 +50,5 @@ public struct KeyedPair<T, K: Hashable>: Hashable {
         return lhs.key == rhs.key
     }
 }
+
+extension KeyedPair: Sendable where T: Sendable, K: Sendable {}
diff --git a/Sources/TSCBasic/LazyCache.swift b/Sources/TSCBasic/LazyCache.swift
@@ -30,6 +30,7 @@ import class Foundation.NSLock
 /// ```
 ///
 /// See: https://bugs.swift.org/browse/SR-1042
+@available(*, deprecated, message: "This implementation does not work -- https://github.com/apple/swift-tools-support-core/issues/385")
 public struct LazyCache<Class, T> {
     // FIXME: It would be nice to avoid a per-instance lock, but this type isn't
     // intended for creating large numbers of instances of. We also really want
@@ -57,3 +58,8 @@ public struct LazyCache<Class, T> {
         }
     }
 }
+
+#if swift(>=5.6)
+@available(*, unavailable) // until https://github.com/apple/swift-tools-support-core/issues/385 is fixed
+extension LazyCache: Sendable {}
+#endif
diff --git a/Sources/TSCBasic/OrderedDictionary.swift b/Sources/TSCBasic/OrderedDictionary.swift
@@ -123,3 +123,5 @@ extension OrderedDictionary: RandomAccessCollection {
         return (key, value)
     }
 }
+
+extension OrderedDictionary: Sendable where Key: Sendable, Value: Sendable {}
diff --git a/Sources/TSCBasic/OrderedSet.swift b/Sources/TSCBasic/OrderedSet.swift
@@ -128,3 +128,5 @@ public func == <T>(lhs: OrderedSet<T>, rhs: OrderedSet<T>) -> Bool {
 }
 
 extension OrderedSet: Hashable where Element: Hashable { }
+
+extension OrderedSet: Sendable where Element: Sendable { }
diff --git a/Sources/TSCBasic/misc.swift b/Sources/TSCBasic/misc.swift
@@ -264,6 +264,8 @@ public struct CodableRange<Bound> where Bound: Comparable & Codable {
     }
 }
 
+extension CodableRange: Sendable where Bound: Sendable {}
+
 extension CodableRange: Codable {
     private enum CodingKeys: String, CodingKey {
         case lowerBound, upperBound
diff --git a/Sources/TSCUtility/Context.swift b/Sources/TSCUtility/Context.swift
@@ -9,11 +9,127 @@
 */
 
 import Foundation
+import _Concurrency
 
-/// Typealias for an any typed dictionary for arbitrary usage to store context.
-public typealias Context = [ObjectIdentifier: Any]
+
+public struct Context {
+    private var backing: [ObjectIdentifier: Any] = [:]
+
+#if compiler(>=5.5.2)
+    @available(*, deprecated, message: "Values should be Sendable")
+    @_disfavoredOverload
+    public init(dictionaryLiteral keyValuePairs: (ObjectIdentifier, Any)...) {
+        self.backing = Dictionary(uniqueKeysWithValues: keyValuePairs)
+    }
+
+    public init(dictionaryLiteral keyValuePairs: (ObjectIdentifier, Sendable)...) {
+        self.backing = Dictionary(uniqueKeysWithValues: keyValuePairs)
+    }
+
+    @available(*, deprecated, message: "Values should be Sendable")
+    @_disfavoredOverload
+    public subscript(key: ObjectIdentifier) -> Any? {
+        get {
+            return self.backing[key]
+        }
+        set {
+            self.backing[key] = newValue
+        }
+    }
+
+    public subscript<Value>(key: ObjectIdentifier, as type: Value.Type = Value.self) -> Value? where Value: Sendable {
+        get {
+            return self.backing[key] as? Value
+        }
+        set {
+            self.backing[key] = newValue
+        }
+    }
+#else
+    public init(dictionaryLiteral keyValuePairs: (ObjectIdentifier, Any)...) {
+        self.backing = Dictionary(uniqueKeysWithValues: keyValuePairs)
+    }
+
+    @_disfavoredOverload
+    public subscript(key: ObjectIdentifier) -> Any? {
+        get {
+            return self.backing[key]
+        }
+        set {
+            self.backing[key] = newValue
+        }
+    }
+
+    public subscript<Value>(key: ObjectIdentifier, as type: Value.Type = Value.self) -> Value? {
+        get {
+            return self.backing[key] as? Value
+        }
+        set {
+            self.backing[key] = newValue
+        }
+    }
+#endif
+}
+
+#if compiler(>=5.7)
+extension Context: /* until we can remove the support for 'Any' values */ @unchecked Sendable {}
+#else
+#if compiler(>=5.5.2)
+extension Context: UnsafeSendable {}
+#endif
+#endif
+
+@available(*, deprecated, renamed: "init()")
+extension Context: ExpressibleByDictionaryLiteral {
+    public typealias Key = ObjectIdentifier
+    public typealias Value = Any
+}
 
 extension Context {
+#if compiler(>=5.5.2)
+    /// Get the value for the given type.
+    @available(*, deprecated, message: "Values should be Sendable")
+    @_disfavoredOverload
+    public func get<T>(_ type: T.Type = T.self) -> T {
+        guard let value = getOptional(type) else {
+            fatalError("no type \(T.self) in context")
+        }
+        return value
+    }
+
+    public func get<T: Sendable>(_ type: T.Type = T.self) -> T {
+        guard let value = self.getOptional(type) else {
+            fatalError("no type \(T.self) in context")
+        }
+        return value
+    }
+
+    /// Get the value for the given type, if present.
+    @available(*, deprecated, message: "Values should be Sendable")
+    @_disfavoredOverload
+    public func getOptional<T>(_ type: T.Type = T.self) -> T? {
+        guard let value = self[ObjectIdentifier(T.self)] else {
+            return nil
+        }
+        return value as? T
+    }
+
+    /// Get the value for the given type, if present.
+    public func getOptional<T: Sendable>(_ type: T.Type = T.self) -> T? {
+        return self[ObjectIdentifier(T.self)]
+    }
+
+    /// Set a context value for a type.
+    @available(*, deprecated, message: "Values should be Sendable")
+    @_disfavoredOverload
+    public mutating func set<T>(_ value: T) {
+        self[ObjectIdentifier(T.self)] = value
+    }
+
+    public mutating func set<Value: Sendable>(_ value: Value) {
+        self[ObjectIdentifier(Value.self)] = value
+    }
+#else
     /// Get the value for the given type.
     public func get<T>(_ type: T.Type = T.self) -> T {
         guard let value = getOptional(type) else {
@@ -34,4 +150,5 @@ extension Context {
     public mutating func set<T>(_ value: T) {
         self[ObjectIdentifier(T.self)] = value
     }
+#endif
 }
diff --git a/Sources/TSCUtility/SerializedDiagnostics.swift b/Sources/TSCUtility/SerializedDiagnostics.swift
@@ -11,7 +11,7 @@ import Foundation
 import TSCBasic
 
 /// Represents diagnostics serialized in a .dia file by the Swift compiler or Clang.
-public struct SerializedDiagnostics {
+public struct SerializedDiagnostics: Sendable {
   public enum Error: Swift.Error {
     case badMagic
     case unexpectedTopLevelRecord
@@ -61,7 +61,7 @@ extension SerializedDiagnostics.Error: CustomNSError {
 extension SerializedDiagnostics {
   public struct Diagnostic {
 
-    public enum Level: UInt64 {
+    public enum Level: UInt64, Sendable {
       case ignored, note, warning, error, fatal, remark
     }
     /// The diagnostic message text.
@@ -168,7 +168,7 @@ extension SerializedDiagnostics {
     }
   }
 
-  public struct FixIt {
+  public struct FixIt: Sendable {
     /// Start location.
     public var start: SourceLocation
     /// End location.
@@ -178,6 +178,12 @@ extension SerializedDiagnostics {
   }
 }
 
+#if compiler(>=5.7)
+extension SerializedDiagnostics.Diagnostic: Sendable {}
+#else
+extension SerializedDiagnostics.Diagnostic: UnsafeSendable {}
+#endif
+
 extension SerializedDiagnostics {
   private struct Reader: BitstreamVisitor {
     var diagnosticRecords: [[OwnedRecord]] = []
diff --git a/Sources/TSCUtility/Tracing.swift b/Sources/TSCUtility/Tracing.swift
@@ -10,7 +10,7 @@
 
 import Foundation
 
-public enum TracingEventType: String, Codable {
+public enum TracingEventType: String, Codable, Sendable {
     case asyncBegin
     case asyncEnd
 }
@@ -51,7 +51,7 @@ public protocol TracingEventProtocol {
     )
 }
 
-public protocol TracingCollectionProtocol {
+public protocol TracingCollectionProtocol: Sendable {
     var events: [TracingEventProtocol] { get set }
     init(_ events: [TracingEventProtocol])
 }
@@ -62,7 +62,7 @@ extension TracingCollectionProtocol {
     }
 }
 
-public struct TracingEvent: TracingEventProtocol, Codable {
+public struct TracingEvent: TracingEventProtocol, Codable, Sendable {
     public let cat: String
     public let name: String
     public let id: String
@@ -135,13 +135,37 @@ public struct TracingEvent: TracingEventProtocol, Codable {
     #endif
 }
 
-public class TracingCollection: TracingCollectionProtocol {
-    public var events: [TracingEventProtocol] = []
+public final class TracingCollection {
+    private let lock = NSLock()
+    private var _events: [TracingEventProtocol] = []
+
+    public var events: [TracingEventProtocol] {
+        get {
+            return self.lock.withLock {
+                self._events
+            }
+        }
+
+        set {
+            self.lock.withLock {
+                self._events = newValue
+            }
+        }
+    }
+
     public required init(_ events: [TracingEventProtocol] = []) {
         self.events = events
     }
 }
 
+#if compiler(>=5.7)
+extension TracingCollection: @unchecked /* because self-locked */ Sendable {}
+extension TracingCollection: TracingCollectionProtocol {}
+#else
+extension TracingCollection: UnsafeSendable {}
+extension TracingCollection: TracingCollectionProtocol {}
+#endif
+
 extension Context {
     public static func withTracing(_ collection: TracingCollectionProtocol) -> Context {
         return Context(dictionaryLiteral: (ObjectIdentifier(TracingCollectionProtocol.self), collection as Any))
@@ -154,10 +178,7 @@ extension Context {
 
     public var tracing: TracingCollectionProtocol? {
         get {
-            guard let collection = self[ObjectIdentifier(TracingCollectionProtocol.self)] as? TracingCollectionProtocol else {
-                return nil
-            }
-            return collection
+            return self[ObjectIdentifier(TracingCollectionProtocol.self), as: TracingCollectionProtocol.self]
         }
         set {
             self[ObjectIdentifier(TracingCollectionProtocol.self)] = newValue
diff --git a/Sources/TSCUtility/Triple.swift b/Sources/TSCUtility/Triple.swift
diff --git a/Tests/TSCBasicTests/LazyCacheTests.swift b/Tests/TSCBasicTests/LazyCacheTests.swift
diff --git a/Tests/TSCBasicTests/SendableTests.swift b/Tests/TSCBasicTests/SendableTests.swift
diff --git a/Tests/TSCUtilityTests/SendableTests.swift b/Tests/TSCUtilityTests/SendableTests.swift

Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,8 @@ public struct CodableResult<Success, Failure>: Codable where Success: Codable, F`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
	`52`	`+extension CodableResult: Sendable where Success: Sendable, Failure: Sendable {}`
	`53`	`+`
`52`	`54`	`extension CodableResult where Failure == StringError {`
`53`	`55`	`public init(body: () throws -> Success) {`
`54`	`56`	`do {`
Original file line number	Diff line number	Diff line change
`@@ -50,3 +50,7 @@ public struct Condition {`
`50`	`50`	`return try body()`
`51`	`51`	`}`
`52`	`52`	`}`
	`53`	`+`
	`54`	`+#if compiler(>=5.7)`
	`55`	`+extension Condition: Sendable {}`
	`56`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@ extension DiagnosticData {`
`21`	`21`	`public protocol DiagnosticLocation: Sendable, CustomStringConvertible {`
`22`	`22`	`}`
`23`	`23`
`24`		`-public struct Diagnostic: CustomStringConvertible {`
	`24`	`+public struct Diagnostic: CustomStringConvertible, Sendable {`
`25`	`25`	`/// The behavior associated with this diagnostic.`
`26`		`- public enum Behavior {`
	`26`	`+ public enum Behavior: Sendable {`
`27`	`27`	`/// An error which will halt the operation.`
`28`	`28`	`case error`
`29`	`29`
`@@ -38,7 +38,7 @@ public struct Diagnostic: CustomStringConvertible {`
`38`	`38`	`case ignored`
`39`	`39`	`}`
`40`	`40`
`41`		`- public struct Message {`
	`41`	`+ public struct Message: Sendable {`
`42`	`42`	`/// The diagnostic's behavior.`
`43`	`43`	`public let behavior: Behavior`
`44`	`44`
`@@ -191,7 +191,7 @@ extension Diagnostic.Message {`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`
`194`		`-public struct StringDiagnostic: DiagnosticData {`
	`194`	`+public struct StringDiagnostic: DiagnosticData, Sendable {`
`195`	`195`	`/// The diagnostic description.`
`196`	`196`	`public let description: String`
`197`	`197`
Original file line number	Diff line number	Diff line change
`@@ -50,3 +50,5 @@ public struct KeyedPair<T, K: Hashable>: Hashable {`
`50`	`50`	`return lhs.key == rhs.key`
`51`	`51`	`}`
`52`	`52`	`}`
	`53`	`+`
	`54`	`+extension KeyedPair: Sendable where T: Sendable, K: Sendable {}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@ import class Foundation.NSLock`
`30`	`30`	/// ```
`31`	`31`	`///`
`32`	`32`	`/// See: https://bugs.swift.org/browse/SR-1042`
	`33`	`+@available(*, deprecated, message: "This implementation does not work -- https://github.com/apple/swift-tools-support-core/issues/385")`
`33`	`34`	`public struct LazyCache<Class, T> {`
`34`	`35`	`// FIXME: It would be nice to avoid a per-instance lock, but this type isn't`
`35`	`36`	`// intended for creating large numbers of instances of. We also really want`
`@@ -57,3 +58,8 @@ public struct LazyCache<Class, T> {`
`57`	`58`	`}`
`58`	`59`	`}`
`59`	`60`	`}`
	`61`	`+`
	`62`	`+#if swift(>=5.6)`
	`63`	`+@available(*, unavailable) // until https://github.com/apple/swift-tools-support-core/issues/385 is fixed`
	`64`	`+extension LazyCache: Sendable {}`
	`65`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -123,3 +123,5 @@ extension OrderedDictionary: RandomAccessCollection {`
`123`	`123`	`return (key, value)`
`124`	`124`	`}`
`125`	`125`	`}`
	`126`	`+`
	`127`	`+extension OrderedDictionary: Sendable where Key: Sendable, Value: Sendable {}`
Original file line number	Diff line number	Diff line change
`@@ -128,3 +128,5 @@ public func == <T>(lhs: OrderedSet<T>, rhs: OrderedSet<T>) -> Bool {`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`extension OrderedSet: Hashable where Element: Hashable { }`
	`131`	`+`
	`132`	`+extension OrderedSet: Sendable where Element: Sendable { }`