Revert 'defer' for lock()/unlock()

Revert 'defer' for lock()/unlock()

Author: naithar

Foundation/NSCache.swift

@@ -75,11 +75,10 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
         let key = NSCacheKey(key)
 
         _lock.lock()
-        defer { _lock.unlock() }
-        
         if let entry = _entries[key] {
             object = entry.value
         }
+        _lock.unlock()
 
         return object
     }
@@ -193,19 +192,19 @@ open class NSCache<KeyType : AnyObject, ObjectType : AnyObject> : NSObject {
         let keyRef = NSCacheKey(key)
 
         _lock.lock()
-        defer { _lock.unlock() }
         if let entry = _entries.removeValue(forKey: keyRef) {
             _totalCost -= entry.cost
             remove(entry)
         }
+        _lock.unlock()
     }
 
     open func removeAllObjects() {
         _lock.lock()
-        defer { _lock.unlock() }
         _entries.removeAll()
         _byCost = nil
         _totalCost = 0
+        _lock.unlock()
     }    
 }
 

Foundation/NSLock.swift

@@ -84,11 +84,9 @@ open class NSConditionLock : NSObject, NSLocking {
 
     open func unlock() {
         _cond.lock()
-        defer {
-            _cond.broadcast()
-            _cond.unlock()
-        }
         _thread = nil
+        _cond.broadcast()
+        _cond.unlock()
     }
 
     open var condition: Int {
@@ -109,35 +107,35 @@ open class NSConditionLock : NSObject, NSLocking {
 
     open func unlock(withCondition condition: Int) {
         _cond.lock()
-        defer {
-            _cond.broadcast()
-            _cond.unlock()
-        }
         _thread = nil
         _value = condition
+        _cond.broadcast()
+        _cond.unlock()
     }
 
     open func lock(before limit: Date) -> Bool {
         _cond.lock()
-        defer { _cond.unlock() }
         while _thread != nil {
             if !_cond.wait(until: limit) {
+                _cond.unlock()
                 return false
             }
         }
         _thread = pthread_self()
+        _cond.unlock()
         return true
     }
 
     open func lock(whenCondition condition: Int, before limit: Date) -> Bool {
         _cond.lock()
-        defer { _cond.unlock() }
         while _thread != nil || _value != condition {
             if !_cond.wait(until: limit) {
+                _cond.unlock()
                 return false
             }
         }
         _thread = pthread_self()
+        _cond.unlock()
         return true
     }
 

Foundation/NSOperation.swift

@@ -80,9 +80,9 @@ open class Operation : NSObject {
 
     open func cancel() {
         lock.lock()
-        defer { lock.unlock() }
         _cancelled = true
         _leaveGroups()
+        lock.unlock()
     }
 
     open var isExecuting: Bool {
@@ -104,35 +104,35 @@ open class Operation : NSObject {
 
     open func addDependency(_ op: Operation) {
         lock.lock()
-        defer { lock.unlock() }
         _dependencies.insert(op)
         op.lock.lock()
-        defer { op.lock.unlock() }
 #if DEPLOYMENT_ENABLE_LIBDISPATCH
         _depGroup.enter()
         op._groups.append(_depGroup)
 #endif
+        op.lock.unlock()
+        lock.unlock()
     }
 
     open func removeDependency(_ op: Operation) {
         lock.lock()
-        defer { lock.unlock() }
         _dependencies.remove(op)
         op.lock.lock()
-        defer { op.lock.unlock() }
 #if DEPLOYMENT_ENABLE_LIBDISPATCH
         let groupIndex = op._groups.index(where: { $0 === self._depGroup })
         if let idx = groupIndex {
             let group = op._groups.remove(at: idx)
             group.leave()
         }
 #endif
+        op.lock.unlock()
+        lock.unlock()
     }
 
     open var dependencies: [Operation] {
         lock.lock()
-        defer { lock.unlock() }
         let ops = _dependencies.map() { $0 }
+        lock.unlock()
         return ops
     }
 
@@ -189,14 +189,14 @@ open class BlockOperation: Operation {
 
     open func addExecutionBlock(_ block: @escaping () -> Void) {
         lock.lock()
-        defer { lock.unlock() }
         _executionBlocks.append(block)
+        lock.unlock()
     }
 
     open var executionBlocks: [() -> Void] {
         lock.lock()
-        defer { lock.unlock() }
         let blocks = _executionBlocks
+        lock.unlock()
         return blocks
     }
 }
@@ -308,8 +308,8 @@ open class OperationQueue: NSObject {
     // However this is considerably faster and probably more effecient.
     internal var _underlyingQueue: DispatchQueue {
         lock.lock()
-        defer { lock.unlock() }
         if let queue = __underlyingQueue {
+            lock.unlock()
             return queue
         } else {
             let effectiveName: String
@@ -333,6 +333,7 @@ open class OperationQueue: NSObject {
                 queue.suspend()
             }
             __underlyingQueue = queue
+            lock.unlock()
             return queue
         }
     }
@@ -353,8 +354,8 @@ open class OperationQueue: NSObject {
 
     internal func _dequeueOperation() -> Operation? {
         lock.lock()
-        defer { lock.unlock() }
         let op = _operations.dequeue()
+        lock.unlock()
         return op
     }
 
@@ -426,9 +427,9 @@ open class OperationQueue: NSObject {
 
     internal func _operationFinished(_ operation: Operation) {
         lock.lock()
-        defer { lock.unlock() }
         _operations.remove(operation)
         operation._queue = nil
+        lock.unlock()
     }
 
     open func addOperation(_ block: @escaping () -> Swift.Void) {
@@ -440,16 +441,16 @@ open class OperationQueue: NSObject {
     // WARNING: the return value of this property can never be used to reliably do anything sensible
     open var operations: [Operation] {
         lock.lock()
-        defer { lock.unlock() }
         let ops = _operations.map() { $0 }
+        lock.unlock()
         return ops
     }
 
     // WARNING: the return value of this property can never be used to reliably do anything sensible
     open var operationCount: Int {
         lock.lock()
-        defer { lock.unlock() }
         let count = _operations.count
+        lock.unlock()
         return count
     }
 
@@ -462,7 +463,6 @@ open class OperationQueue: NSObject {
         }
         set {
             lock.lock()
-            defer { lock.unlock() }
             if _suspended != newValue {
                 _suspended = newValue
 #if DEPLOYMENT_ENABLE_LIBDISPATCH
@@ -475,24 +475,25 @@ open class OperationQueue: NSObject {
                 }
 #endif
             }
+            lock.unlock()
         }
     }
 
     internal var _name: String?
     open var name: String? {
         get {
             lock.lock()
-            defer { lock.unlock() }
             let val = _name
+            lock.unlock()
             return val
         }
         set {
             lock.lock()
-            defer { lock.unlock() }
             _name = newValue
 #if DEPLOYMENT_ENABLE_LIBDISPATCH
             __underlyingQueue = nil
 #endif
+            lock.unlock()
         }
     }
 
@@ -503,14 +504,14 @@ open class OperationQueue: NSObject {
     open var underlyingQueue: DispatchQueue? {
         get {
             lock.lock()
-            defer { lock.unlock() }
             let queue = __underlyingQueue
+            lock.unlock()
             return queue
         }
         set {
             lock.lock()
-            defer { lock.unlock() }
             __underlyingQueue = newValue
+            lock.unlock()
         }
     }
 #endif

Foundation/Process.swift

@@ -202,10 +202,6 @@ open class Process: NSObject {
     open func launch() {
 
         self.processLaunchedCondition.lock()
-        defer {
-            self.processLaunchedCondition.unlock()
-            self.processLaunchedCondition.broadcast()
-        }
 
         // Dispatch the manager thread if it isn't already running
 
@@ -440,6 +436,9 @@ open class Process: NSObject {
         isRunning = true
 
         self.processIdentifier = pid
+        
+        self.processLaunchedCondition.unlock()
+        self.processLaunchedCondition.broadcast()
     }
 
     open func interrupt() { NSUnimplemented() } // Not always possible. Sends SIGINT.