Replace LockedState with Mutex (swiftlang#1840)

Author: jmschonfeld

Sources/FoundationEssentials/AttributedString/AttributeScope.swift

@@ -10,6 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+internal import Synchronization
+
 // Developers can also add the attributes to pre-defined scopes of attributes, which are used to provide type information to the encoding and decoding of AttributedString values, as well as allow for dynamic member lookup in Runs of AttributedStrings.
 // Example, where ForegroundColor is an existing AttributedStringKey:
 // struct MyAttributes : AttributeScope {
@@ -121,7 +123,7 @@ fileprivate struct LoadedScopeCache : Sendable {
     }
 }
 
-fileprivate let _loadedScopeCache = LockedState(initialState: LoadedScopeCache())
+fileprivate let _loadedScopeCache = Mutex(LoadedScopeCache())
 
 extension AttributeScopes {
     @_spi(AttributedStringDefaultScopes)

Sources/FoundationEssentials/AttributedString/AttributedString+IndexValidity.swift

@@ -10,30 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if canImport(Synchronization)
 internal import Synchronization
-#endif
 
 extension AttributedString.Guts {
     typealias Version = UInt
-    
-    #if canImport(Synchronization)
+
     private static let _nextVersion = Atomic<Version>(0)
-    #else
-    private static let _nextVersion = LockedState<Version>(initialState: 0)
-    #endif
 
     static func createNewVersion() -> Version {
-        #if canImport(Synchronization)
         _nextVersion.wrappingAdd(1, ordering: .relaxed).oldValue
-        #else
-        _nextVersion.withLock { value in
-            defer {
-                value &+= 1
-            }
-            return value
-        }
-        #endif
     }
 
     func incrementVersion() {

Sources/FoundationEssentials/AttributedString/AttributedString.swift

@@ -18,6 +18,8 @@ internal import _RopeModule
 internal import _FoundationCollections
 #endif
 
+internal import Synchronization
+
 @dynamicMemberLookup
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 public struct AttributedString : Sendable {
@@ -30,12 +32,9 @@ public struct AttributedString : Sendable {
 
 @available(macOS 12, iOS 15, tvOS 15, watchOS 8, *)
 extension AttributedString {
-    internal static let currentIdentity = LockedState(initialState: 0)
+    internal static let currentIdentity = Atomic(0)
     internal static var _nextModifyIdentity : Int {
-        currentIdentity.withLock { identity in
-            identity += 1
-            return identity
-        }
+        currentIdentity.wrappingAdd(1, ordering: .relaxed).newValue
     }
 }
 

Sources/FoundationEssentials/CMakeLists.txt

@@ -23,8 +23,8 @@ add_library(FoundationEssentials
     DateInterval.swift
     FoundationEssentials.swift
     IndexPath.swift
-    LockedState.swift
     Logging.swift
+    Mutex+ExtendedLifetime.swift
     OutputBuffer.swift
     Platform.swift
     Progress+Stub.swift

Sources/FoundationEssentials/Calendar/Calendar_Cache.swift

@@ -15,6 +15,8 @@ internal import _ForSwiftFoundation
 import CoreFoundation
 #endif
 
+internal import Synchronization
+
 #if FOUNDATION_FRAMEWORK && canImport(_FoundationICU)
 internal func _calendarICUClass() -> _CalendarProtocol.Type? {
     _CalendarICU.self
@@ -41,9 +43,9 @@ struct CalendarCache : Sendable, ~Copyable {
 
     // The values stored in these two locks do not depend upon each other, so it is safe to access them with separate locks. This helps avoids contention on a single lock.
 
-    private let _current = LockedState<(any _CalendarProtocol)?>(initialState: nil)
-    private let _fixed = LockedState<[Calendar.Identifier: any _CalendarProtocol]>(initialState: [:])
-    
+    private let _current = Mutex<(any _CalendarProtocol)?>(nil)
+    private let _fixed = Mutex<[Calendar.Identifier: any _CalendarProtocol]>([:])
+
     fileprivate init() {
     }
 

Sources/FoundationEssentials/FileManager/SwiftFileManager.swift

@@ -12,6 +12,8 @@
 
 #if !FOUNDATION_FRAMEWORK
 
+internal import Synchronization
+
 public struct FileAttributeType : Hashable, RawRepresentable, Sendable {
     public let rawValue: String
     public init(rawValue: String) {
@@ -179,7 +181,7 @@ extension FileManager {
 open class FileManager : @unchecked Sendable {
     // Sendable note: _impl may only be mutated in `init`
     private var _impl: _FileManagerImpl
-    private let _lock = LockedState<State>(initialState: .init(delegate: nil))
+    private let _lock = Mutex(State(delegate: nil))
     private let isDefault: Bool
 
     private static let _default = FileManager(default: true)

Sources/FoundationEssentials/Formatting/FormatterCache.swift

@@ -10,10 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-package struct FormatterCache<Format : Hashable & Sendable, FormattingType: Sendable>: Sendable {
+internal import Synchronization
+
+package struct FormatterCache<Format : Hashable & Sendable, FormattingType: Sendable>: Sendable, ~Copyable {
     let countLimit = 100
 
-    private let _lock: LockedState<[Format: FormattingType]>
+    private let _lock: Mutex<[Format: FormattingType]>
     package func formatter(for config: Format, creator: () throws -> FormattingType) rethrows -> FormattingType {
         let existed = _lock.withLock { cache in
             return cache [config]
@@ -43,12 +45,12 @@ package struct FormatterCache<Format : Hashable & Sendable, FormattingType: Send
     }
 
     package subscript(key: Format) -> FormattingType? {
-        _lock.withLock {
+        _lock.withLockExtendingLifetimeOfState {
             $0[key]
         }
     }
 
     package init() {
-        _lock = LockedState(initialState: [Format: FormattingType]())
+        _lock = Mutex([Format: FormattingType]())
     }
 }

Sources/FoundationEssentials/JSON/BufferView.swift

@@ -75,6 +75,8 @@ extension BufferView /*where Element: BitwiseCopyable*/ {
     }
 }
 
+extension BufferView: Sendable where Element: Sendable {}
+
 //MARK: Sequence
 
 extension BufferView: Sequence {
@@ -94,9 +96,6 @@ extension BufferView: Sequence {
     }
 }
 
-@available(*, unavailable)
-extension BufferView: Sendable {}
-
 extension BufferView where Element: Equatable {
 
     internal func elementsEqual(_ other: Self) -> Bool {

Sources/FoundationEssentials/JSON/BufferViewIndex.swift

@@ -24,6 +24,8 @@ internal struct BufferViewIndex<Element> {
     }
 }
 
+extension BufferViewIndex: @unchecked Sendable where Element: Sendable {}
+
 extension BufferViewIndex: Equatable {}
 
 extension BufferViewIndex: Hashable {}
@@ -48,6 +50,3 @@ extension BufferViewIndex: Comparable {
         lhs._rawValue < rhs._rawValue
     }
 }
-
-@available(*, unavailable)
-extension BufferViewIndex: Sendable {}