Merge pull request #339 from apple/swift-3-indexing-model

gribozavr · gribozavr · commit 9f8fa52dfe1c · 2016-04-27T11:11:46.000-07:00
[swift-3-indexing-model] porting Foundation to the new indexing model
diff --git a/Foundation/NSCFString.swift b/Foundation/NSCFString.swift
@@ -133,7 +133,8 @@ internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncodin
         let start = encodingView.startIndex
         if let buffer = buffer {
             for idx in 0..<range.length {
-                let character = encodingView[start.advanced(by: idx + range.location)]
+                let characterIndex = encodingView.index(start, offsetBy: idx + range.location)
+                let character = encodingView[characterIndex]
                 buffer.advanced(by: idx).initialize(with: character)
             }
         }
diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift
@@ -1038,9 +1038,9 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
             comps.minute = m
             comps.second = s
             var options: NSCalendarOptions = .MatchNextTime
-            options.unionInPlace(opts.contains(.MatchLast) ? .MatchLast : .MatchFirst)
+            options.formUnion(opts.contains(.MatchLast) ? .MatchLast : .MatchFirst)
             if opts.contains(.MatchStrictly) {
-                options.unionInPlace(.MatchStrictly)
+                options.formUnion(.MatchStrictly)
             }
             if let result = nextDateAfterDate(range.start.addingTimeInterval(-0.5), matchingComponents: comps, options: options) {
                 if result.compare(range.start) == .OrderedAscending {
@@ -1062,7 +1062,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding {
         var unitFlags: NSCalendarUnit = []
         for unit in units {
             if components.valueForComponent(unit) != NSDateComponentUndefined {
-                unitFlags.unionInPlace(unit)
+                unitFlags.formUnion(unit)
             }
         }
         if unitFlags == [] {
diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift
@@ -539,7 +539,7 @@ extension NSData {
         }
         return location.map {NSRange(location: $0, length: search.count)} ?? NSRange(location: NSNotFound, length: 0)
     }
-    private static func searchSubSequence<T : Collection,T2 : Sequence where T.Iterator.Element : Equatable, T.Iterator.Element == T2.Iterator.Element, T.SubSequence.Iterator.Element == T.Iterator.Element>(_ subSequence : T2, inSequence seq: T,anchored : Bool) -> T.Index? {
+    private static func searchSubSequence<T : Collection, T2 : Sequence where T.Iterator.Element : Equatable, T.Iterator.Element == T2.Iterator.Element, T.SubSequence.Iterator.Element == T.Iterator.Element, T.Indices.Iterator.Element == T.Index>(_ subSequence : T2, inSequence seq: T,anchored : Bool) -> T.Index? {
         for index in seq.indices {
             if seq.suffix(from: index).starts(with: subSequence) {
                 return index
@@ -684,10 +684,10 @@ extension NSData {
         var decodedStart: UInt8 = 0
         for range in base64ByteMappings {
             if range.contains(byte) {
-                let result = decodedStart + (byte - range.startIndex)
+                let result = decodedStart + (byte - range.lowerBound)
                 return .Valid(result)
             }
-            decodedStart += range.endIndex - range.startIndex
+            decodedStart += range.upperBound - range.lowerBound
         }
         return .Invalid
     }
@@ -706,11 +706,11 @@ extension NSData {
         assert(byte < 64)
         var decodedStart: UInt8 = 0
         for range in base64ByteMappings {
-            let decodedRange = decodedStart ..< decodedStart + (range.endIndex - range.startIndex)
+            let decodedRange = decodedStart ..< decodedStart + (range.upperBound - range.lowerBound)
             if decodedRange.contains(byte) {
-                return range.startIndex + (byte - decodedStart)
+                return range.lowerBound + (byte - decodedStart)
             }
-            decodedStart += range.endIndex - range.startIndex
+            decodedStart += range.upperBound - range.lowerBound
         }
         return 0
     }
diff --git a/Foundation/NSHTTPCookie.swift b/Foundation/NSHTTPCookie.swift
@@ -323,8 +323,8 @@ public class NSHTTPCookie : NSObject {
         }
         //Remove the final trailing semicolon and whitespace
         if ( cookieString.length > 0 ) {
-            cookieString.remove(at: cookieString.endIndex.predecessor())
-            cookieString.remove(at: cookieString.endIndex.predecessor())
+            cookieString.characters.removeLast()
+            cookieString.characters.removeLast()
         }
         return ["Cookie": cookieString]
     }
diff --git a/Foundation/NSJSONSerialization.swift b/Foundation/NSJSONSerialization.swift
@@ -406,6 +406,7 @@ private struct JSONReader {
     }
 
     typealias Index = Int
+    typealias IndexDistance = Int
 
     struct UnicodeSource {
         let buffer: UnsafeBufferPointer<UInt8>
@@ -467,7 +468,7 @@ private struct JSONReader {
             return input + step <= buffer.endIndex
         }
         
-        func distanceFromStart(_ index: Index) -> Index.Distance {
+        func distanceFromStart(_ index: Index) -> IndexDistance {
             return buffer.startIndex.distance(to: index) / step
         }
     }
@@ -625,7 +626,7 @@ private struct JSONReader {
         0x2E, 0x2D, 0x2B, 0x45, 0x65, // . - + E e
     ]
     func parseNumber(_ input: Index) throws -> (Double, Index)? {
-        func parseDouble(_ address: UnsafePointer<UInt8>) -> (Double, Index.Distance)? {
+        func parseDouble(_ address: UnsafePointer<UInt8>) -> (Double, IndexDistance)? {
             let startPointer = UnsafePointer<Int8>(address)
             let endPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 1)
             defer { endPointer.deallocateCapacity(1) }
diff --git a/Foundation/NSKeyedUnarchiver.swift b/Foundation/NSKeyedUnarchiver.swift
@@ -527,7 +527,7 @@ public class NSKeyedUnarchiver : NSCoder {
         Helper for NSArray/NSDictionary to dereference and decode an array of objects
      */
     internal func _decodeArrayOfObjectsForKey(_ key: String,
-                                              @noescape withBlock block: (Any) -> Void) throws {
+                                              withBlock block: @noescape (Any) -> Void) throws {
         let objectRefs : Array<Any>? = _decodeValue(forKey: key)
         
         guard let unwrappedObjectRefs = objectRefs else {
diff --git a/Foundation/NSLock.swift b/Foundation/NSLock.swift
@@ -51,7 +51,7 @@ public class NSLock : NSObject, NSLocking {
 }
 
 extension NSLock {
-    internal func synchronized<T>(@noescape _ closure: () -> T) -> T {
+    internal func synchronized<T>(_ closure: @noescape () -> T) -> T {
         self.lock()
         defer { self.unlock() }
         return closure()
diff --git a/Foundation/NSOperation.swift b/Foundation/NSOperation.swift
@@ -279,7 +279,7 @@ internal struct _OperationList {
         return all.count
     }
     
-    func map<T>(@noescape _ transform: (NSOperation) throws -> T) rethrows -> [T] {
+    func map<T>(_ transform: @noescape (NSOperation) throws -> T) rethrows -> [T] {
         return try all.map(transform)
     }
 }
diff --git a/Foundation/NSPathUtilities.swift b/Foundation/NSPathUtilities.swift
@@ -45,7 +45,7 @@ internal extension String {
         
         // Find the beginning of the component
         while curPos > startPos {
-            let prevPos = curPos.predecessor()
+            let prevPos = characterView.index(before: curPos)
             if characterView[prevPos] == "/" {
                 break
             }
@@ -66,7 +66,7 @@ internal extension String {
         
         // Find the beginning of the extension
         while curPos > lastCompStartPos {
-            let prevPos = curPos.predecessor()
+            let prevPos = characterView.index(before: curPos)
             let char = characterView[prevPos]
             if char == "/" {
                 return nil
@@ -111,21 +111,21 @@ internal extension String {
                     if characterView[curPos] == "/" {
                         var afterLastSlashPos = curPos
                         while afterLastSlashPos < endPos && characterView[afterLastSlashPos] == "/" {
-                            afterLastSlashPos = afterLastSlashPos.successor()
+                            afterLastSlashPos = characterView.index(after: afterLastSlashPos)
                         }
-                        if afterLastSlashPos != curPos.successor() {
+                        if afterLastSlashPos != characterView.index(after: curPos) {
                             characterView.replaceSubrange(curPos ..< afterLastSlashPos, with: ["/"])
                             endPos = characterView.endIndex
                         }
                         curPos = afterLastSlashPos
                     } else {
-                        curPos = curPos.successor()
+                        curPos = characterView.index(after: curPos)
                     }
                 }
             }
         }
         if stripTrailing && result.length > 1 && result.hasSuffix("/") {
-            result.remove(at: result.characters.endIndex.predecessor())
+            result.remove(at: result.characters.index(before: result.characters.endIndex))
         }
         return result
     }
@@ -185,14 +185,14 @@ public extension NSString {
             
             while curPos < endPos {
                 while curPos < endPos && characterView[curPos] == "/" {
-                    curPos = curPos.successor()
+                    curPos = characterView.index(after: curPos)
                 }
                 if curPos == endPos {
                     break
                 }
                 var curEnd = curPos
                 while curEnd < endPos && characterView[curEnd] != "/" {
-                    curEnd = curEnd.successor()
+                    curEnd = characterView.index(after: curEnd)
                 }
                 result.append(String(characterView[curPos ..< curEnd]))
                 curPos = curEnd
@@ -226,12 +226,12 @@ public extension NSString {
             return ""
         
         // absolute path, single component
-        case fixedSelf.startIndex.successor():
+        case fixedSelf.index(after: fixedSelf.startIndex):
             return "/"
         
         // all common cases
         case let startOfLast:
-            return String(fixedSelf.characters.prefix(upTo: startOfLast.predecessor()))
+            return String(fixedSelf.characters.prefix(upTo: fixedSelf.index(before: startOfLast)))
         }
     }
     
@@ -251,21 +251,21 @@ public extension NSString {
                     if characterView[curPos] == "/" {
                         var afterLastSlashPos = curPos
                         while afterLastSlashPos < endPos && characterView[afterLastSlashPos] == "/" {
-                            afterLastSlashPos = afterLastSlashPos.successor()
+                            afterLastSlashPos = characterView.index(after: afterLastSlashPos)
                         }
-                        if afterLastSlashPos != curPos.successor() {
+                        if afterLastSlashPos != characterView.index(after: curPos) {
                             characterView.replaceSubrange(curPos ..< afterLastSlashPos, with: ["/"])
                             endPos = characterView.endIndex
                         }
                         curPos = afterLastSlashPos
                     } else {
-                        curPos = curPos.successor()
+                        curPos = characterView.index(after: curPos)
                     }
                 }
             }
         }
         if stripTrailing && result.hasSuffix("/") {
-            result.remove(at: result.characters.endIndex.predecessor())
+            result.remove(at: result.characters.index(before: result.characters.endIndex))
         }
         return result
     }
@@ -306,7 +306,7 @@ public extension NSString {
             return fixedSelf
         }
         if let extensionPos = (fixedSelf._startOfPathExtension) {
-            return String(fixedSelf.characters.prefix(upTo: extensionPos.predecessor()))
+            return String(fixedSelf.characters.prefix(upTo: fixedSelf.characters.index(before: extensionPos)))
         } else {
             return fixedSelf
         }
@@ -327,7 +327,8 @@ public extension NSString {
         }
 
         let endOfUserName = _swiftObject.characters.index(of: "/") ?? _swiftObject.endIndex
-        let userName = String(_swiftObject.characters[_swiftObject.startIndex.successor()..<endOfUserName])
+        let startOfUserName = _swiftObject.characters.index(after: _swiftObject.characters.startIndex)
+        let userName = String(_swiftObject.characters[startOfUserName..<endOfUserName])
         let optUserName: String? = userName.isEmpty ? nil : userName
         
         guard let homeDir = NSHomeDirectoryForUser(optUserName) else {
diff --git a/Foundation/NSRange.swift b/Foundation/NSRange.swift
@@ -38,13 +38,13 @@ extension CFRange {
 public typealias NSRange = _NSRange
 
 extension NSRange {
-    public init(_ x: Range<Int>) {
+    public init(_ x: CountableRange<Int>) {
         location = x.startIndex
         length = x.count
     }
     
     @warn_unused_result
-    public func toRange() -> Range<Int>? {
+    public func toRange() -> CountableRange<Int>? {
         if location == NSNotFound { return nil }
         let min = location
         let max = location + length
diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift
@@ -157,7 +157,7 @@ extension NSRegularExpression {
     
     public func matches(in string: String, options: NSMatchingOptions, range: NSRange) -> [NSTextCheckingResult] {
         var matches = [NSTextCheckingResult]()
-        enumerateMatches(in: string, options: options.subtract(.reportProgress).subtract(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
             if let match = result {
                 matches.append(match)
             }
@@ -168,15 +168,15 @@ extension NSRegularExpression {
     
     public func numberOfMatches(in string: String, options: NSMatchingOptions, range: NSRange) -> Int {
         var count = 0
-        enumerateMatches(in: string, options: options.subtract(.reportProgress).subtract(.reportCompletion).union(.OmitResult), range: range) {_,_,_ in 
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion).union(.OmitResult), range: range) {_,_,_ in 
             count += 1
         }
         return count
     }
     
     public func firstMatch(in string: String, options: NSMatchingOptions, range: NSRange) -> NSTextCheckingResult? {
         var first: NSTextCheckingResult?
-        enumerateMatches(in: string, options: options.subtract(.reportProgress).subtract(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
             first = result
             stop.pointee = true
         }
@@ -185,7 +185,7 @@ extension NSRegularExpression {
     
     public func rangeOfFirstMatch(in string: String, options: NSMatchingOptions, range: NSRange) -> NSRange {
         var firstRange = NSMakeRange(NSNotFound, 0)
-        enumerateMatches(in: string, options: options.subtract(.reportProgress).subtract(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
+        enumerateMatches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range) { (result: NSTextCheckingResult?, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
             if let match = result {
                 firstRange = match.range
             } else {
@@ -214,7 +214,7 @@ extension NSRegularExpression {
         var str: String = ""
         let length = string.length
         var previousRange = NSMakeRange(0, 0)
-        let results = matches(in: string, options: options.subtract(.reportProgress).subtract(.reportCompletion), range: range)
+        let results = matches(in: string, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range)
         let start = string.utf16.startIndex
         
         for result in results {
@@ -239,7 +239,7 @@ extension NSRegularExpression {
     }
     
     public func replaceMatches(in string: NSMutableString, options: NSMatchingOptions, range: NSRange, withTemplate templ: String) -> Int {
-        let results = matches(in: string._swiftObject, options: options.subtract(.reportProgress).subtract(.reportCompletion), range: range)
+        let results = matches(in: string._swiftObject, options: options.subtracting(.reportProgress).subtracting(.reportCompletion), range: range)
         var count = 0
         var offset = 0
         for result in results {
diff --git a/Foundation/NSSet.swift b/Foundation/NSSet.swift
@@ -271,7 +271,7 @@ extension NSSet {
     public func setByAddingObjectsFromSet(_ other: Set<NSObject>) -> Set<NSObject> {
         var result = Set<NSObject>(minimumCapacity: Swift.max(count, other.count))
         if self.dynamicType === NSSet.self || self.dynamicType === NSMutableSet.self {
-            result.unionInPlace(_storage)
+            result.formUnion(_storage)
         } else {
             for case let obj as NSObject in self {
                 result.insert(obj)
@@ -283,7 +283,7 @@ extension NSSet {
     public func setByAddingObjectsFromArray(_ other: [AnyObject]) -> Set<NSObject> {
         var result = Set<NSObject>(minimumCapacity: count)
         if self.dynamicType === NSSet.self || self.dynamicType === NSMutableSet.self {
-            result.unionInPlace(_storage)
+            result.formUnion(_storage)
         } else {
             for case let obj as NSObject in self {
                 result.insert(obj)
@@ -400,7 +400,7 @@ public class NSMutableSet : NSSet {
     
     public func intersectSet(_ otherSet: Set<NSObject>) {
         if self.dynamicType === NSMutableSet.self {
-            _storage.intersectInPlace(otherSet)
+            _storage.formIntersection(otherSet)
         } else {
             for case let obj as NSObject in self where !otherSet.contains(obj) {
                 removeObject(obj)
@@ -410,7 +410,7 @@ public class NSMutableSet : NSSet {
     
     public func minusSet(_ otherSet: Set<NSObject>) {
         if self.dynamicType === NSMutableSet.self {
-            _storage.subtractInPlace(otherSet)
+            _storage.subtract(otherSet)
         } else {
             otherSet.forEach(removeObject)
         }
@@ -426,7 +426,7 @@ public class NSMutableSet : NSSet {
     
     public func unionSet(_ otherSet: Set<NSObject>) {
         if self.dynamicType === NSMutableSet.self {
-            _storage.unionInPlace(otherSet)
+            _storage.formUnion(otherSet)
         } else {
             otherSet.forEach(addObject)
         }
diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift
@@ -169,10 +169,10 @@ internal func _bytesInEncoding(_ str: NSString, _ encoding: NSStringEncoding, _
     var used = 0
     var options: NSStringEncodingConversionOptions = []
     if externalRep {
-        options.unionInPlace(.ExternalRepresentation)
+        options.formUnion(.ExternalRepresentation)
     }
     if lossy {
-        options.unionInPlace(.AllowLossy)
+        options.formUnion(.AllowLossy)
     }
     if !str.getBytes(nil, maxLength: Int.max - 1, usedLength: &cLength, encoding: encoding, options: options, range: theRange, remainingRange: nil) {
         if fatalOnError {
@@ -1294,8 +1294,8 @@ public class NSMutableString : NSString {
         if self.dynamicType === NSString.self || self.dynamicType === NSMutableString.self {
             // this is incorrectly calculated for grapheme clusters that have a size greater than a single unichar
             let start = _storage.startIndex
-            let min = start.advanced(by: range.location)
-            let max = start.advanced(by: range.location + range.length)
+            let min = _storage.index(start, offsetBy: range.location)
+            let max = _storage.index(start, offsetBy: range.location + range.length)
             _storage.replaceSubrange(min..<max, with: aString)
         } else {
             NSRequiresConcreteImplementation()
diff --git a/Foundation/NSSwiftRuntime.swift b/Foundation/NSSwiftRuntime.swift
diff --git a/Foundation/NSURLResponse.swift b/Foundation/NSURLResponse.swift
diff --git a/Foundation/NSXMLNode.swift b/Foundation/NSXMLNode.swift
diff --git a/Foundation/String.swift b/Foundation/String.swift
diff --git a/TestFoundation/TestNSCharacterSet.swift b/TestFoundation/TestNSCharacterSet.swift
diff --git a/TestFoundation/TestNSFileManager.swift b/TestFoundation/TestNSFileManager.swift

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,8 @@ internal func _CFSwiftStringGetBytes(_ str: AnyObject, encoding: CFStringEncodin`
`133`	`133`	`let start = encodingView.startIndex`
`134`	`134`	`if let buffer = buffer {`
`135`	`135`	`for idx in 0..<range.length {`
`136`		`- let character = encodingView[start.advanced(by: idx + range.location)]`
	`136`	`+ let characterIndex = encodingView.index(start, offsetBy: idx + range.location)`
	`137`	`+ let character = encodingView[characterIndex]`
`137`	`138`	`buffer.advanced(by: idx).initialize(with: character)`
`138`	`139`	`}`
`139`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,7 @@ extension NSData {`
`539`	`539`	`}`
`540`	`540`	`return location.map {NSRange(location: $0, length: search.count)} ?? NSRange(location: NSNotFound, length: 0)`
`541`	`541`	`}`
`542`		`- private static func searchSubSequence<T : Collection,T2 : Sequence where T.Iterator.Element : Equatable, T.Iterator.Element == T2.Iterator.Element, T.SubSequence.Iterator.Element == T.Iterator.Element>(_ subSequence : T2, inSequence seq: T,anchored : Bool) -> T.Index? {`
	`542`	`+ private static func searchSubSequence<T : Collection, T2 : Sequence where T.Iterator.Element : Equatable, T.Iterator.Element == T2.Iterator.Element, T.SubSequence.Iterator.Element == T.Iterator.Element, T.Indices.Iterator.Element == T.Index>(_ subSequence : T2, inSequence seq: T,anchored : Bool) -> T.Index? {`
`543`	`543`	`for index in seq.indices {`
`544`	`544`	`if seq.suffix(from: index).starts(with: subSequence) {`
`545`	`545`	`return index`
`@@ -684,10 +684,10 @@ extension NSData {`
`684`	`684`	`var decodedStart: UInt8 = 0`
`685`	`685`	`for range in base64ByteMappings {`
`686`	`686`	`if range.contains(byte) {`
`687`		`- let result = decodedStart + (byte - range.startIndex)`
	`687`	`+ let result = decodedStart + (byte - range.lowerBound)`
`688`	`688`	`return .Valid(result)`
`689`	`689`	`}`
`690`		`- decodedStart += range.endIndex - range.startIndex`
	`690`	`+ decodedStart += range.upperBound - range.lowerBound`
`691`	`691`	`}`
`692`	`692`	`return .Invalid`
`693`	`693`	`}`
`@@ -706,11 +706,11 @@ extension NSData {`
`706`	`706`	`assert(byte < 64)`
`707`	`707`	`var decodedStart: UInt8 = 0`
`708`	`708`	`for range in base64ByteMappings {`
`709`		`- let decodedRange = decodedStart ..< decodedStart + (range.endIndex - range.startIndex)`
	`709`	`+ let decodedRange = decodedStart ..< decodedStart + (range.upperBound - range.lowerBound)`
`710`	`710`	`if decodedRange.contains(byte) {`
`711`		`- return range.startIndex + (byte - decodedStart)`
	`711`	`+ return range.lowerBound + (byte - decodedStart)`
`712`	`712`	`}`
`713`		`- decodedStart += range.endIndex - range.startIndex`
	`713`	`+ decodedStart += range.upperBound - range.lowerBound`
`714`	`714`	`}`
`715`	`715`	`return 0`
`716`	`716`	`}`
Original file line number	Diff line number	Diff line change
`@@ -323,8 +323,8 @@ public class NSHTTPCookie : NSObject {`
`323`	`323`	`}`
`324`	`324`	`//Remove the final trailing semicolon and whitespace`
`325`	`325`	`if ( cookieString.length > 0 ) {`
`326`		`- cookieString.remove(at: cookieString.endIndex.predecessor())`
`327`		`- cookieString.remove(at: cookieString.endIndex.predecessor())`
	`326`	`+ cookieString.characters.removeLast()`
	`327`	`+ cookieString.characters.removeLast()`
`328`	`328`	`}`
`329`	`329`	`return ["Cookie": cookieString]`
`330`	`330`	`}`
Original file line number	Diff line number	Diff line change
`@@ -406,6 +406,7 @@ private struct JSONReader {`
`406`	`406`	`}`
`407`	`407`
`408`	`408`	`typealias Index = Int`
	`409`	`+ typealias IndexDistance = Int`
`409`	`410`
`410`	`411`	`struct UnicodeSource {`
`411`	`412`	`let buffer: UnsafeBufferPointer<UInt8>`
`@@ -467,7 +468,7 @@ private struct JSONReader {`
`467`	`468`	`return input + step <= buffer.endIndex`
`468`	`469`	`}`
`469`	`470`
`470`		`- func distanceFromStart(_ index: Index) -> Index.Distance {`
	`471`	`+ func distanceFromStart(_ index: Index) -> IndexDistance {`
`471`	`472`	`return buffer.startIndex.distance(to: index) / step`
`472`	`473`	`}`
`473`	`474`	`}`
`@@ -625,7 +626,7 @@ private struct JSONReader {`
`625`	`626`	`0x2E, 0x2D, 0x2B, 0x45, 0x65, // . - + E e`
`626`	`627`	`]`
`627`	`628`	`func parseNumber(_ input: Index) throws -> (Double, Index)? {`
`628`		`- func parseDouble(_ address: UnsafePointer<UInt8>) -> (Double, Index.Distance)? {`
	`629`	`+ func parseDouble(_ address: UnsafePointer<UInt8>) -> (Double, IndexDistance)? {`
`629`	`630`	`let startPointer = UnsafePointer<Int8>(address)`
`630`	`631`	`let endPointer = UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>(allocatingCapacity: 1)`
`631`	`632`	`defer { endPointer.deallocateCapacity(1) }`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public class NSLock : NSObject, NSLocking {`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`extension NSLock {`
`54`		`- internal func synchronized<T>(@noescape _ closure: () -> T) -> T {`
	`54`	`+ internal func synchronized<T>(_ closure: @noescape () -> T) -> T {`
`55`	`55`	`self.lock()`
`56`	`56`	`defer { self.unlock() }`
`57`	`57`	`return closure()`
Original file line number	Diff line number	Diff line change
`@@ -279,7 +279,7 @@ internal struct _OperationList {`
`279`	`279`	`return all.count`
`280`	`280`	`}`
`281`	`281`
`282`		`- func map<T>(@noescape _ transform: (NSOperation) throws -> T) rethrows -> [T] {`
	`282`	`+ func map<T>(_ transform: @noescape (NSOperation) throws -> T) rethrows -> [T] {`
`283`	`283`	`return try all.map(transform)`
`284`	`284`	`}`
`285`	`285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ internal extension String {`
`45`	`45`
`46`	`46`	`// Find the beginning of the component`
`47`	`47`	`while curPos > startPos {`
`48`		`- let prevPos = curPos.predecessor()`
	`48`	`+ let prevPos = characterView.index(before: curPos)`
`49`	`49`	`if characterView[prevPos] == "/" {`
`50`	`50`	`break`
`51`	`51`	`}`
`@@ -66,7 +66,7 @@ internal extension String {`
`66`	`66`
`67`	`67`	`// Find the beginning of the extension`
`68`	`68`	`while curPos > lastCompStartPos {`
`69`		`- let prevPos = curPos.predecessor()`
	`69`	`+ let prevPos = characterView.index(before: curPos)`
`70`	`70`	`let char = characterView[prevPos]`
`71`	`71`	`if char == "/" {`
`72`	`72`	`return nil`
`@@ -111,21 +111,21 @@ internal extension String {`
`111`	`111`	`if characterView[curPos] == "/" {`
`112`	`112`	`var afterLastSlashPos = curPos`
`113`	`113`	`while afterLastSlashPos < endPos && characterView[afterLastSlashPos] == "/" {`
`114`		`- afterLastSlashPos = afterLastSlashPos.successor()`
	`114`	`+ afterLastSlashPos = characterView.index(after: afterLastSlashPos)`
`115`	`115`	`}`
`116`		`- if afterLastSlashPos != curPos.successor() {`
	`116`	`+ if afterLastSlashPos != characterView.index(after: curPos) {`
`117`	`117`	`characterView.replaceSubrange(curPos ..< afterLastSlashPos, with: ["/"])`
`118`	`118`	`endPos = characterView.endIndex`
`119`	`119`	`}`
`120`	`120`	`curPos = afterLastSlashPos`
`121`	`121`	`} else {`
`122`		`- curPos = curPos.successor()`
	`122`	`+ curPos = characterView.index(after: curPos)`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`	`if stripTrailing && result.length > 1 && result.hasSuffix("/") {`
`128`		`- result.remove(at: result.characters.endIndex.predecessor())`
	`128`	`+ result.remove(at: result.characters.index(before: result.characters.endIndex))`
`129`	`129`	`}`
`130`	`130`	`return result`
`131`	`131`	`}`
`@@ -185,14 +185,14 @@ public extension NSString {`
`185`	`185`
`186`	`186`	`while curPos < endPos {`
`187`	`187`	`while curPos < endPos && characterView[curPos] == "/" {`
`188`		`- curPos = curPos.successor()`
	`188`	`+ curPos = characterView.index(after: curPos)`
`189`	`189`	`}`
`190`	`190`	`if curPos == endPos {`
`191`	`191`	`break`
`192`	`192`	`}`
`193`	`193`	`var curEnd = curPos`
`194`	`194`	`while curEnd < endPos && characterView[curEnd] != "/" {`
`195`		`- curEnd = curEnd.successor()`
	`195`	`+ curEnd = characterView.index(after: curEnd)`
`196`	`196`	`}`
`197`	`197`	`result.append(String(characterView[curPos ..< curEnd]))`
`198`	`198`	`curPos = curEnd`
`@@ -226,12 +226,12 @@ public extension NSString {`
`226`	`226`	`return ""`
`227`	`227`
`228`	`228`	`// absolute path, single component`
`229`		`- case fixedSelf.startIndex.successor():`
	`229`	`+ case fixedSelf.index(after: fixedSelf.startIndex):`
`230`	`230`	`return "/"`
`231`	`231`
`232`	`232`	`// all common cases`
`233`	`233`	`case let startOfLast:`
`234`		`- return String(fixedSelf.characters.prefix(upTo: startOfLast.predecessor()))`
	`234`	`+ return String(fixedSelf.characters.prefix(upTo: fixedSelf.index(before: startOfLast)))`
`235`	`235`	`}`
`236`	`236`	`}`
`237`	`237`
`@@ -251,21 +251,21 @@ public extension NSString {`
`251`	`251`	`if characterView[curPos] == "/" {`
`252`	`252`	`var afterLastSlashPos = curPos`
`253`	`253`	`while afterLastSlashPos < endPos && characterView[afterLastSlashPos] == "/" {`
`254`		`- afterLastSlashPos = afterLastSlashPos.successor()`
	`254`	`+ afterLastSlashPos = characterView.index(after: afterLastSlashPos)`
`255`	`255`	`}`
`256`		`- if afterLastSlashPos != curPos.successor() {`
	`256`	`+ if afterLastSlashPos != characterView.index(after: curPos) {`
`257`	`257`	`characterView.replaceSubrange(curPos ..< afterLastSlashPos, with: ["/"])`
`258`	`258`	`endPos = characterView.endIndex`
`259`	`259`	`}`
`260`	`260`	`curPos = afterLastSlashPos`
`261`	`261`	`} else {`
`262`		`- curPos = curPos.successor()`
	`262`	`+ curPos = characterView.index(after: curPos)`
`263`	`263`	`}`
`264`	`264`	`}`
`265`	`265`	`}`
`266`	`266`	`}`
`267`	`267`	`if stripTrailing && result.hasSuffix("/") {`
`268`		`- result.remove(at: result.characters.endIndex.predecessor())`
	`268`	`+ result.remove(at: result.characters.index(before: result.characters.endIndex))`
`269`	`269`	`}`
`270`	`270`	`return result`
`271`	`271`	`}`
`@@ -306,7 +306,7 @@ public extension NSString {`
`306`	`306`	`return fixedSelf`
`307`	`307`	`}`
`308`	`308`	`if let extensionPos = (fixedSelf._startOfPathExtension) {`
`309`		`- return String(fixedSelf.characters.prefix(upTo: extensionPos.predecessor()))`
	`309`	`+ return String(fixedSelf.characters.prefix(upTo: fixedSelf.characters.index(before: extensionPos)))`
`310`	`310`	`} else {`
`311`	`311`	`return fixedSelf`
`312`	`312`	`}`
`@@ -327,7 +327,8 @@ public extension NSString {`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`let endOfUserName = _swiftObject.characters.index(of: "/") ?? _swiftObject.endIndex`
`330`		`- let userName = String(_swiftObject.characters[_swiftObject.startIndex.successor()..<endOfUserName])`
	`330`	`+ let startOfUserName = _swiftObject.characters.index(after: _swiftObject.characters.startIndex)`
	`331`	`+ let userName = String(_swiftObject.characters[startOfUserName..<endOfUserName])`
`331`	`332`	`let optUserName: String? = userName.isEmpty ? nil : userName`
`332`	`333`
`333`	`334`	`guard let homeDir = NSHomeDirectoryForUser(optUserName) else {`