SR-14635: __SwiftValue should be transparent to casting

This PR changes the casting machinery to avoid casting `__SwiftValue` boxes
directly.  This forces the caster to instead unwrap `__SwiftValue` boxes and
retry with the inner content.  This results in boxed values being cast like the
inner content.

This fixes the behavior in situations like the following:
```
   let t = ...
   let s = t as Any as! AnyObject
   // `s` is now a `__SwiftValue` box
   // Next line should be true iff t conforms to NSCopying
   // Prior to this change, it always succeeds
   s is NSCopying
```

After this change, the above cast succeeds only if `t` actually
conforms to `NSCopying`.

This is a follow-on to PR#37683.
Related to: SR-14635

Author: tbkka

stdlib/public/runtime/DynamicCast.cpp

@@ -425,6 +425,29 @@ tryCastUnwrappingObjCSwiftValueSource(
       destFailureType, srcFailureType,
       /*takeOnSuccess=*/ false, mayDeferChecks);
 }
+#else
+static DynamicCastResult
+tryCastUnwrappingSwiftValueSource(
+  OpaqueValue *destLocation, const Metadata *destType,
+  OpaqueValue *srcValue, const Metadata *srcType,
+  const Metadata *&destFailureType, const Metadata *&srcFailureType,
+  bool takeOnSuccess, bool mayDeferChecks)
+{
+    const Metadata *srcInnerType;
+    const OpaqueValue *srcInnerValue;
+    if (swift_unboxFromSwiftValueWithType(srcValue, &srcInnerValue, &srcInnerType)) {
+      return DynamicCastResult::SuccessViaCopy;
+    }
+
+    // Note: We never `take` the contents from a SwiftValue box as
+    // it might have other references.  Instead, let our caller
+    // destroy the reference if necessary.
+    return tryCast(
+      destLocation, destType,
+      const_cast<OpaqueValue *>(srcInnerValue), srcInnerType,
+      destFailureType, srcFailureType,
+      /*takeOnSuccess=*/ false, mayDeferChecks);
+}
 #endif
 
 /******************************************************************************/
@@ -1474,6 +1497,16 @@ tryCastToClassExistential(
   }
 
   case MetadataKind::ObjCClassWrapper:
+#if SWIFT_OBJC_INTEROP
+    id srcObject;
+    memcpy(&srcObject, srcValue, sizeof(id));
+    if (getAsSwiftValue(srcObject) != nullptr) {
+      // Do not directly cast a `__SwiftValue` box
+      // Return failure so our caller will unwrap and try again
+      return DynamicCastResult::Failure;
+    }
+#endif
+    SWIFT_FALLTHROUGH;
   case MetadataKind::Class:
   case MetadataKind::ForeignClass: {
     auto srcObject = getNonNullSrcObject(srcValue, srcType, destType);
@@ -2285,8 +2318,11 @@ tryCast(
   case MetadataKind::Class: {
 #if !SWIFT_OBJC_INTEROP
     // Try unwrapping native __SwiftValue implementation
-    if (swift_unboxFromSwiftValueWithType(srcValue, destLocation, destType)) {
-      return DynamicCastResult::SuccessViaCopy;
+    auto subcastResult = tryCastUnwrappingSwiftValueSource(
+      destLocation, destType, srcValue, srcType,
+      destFailureType, srcFailureType, takeOnSuccess, mayDeferChecks);
+    if (isSuccess(subcastResult)) {
+      return subcastResult;
     }
 #endif
     break;

stdlib/public/runtime/SwiftObject.mm

@@ -41,6 +41,7 @@
 #include "ErrorObject.h"
 #include "Private.h"
 #include "SwiftObject.h"
+#include "SwiftValue.h"
 #include "WeakReference.h"
 #if SWIFT_OBJC_INTEROP
 #include <dlfcn.h>
@@ -1269,6 +1270,10 @@ id swift_dynamicCastObjCProtocolUnconditional(id object,
 id swift_dynamicCastObjCProtocolConditional(id object,
                                             size_t numProtocols,
                                             Protocol * const *protocols) {
+  if (getAsSwiftValue(object) != nil) {
+    // SwiftValue wrapper never holds a class object
+    return nil;
+  }
   for (size_t i = 0; i < numProtocols; ++i) {
     if (![object conformsToProtocol:protocols[i]]) {
       return nil;

test/Casting/Casts.swift

@@ -993,25 +993,33 @@ CastsTests.test("Do not overuse __SwiftValue")
   // This used to succeed because of overeager __SwiftValue
   // boxing (and __SwiftValue does satisfy NSCopying)
   expectFalse(Bar() is NSCopying)
+  expectNil(runtimeCast(Bar(), to: NSCopying.self))
   expectFalse(Bar() as Any is NSCopying)
+  expectNil(runtimeCast(Bar() as Any, to: NSCopying.self))
 
-  // This seems unavoidable?
-  // `Bar() as! AnyObject` gets boxed as a __SwiftValue,
-  // and __SwiftValue does conform to NSCopying
-  expectTrue(Bar() as! AnyObject is NSCopying)
+  // `Bar() as! AnyObject` gets boxed as a __SwiftValue.
+  // __SwiftValue does conform to NSCopying, but that should
+  // not be visible here.
+  let anyBar = Bar() as! AnyObject
+  expectNil(runtimeCast(anyBar, to: NSCopying.self))
+  expectFalse(anyBar is NSCopying)
 
   class Foo {}
   // Foo does not conform to NSCopying
   // (This used to succeed due to over-eager __SwiftValue boxing)
   expectFalse(Foo() is NSCopying)
+  expectNil(runtimeCast(Foo(), to: NSCopying.self))
   expectFalse(Foo() as Any is NSCopying)
+  expectNil(runtimeCast(Foo() as Any, to: NSCopying.self))
 
   // A type that really does conform should cast to NSCopying
   class Foo2: NSCopying {
     func copy(with: NSZone?) -> Any { return self }
   }
   expectTrue(Foo2() is NSCopying)
+  expectNotNil(runtimeCast(Foo2(), to: NSCopying.self))
   expectTrue(Foo2() is AnyObject)
+  expectNotNil(runtimeCast(Foo2(), to: AnyObject.self))
 }
 #endif
 
@@ -1030,10 +1038,21 @@ CastsTests.test("Do not overuse __SwiftValue (non-ObjC)") {
   // This should succeed because this is what __SwiftValue boxing is for
   expectTrue(Bar() is AnyObject)
   expectTrue(Bar() as Any is AnyObject)
+  let a = Bar() as Any as! AnyObject
+  expectTrue(a is Bar)
 
   class Foo {}
   // Any class type can be cast to AnyObject
   expectTrue(Foo() is AnyObject)
+  let b = Foo() as! AnyObject
+  expectTrue(b is Foo)
+
+  // As above, but force use of runtime casting
+  expectNotNil(runtimeCast(Bar(), to: AnyObject.self))
+  expectNotNil(runtimeCast(Bar() as Any, to: AnyObject.self))
+  expectNotNil(runtimeCast(a, to: Bar.self))
+  expectNotNil(runtimeCast(Foo(), to: AnyObject.self))
+  expectNotNil(runtimeCast(b, to: Foo.self))
 }
 
 runAllTests()