Runtime: Look through existentials when bridging to id.

Author: jckarter

stdlib/public/core/BridgeObjectiveC.swift

@@ -209,16 +209,18 @@ func _bridgeNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject?
 ///   the boxed value, but is otherwise opaque.
 ///
 /// TODO: This should subsume `_bridgeToObjectiveC` above.
-func _bridgeAnythingToObjectiveC<T>(_ x: T) -> AnyObject {
+/// COMPILER_INTRINSIC
+public func _bridgeAnythingToObjectiveC<T>(_ x: T) -> AnyObject {
   if _fastPath(_isClassOrObjCExistential(T.self)) {
     return unsafeBitCast(x, to: AnyObject.self)
   }
   return _bridgeAnythingNonVerbatimToObjectiveC(x)
 }
 
 // TODO: This should subsume `_bridgeNonVerbatimToObjectiveC` above.
+/// COMPILER_INTRINSIC
 @_silgen_name("_swift_bridgeAnythingNonVerbatimToObjectiveC")
-func _bridgeAnythingNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject
+public func _bridgeAnythingNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject
 
 /// Convert `x` from its Objective-C representation to its Swift
 /// representation.

stdlib/public/runtime/Casting.cpp

@@ -1557,6 +1557,50 @@ static bool _dynamicCastToUnknownClassFromExistential(OpaqueValue *dest,
   }
 }
 
+static void unwrapExistential(OpaqueValue *src,
+                              const ExistentialTypeMetadata *srcType,
+                              OpaqueValue *&srcValue,
+                              const Metadata *&srcCapturedType,
+                              bool &isOutOfLine,
+                              bool &canTake) {
+  switch (srcType->getRepresentation()) {
+    case ExistentialTypeRepresentation::Class: {
+      auto classContainer =
+      reinterpret_cast<const ClassExistentialContainer*>(src);
+      srcValue = (OpaqueValue*) &classContainer->Value;
+      void *obj = classContainer->Value;
+      srcCapturedType = swift_getObjectType(reinterpret_cast<HeapObject*>(obj));
+      isOutOfLine = false;
+      canTake = true;
+      break;
+    }
+    case ExistentialTypeRepresentation::Opaque: {
+      auto opaqueContainer = reinterpret_cast<OpaqueExistentialContainer*>(src);
+      srcCapturedType = opaqueContainer->Type;
+      srcValue = srcCapturedType->vw_projectBuffer(&opaqueContainer->Buffer);
+      isOutOfLine = (src != srcValue);
+      canTake = true;
+      break;
+    }
+    case ExistentialTypeRepresentation::Error: {
+      const SwiftError *errorBox
+      = *reinterpret_cast<const SwiftError * const *>(src);
+      
+      srcCapturedType = errorBox->getType();
+      // A bridged NSError is itself the value.
+      if (errorBox->isPureNSError())
+        srcValue = src;
+      else
+        srcValue = const_cast<OpaqueValue*>(errorBox->getValue());
+      
+      // The value is out-of-line, but we can't take it, since it may be shared.
+      isOutOfLine = true;
+      canTake = false;
+      break;
+    }
+  }
+}
+
 /// Perform a dynamic cast from an existential type to a
 /// non-existential type.
 static bool _dynamicCastFromExistential(OpaqueValue *dest,
@@ -1569,42 +1613,8 @@ static bool _dynamicCastFromExistential(OpaqueValue *dest,
   bool isOutOfLine;
   bool canTake;
 
-  switch (srcType->getRepresentation()) {
-  case ExistentialTypeRepresentation::Class: {
-    auto classContainer =
-      reinterpret_cast<const ClassExistentialContainer*>(src);
-    srcValue = (OpaqueValue*) &classContainer->Value;
-    void *obj = classContainer->Value;
-    srcCapturedType = swift_getObjectType(reinterpret_cast<HeapObject*>(obj));
-    isOutOfLine = false;
-    canTake = true;
-    break;
-  }
-  case ExistentialTypeRepresentation::Opaque: {
-    auto opaqueContainer = reinterpret_cast<OpaqueExistentialContainer*>(src);
-    srcCapturedType = opaqueContainer->Type;
-    srcValue = srcCapturedType->vw_projectBuffer(&opaqueContainer->Buffer);
-    isOutOfLine = (src != srcValue);
-    canTake = true;
-    break;
-  }
-  case ExistentialTypeRepresentation::Error: {
-    const SwiftError *errorBox
-      = *reinterpret_cast<const SwiftError * const *>(src);
-    
-    srcCapturedType = errorBox->getType();
-    // A bridged NSError is itself the value.
-    if (errorBox->isPureNSError())
-      srcValue = src;
-    else
-      srcValue = const_cast<OpaqueValue*>(errorBox->getValue());
-
-    // The value is out-of-line, but we can't take it, since it may be shared.
-    isOutOfLine = true;
-    canTake = false;
-    break;
-  }
-  }
+  unwrapExistential(src, srcType,
+                    srcValue, srcCapturedType, isOutOfLine, canTake);
 
   auto subFlags = flags;
   if (!canTake)
@@ -1622,8 +1632,11 @@ static bool _dynamicCastFromExistential(OpaqueValue *dest,
   } else {
     // swift_dynamicCast took or destroyed the value as per the original request
     // We may still have an opaque existential container to deallocate.
-    if (isOutOfLine)
+    if (isOutOfLine) {
+      assert(srcType->getRepresentation()
+               == ExistentialTypeRepresentation::Opaque);
       _maybeDeallocateOpaqueExistential(src, result, flags);
+    }
   }
 
   return result;
@@ -2515,16 +2528,48 @@ static bool _dynamicCastClassToValueViaObjCBridgeable(
   return success;
 }
 
-SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
-extern "C"
-id _swift_bridgeAnythingNonVerbatimToObjectiveC(OpaqueValue *src,
-                                                const Metadata *srcType) {
+static id bridgeAnythingNonVerbatimToObjectiveC(OpaqueValue *src,
+                                                const Metadata *srcType,
+                                                bool consume) {
   // We can always bridge objects verbatim.
   if (srcType->isAnyClass()) {
-    return *(id*)src;
+    id result;
+    memcpy(&result, src, sizeof(id));
+    if (!consume)
+      swift_unknownRetain(result);
+    return result;
   }
 
-  // TODO: Look through existential containers.
+  // Dig through existential types.
+  if (auto srcExistentialTy = dyn_cast<ExistentialTypeMetadata>(srcType)) {
+    OpaqueValue *srcInnerValue;
+    const Metadata *srcInnerType;
+    bool isOutOfLine;
+    bool canTake;
+    
+    unwrapExistential(src, srcExistentialTy,
+                      srcInnerValue, srcInnerType, isOutOfLine, canTake);
+    auto result = bridgeAnythingNonVerbatimToObjectiveC(srcInnerValue,
+                                                        srcInnerType,
+                                                        consume && canTake);
+    // Clean up the existential, or its remains after taking the value from
+    // it.
+    if (consume) {
+      if (canTake) {
+        if (isOutOfLine) {
+          // Should only be true of opaque existentials.
+          assert(srcExistentialTy->getRepresentation()
+                   == ExistentialTypeRepresentation::Opaque);
+          auto container = reinterpret_cast<OpaqueExistentialContainer*>(src);
+          srcInnerType->vw_deallocateBuffer(&container->Buffer);
+        }
+      } else {
+        // We didn't take the value, so clean up the existential value.
+        srcType->vw_destroy(src);
+      }
+    }
+    return result;
+  }
 
   if (auto srcBridgeWitness = findBridgeWitness(srcType)) {
     // Check whether the source is bridged to Objective-C.
@@ -2537,14 +2582,22 @@ id _swift_bridgeAnythingNonVerbatimToObjectiveC(OpaqueValue *src,
     auto srcBridgedObject =
       srcBridgeWitness->bridgeToObjectiveC(src, srcType, srcBridgeWitness);
 
-    // The source object was passed in +1.
-    srcType->vw_destroy(src);
+    // Consume if the source object was passed in +1.
+    if (consume)
+      srcType->vw_destroy(src);
 
     return (id)srcBridgedObject;
   }
 
   // TODO: Fall back to boxing here.
-  crash("unimplemented universal bridging conversion");
+  crash("unimplemented boxing bridge");
+}
+
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERFACE
+extern "C"
+id _swift_bridgeAnythingNonVerbatimToObjectiveC(OpaqueValue *src,
+                                                const Metadata *srcType) {
+  return bridgeAnythingNonVerbatimToObjectiveC(src, srcType, /*consume*/ true);
 }
 
 //===--- Bridging helpers for the Swift stdlib ----------------------------===//

test/1_stdlib/BridgeIdAsAny.swift.gyb

@@ -0,0 +1,51 @@
+// RUN: rm -rf %t  &&  mkdir %t
+//
+// RUN: %gyb %s -o %t/BridgeIdAsAny.swift
+// RUN: %target-build-swift -module-name a %t/BridgeIdAsAny.swift -o %t.out
+// RUN: %target-run %t.out
+// REQUIRES: executable_test
+//
+// REQUIRES: objc_interop
+
+import StdlibUnittest
+import Foundation
+
+var BridgeAnything = TestSuite("BridgeAnything")
+
+func wantonlyWrapInAny<T>(_ x: T) -> Any {
+  return x
+}
+
+// Professional runtime testers on a closed course. Do not attempt at home.
+extension LifetimeTracked: Error {}
+extension String: Error {}
+
+% for testName, valueExpr, testExpr in [("classes", "LifetimeTracked(0)", " === x"), ("strings", '"vitameatavegamin"', '.isEqual(to: "vitameatavegamin")')]:
+BridgeAnything.test("${testName}") {
+  do {
+    let x = ${valueExpr}
+    expectTrue(_bridgeAnythingToObjectiveC(x)${testExpr})
+    expectTrue(_bridgeAnythingNonVerbatimToObjectiveC(x)${testExpr})
+
+    let xInAny: Any = x
+    expectTrue(_bridgeAnythingToObjectiveC(xInAny)${testExpr})
+    expectTrue(_bridgeAnythingNonVerbatimToObjectiveC(xInAny)${testExpr})
+
+    let xInAnyInAny = wantonlyWrapInAny(xInAny)
+    expectTrue(_bridgeAnythingToObjectiveC(xInAnyInAny)${testExpr})
+    expectTrue(_bridgeAnythingNonVerbatimToObjectiveC(xInAnyInAny)${testExpr})
+
+    let xInError: Error = x
+    expectTrue(_bridgeAnythingToObjectiveC(xInError)${testExpr})
+    expectTrue(_bridgeAnythingNonVerbatimToObjectiveC(xInError)${testExpr})
+
+    let xInErrorInAny = wantonlyWrapInAny(xInError)
+    expectTrue(_bridgeAnythingToObjectiveC(xInErrorInAny)${testExpr})
+    expectTrue(_bridgeAnythingNonVerbatimToObjectiveC(xInErrorInAny)${testExpr})
+  }
+
+  expectEqual(0, LifetimeTracked.instances)
+}
+% end
+
+runAllTests()