defer usage where possible

Author: Sergey Minakov

Foundation/NSCache.swift

@@ -75,10 +75,11 @@ 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
     }
@@ -192,19 +193,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/NSKeyedArchiver.swift

@@ -159,13 +159,13 @@ open class NSKeyedArchiver : NSCoder {
             return false
         }
 
+        defer { CFWriteStreamClose(writeStream) }
+        
         let keyedArchiver = NSKeyedArchiver(output: writeStream)
 
         keyedArchiver.encode(rootObject, forKey: NSKeyedArchiveRootObjectKey)
         keyedArchiver.finishEncoding()
         finishedEncoding = keyedArchiver._flags.contains(ArchiverFlags.finishedEncoding)
-
-        CFWriteStreamClose(writeStream)
 
         return finishedEncoding
     }

Foundation/NSKeyedUnarchiver.swift

@@ -74,15 +74,15 @@ open class NSKeyedUnarchiver : NSCoder {
             return nil
         }
 
+        defer { CFReadStreamClose(readStream) }
+        
         let keyedUnarchiver = NSKeyedUnarchiver(stream: Stream.stream(readStream))
         do {
             try root = keyedUnarchiver.decodeTopLevelObject(forKey: NSKeyedArchiveRootObjectKey)
             keyedUnarchiver.finishDecoding()
         } catch {
         }
 
-        CFReadStreamClose(readStream)
-        
         return root
     }
 

Foundation/NSLock.swift

@@ -84,9 +84,11 @@ 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 {
@@ -107,35 +109,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,7 +333,6 @@ open class OperationQueue: NSObject {
                 queue.suspend()
             }
             __underlyingQueue = queue
-            lock.unlock()
             return queue
         }
     }
@@ -354,8 +353,8 @@ open class OperationQueue: NSObject {
 
     internal func _dequeueOperation() -> Operation? {
         lock.lock()
+        defer { lock.unlock() }
         let op = _operations.dequeue()
-        lock.unlock()
         return op
     }
 
@@ -427,9 +426,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) {
@@ -441,16 +440,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
     }
 
@@ -463,6 +462,7 @@ open class OperationQueue: NSObject {
         }
         set {
             lock.lock()
+            defer { lock.unlock() }
             if _suspended != newValue {
                 _suspended = newValue
 #if DEPLOYMENT_ENABLE_LIBDISPATCH
@@ -475,25 +475,24 @@ 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()
         }
     }
 
@@ -504,14 +503,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/NSXMLParser.swift

@@ -559,9 +559,12 @@ open class XMLParser : NSObject {
     internal func parseFromStream() -> Bool {
         var result = true
         XMLParser.setCurrentParser(self)
+        defer { XMLParser.setCurrentParser(nil) }
         if let stream = _stream {
             stream.open()
+            defer { stream.close() }
             let buffer = malloc(_chunkSize)!.bindMemory(to: UInt8.self, capacity: _chunkSize)
+            defer { free(buffer) }
             var len = stream.read(buffer, maxLength: _chunkSize)
             if len != -1 {
                 while len > 0 {
@@ -572,10 +575,9 @@ open class XMLParser : NSObject {
             } else {
                 result = false
             }
-            free(buffer)
-            stream.close()
         } else if let data = _data {
             let buffer = malloc(_chunkSize)!.bindMemory(to: UInt8.self, capacity: _chunkSize)
+            defer { free(buffer) }
             var range = NSMakeRange(0, min(_chunkSize, data.count))
             while result {
                 let chunk = data.withUnsafeBytes { (buffer: UnsafePointer<UInt8>) -> Data in
@@ -588,11 +590,9 @@ open class XMLParser : NSObject {
                 }
                 range = NSMakeRange(range.location + range.length, min(_chunkSize, data.count - (range.location + range.length)))
             }
-            free(buffer)
         } else {
             result = false
         }
-        XMLParser.setCurrentParser(nil)
         return result
     }
 

Foundation/Process.swift

@@ -202,6 +202,10 @@ 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
 
@@ -436,9 +440,6 @@ open class Process: NSObject {
         isRunning = true
 
         self.processIdentifier = pid
-        
-        self.processLaunchedCondition.unlock()
-        self.processLaunchedCondition.broadcast()
     }
 
     open func interrupt() { NSUnimplemented() } // Not always possible. Sends SIGINT.