[Dynamic Casting] Overhauled Runtime (#33561)

* Dynamic Cast Rework: Runtime

This is a completely refactored version of the core swift_dynamicCast
runtime method.

This fixes a number of bugs, especially in the handling of multiply-wrapped
types such as Optional within Any.  The result should be much closer to the
behavior specified by `docs/DynamicCasting.md`.

Most of the type-specific logic is simply copied over from the
earlier implementation, but the overall structure has been changed
to be uniformly recursive.  In particular, this provides uniform
handling of Optional, existentials, Any and other common "box"
types along all paths.  The consistent structure should also be
easier to update in the future with new general types.

Benchmarking does not show any noticable performance implications.

**Temporarily**, the old implementation is still available.  Setting the
environment variable `SWIFT_OLD_DYNAMIC_CAST_RUNTIME` before launching a program
will use the old runtime implementation.  This is only to facilitate testing;
once the new implementation is stable, I expect to completely remove the old
implementation.

Author: tbkka

stdlib/public/core/DebuggerSupport.swift

@@ -152,7 +152,14 @@ public enum _DebuggerSupport {
     // yes, a type can lie and say it's a class when it's not since we only
     // check the displayStyle - but then the type would have a custom Mirror
     // anyway, so there's that...
-    let willExpand = mirror.displayStyle != .`class` || value is CustomReflectable?
+    let isNonClass = mirror.displayStyle != .`class`
+    let isCustomReflectable: Bool
+    if let value = value {
+      isCustomReflectable = value is CustomReflectable
+    } else {
+      isCustomReflectable = true
+    }
+    let willExpand = isNonClass || isCustomReflectable
 
     let count = mirror._children.count
     let bullet = isRoot && (count == 0 || !willExpand) ? ""

stdlib/public/runtime/CMakeLists.txt

@@ -33,6 +33,7 @@ set(swift_runtime_sources
     CompatibilityOverride.cpp
     CygwinPort.cpp
     Demangle.cpp
+    DynamicCast.cpp
     Enum.cpp
     EnvironmentVariables.cpp
     ErrorObjectCommon.cpp

stdlib/public/runtime/Casting.cpp

@@ -339,6 +339,15 @@ _dynamicCastClassMetatype(const ClassMetadata *sourceType,
   return nullptr;
 }
 
+#if !SWIFT_OBJC_INTEROP // __SwiftValue is a native class
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
+bool swift_unboxFromSwiftValueWithType(OpaqueValue *source,
+                                       OpaqueValue *result,
+                                       const Metadata *destinationType);
+/// Nominal type descriptor for Swift.__SwiftValue
+extern "C" const ClassDescriptor NOMINAL_TYPE_DESCR_SYM(s12__SwiftValueC);
+#endif
+
 /// Dynamically cast a class instance to a Swift class type.
 static const void *swift_dynamicCastClassImpl(const void *object,
                                               const ClassMetadata *targetType) {
@@ -351,10 +360,28 @@ static const void *swift_dynamicCastClassImpl(const void *object,
   }
 #endif
 
-  auto isa = _swift_getClassOfAllocated(object);
+  auto srcType = _swift_getClassOfAllocated(object);
 
-  if (_dynamicCastClassMetatype(isa, targetType))
+  if (_dynamicCastClassMetatype(srcType, targetType))
     return object;
+
+#if !SWIFT_OBJC_INTEROP // __SwiftValue is a native class on Linux
+  if (srcType->getKind() == MetadataKind::Class
+      && targetType->getKind() == MetadataKind::Class) {
+    auto srcClassType = cast<ClassMetadata>(srcType);
+    auto srcDescr = srcClassType->getDescription();
+    if (srcDescr == &NOMINAL_TYPE_DESCR_SYM(s12__SwiftValueC)) {
+      auto srcValue = reinterpret_cast<OpaqueValue *>(&object);
+      void *result;
+      auto destLocation = reinterpret_cast<OpaqueValue *>(&result);
+      if (swift_unboxFromSwiftValueWithType(srcValue, destLocation, targetType)) {
+        swift_unknownObjectRelease(const_cast<void *>(object));
+        return result;
+      }
+    }
+  }
+#endif
+
   return nullptr;
 }
 
@@ -3262,3 +3289,30 @@ HeapObject *_swift_bridgeToObjectiveCUsingProtocolIfPossible(
 #define OVERRIDE_CASTING COMPATIBILITY_OVERRIDE
 #include "CompatibilityOverride.def"
 
+// XXX TODO XXX REMOVE XXX TRANSITION SHIM XXX
+// XXX TODO XXX REMOVE XXX TRANSITION SHIM XXX
+// XXX TODO XXX REMOVE XXX TRANSITION SHIM XXX
+
+// A way for the new implementation to call the old one, so we
+// can support switching between the two until the new one is
+// fully settled.
+
+// XXX TODO XXX Once the new implementation is stable, remove the following,
+// swift_dynamicCastImpl above, and all the other code above that only exists to
+// support that.  (Don't forget _dynamicCastToExistential!!)  This file should
+// be only ~1400 lines when you're done.
+
+extern "C" {
+  bool swift_dynamicCast_OLD(OpaqueValue *destLocation,
+                             OpaqueValue *srcValue,
+                             const Metadata *srcType,
+                             const Metadata *destType,
+                             DynamicCastFlags flags)
+  {
+    return swift_dynamicCastImpl(destLocation, srcValue, srcType, destType, flags);
+  }
+}
+
+// XXX TODO XXX REMOVE XXX TRANSITION SHIM XXX
+// XXX TODO XXX REMOVE XXX TRANSITION SHIM XXX
+// XXX TODO XXX REMOVE XXX TRANSITION SHIM XXX

stdlib/public/runtime/CompatibilityOverride.def

@@ -40,6 +40,7 @@
 #ifdef OVERRIDE
 #  define OVERRIDE_METADATALOOKUP OVERRIDE
 #  define OVERRIDE_CASTING OVERRIDE
+#  define OVERRIDE_DYNAMICCASTING OVERRIDE
 #  define OVERRIDE_OBJC OVERRIDE
 #  define OVERRIDE_FOREIGN OVERRIDE
 #  define OVERRIDE_PROTOCOLCONFORMANCE OVERRIDE
@@ -52,6 +53,9 @@
 #  ifndef OVERRIDE_CASTING
 #    define OVERRIDE_CASTING(...)
 #  endif
+#  ifndef OVERRIDE_DYNAMICCASTING
+#    define OVERRIDE_DYNAMICCASTING(...)
+#  endif
 #  ifndef OVERRIDE_OBJC
 #    define OVERRIDE_OBJC(...)
 #  endif
@@ -69,12 +73,12 @@
 #  endif
 #endif
 
-OVERRIDE_CASTING(dynamicCast, bool, , , swift::,
-                 (OpaqueValue *dest, OpaqueValue *src,
-                  const Metadata *srcType,
-                  const Metadata *targetType,
-                  DynamicCastFlags flags),
-                 (dest, src, srcType, targetType, flags))
+OVERRIDE_DYNAMICCASTING(dynamicCast, bool, , , swift::,
+                        (OpaqueValue *dest, OpaqueValue *src,
+                         const Metadata *srcType,
+                         const Metadata *targetType,
+                         DynamicCastFlags flags),
+                        (dest, src, srcType, targetType, flags))
 
 
 OVERRIDE_CASTING(dynamicCastClass, const void *, , , swift::,
@@ -212,6 +216,7 @@ OVERRIDE_FOREIGN(dynamicCastForeignClassUnconditional, const void *, , , swift::
 #undef OVERRIDE
 #undef OVERRIDE_METADATALOOKUP
 #undef OVERRIDE_CASTING
+#undef OVERRIDE_DYNAMICCASTING
 #undef OVERRIDE_OBJC
 #undef OVERRIDE_FOREIGN
 #undef OVERRIDE_PROTOCOLCONFORMANCE