Use an argument label to disambiguate calls to _SwiftValue.fetch. (#753)

rudkx · phausler · commit 6cda1f30f4d2 · 2016-12-20T11:25:39.000-08:00
Back out the changes from d9cdc7e and 1576958, and instead use an argument label to disambiguate calls to `fetch`.
diff --git a/Foundation/Bridging.swift b/Foundation/Bridging.swift
@@ -77,12 +77,12 @@ internal final class _SwiftValue : NSObject, NSCopying {
     
     static func fetch(_ object: AnyObject?) -> Any? {
         if let obj = object {
-            return fetch(obj)
+            return fetch(nonOptional: obj)
         }
         return nil
     }
     
-    static func fetch(_ object: AnyObject) -> Any {
+    static func fetch(nonOptional object: AnyObject) -> Any {
         if let container = object as? _SwiftValue {
             return container.value
         } else if let val = object as? _StructBridgeable {
diff --git a/Foundation/Dictionary.swift b/Foundation/Dictionary.swift
@@ -65,8 +65,8 @@ extension Dictionary : _ObjectTypeBridgeable {
             CFDictionaryGetKeysAndValues(cf, keys, values)
 
             for idx in 0..<cnt {
-                let key = _SwiftValue.fetch(unsafeBitCast(keys.advanced(by: idx).pointee!, to: AnyObject.self))
-                let value = _SwiftValue.fetch(unsafeBitCast(values.advanced(by: idx).pointee!, to: AnyObject.self))
+                let key = _SwiftValue.fetch(nonOptional: unsafeBitCast(keys.advanced(by: idx).pointee!, to: AnyObject.self))
+                let value = _SwiftValue.fetch(nonOptional: unsafeBitCast(values.advanced(by: idx).pointee!, to: AnyObject.self))
                 guard let k = key as? Key, let v = value as? Value else {
                     failedConversion = true
                     break
diff --git a/Foundation/NSArray.swift b/Foundation/NSArray.swift
@@ -24,7 +24,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
         guard type(of: self) === NSArray.self || type(of: self) === NSMutableArray.self else {
            NSRequiresConcreteImplementation()
         }
-        return _SwiftValue.fetch(_storage[index])
+        return _SwiftValue.fetch(nonOptional: _storage[index])
     }
     
     public convenience override init() {
@@ -151,7 +151,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
 
     internal var allObjects: [Any] {
         if type(of: self) === NSArray.self || type(of: self) === NSMutableArray.self {
-            return _storage.map { _SwiftValue.fetch($0) }
+            return _storage.map { _SwiftValue.fetch(nonOptional: $0) }
         } else {
             return (0..<count).map { idx in
                 return self[idx]
@@ -226,7 +226,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
         for idx in 0..<count {
             let item = _SwiftValue.store(self[idx])
             if set.contains(item) {
-                return _SwiftValue.fetch(item)
+                return _SwiftValue.fetch(nonOptional: item)
             }
         }
         return nil
@@ -236,7 +236,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo
         objects.reserveCapacity(objects.count + range.length)
 
         if type(of: self) === NSArray.self || type(of: self) === NSMutableArray.self {
-            objects += _storage[range.toRange()!].map { _SwiftValue.fetch($0) }
+            objects += _storage[range.toRange()!].map { _SwiftValue.fetch(nonOptional: $0) }
             return
         }
         
diff --git a/Foundation/NSCFArray.swift b/Foundation/NSCFArray.swift
@@ -34,7 +34,7 @@ internal final class _NSCFArray : NSMutableArray {
     
     override func object(at index: Int) -> Any {
         let value = CFArrayGetValueAtIndex(_cfObject, index)
-        return _SwiftValue.fetch(unsafeBitCast(value, to: AnyObject.self))
+        return _SwiftValue.fetch(nonOptional: unsafeBitCast(value, to: AnyObject.self))
     }
     
     override func insert(_ value: Any, at index: Int) {
diff --git a/Foundation/NSCFDictionary.swift b/Foundation/NSCFDictionary.swift
@@ -39,7 +39,7 @@ internal final class _NSCFDictionary : NSMutableDictionary {
     override func object(forKey aKey: Any) -> Any? {
         let value = CFDictionaryGetValue(_cfObject, unsafeBitCast(_SwiftValue.store(aKey), to: UnsafeRawPointer.self))
         if value != nil {
-            return _SwiftValue.fetch(unsafeBitCast(value, to: AnyObject.self) as AnyObject?)
+            return _SwiftValue.fetch(nonOptional: unsafeBitCast(value, to: AnyObject.self))
         } else {
             return nil
         }
@@ -117,7 +117,7 @@ internal func _CFSwiftDictionaryGetValue(_ dictionary: AnyObject, key: AnyObject
             return Unmanaged<AnyObject>.passUnretained(obj)
         }
     } else {
-        let k = _SwiftValue.fetch(key)
+        let k = _SwiftValue.fetch(nonOptional: key)
         let value = dict.object(forKey: k)
         let v = _SwiftValue.store(value)
         dict._storage[key as! NSObject] = v
diff --git a/Foundation/NSCFSet.swift b/Foundation/NSCFSet.swift
@@ -41,7 +41,7 @@ internal final class _NSCFSet : NSMutableSet {
         guard let value = CFSetGetValue(_cfObject, unsafeBitCast(_SwiftValue.store(object), to: UnsafeRawPointer.self)) else {
             return nil
         }
-        return _SwiftValue.fetch(unsafeBitCast(value, to: AnyObject.self) as AnyObject?)
+        return _SwiftValue.fetch(nonOptional: unsafeBitCast(value, to: AnyObject.self))
         
     }
     
diff --git a/Foundation/NSDictionary.swift b/Foundation/NSDictionary.swift
@@ -27,7 +27,7 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
             NSRequiresConcreteImplementation()
         }
         if let val = _storage[_SwiftValue.store(aKey)] {
-            return _SwiftValue.fetch(val)
+            return _SwiftValue.fetch(nonOptional: val)
         }
         return nil
     }
@@ -37,7 +37,7 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
             NSRequiresConcreteImplementation()
         }
         
-        return NSGeneratorEnumerator(_storage.keys.map { _SwiftValue.fetch($0) }.makeIterator())
+        return NSGeneratorEnumerator(_storage.keys.map { _SwiftValue.fetch(nonOptional: $0) }.makeIterator())
     }
     
     public override convenience init() {
@@ -186,8 +186,8 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
     open func getObjects(_ objects: inout [Any], andKeys keys: inout [Any], count: Int) {
         if type(of: self) === NSDictionary.self || type(of: self) === NSMutableDictionary.self {
             for (key, value) in _storage {
-                keys.append(_SwiftValue.fetch(key))
-                objects.append(_SwiftValue.fetch(value))
+                keys.append(_SwiftValue.fetch(nonOptional: key))
+                objects.append(_SwiftValue.fetch(nonOptional: value))
             }
         } else {
             
diff --git a/Foundation/NSOrderedSet.swift b/Foundation/NSOrderedSet.swift
@@ -70,7 +70,7 @@ open class NSOrderedSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
     }
 
     open func object(at idx: Int) -> Any {
-        return _SwiftValue.fetch(_orderedStorage[idx])
+        return _SwiftValue.fetch(nonOptional: _orderedStorage[idx])
     }
 
     open func index(of object: Any) -> Int {
@@ -121,7 +121,7 @@ open class NSOrderedSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,
     
     internal var allObjects: [Any] {
         if type(of: self) === NSOrderedSet.self || type(of: self) === NSMutableOrderedSet.self {
-            return _orderedStorage.map { _SwiftValue.fetch($0) }
+            return _orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }
         } else {
             return (0..<count).map { idx in
                 return self[idx]
@@ -161,15 +161,15 @@ extension NSOrderedSet {
 
     public var firstObject: Any? {
         if let value = _orderedStorage.first {
-            return _SwiftValue.fetch(value)
+            return _SwiftValue.fetch(nonOptional: value)
         } else {
             return nil
         }
     }
 
     public var lastObject: Any? {
         if let value = _orderedStorage.last {
-            return _SwiftValue.fetch(value)
+            return _SwiftValue.fetch(nonOptional: value)
         } else {
             return nil
         }
@@ -234,19 +234,19 @@ extension NSOrderedSet {
         guard type(of: self) === NSOrderedSet.self || type(of: self) === NSMutableOrderedSet.self else {
             NSRequiresConcreteImplementation()
         }
-        return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch($0) }.makeIterator())
+        return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }.makeIterator())
     }
 
     public func reverseObjectEnumerator() -> NSEnumerator { 
         guard type(of: self) === NSOrderedSet.self || type(of: self) === NSMutableOrderedSet.self else {
             NSRequiresConcreteImplementation()
         }
-        return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch($0) }.reversed().makeIterator())
+        return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }.reversed().makeIterator())
     }
     
     /*@NSCopying*/ 
     public var reversed: NSOrderedSet {
-        return NSOrderedSet(array: _orderedStorage.map { _SwiftValue.fetch($0) }.reversed())
+        return NSOrderedSet(array: _orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }.reversed())
     }
     
     // These two methods return a facade object for the receiving ordered set,
@@ -548,7 +548,7 @@ extension NSMutableOrderedSet {
 
         let swiftRange = range.toRange()!
         _orderedStorage[swiftRange].sort { lhs, rhs in
-            return cmptr(_SwiftValue.fetch(lhs), _SwiftValue.fetch(rhs)) == .orderedAscending
+            return cmptr(_SwiftValue.fetch(nonOptional: lhs), _SwiftValue.fetch(nonOptional: rhs)) == .orderedAscending
         }
     }
 }
diff --git a/Foundation/NSPropertyList.swift b/Foundation/NSPropertyList.swift
@@ -84,7 +84,7 @@ open class PropertyListSerialization : NSObject {
         if let err = error {
             throw err.takeUnretainedValue()._nsObject
         } else {
-            return _SwiftValue.fetch(decoded!)
+            return _SwiftValue.fetch(nonOptional: decoded!)
         }
     }
     
@@ -104,7 +104,7 @@ open class PropertyListSerialization : NSObject {
         if let err = error {
             throw err.takeUnretainedValue()._nsObject
         } else {
-            return _SwiftValue.fetch(decoded!)
+            return _SwiftValue.fetch(nonOptional: decoded!)
         }
     }
     
diff --git a/Foundation/NSSet.swift b/Foundation/NSSet.swift
@@ -34,7 +34,7 @@ open class NSSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCodi
         guard type(of: self) === NSSet.self || type(of: self) === NSMutableSet.self || type(of: self) === NSCountedSet.self else {
             NSRequiresConcreteImplementation()
         }
-        return NSGeneratorEnumerator(_storage.map { _SwiftValue.fetch($0) }.makeIterator())
+        return NSGeneratorEnumerator(_storage.map { _SwiftValue.fetch(nonOptional: $0) }.makeIterator())
     }
 
     public convenience override init() {
@@ -166,7 +166,7 @@ extension NSSet {
     
     open var allObjects: [Any] {
         if type(of: self) === NSSet.self || type(of: self) === NSMutableSet.self {
-            return _storage.map { _SwiftValue.fetch($0) }
+            return _storage.map { _SwiftValue.fetch(nonOptional: $0) }
         } else {
             let enumerator = objectEnumerator()
             var items = [Any]()
@@ -219,7 +219,7 @@ extension NSSet {
     open func addingObjects(from other: Set<AnyHashable>) -> Set<AnyHashable> {
         var result = Set<AnyHashable>(minimumCapacity: Swift.max(count, other.count))
         if type(of: self) === NSSet.self || type(of: self) === NSMutableSet.self {
-            result.formUnion(_storage.map { _SwiftValue.fetch($0) as! AnyHashable })
+            result.formUnion(_storage.map { _SwiftValue.fetch(nonOptional: $0) as! AnyHashable })
         } else {
             for case let obj as NSObject in self {
                 _ = result.insert(obj)
@@ -231,7 +231,7 @@ extension NSSet {
     open func addingObjects(from other: [Any]) -> Set<AnyHashable> {
         var result = Set<AnyHashable>(minimumCapacity: count)
         if type(of: self) === NSSet.self || type(of: self) === NSMutableSet.self {
-            result.formUnion(_storage.map { _SwiftValue.fetch($0) as! AnyHashable })
+            result.formUnion(_storage.map { _SwiftValue.fetch(nonOptional: $0) as! AnyHashable })
         } else {
             for case let obj as AnyHashable in self {
                 result.insert(obj)
diff --git a/Foundation/NSUserDefaults.swift b/Foundation/NSUserDefaults.swift
@@ -150,7 +150,7 @@ open class UserDefaults: NSObject {
               let bVal = aVal as? NSArray else {
             return nil
         }
-        return _SwiftValue.fetch(bVal) as? [String]
+        return _SwiftValue.fetch(nonOptional: bVal) as? [String]
     }
     open func integer(forKey defaultName: String) -> Int {
         guard let aVal = object(forKey: defaultName),

Original file line number	Diff line number	Diff line change
`@@ -77,12 +77,12 @@ internal final class _SwiftValue : NSObject, NSCopying {`
`77`	`77`
`78`	`78`	`static func fetch(_ object: AnyObject?) -> Any? {`
`79`	`79`	`if let obj = object {`
`80`		`- return fetch(obj)`
	`80`	`+ return fetch(nonOptional: obj)`
`81`	`81`	`}`
`82`	`82`	`return nil`
`83`	`83`	`}`
`84`	`84`
`85`		`- static func fetch(_ object: AnyObject) -> Any {`
	`85`	`+ static func fetch(nonOptional object: AnyObject) -> Any {`
`86`	`86`	`if let container = object as? _SwiftValue {`
`87`	`87`	`return container.value`
`88`	`88`	`} else if let val = object as? _StructBridgeable {`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo`
`24`	`24`	`guard type(of: self) === NSArray.self \|\| type(of: self) === NSMutableArray.self else {`
`25`	`25`	`NSRequiresConcreteImplementation()`
`26`	`26`	`}`
`27`		`- return _SwiftValue.fetch(_storage[index])`
	`27`	`+ return _SwiftValue.fetch(nonOptional: _storage[index])`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`public convenience override init() {`
`@@ -151,7 +151,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo`
`151`	`151`
`152`	`152`	`internal var allObjects: [Any] {`
`153`	`153`	`if type(of: self) === NSArray.self \|\| type(of: self) === NSMutableArray.self {`
`154`		`- return _storage.map { _SwiftValue.fetch($0) }`
	`154`	`+ return _storage.map { _SwiftValue.fetch(nonOptional: $0) }`
`155`	`155`	`} else {`
`156`	`156`	`return (0..<count).map { idx in`
`157`	`157`	`return self[idx]`
`@@ -226,7 +226,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo`
`226`	`226`	`for idx in 0..<count {`
`227`	`227`	`let item = _SwiftValue.store(self[idx])`
`228`	`228`	`if set.contains(item) {`
`229`		`- return _SwiftValue.fetch(item)`
	`229`	`+ return _SwiftValue.fetch(nonOptional: item)`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`	`return nil`
`@@ -236,7 +236,7 @@ open class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NSCo`
`236`	`236`	`objects.reserveCapacity(objects.count + range.length)`
`237`	`237`
`238`	`238`	`if type(of: self) === NSArray.self \|\| type(of: self) === NSMutableArray.self {`
`239`		`- objects += _storage[range.toRange()!].map { _SwiftValue.fetch($0) }`
	`239`	`+ objects += _storage[range.toRange()!].map { _SwiftValue.fetch(nonOptional: $0) }`
`240`	`240`	`return`
`241`	`241`	`}`
`242`	`242`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ internal final class _NSCFArray : NSMutableArray {`
`34`	`34`
`35`	`35`	`override func object(at index: Int) -> Any {`
`36`	`36`	`let value = CFArrayGetValueAtIndex(_cfObject, index)`
`37`		`- return _SwiftValue.fetch(unsafeBitCast(value, to: AnyObject.self))`
	`37`	`+ return _SwiftValue.fetch(nonOptional: unsafeBitCast(value, to: AnyObject.self))`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`override func insert(_ value: Any, at index: Int) {`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ internal final class _NSCFSet : NSMutableSet {`
`41`	`41`	`guard let value = CFSetGetValue(_cfObject, unsafeBitCast(_SwiftValue.store(object), to: UnsafeRawPointer.self)) else {`
`42`	`42`	`return nil`
`43`	`43`	`}`
`44`		`- return _SwiftValue.fetch(unsafeBitCast(value, to: AnyObject.self) as AnyObject?)`
	`44`	`+ return _SwiftValue.fetch(nonOptional: unsafeBitCast(value, to: AnyObject.self))`
`45`	`45`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,`
`27`	`27`	`NSRequiresConcreteImplementation()`
`28`	`28`	`}`
`29`	`29`	`if let val = _storage[_SwiftValue.store(aKey)] {`
`30`		`- return _SwiftValue.fetch(val)`
	`30`	`+ return _SwiftValue.fetch(nonOptional: val)`
`31`	`31`	`}`
`32`	`32`	`return nil`
`33`	`33`	`}`
`@@ -37,7 +37,7 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,`
`37`	`37`	`NSRequiresConcreteImplementation()`
`38`	`38`	`}`
`39`	`39`
`40`		`- return NSGeneratorEnumerator(_storage.keys.map { _SwiftValue.fetch($0) }.makeIterator())`
	`40`	`+ return NSGeneratorEnumerator(_storage.keys.map { _SwiftValue.fetch(nonOptional: $0) }.makeIterator())`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public override convenience init() {`
`@@ -186,8 +186,8 @@ open class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,`
`186`	`186`	`open func getObjects(_ objects: inout [Any], andKeys keys: inout [Any], count: Int) {`
`187`	`187`	`if type(of: self) === NSDictionary.self \|\| type(of: self) === NSMutableDictionary.self {`
`188`	`188`	`for (key, value) in _storage {`
`189`		`- keys.append(_SwiftValue.fetch(key))`
`190`		`- objects.append(_SwiftValue.fetch(value))`
	`189`	`+ keys.append(_SwiftValue.fetch(nonOptional: key))`
	`190`	`+ objects.append(_SwiftValue.fetch(nonOptional: value))`
`191`	`191`	`}`
`192`	`192`	`} else {`
`193`	`193`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ open class NSOrderedSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`open func object(at idx: Int) -> Any {`
`73`		`- return _SwiftValue.fetch(_orderedStorage[idx])`
	`73`	`+ return _SwiftValue.fetch(nonOptional: _orderedStorage[idx])`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`open func index(of object: Any) -> Int {`
`@@ -121,7 +121,7 @@ open class NSOrderedSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding,`
`121`	`121`
`122`	`122`	`internal var allObjects: [Any] {`
`123`	`123`	`if type(of: self) === NSOrderedSet.self \|\| type(of: self) === NSMutableOrderedSet.self {`
`124`		`- return _orderedStorage.map { _SwiftValue.fetch($0) }`
	`124`	`+ return _orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }`
`125`	`125`	`} else {`
`126`	`126`	`return (0..<count).map { idx in`
`127`	`127`	`return self[idx]`
`@@ -161,15 +161,15 @@ extension NSOrderedSet {`
`161`	`161`
`162`	`162`	`public var firstObject: Any? {`
`163`	`163`	`if let value = _orderedStorage.first {`
`164`		`- return _SwiftValue.fetch(value)`
	`164`	`+ return _SwiftValue.fetch(nonOptional: value)`
`165`	`165`	`} else {`
`166`	`166`	`return nil`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`public var lastObject: Any? {`
`171`	`171`	`if let value = _orderedStorage.last {`
`172`		`- return _SwiftValue.fetch(value)`
	`172`	`+ return _SwiftValue.fetch(nonOptional: value)`
`173`	`173`	`} else {`
`174`	`174`	`return nil`
`175`	`175`	`}`
`@@ -234,19 +234,19 @@ extension NSOrderedSet {`
`234`	`234`	`guard type(of: self) === NSOrderedSet.self \|\| type(of: self) === NSMutableOrderedSet.self else {`
`235`	`235`	`NSRequiresConcreteImplementation()`
`236`	`236`	`}`
`237`		`- return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch($0) }.makeIterator())`
	`237`	`+ return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }.makeIterator())`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`public func reverseObjectEnumerator() -> NSEnumerator {`
`241`	`241`	`guard type(of: self) === NSOrderedSet.self \|\| type(of: self) === NSMutableOrderedSet.self else {`
`242`	`242`	`NSRequiresConcreteImplementation()`
`243`	`243`	`}`
`244`		`- return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch($0) }.reversed().makeIterator())`
	`244`	`+ return NSGeneratorEnumerator(_orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }.reversed().makeIterator())`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`/@NSCopying/`
`248`	`248`	`public var reversed: NSOrderedSet {`
`249`		`- return NSOrderedSet(array: _orderedStorage.map { _SwiftValue.fetch($0) }.reversed())`
	`249`	`+ return NSOrderedSet(array: _orderedStorage.map { _SwiftValue.fetch(nonOptional: $0) }.reversed())`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`// These two methods return a facade object for the receiving ordered set,`
`@@ -548,7 +548,7 @@ extension NSMutableOrderedSet {`
`548`	`548`
`549`	`549`	`let swiftRange = range.toRange()!`
`550`	`550`	`_orderedStorage[swiftRange].sort { lhs, rhs in`
`551`		`- return cmptr(_SwiftValue.fetch(lhs), _SwiftValue.fetch(rhs)) == .orderedAscending`
	`551`	`+ return cmptr(_SwiftValue.fetch(nonOptional: lhs), _SwiftValue.fetch(nonOptional: rhs)) == .orderedAscending`
`552`	`552`	`}`
`553`	`553`	`}`
`554`	`554`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ open class PropertyListSerialization : NSObject {`
`84`	`84`	`if let err = error {`
`85`	`85`	`throw err.takeUnretainedValue()._nsObject`
`86`	`86`	`} else {`
`87`		`- return _SwiftValue.fetch(decoded!)`
	`87`	`+ return _SwiftValue.fetch(nonOptional: decoded!)`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`@@ -104,7 +104,7 @@ open class PropertyListSerialization : NSObject {`
`104`	`104`	`if let err = error {`
`105`	`105`	`throw err.takeUnretainedValue()._nsObject`
`106`	`106`	`} else {`
`107`		`- return _SwiftValue.fetch(decoded!)`
	`107`	`+ return _SwiftValue.fetch(nonOptional: decoded!)`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ open class UserDefaults: NSObject {`
`150`	`150`	`let bVal = aVal as? NSArray else {`
`151`	`151`	`return nil`
`152`	`152`	`}`
`153`		`- return _SwiftValue.fetch(bVal) as? [String]`
	`153`	`+ return _SwiftValue.fetch(nonOptional: bVal) as? [String]`
`154`	`154`	`}`
`155`	`155`	`open func integer(forKey defaultName: String) -> Int {`
`156`	`156`	`guard let aVal = object(forKey: defaultName),`