Runtime: Add preliminary _swift_bridgeUnknownToObject() entry point.

Author: slavapestov

stdlib/public/core/BridgeObjectiveC.swift

@@ -193,6 +193,33 @@ func _bridgeToObjectiveCUnconditionalAutorelease<T>(_ x: T) -> AnyObject
 @_silgen_name("_swift_bridgeNonVerbatimToObjectiveC")
 func _bridgeNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject?
 
+/// Bridge an arbitrary value to an Objective-C object.
+///
+/// - If `T` is a class type, it is always bridged verbatim, the function
+///   returns `x`;
+///
+/// - otherwise, `T` conforms to `_ObjectiveCBridgeable`:
+///   + if `T._isBridgedToObjectiveC()` returns `false`, then
+///     we fall back to boxing (below);
+///   + otherwise, returns the result of `x._bridgeToObjectiveC()`;
+///
+/// - otherwise, we use **boxing** to bring the value into Objective-C.
+///   The value is wrapped in an instance of a private Objective-C class
+///   that is `id`-compatible and dynamically castable back to the type of
+///   the boxed value, but is otherwise opaque.
+///
+/// TODO: This should subsume `_bridgeToObjectiveC` above.
+func _bridgeAnythingToObjectiveC<T>(_: T) -> AnyObject {
+  if _fastPath(_isClassOrObjCExistential(T.self)) {
+    return unsafeBitCast(x, to: AnyObject.self)
+  }
+  return _bridgeAnythingNonVerbatimToObjectiveC(x)
+}
+
+// TODO: This should subsume `_bridgeNonVerbatimToObjectiveC` above.
+@_silgen_name("_swift_bridgeAnythingNonVerbatimToObjectiveC")
+func _bridgeAnythingNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject
+
 /// Convert `x` from its Objective-C representation to its Swift
 /// representation.
 ///
@@ -523,4 +550,5 @@ extension AutoreleasingUnsafeMutablePointer {
     Builtin.unreachable()
   }
 }
+
 #endif

stdlib/public/runtime/Casting.cpp

@@ -2515,6 +2515,38 @@ static bool _dynamicCastClassToValueViaObjCBridgeable(
   return success;
 }
 
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
+extern "C"
+id _swift_bridgeAnythingNonVerbatimToObjectiveC(OpaqueValue *src,
+                                                const Metadata *srcType) {
+  // We can always bridge objects verbatim.
+  if (srcType->isAnyClass()) {
+    return *(id*)src;
+  }
+  
+  // TODO: Look through existential containers.
+  
+  if (auto srcBridgeWitness = findBridgeWitness(srcType)) {
+    // Check whether the source is bridged to Objective-C.
+    if (!srcBridgeWitness->isBridgedToObjectiveC(srcType, srcType,
+                                                 srcBridgeWitness)) {
+      return nil;
+    }
+
+    // Bridge the source value to an object.
+    auto srcBridgedObject =
+      srcBridgeWitness->bridgeToObjectiveC(src, srcType, srcBridgeWitness);
+
+    // The source object was passed in +1.
+    srcType->vw_destroy(src);
+
+    return (id)srcBridgedObject;
+  }
+
+  // TODO: Fall back to boxing here.
+  crash("unimplemented universal bridging conversion");
+}
+
 //===--- Bridging helpers for the Swift stdlib ----------------------------===//
 // Functions that must discover and possibly use an arbitrary type's
 // conformance to a given protocol.  See ../core/BridgeObjectiveC.swift for