Fixup Extended Existential Metatype Casts

The fix here is two-fold:

1) Teach SILGen that it cannot use the scalar casting paths for extended existentials
2) Teach the runtime casting entrypoint to unwrap as much metatype structure as possible
   before arriving at a 'Self' type bound for the requirement checking paths.

The code here mirrors the destructuring check we're doing in remote mirrors.

rdar://95166916

Author: CodaFi

lib/IRGen/GenCast.cpp

@@ -848,7 +848,7 @@ void irgen::emitScalarExistentialDowncast(IRGenFunction &IGF,
 /// that the actual value isn't changed in any way, thus preserving its
 /// reference identity.
 ///
-/// These restrictions are set by canUseScalarCheckedCastInstructions.
+/// These restrictions are set by \c canSILUseScalarCheckedCastInstructions.
 /// Essentially, both the source and target types must be one of:
 ///   - a (possibly generic) concrete class type,
 ///   - a class-bounded archetype,

lib/SIL/Utils/DynamicCasts.cpp

@@ -1311,6 +1311,14 @@ bool swift::canSILUseScalarCheckedCastInstructions(SILModule &M,
 bool swift::canIRGenUseScalarCheckedCastInstructions(SILModule &M,
                                                      CanType sourceFormalType,
                                                      CanType targetFormalType) {
+  // If the cast involves any kind of generalized existential we
+  // need to use the indirect-cast path to handle checking the extra
+  // constraints there as the scalar path does not (yet) know how to do it.
+  if (sourceFormalType->hasParameterizedExistential() ||
+      targetFormalType->hasParameterizedExistential()) {
+    return false;
+  }
+
   // Look through one level of optionality on the source.
   auto objectType = sourceFormalType;
   if (auto type = objectType.getOptionalObjectType())

stdlib/public/runtime/DynamicCast.cpp

@@ -1780,6 +1780,29 @@ static DynamicCastResult tryCastToExtendedExistential(
   auto *destExistentialShape = destExistentialType->Shape;
   const unsigned shapeArgumentCount =
       destExistentialShape->getGenSigArgumentLayoutSizeInWords();
+  const Metadata *selfType = srcType;
+
+  // If we have a type expression to look into, unwrap as much metatype
+  // structure as possible so we can reach the type metadata for the 'Self'
+  // parameter.
+  if (destExistentialShape->Flags.hasTypeExpression()) {
+    Demangler dem;
+    auto *node = dem.demangleType(destExistentialShape->getTypeExpression()->name.get());
+    if (!node)
+      return DynamicCastResult::Failure;
+
+    while (node->getKind() == Demangle::Node::Kind::Type &&
+           node->getNumChildren() &&
+           node->getChild(0)->getKind() == Demangle::Node::Kind::Metatype &&
+           node->getChild(0)->getNumChildren()) {
+      auto *metatypeMetadata = dyn_cast<MetatypeMetadata>(selfType);
+      if (!metatypeMetadata)
+        return DynamicCastResult::Failure;
+
+      selfType = metatypeMetadata->InstanceType;
+      node = node->getChild(0)->getChild(0);
+    }
+  }
 
   llvm::SmallVector<const void *, 8> allGenericArgsVec;
   unsigned witnessesMark = 0;
@@ -1788,7 +1811,7 @@ static DynamicCastResult tryCastToExtendedExistential(
     auto genArgs = destExistentialType->getGeneralizationArguments();
     allGenericArgsVec.append(genArgs, genArgs + shapeArgumentCount);
     // Tack on the `Self` argument.
-    allGenericArgsVec.push_back((const void *)srcType);
+    allGenericArgsVec.push_back((const void *)selfType);
     // Mark the point where the generic arguments end.
     // _checkGenericRequirements is going to fill in a set of witness tables
     // after that.

test/Casting/ParameterizedExistentials.swift

@@ -82,9 +82,7 @@ tests.test("Parameterized existential casting basics work") {
   expectNil(d)
 }
 
-tests.test("Metatype existential casting basics work")
-  .xfail(.custom({ true }, reason: "IRGen peepholes these casts"))
-  .code {
+tests.test("Metatype existential casting basics work") {
   let a = GenericHolder<Int>.self as any Holder<Int>.Type
   let b = GenericHolder<Int>.self as! any Holder<Int>.Type
   expectTrue(a == b)