Implement concurrent enumeration for NSArray, NSDictionary and NSIndexSet (swiftlang#1066)

Author: phausler

Diff for: Foundation/NSArray.swift

@@ -446,9 +446,6 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
         self.enumerateObjects(at: IndexSet(integersIn: 0..<count), options: opts, using: block)
     }
     open func enumerateObjects(at s: IndexSet, options opts: NSEnumerationOptions = [], using block: (Any, Int, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
-        guard !opts.contains(.concurrent) else {
-            NSUnimplemented()
-        }
         s._bridgeToObjectiveC().enumerate(options: opts) { (idx, stop) in
             block(self.object(at: idx), idx, stop)
         }

Diff for: Foundation/NSDictionary.swift

@@ -9,7 +9,7 @@
 
 
 import CoreFoundation
-
+import Dispatch
 
 open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCoding {
     private let _cfinfo = _CFInfo(typeID: CFDictionaryGetTypeID())
@@ -454,19 +454,37 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
         enumerateKeysAndObjects(options: [], using: block)
     }
 
-    open func enumerateKeysAndObjects(options opts: NSEnumerationOptions = [], using block: (Any, Any, UnsafeMutablePointer<ObjCBool>) -> Swift.Void) {
+    open func enumerateKeysAndObjects(options opts: NSEnumerationOptions = [], using block: (Any, Any, UnsafeMutablePointer<ObjCBool>) -> Void) {
         let count = self.count
         var keys = [Any]()
         var objects = [Any]()
+        var sharedStop = ObjCBool(false)
+        let lock = NSLock()
+        
         getObjects(&objects, andKeys: &keys, count: count)
-        var stop = ObjCBool(false)
-        for idx in 0..<count {
-            withUnsafeMutablePointer(to: &stop, { stop in
-                block(keys[idx], objects[idx], stop)
-            })
-
-            if stop {
-                break
+        let iteration: (Int) -> Void = withoutActuallyEscaping(block) { (closure: @escaping (Any, Any, UnsafeMutablePointer<ObjCBool>) -> Void) -> (Int) -> Void in
+            return { (idx) in
+                lock.lock()
+                var stop = sharedStop
+                lock.unlock()
+                if stop { return }
+                
+                closure(keys[idx], objects[idx], &stop)
+                
+                if stop {
+                    lock.lock()
+                    sharedStop = stop
+                    lock.unlock()
+                    return
+                }
+            }
+        }
+        
+        if opts.contains(.concurrent) {
+            DispatchQueue.concurrentPerform(iterations: count, execute: iteration)
+        } else {
+            for idx in 0..<count {
+                iteration(idx)
             }
         }
     }

Diff for: Foundation/NSIndexSet.swift

@@ -7,6 +7,7 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
+import Dispatch
 
 /* Class for managing set of indexes. The set of valid indexes are 0 .. NSNotFound - 1; trying to use indexes outside this range is an error.  NSIndexSet uses NSNotFound as a return value in cases where the queried index doesn't exist in the set; for instance, when you ask firstIndex and there are no indexes; or when you ask for indexGreaterThanIndex: on the last index, and so on.
 
@@ -388,36 +389,60 @@ open class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         let reverse = opts.contains(.reverse)
         let passRanges = paramType == NSRange.self
         let findIndex = returnType == Bool.self
-        var stop = false
+        var sharedStop = false
+        let lock = NSLock()
         let ranges = _ranges[startRangeIndex...endRangeIndex]
-        let rangeSequence = (reverse ? AnySequence(ranges.reversed()) : AnySequence(ranges))
-        outer: for curRange in rangeSequence {
-            let intersection = NSIntersectionRange(curRange, range)
-            if passRanges {
-                if intersection.length > 0 {
-                    let _ = block(intersection as! P, &stop)
-                }
-                if stop {
-                    break outer
-                }
-            } else if intersection.length > 0 {
-                let maxIndex = NSMaxRange(intersection) - 1
-                let indexes = reverse ? stride(from: maxIndex, through: intersection.location, by: -1) : stride(from: intersection.location, through: maxIndex, by: 1)
-                for idx in indexes {
-                    if findIndex {
-                        let found : Bool = block(idx as! P, &stop) as! Bool
-                        if found {
-                            result = idx
-                            stop = true
-                        }
-                    } else {
-                        let _ = block(idx as! P, &stop)
+        let rangeSequence = (reverse ? AnyCollection(ranges.reversed()) : AnyCollection(ranges))
+        let iteration = withoutActuallyEscaping(block) { (closure: @escaping (P, UnsafeMutablePointer<ObjCBool>) -> R) -> (Int) -> Void in
+            return { (rangeIdx) in
+                lock.lock()
+                var stop = sharedStop
+                lock.unlock()
+                if stop { return }
+                
+                let idx = rangeSequence.index(rangeSequence.startIndex, offsetBy: IntMax(rangeIdx))
+                let curRange = rangeSequence[idx]
+                let intersection = NSIntersectionRange(curRange, range)
+                if passRanges {
+                    if intersection.length > 0 {
+                        let _ = closure(intersection as! P, &stop)
                     }
                     if stop {
-                        break outer
+                        lock.lock()
+                        sharedStop = stop
+                        lock.unlock()
+                        return
+                    }
+                } else if intersection.length > 0 {
+                    let maxIndex = NSMaxRange(intersection) - 1
+                    let indexes = reverse ? stride(from: maxIndex, through: intersection.location, by: -1) : stride(from: intersection.location, through: maxIndex, by: 1)
+                    for idx in indexes {
+                        if findIndex {
+                            let found : Bool = closure(idx as! P, &stop) as! Bool
+                            if found {
+                                result = idx
+                                stop = true
+                            }
+                        } else {
+                            let _ = closure(idx as! P, &stop)
+                        }
+                        if stop {
+                            lock.lock()
+                            sharedStop = stop
+                            lock.unlock()
+                            return
+                        }
                     }
                 }
-            } // else, continue
+            }
+        }
+        
+        if opts.contains(.concurrent) {
+            DispatchQueue.concurrentPerform(iterations: Int(rangeSequence.count), execute: iteration)
+        } else {
+            for idx in 0..<Int(rangeSequence.count) {
+                iteration(idx)
+            }
         }
 
         return result