WIP: attempt to provide cleaner bridging interface

Author: Dave Abrahams

apinotes/Foundation.apinotes

@@ -91,6 +91,9 @@ Classes:
   - Selector: 'setUserInfoValueProviderForDomain:provider:'
     SwiftName: setUserInfoValueProvider(forDomain:provider:)
     MethodKind: Class
+  Properties:
+  - Name: userInfo
+    SwiftName: _objc_userInfo
 - Name: NSDictionary
   SwiftBridge: Swift.Dictionary
 - Name: NSSet

stdlib/public/SDK/Foundation/Foundation.swift

@@ -560,114 +560,26 @@ extension NSDictionary : ExpressibleByDictionaryLiteral {
   }
 }
 
-extension Dictionary {
-  /// Private initializer used for bridging.
-  ///
-  /// The provided `NSDictionary` will be copied to ensure that the copy can
-  /// not be mutated by other code.
-  public init(_cocoaDictionary: _NSDictionary) {
-    _sanityCheck(
-      _isBridgedVerbatimToObjectiveC(Key.self) &&
-      _isBridgedVerbatimToObjectiveC(Value.self),
-      "Dictionary can be backed by NSDictionary storage only when both key and value are bridged verbatim to Objective-C")
-    // FIXME: We would like to call CFDictionaryCreateCopy() to avoid doing an
-    // objc_msgSend() for instances of CoreFoundation types.  We can't do that
-    // today because CFDictionaryCreateCopy() copies dictionary contents
-    // unconditionally, resulting in O(n) copies even for immutable dictionaries.
-    //
-    // <rdar://problem/20690755> CFDictionaryCreateCopy() does not call copyWithZone:
-    //
-    // The bug is fixed in: OS X 10.11.0, iOS 9.0, all versions of tvOS
-    // and watchOS.
-    self = Dictionary(
-        _unsafeReferenceCast(_cocoaDictionary, to: _NSDictionary.self))
-  }
-}
-
 // Dictionary<Key, Value> is conditionally bridged to NSDictionary
-extension Dictionary : _ObjectiveCBridgeable {
+extension Dictionary : _CustomObjectiveCBridgeable {
   @_semantics("convertToObjectiveC")
   public func _bridgeToObjectiveC() -> NSDictionary {
     return unsafeBitCast(_bridgeToObjectiveCImpl() as AnyObject,
                          to: NSDictionary.self)
   }
 
-  public static func _forceBridgeFromObjectiveC(
-    _ d: NSDictionary,
-    result: inout Dictionary?
-  ) {
-    if let native = [Key : Value]._bridgeFromObjectiveCAdoptingNativeStorageOf(
-        d as AnyObject) {
-      result = native
-      return
-    }
-
-    if _isBridgedVerbatimToObjectiveC(Key.self) &&
-       _isBridgedVerbatimToObjectiveC(Value.self) {
-      result = [Key : Value](
-        _cocoaDictionary: unsafeBitCast(d as AnyObject, to: _NSDictionary.self))
-      return
-    }
-
-    // `Dictionary<Key, Value>` where either `Key` or `Value` is a value type
-    // may not be backed by an NSDictionary.
-    var builder = _DictionaryBuilder<Key, Value>(count: d.count)
-    d.enumerateKeysAndObjects({
-      (anyKey: Any, anyValue: Any,
-       stop: UnsafeMutablePointer<ObjCBool>) in
-      let anyObjectKey = anyKey as AnyObject
-      let anyObjectValue = anyValue as AnyObject
-      builder.add(
-          key: Swift._forceBridgeFromObjectiveC(anyObjectKey, Key.self),
-          value: Swift._forceBridgeFromObjectiveC(anyObjectValue, Value.self))
-    })
-    result = builder.take()
-  }
-
-  public static func _conditionallyBridgeFromObjectiveC(
-    _ x: NSDictionary,
-    result: inout Dictionary?
-  ) -> Bool {
-    let anyDict = x as [NSObject : AnyObject]
-    if _isBridgedVerbatimToObjectiveC(Key.self) &&
-       _isBridgedVerbatimToObjectiveC(Value.self) {
-      result = Swift._dictionaryDownCastConditional(anyDict)
-      return result != nil
-    }
-
-    result = Swift._dictionaryBridgeFromObjectiveCConditional(anyDict)
-    return result != nil
+  public static func _bridgedFromNil(_: NSDictionary?) -> Dictionary {
+    return [:]
   }
-
-  public static func _unconditionallyBridgeFromObjectiveC(
-    _ d: NSDictionary?
-  ) -> Dictionary {
-    // `nil` has historically been used as a stand-in for an empty
-    // dictionary; map it to an empty dictionary.
-    if _slowPath(d == nil) { return Dictionary() }
-
-    if let native = [Key : Value]._bridgeFromObjectiveCAdoptingNativeStorageOf(
-        d! as AnyObject) {
-      return native
+  
+  public static func _bridged<Policy: _BridgePolicy>(
+    from objc: NSDictionary, by policy: Policy.Type
+  ) -> Dictionary? {
+    if let n = Dictionary._bridgeFromObjectiveCAdoptingNativeStorageOf(objc) {
+      return n
     }
-
-    if _isBridgedVerbatimToObjectiveC(Key.self) &&
-       _isBridgedVerbatimToObjectiveC(Value.self) {
-      return [Key : Value](
-        _cocoaDictionary: unsafeBitCast(d! as AnyObject, to: _NSDictionary.self))
-    }
-
-    // `Dictionary<Key, Value>` where either `Key` or `Value` is a value type
-    // may not be backed by an NSDictionary.
-    var builder = _DictionaryBuilder<Key, Value>(count: d!.count)
-    d!.enumerateKeysAndObjects({
-      (anyKey: Any, anyValue: Any,
-       stop: UnsafeMutablePointer<ObjCBool>) in
-      builder.add(
-          key: Swift._forceBridgeFromObjectiveC(anyKey as AnyObject, Key.self),
-          value: Swift._forceBridgeFromObjectiveC(anyValue as AnyObject, Value.self))
-    })
-    return builder.take()
+    return Dictionary(
+      _unsafeReferenceCast(objc, to: _NSDictionary.self), by: policy)
   }
 }
 

stdlib/public/SDK/Foundation/NSError.swift

@@ -241,11 +241,21 @@ public func _swift_Foundation_getErrorDefaultUserInfo(_ error: Error)
 // magic allows this to be done as a "toll-free" conversion when an NSError
 // or CFError is used as an Error existential.
 
+@objc protocol _NSError : class {
+  @objc var userInfo: NSDictionary { get }
+}
+
 extension NSError : Error {
   public var _domain: String { return domain }
   public var _code: Int { return code }
   public var _userInfo: Any? { return userInfo }
 
+  @nonobjc
+  public var userInfo: [AnyHashable : Any] {
+    let proxy = _unsafeReferenceCast(self, to: _NSError.self)
+    return proxy.userInfo as! [AnyHashable : Any]
+  }
+  
   /// The "embedded" NSError is itself.
   public func _getEmbeddedNSError() -> AnyObject? {
     return self

stdlib/public/core/BridgeObjectiveC.swift

@@ -98,22 +98,20 @@ struct _ConditionalCasting : _BridgePolicy {
 }
 
 public protocol _CustomObjectiveCBridgeable : _ObjectiveCBridgeable {
+  /// An Objective-C type to which `Self` can be losslessly round-trip
+  /// converted.
+  associatedtype _ObjectiveCType : AnyObject
+
+  /// Convert `self` to Objective-C.
+  func _bridgeToObjectiveC() -> _ObjectiveCType
+  
   static func _bridged<Policy: _BridgePolicy>(
     from objc: _ObjectiveCType, by policy: Policy.Type) -> Self?
 
   static func _bridgedFromNil(_: _ObjectiveCType?) -> Self
 }
 
-extension _ObjectiveCBridgeable {
-  public static func _bridgedFromNil(_: _ObjectiveCType?) -> Self {
-    fatalError(
-      "Objective-C nil of type \(String(reflecting: _ObjectiveCType.self)) "
-      + "does not bridge to \(String(reflecting: Self.self))")
-  }
-}
-
-
-extension _ObjectiveCBridgeable where Self : _CustomObjectiveCBridgeable {
+extension _CustomObjectiveCBridgeable {
   /// Bridge from an Objective-C object of the bridged class type to a
   /// value of the Self type.
   ///
@@ -173,7 +171,7 @@ extension _ObjectiveCBridgeable where Self : _CustomObjectiveCBridgeable {
   /// measure against mis-annotation, this method accepts `source` as an
   /// `Optional`, so implementations can return an appropriate default value
   /// (e.g. an empty `Array`) when `source` is `nil`.
-  static func _unconditionallyBridgeFromObjectiveC(
+  public static func _unconditionallyBridgeFromObjectiveC(
     _ source: _ObjectiveCType?
   ) -> Self {
     if _slowPath(source == nil) {
@@ -188,6 +186,12 @@ extension _ObjectiveCBridgeable where Self : _CustomObjectiveCBridgeable {
       + "\(String(reflecting: Self.self)) failed with actual value "
       + "\(String(reflecting: source))")
   }
+
+  public static func _bridgedFromNil(_: _ObjectiveCType?) -> Self {
+    fatalError(
+      "Objective-C nil of type \(String(reflecting: _ObjectiveCType.self)) "
+      + "does not bridge to \(String(reflecting: Self.self))")
+  }
 }
 
 //===--- Bridging for metatypes -------------------------------------------===//

stdlib/public/core/HashedCollections.swift.gyb

@@ -1629,22 +1629,25 @@ public struct Dictionary<Key : Hashable, Value> :
 
 #if _runtime(_ObjC)
   /// Private initializer used for bridging.
-  ///
-  /// - Precondition: * `Key` and `Value` are bridged verbatim to Objective-C
-  ///   (i.e., are reference types).
-  public init(_ source: _NSDictionary) {
-    _sanityCheck(
-      _isBridgedVerbatimToObjectiveC(Key.self) &&
-      _isBridgedVerbatimToObjectiveC(Value.self),
-      "Expecting both key and value to be bridged verbatim to Objective-C")
+  public init?<Policy: _BridgePolicy>(
+    _ source: _NSDictionary, by policy: Policy.Type) {
     self.init(minimumCapacity: source.count)
-    source._forEachBatch { b in
+    let success: Void? = try? source._forEachBatch { b in
       for k in b {
         // FIXME: Use objectsForKeys as an optimization
         // FIXME: Use unsafeDowncasts as an optimization?
-        self[k as! Key] = (source.objectFor(k)! as! Value)
+        
+        guard
+          let key = policy.bridge(k, to: Key.self),
+          let value = policy.bridge(
+            source.objectFor(k)!, to: Value.self
+          )
+        else { throw _StopIteration.stop }
+        
+        self[key] = value
       }
     }
+    if success == nil { return nil }
   }
 #endif
 
@@ -2229,7 +2232,9 @@ public func _dictionaryDownCast<BaseKey, BaseValue, DerivedKey, DerivedValue>(
       // Note: it is safe to treat the storage as immutable here because
       // Dictionary will not mutate storage with reference count greater than 1.
       return Dictionary(
-        _unsafeReferenceCast(nativeOwner, to: _NSDictionary.self))
+        _unsafeReferenceCast(nativeOwner, to: _NSDictionary.self),
+        by: _ForceCasting.self
+      ).unsafelyUnwrapped
     }
   }
 #endif