CHANGELOG.md

@@ -1,11 +1,5 @@
 # Changelog
 
-## 2022.1 (39)
-This is a(nother) hotfix for the previous build. Their changelogs are included below.
-
-Bugfixes:
-- Fix instance selector screen crashing on iOS 15
-
 ## 2022.1 (38)
 This is a hotfix for the previous build. Its changelog is included below.
 

Tusker.xcodeproj/project.pbxproj

@@ -2213,7 +2213,7 @@
 				CODE_SIGN_ENTITLEMENTS = Tusker/Tusker.entitlements;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 39;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = V4WK9KR9U2;
 				INFOPLIST_FILE = Tusker/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
@@ -2242,7 +2242,7 @@
 				CODE_SIGN_ENTITLEMENTS = Tusker/Tusker.entitlements;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 39;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = V4WK9KR9U2;
 				INFOPLIST_FILE = Tusker/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
@@ -2352,7 +2352,7 @@
 				CODE_SIGN_ENTITLEMENTS = OpenInTusker/OpenInTusker.entitlements;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 39;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = V4WK9KR9U2;
 				INFOPLIST_FILE = OpenInTusker/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 14.1;
@@ -2379,7 +2379,7 @@
 				CODE_SIGN_ENTITLEMENTS = OpenInTusker/OpenInTusker.entitlements;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 39;
+				CURRENT_PROJECT_VERSION = 38;
 				DEVELOPMENT_TEAM = V4WK9KR9U2;
 				INFOPLIST_FILE = OpenInTusker/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 14.1;

Tusker/MultiThreadDictionary.swift

@@ -13,26 +13,24 @@ import os
 // to make the lock semantics more clear
 @available(iOS, obsoleted: 16.0)
 class MultiThreadDictionary<Key: Hashable & Sendable, Value: Sendable> {
-    private let lock: LockHolder<[AnyHashable: Any]>
+    private let lock: any Lock<[Key: Value]>
     
     init() {
         if #available(iOS 16.0, *) {
-            let lock = OSAllocatedUnfairLock(initialState: [:])
+            self.lock = OSAllocatedUnfairLock(initialState: [:])
-            self.lock = LockHolder(withLock: lock.withLock(_:))
         } else {
-            let lock = UnfairLock(initialState: [:])
+            self.lock = MutexLock(initialState: [:])
-            self.lock = LockHolder(withLock: lock.withLock(_:))
         }
     }
     
     subscript(key: Key) -> Value? {
         get {
-            return try! lock.withLock { dict in
+            return lock.withLock { dict in
                 dict[key]
-            } as! Value?
+            }
         }
         set(value) {
-            _ = try! lock.withLock { dict in
+            lock.withLock { dict in
                 dict[key] = value
             }
         }
@@ -40,34 +38,22 @@ class MultiThreadDictionary<Key: Hashable & Sendable, Value: Sendable> {
     
     /// If the result of this function is unused, it is preferable to use `removeValueWithoutReturning` as it executes asynchronously and doesn't block the calling thread.
     func removeValue(forKey key: Key) -> Value? {
-        return try! lock.withLock { dict in
+        return lock.withLock { dict in
             dict.removeValue(forKey: key)
-        } as! Value?
+        }
     }
     
     func contains(key: Key) -> Bool {
-        return try! lock.withLock { dict in
+        return lock.withLock { dict in
             dict.keys.contains(key)
-        } as! Bool
+        }
     }
     
-    // TODO: this should really be throws/rethrows but the stupid type-erased lock makes that not possible
+    func withLock<R>(_ body: @Sendable (inout [Key: Value]) throws -> R) rethrows -> R where R: Sendable {
-    func withLock<R>(_ body: @Sendable (inout [Key: Value]) -> R) -> R where R: Sendable {
+        return try lock.withLock(body)
-        return try! lock.withLock { dict in
-            var downcasted = dict as! [Key: Value]
-            defer { dict = downcasted }
-            return body(&downcasted)
-        } as! R
     }
 }
 
-// this type erased struct is necessary due to a compiler bug with stored constrained existential types
-// see https://github.com/apple/swift/issues/61403
-// see #178
-fileprivate struct LockHolder<State> {
-    let withLock: (_ body: @Sendable (inout State) throws -> any Sendable) throws -> any Sendable
-}
-
 // TODO: replace this only with OSAllocatedUnfairLock
 @available(iOS, obsoleted: 16.0)
 fileprivate protocol Lock<State> {
@@ -79,22 +65,41 @@ fileprivate protocol Lock<State> {
 extension OSAllocatedUnfairLock: Lock {
 }
 
-// from http://www.russbishop.net/the-law
+// something is wrong with the UnfairLock impl and it results in segv_accerrs 
-fileprivate class UnfairLock<State>: Lock {
+fileprivate class MutexLock<State>: Lock {
-    private var lock: UnsafeMutablePointer<os_unfair_lock>
     private var state: State
+    private var lock = NSLock()
+    
     init(initialState: State) {
         self.state = initialState
-        self.lock = .allocate(capacity: 1)
-        self.lock.initialize(to: os_unfair_lock())
     }
-    deinit {
+    
-        self.lock.deinitialize(count: 1)
+    func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R : Sendable {
-        self.lock.deallocate()
+        if !lock.lock(before: Date(timeIntervalSinceNow: 1)) {
-    }
+            // if we can't acquire the lock after 1 second, something has gone catastrophically wrong
-    func withLock<R>(_ body: (inout State) throws -> R) rethrows -> R where R: Sendable {
+            fatalError()
-        os_unfair_lock_lock(lock)
+        }
-        defer { os_unfair_lock_unlock(lock) }
+        defer { lock.unlock() }
         return try body(&state)
     }
 }
+
+//// from http://www.russbishop.net/the-law
+//fileprivate class UnfairLock<State>: Lock {
+//    private var lock: UnsafeMutablePointer<os_unfair_lock>
+//    private var state: State
+//    init(initialState: State) {
+//        self.state = initialState
+//        self.lock = .allocate(capacity: 1)
+//        self.lock.initialize(to: os_unfair_lock())
+//    }
+//    deinit {
+//        self.lock.deinitialize(count: 1)
+//        self.lock.deallocate()
+//    }
+//    func withLock<R>(_ body: (inout State) throws -> R) rethrows -> R where R: Sendable {
+//        os_unfair_lock_lock(lock)
+//        defer { os_unfair_lock_unlock(lock) }
+//        return try body(&state)
+//    }
+//}