Release 6.22.1

commit_hash:5f79bf67ca03abd426afa2c671efc0e83f55f984

Author: robot-vgsl

VGSLFundamentals/OSInfo.swift

@@ -50,7 +50,15 @@ public struct OSInfo: Sendable {
   }
 
   #if INTERNAL_BUILD
-  public static var current: Self = ._current
+  private static let __current: AllocatedUnfairLock<Self> = .init(initialState: ._current)
+  public static var current: Self {
+    get {
+      __current.withLock { $0 }
+    }
+    set {
+      __current.withLock { $0 = newValue }
+    }
+  }
 
   static func restoreSystemCurrent() {
     current = _current

VGSLFundamentals/concurrency/GCD.swift

@@ -10,6 +10,40 @@ public typealias DelayedExecution = (TimeInterval, @escaping () -> Void) -> Void
 public typealias DelayedRunner = (_ delay: TimeInterval, _ block: @escaping () -> Void)
   -> Cancellable
 
+@_unavailableFromAsync(message: "await the call to the @MainActor closure directly")
+@available(iOS, introduced: 9.0, deprecated: 13.0, message: "Use MainActor.assumeIsolated instead.")
+private func backportedAssumeIsolatedToMainActor<T>(
+  _ operation: @MainActor () throws -> T,
+  file _: StaticString = #fileID, line _: UInt = #line
+) rethrows -> T where T: Sendable {
+  typealias YesActor = @MainActor () throws -> T
+  typealias NoActor = () throws -> T
+
+  assert(Thread.isMainThread)
+  // To do the unsafe cast, we have to pretend it's @escaping.
+  return try withoutActuallyEscaping(operation) {
+    (_ fn: @escaping YesActor) throws -> T in
+    let rawFn = unsafeBitCast(fn, to: NoActor.self)
+    return try rawFn()
+  }
+}
+
+@_unavailableFromAsync(message: "await the call to the @MainActor closure directly")
+public func assumeIsolatedToMainActor<T>(
+  _ operation: @MainActor () throws -> T,
+  file _: StaticString = #fileID, line _: UInt = #line
+) rethrows -> T where T: Sendable {
+  if #available(iOS 13.0, tvOS 13.0, *) {
+    try MainActor.assumeIsolated {
+      try operation()
+    }
+  } else {
+    try backportedAssumeIsolatedToMainActor {
+      try operation()
+    }
+  }
+}
+
 public func onMainThread(_ block: @escaping () -> Void) {
   if Thread.isMainThread {
     block()
@@ -38,6 +72,19 @@ public func onMainThreadResult<T>(_ function: @escaping () -> Future<T>) -> Futu
   return future
 }
 
+/// Executes a @MainActor closure by bypassing actor isolation checks.
+///
+/// - Warning: Only use if you fully understand the memory safety implications.
+@_unavailableFromAsync
+@inlinable
+@inline(__always)
+@_spi(Unsafe)
+public func runUnsafelyOnMainActor<T>(_ body: @MainActor () throws -> T) rethrows -> T {
+  try withoutActuallyEscaping(body) { fn in
+    try unsafeBitCast(fn, to: (() throws -> T).self)()
+  }
+}
+
 public func onMainThreadAsync(_ block: @escaping () -> Void) {
   DispatchQueue.main.async(execute: block)
 }

VGSLFundamentals/concurrency/RWLock.swift

@@ -2,7 +2,15 @@
 
 import Foundation
 
-public var _RWLockUsesAllocatedUnfairLock = false
+private let __RWLockUsesAllocatedUnfairLock: AllocatedUnfairLock<Bool> = .init(initialState: false)
+public var _RWLockUsesAllocatedUnfairLock: Bool {
+  get {
+    __RWLockUsesAllocatedUnfairLock.withLock { $0 }
+  }
+  set {
+    __RWLockUsesAllocatedUnfairLock.withLock { $0 = newValue }
+  }
+}
 
 public struct RWLock {
   private let impl: any _ReadWriteLock

VGSLFundamentals/os/FileManaging.swift

@@ -4,7 +4,7 @@ import Foundation
 
 // swiftlint:disable use_make_instead_of_create
 
-public protocol FileManaging {
+public protocol FileManaging: Sendable {
   var applicationSupportDirectory: URL { get }
   var documentDirectory: URL { get }
   var libraryDirectory: URL { get }
@@ -18,7 +18,7 @@ public protocol FileManaging {
   func moveItem(at srcURL: URL, to dstURL: URL) throws
 }
 
-extension FileManager: FileManaging {
+extension FileManager: @unchecked @retroactive Sendable, FileManaging {
   public var applicationSupportDirectory: URL {
     getSystemDirectoryURL(.applicationSupportDirectory)
   }

VGSLFundamentals/reactive/Lazy.swift

@@ -297,5 +297,13 @@ extension Lazy {
 }
 
 #if DEBUG
-public var _LazyTraceLoggingEnabled = false
+private let __LazyTraceLoggingEnabled: AllocatedUnfairLock<Bool> = .init(initialState: false)
+public var _LazyTraceLoggingEnabled: Bool {
+  get {
+    __LazyTraceLoggingEnabled.withLock { $0 }
+  }
+  set {
+    __LazyTraceLoggingEnabled.withLock { $0 = newValue }
+  }
+}
 #endif

VGSLFundamentals/reactive/Signal.swift

@@ -223,13 +223,13 @@ extension Signal {
   @inlinable
   public func delay(_ interval: TimeInterval) -> Signal {
     Signal { observer in
-      var cancellable: Cancellable?
+      let cancellable: AllocatedUnfairLock<Cancellable?> = .init(initialState: nil)
       let disposable = addObserver { t in
-        cancellable = after(interval, onQueue: .main) { observer.action(t) }
+        cancellable.withLock { $0 = after(interval, onQueue: .main) { observer.action(t) } }
       }
       return Disposable {
         disposable.dispose()
-        cancellable?.cancel()
+        cancellable.withLock { $0 }?.cancel()
       }
     }
   }

VGSLNetworking/Retrying/NetworkRetryIntervalSource.swift

@@ -57,13 +57,13 @@ public final class HTTPHeaderRetryIntervalSource: NetworkRetryIntervalSource {
 
 public final class LocalRetryIntervalSource: NetworkRetryIntervalSource {
   // Starting value of 1 sec should be a reasonable compromise for retries.
-  private var retryingTimeout = RetryingTimeout(value: 1)
+  private let retryingTimeout = AllocatedUnfairLock<RetryingTimeout>(initialState: .init(value: 1))
 
   public init() {}
 
   public func determineInterval(from error: NSError, since _: Date) -> TimeInterval? {
     if error.isNonRecoverableServerError { return nil }
-    return retryingTimeout.getValueAndIncrement()
+    return retryingTimeout.withLock { $0.getValueAndIncrement() }
   }
 }
 

VGSLUI/PublicInterfaces.swift

@@ -2,10 +2,20 @@
 
 import CoreGraphics
 
-public var fontSpecifiers = FontSpecifiers(
+import VGSLFundamentals
+
+private let _fontSpecifiers = AllocatedUnfairLock<FontSpecifiers>(initialState: .init(
   text: systemFontSpecifier,
   display: systemFontSpecifier
-)
+))
+public var fontSpecifiers: FontSpecifiers {
+  get {
+    _fontSpecifiers.withLock { $0 }
+  }
+  set {
+    _fontSpecifiers.withLock { $0 = newValue }
+  }
+}
 
 private let systemFontSpecifier = SystemFontSpecifier()
 

VGSLUI/alert/AlertTextField.swift

@@ -3,17 +3,38 @@
 import Foundation
 
 public struct AlertTextField: Equatable, Sendable {
+  public enum ReturnKeyType: Sendable {
+    case `default`
+    case go
+    case google
+    case join
+    case next
+    case route
+    case search
+    case send
+    case yahoo
+    case done
+    case emergencyCall
+    case `continue`
+  }
+
   public let placeholder: String?
   public let initialText: String?
   public let isSecureTextEntry: Bool
+  public let enablesReturnKeyAutomatically: Bool
+  public let returnKeyType: ReturnKeyType
 
   public init(
     placeholder: String? = nil,
     initialText: String? = nil,
-    isSecureTextEntry: Bool = false
+    isSecureTextEntry: Bool = false,
+    enablesReturnKeyAutomatically: Bool = false,
+    returnKeyType: ReturnKeyType = .default
   ) {
     self.placeholder = placeholder
     self.initialText = initialText
     self.isSecureTextEntry = isSecureTextEntry
+    self.enablesReturnKeyAutomatically = enablesReturnKeyAutomatically
+    self.returnKeyType = returnKeyType
   }
 }

VGSLUI/extensions/UIDeviceExtensions.swift

@@ -16,7 +16,11 @@ extension UIDevice {
     uname(&systemInfo)
     let identifier = withUnsafePointer(to: &systemInfo.machine) {
       $0.withMemoryRebound(to: CChar.self, capacity: 1) { ptr in
+        #if swift(>=6.0)
         String(validatingCString: ptr)
+        #else
+        String(validatingUTF8: ptr)
+        #endif
       }
     }
     #else