Merge pull request #1360 from ikesyo/nsrange-init

[gardening] Use `NSRange.init` over `NSMakeRange`

Author: ikesyo

Foundation/CharacterSet.swift

@@ -11,11 +11,11 @@
 //===----------------------------------------------------------------------===//
 
 private func _utfRangeToNSRange(_ inRange : Range<UnicodeScalar>) -> NSRange {
-    return NSMakeRange(Int(inRange.lowerBound.value), Int(inRange.upperBound.value - inRange.lowerBound.value))
+    return NSRange(location: Int(inRange.lowerBound.value), length: Int(inRange.upperBound.value - inRange.lowerBound.value))
 }
 
 private func _utfRangeToNSRange(_ inRange : ClosedRange<UnicodeScalar>) -> NSRange {
-    return NSMakeRange(Int(inRange.lowerBound.value), Int(inRange.upperBound.value - inRange.lowerBound.value + 1))
+    return NSRange(location: Int(inRange.lowerBound.value), length: Int(inRange.upperBound.value - inRange.lowerBound.value + 1))
 }
 
 internal final class _SwiftNSCharacterSet : NSCharacterSet, _SwiftNativeFoundationType {
@@ -379,7 +379,7 @@ public struct CharacterSet : ReferenceConvertible, Equatable, Hashable, SetAlgeb
     /// `UnicodeScalar` values are available on `Swift.String.UnicodeScalarView`.
     @discardableResult
     public mutating func insert(_ character: UnicodeScalar) -> (inserted: Bool, memberAfterInsert: UnicodeScalar) {
-        let nsRange = NSMakeRange(Int(character.value), 1)
+        let nsRange = NSRange(location: Int(character.value), length: 1)
         _applyUnmanagedMutation {
             $0.addCharacters(in: nsRange)
         }
@@ -392,7 +392,7 @@ public struct CharacterSet : ReferenceConvertible, Equatable, Hashable, SetAlgeb
     /// `UnicodeScalar` values are available on `Swift.String.UnicodeScalarView`.
     @discardableResult
     public mutating func update(with character: UnicodeScalar) -> UnicodeScalar? {
-        let nsRange = NSMakeRange(Int(character.value), 1)
+        let nsRange = NSRange(location: Int(character.value), length: 1)
         _applyUnmanagedMutation {
             $0.addCharacters(in: nsRange)
         }
@@ -408,7 +408,7 @@ public struct CharacterSet : ReferenceConvertible, Equatable, Hashable, SetAlgeb
     public mutating func remove(_ character: UnicodeScalar) -> UnicodeScalar? {
         // TODO: Add method to NSCharacterSet to do this in one call
         let result : UnicodeScalar? = contains(character) ? character : nil
-        let r = NSMakeRange(Int(character.value), 1)
+        let r = NSRange(location: Int(character.value), length: 1)
         _applyUnmanagedMutation {
             $0.removeCharacters(in: r)
         }

Foundation/Data.swift

@@ -1381,7 +1381,7 @@ public struct Data : ReferenceConvertible, Equatable, Hashable, RandomAccessColl
 
         guard !copyRange.isEmpty else { return 0 }
 
-        let nsRange = NSMakeRange(copyRange.lowerBound, copyRange.upperBound - copyRange.lowerBound)
+        let nsRange = NSRange(location: copyRange.lowerBound, length: copyRange.upperBound - copyRange.lowerBound)
         _copyBytesHelper(to: buffer.baseAddress!, from: nsRange)
         return copyRange.count
     }
@@ -1437,9 +1437,9 @@ public struct Data : ReferenceConvertible, Equatable, Hashable, RandomAccessColl
         let nsRange : NSRange
         if let r = range {
             _validateRange(r)
-            nsRange = NSMakeRange(r.lowerBound, r.upperBound - r.lowerBound)
+            nsRange = NSRange(location: r.lowerBound, length: r.upperBound - r.lowerBound)
         } else {
-            nsRange = NSMakeRange(0, _backing.length)
+            nsRange = NSRange(location: 0, length: _backing.length)
         }
         let result = _backing.withInteriorPointerReference(_sliceRange) {
             $0.range(of: dataToFind, options: options, in: nsRange)
@@ -1521,7 +1521,7 @@ public struct Data : ReferenceConvertible, Equatable, Hashable, RandomAccessColl
         // it is worth noting that the range here may be out of bounds of the Data itself (which triggers a growth)
         precondition(range.lowerBound >= 0, "Ranges must not be negative bounds")
         precondition(range.upperBound >= 0, "Ranges must not be negative bounds")
-        let range = NSMakeRange(range.lowerBound, range.upperBound - range.lowerBound)
+        let range = NSRange(location: range.lowerBound, length: range.upperBound - range.lowerBound)
         if !isKnownUniquelyReferenced(&_backing) {
             _backing = _backing.mutableCopy(_sliceRange)
         }
@@ -1590,7 +1590,7 @@ public struct Data : ReferenceConvertible, Equatable, Hashable, RandomAccessColl
     @inline(__always)
     public mutating func replaceSubrange(_ subrange: Range<Index>, with bytes: UnsafeRawPointer, count cnt: Int) {
         _validateRange(subrange)
-        let nsRange = NSMakeRange(subrange.lowerBound, subrange.upperBound - subrange.lowerBound)
+        let nsRange = NSRange(location: subrange.lowerBound, length: subrange.upperBound - subrange.lowerBound)
         if !isKnownUniquelyReferenced(&_backing) {
             _backing = _backing.mutableCopy(_sliceRange)
         }

Foundation/IndexSet.swift

@@ -827,7 +827,7 @@ extension IndexSet {
 }
 
 private func _toNSRange(_ r: Range<IndexSet.Element>) -> NSRange {
-    return NSMakeRange(r.lowerBound, r.upperBound - r.lowerBound)
+    return NSRange(location: r.lowerBound, length: r.upperBound - r.lowerBound)
 }
 
 #if DEPLOYMENT_RUNTIME_SWIFT

Foundation/NSArray.swift

@@ -537,11 +537,11 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
     }
 
     open func sortedArray(comparator cmptr: (Any, Any) -> ComparisonResult) -> [Any] {
-        return sortedArray(from: NSMakeRange(0, count), options: [], usingComparator: cmptr)
+        return sortedArray(from: NSRange(location: 0, length: count), options: [], usingComparator: cmptr)
     }
 
     open func sortedArray(options opts: NSSortOptions = [], usingComparator cmptr: (Any, Any) -> ComparisonResult) -> [Any] {
-        return sortedArray(from: NSMakeRange(0, count), options: opts, usingComparator: cmptr)
+        return sortedArray(from: NSRange(location: 0, length: count), options: opts, usingComparator: cmptr)
     }
 
     open func index(of obj: Any, inSortedRange r: NSRange, options opts: NSBinarySearchingOptions = [], usingComparator cmp: (Any, Any) -> ComparisonResult) -> Int {
@@ -884,20 +884,20 @@ open class NSMutableArray : NSArray {
         if type(of: self) === NSMutableArray.self {
             _storage = otherArray.map { _SwiftValue.store($0) }
         } else {
-            replaceObjects(in: NSMakeRange(0, count), withObjectsFrom: otherArray)
+            replaceObjects(in: NSRange(location: 0, length: count), withObjectsFrom: otherArray)
         }
     }
 
     open func removeObjects(at indexes: IndexSet) {
         for range in indexes.rangeView.reversed() {
-            self.removeObjects(in: NSMakeRange(range.lowerBound, range.upperBound - range.lowerBound))
+            self.removeObjects(in: NSRange(location: range.lowerBound, length: range.upperBound - range.lowerBound))
         }
     }
 
     open func replaceObjects(at indexes: IndexSet, with objects: [Any]) {
         var objectIndex = 0
         for countedRange in indexes.rangeView {
-            let range = NSMakeRange(countedRange.lowerBound, countedRange.upperBound - countedRange.lowerBound)
+            let range = NSRange(location: countedRange.lowerBound, length: countedRange.upperBound - countedRange.lowerBound)
             let subObjects = objects[objectIndex..<objectIndex + range.length]
             self.replaceObjects(in: range, withObjectsFrom: Array(subObjects))
             objectIndex += range.length

Foundation/NSCFArray.swift

@@ -126,5 +126,5 @@ internal func _CFSwiftArrayRemoveAllValues(_ array: AnyObject) {
 
 internal func _CFSwiftArrayReplaceValues(_ array: AnyObject, _ range: CFRange, _ newValues: UnsafeMutablePointer<Unmanaged<AnyObject>>, _ newCount: CFIndex) {
     NSUnimplemented()
-//    (array as! NSMutableArray).replaceObjectsInRange(NSMakeRange(range.location, range.length), withObjectsFrom: newValues.array(newCount))
+//    (array as! NSMutableArray).replaceObjectsInRange(NSRange(location: range.location, length: range.length), withObjectsFrom: newValues.array(newCount))
 }

Foundation/NSCFString.swift

@@ -144,7 +144,7 @@ internal func _CFSwiftStringGetCharacterAtIndex(_ str: AnyObject, index: CFIndex
 }
 
 internal func _CFSwiftStringGetCharacters(_ str: AnyObject, range: CFRange, buffer: UnsafeMutablePointer<UniChar>) {
-    (str as! NSString).getCharacters(buffer, range: NSMakeRange(range.location, range.length))
+    (str as! NSString).getCharacters(buffer, range: NSRange(location: range.location, length: range.length))
 }
 
 internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>?, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>?) -> CFIndex {
@@ -191,7 +191,7 @@ internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncodin
 }
 
 internal func _CFSwiftStringCreateWithSubstring(_ str: AnyObject, range: CFRange) -> Unmanaged<AnyObject> {
-    return Unmanaged<AnyObject>.passRetained((str as! NSString).substring(with: NSMakeRange(range.location, range.length))._nsObject)
+    return Unmanaged<AnyObject>.passRetained((str as! NSString).substring(with: NSRange(location: range.location, length: range.length))._nsObject)
 }
 
 
@@ -224,11 +224,11 @@ internal func _CFSwiftStringInsert(_ str: AnyObject, index: CFIndex, inserted: A
 }
 
 internal func _CFSwiftStringDelete(_ str: AnyObject, range: CFRange) {
-    (str as! NSMutableString).deleteCharacters(in: NSMakeRange(range.location, range.length))
+    (str as! NSMutableString).deleteCharacters(in: NSRange(location: range.location, length: range.length))
 }
 
 internal func _CFSwiftStringReplace(_ str: AnyObject, range: CFRange, replacement: AnyObject) {
-    (str as! NSMutableString).replaceCharacters(in: NSMakeRange(range.location, range.length), with: (replacement as! NSString)._swiftObject)
+    (str as! NSMutableString).replaceCharacters(in: NSRange(location: range.location, length: range.length), with: (replacement as! NSString)._swiftObject)
 }
 
 internal func _CFSwiftStringReplaceAll(_ str: AnyObject, replacement: AnyObject) {

Foundation/NSCalendar.swift

@@ -386,25 +386,25 @@ open class NSCalendar : NSObject, NSCopying, NSSecureCoding {
     open func minimumRange(of unit: Unit) -> NSRange {
         let r = CFCalendarGetMinimumRangeOfUnit(self._cfObject, unit._cfValue)
         if (r.location == kCFNotFound) {
-            return NSMakeRange(NSNotFound, NSNotFound)
+            return NSRange(location: NSNotFound, length: NSNotFound)
         }
-        return NSMakeRange(r.location, r.length)
+        return NSRange(location: r.location, length: r.length)
     }
 
     open func maximumRange(of unit: Unit) -> NSRange {
         let r = CFCalendarGetMaximumRangeOfUnit(_cfObject, unit._cfValue)
         if r.location == kCFNotFound {
-            return NSMakeRange(NSNotFound, NSNotFound)
+            return NSRange(location: NSNotFound, length: NSNotFound)
         }
-        return NSMakeRange(r.location, r.length)
+        return NSRange(location: r.location, length: r.length)
     }
 
     open func range(of smaller: Unit, in larger: Unit, for date: Date) -> NSRange {
         let r = CFCalendarGetRangeOfUnit(_cfObject, smaller._cfValue, larger._cfValue, date.timeIntervalSinceReferenceDate)
         if r.location == kCFNotFound {
-            return NSMakeRange(NSNotFound, NSNotFound)
+            return NSRange(location: NSNotFound, length: NSNotFound)
         }
-        return NSMakeRange(r.location, r.length)
+        return NSRange(location: r.location, length: r.length)
     }
 
     open func ordinality(of smaller: Unit, in larger: Unit, for date: Date) -> Int {

Foundation/NSData.swift

@@ -702,7 +702,7 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
             if (stopPointer.pointee) {
                 return
             }
-            block(bytes, NSMakeRange(0, length), stopPointer)
+            block(bytes, NSRange(location: 0, length: length), stopPointer)
         }
     }
 
@@ -1046,7 +1046,7 @@ open class NSMutableData : NSData {
     open func setData(_ data: Data) {
         length = data.count
         data.withUnsafeBytes {
-            replaceBytes(in: NSMakeRange(0, length), withBytes: $0)
+            replaceBytes(in: NSRange(location: 0, length: length), withBytes: $0)
         }
     }
 

Foundation/NSIndexSet.swift

@@ -107,7 +107,7 @@ open class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
     }
 
     public convenience init(index value: Int) {
-        self.init(indexesIn: NSMakeRange(value, 1))
+        self.init(indexesIn: NSRange(location: value, length: 1))
     }
 
     open func isEqual(to indexSet: IndexSet) -> Bool {
@@ -448,7 +448,7 @@ open class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         enumerate(options: [], using: block)
     }
     open func enumerate(options opts: NSEnumerationOptions = [], using block: (Int, UnsafeMutablePointer<ObjCBool>) -> Void) {
-        let _ = _enumerateWithOptions(opts, range: NSMakeRange(0, Int.max), paramType: Int.self, returnType: Void.self, block: block)
+        let _ = _enumerateWithOptions(opts, range: NSRange(location: 0, length: Int.max), paramType: Int.self, returnType: Void.self, block: block)
     }
     open func enumerate(in range: NSRange, options opts: NSEnumerationOptions = [], using block: (Int, UnsafeMutablePointer<ObjCBool>) -> Void) {
         let _ = _enumerateWithOptions(opts, range: range, paramType: Int.self, returnType: Void.self, block: block)
@@ -458,17 +458,17 @@ open class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         return index(options: [], passingTest: predicate)
     }
     open func index(options opts: NSEnumerationOptions = [], passingTest predicate: (Int, UnsafeMutablePointer<ObjCBool>) -> Bool) -> Int {
-        return _enumerateWithOptions(opts, range: NSMakeRange(0, Int.max), paramType: Int.self, returnType: Bool.self, block: predicate) ?? NSNotFound
+        return _enumerateWithOptions(opts, range: NSRange(location: 0, length: Int.max), paramType: Int.self, returnType: Bool.self, block: predicate) ?? NSNotFound
     }
     open func index(in range: NSRange, options opts: NSEnumerationOptions = [], passingTest predicate: (Int, UnsafeMutablePointer<ObjCBool>) -> Bool) -> Int {
         return _enumerateWithOptions(opts, range: range, paramType: Int.self, returnType: Bool.self, block: predicate) ?? NSNotFound
     }
 
     open func indexes(passingTest predicate: (Int, UnsafeMutablePointer<ObjCBool>) -> Bool) -> IndexSet {
-        return indexes(in: NSMakeRange(0, Int.max), options: [], passingTest: predicate)
+        return indexes(in: NSRange(location: 0, length: Int.max), options: [], passingTest: predicate)
     }
     open func indexes(options opts: NSEnumerationOptions = [], passingTest predicate: (Int, UnsafeMutablePointer<ObjCBool>) -> Bool) -> IndexSet {
-        return indexes(in: NSMakeRange(0, Int.max), options: opts, passingTest: predicate)
+        return indexes(in: NSRange(location: 0, length: Int.max), options: opts, passingTest: predicate)
     }
     open func indexes(in range: NSRange, options opts: NSEnumerationOptions = [], passingTest predicate: (Int, UnsafeMutablePointer<ObjCBool>) -> Bool) -> IndexSet {
         var result = IndexSet()
@@ -489,7 +489,7 @@ open class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
         enumerateRanges(options: [], using: block)
     }
     open func enumerateRanges(options opts: NSEnumerationOptions = [], using block: (NSRange, UnsafeMutablePointer<ObjCBool>) -> Void) {
-        let _ = _enumerateWithOptions(opts, range: NSMakeRange(0, Int.max), paramType: NSRange.self, returnType: Void.self, block: block)
+        let _ = _enumerateWithOptions(opts, range: NSRange(location: 0, length: Int.max), paramType: NSRange.self, returnType: Void.self, block: block)
     }
     open func enumerateRanges(in range: NSRange, options opts: NSEnumerationOptions = [], using block: (NSRange, UnsafeMutablePointer<ObjCBool>) -> Void) {
         let _ = _enumerateWithOptions(opts, range: range, paramType: NSRange.self, returnType: Void.self, block: block)
@@ -553,11 +553,11 @@ open class NSMutableIndexSet : NSIndexSet {
     }
 
     open func add(_ value: Int) {
-        add(in: NSMakeRange(value, 1))
+        add(in: NSRange(location: value, length: 1))
     }
 
     open func remove(_ value: Int) {
-        remove(in: NSMakeRange(value, 1))
+        remove(in: NSRange(location: value, length: 1))
     }
 
     internal func _insertRange(_ range: NSRange, atIndex index: Int) {
@@ -672,16 +672,16 @@ open class NSMutableIndexSet : NSIndexSet {
                     // Don't increment rangeIndex
                     continue
                 } else {
-                    self._replaceRangeAtIndex(rangeIndex, withRange: NSMakeRange(removeEnd, curEnd - removeEnd))
+                    self._replaceRangeAtIndex(rangeIndex, withRange: NSRange(location: removeEnd, length: curEnd - removeEnd))
                     return
                 }
             } else if range.location > curRange.location && removeEnd < curEnd {
-                let firstPiece = NSMakeRange(curRange.location, range.location - curRange.location)
-                let secondPiece = NSMakeRange(removeEnd, curEnd - removeEnd)
+                let firstPiece = NSRange(location: curRange.location, length: range.location - curRange.location)
+                let secondPiece = NSRange(location: removeEnd, length: curEnd - removeEnd)
                 _replaceRangeAtIndex(rangeIndex, withRange: secondPiece)
                 _insertRange(firstPiece, atIndex: rangeIndex)
             } else if range.location > curRange.location && range.location < curEnd && removeEnd >= curEnd {
-                _replaceRangeAtIndex(rangeIndex, withRange: NSMakeRange(curRange.location, range.location - curRange.location))
+                _replaceRangeAtIndex(rangeIndex, withRange: NSRange(location: curRange.location, length: range.location - curRange.location))
             }
             rangeIndex += 1
         }

Foundation/NSOrderedSet.swift

@@ -287,7 +287,7 @@ extension NSOrderedSet {
     }
 
     public convenience init(orderedSet set: NSOrderedSet, copyItems flag: Bool) {
-        self.init(orderedSet: set, range: NSMakeRange(0, set.count), copyItems: flag)
+        self.init(orderedSet: set, range: NSRange(location: 0, length: set.count), copyItems: flag)
     }
 
     public convenience init(orderedSet set: NSOrderedSet, range: NSRange, copyItems flag: Bool) {
@@ -306,7 +306,7 @@ extension NSOrderedSet {
     }
 
     public convenience init(array set: [Any], copyItems flag: Bool) {
-        self.init(array: set, range: NSMakeRange(0, set.count), copyItems: flag)
+        self.init(array: set, range: NSRange(location: 0, length: set.count), copyItems: flag)
     }
 
     public convenience init(array set: [Any], range: NSRange, copyItems flag: Bool) {
@@ -540,11 +540,11 @@ extension NSMutableOrderedSet {
     }
 
     open func sort(comparator cmptr: (Any, Any) -> ComparisonResult) {
-        sortRange(NSMakeRange(0, count), options: [], usingComparator: cmptr)
+        sortRange(NSRange(location: 0, length: count), options: [], usingComparator: cmptr)
     }
 
     open func sort(options opts: NSSortOptions = [], usingComparator cmptr: (Any, Any) -> ComparisonResult) {
-        sortRange(NSMakeRange(0, count), options: opts, usingComparator: cmptr)
+        sortRange(NSRange(location: 0, length: count), options: opts, usingComparator: cmptr)
     }
 
     open func sortRange(_ range: NSRange, options opts: NSSortOptions = [], usingComparator cmptr: (Any, Any) -> ComparisonResult) {