[5.7] Runtime Casting for Extended Existentials

include/swift/ABI/MetadataValues.h

@@ -899,6 +899,7 @@ class ExtendedExistentialTypeShapeFlags {
   SpecialKind getSpecialKind() const {
     return SpecialKind((Data & SpecialKindMask) >> SpecialKindShift);
   }
+  bool isOpaque() const { return getSpecialKind() == SpecialKind::None; }
   bool isClassConstrained() const {
     return getSpecialKind() == SpecialKind::Class;
   }

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/Demangle.cpp

@@ -443,6 +443,13 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
     // Just a simple composition of protocols.
     return proto_list;
   }
+  case MetadataKind::ExtendedExistential: {
+    // FIXME: Implement this by demangling the extended existential and
+    // substituting the generalization arguments into the demangle tree.
+    // For now, unconditional casts will report '<<< invalid type >>>' when
+    // they fail.
+    return nullptr;
+  }
   case MetadataKind::ExistentialMetatype: {
     auto metatype = static_cast<const ExistentialMetatypeMetadata *>(type);
     auto instance = _swift_buildDemanglingForMetadata(metatype->InstanceType,

stdlib/public/runtime/DynamicCast.cpp

@@ -1695,10 +1695,56 @@ tryCastUnwrappingExistentialSource(
   return tryCast(destLocation, destType,
                  srcInnerValue, srcInnerType,
                  destFailureType, srcFailureType,
-                 takeOnSuccess & (srcInnerValue == srcValue),
+                 takeOnSuccess && (srcInnerValue == srcValue),
                  mayDeferChecks);
 }
 
+static DynamicCastResult tryCastUnwrappingExtendedExistentialSource(
+    OpaqueValue *destLocation, const Metadata *destType, OpaqueValue *srcValue,
+    const Metadata *srcType, const Metadata *&destFailureType,
+    const Metadata *&srcFailureType, bool takeOnSuccess, bool mayDeferChecks) {
+  assert(srcType != destType);
+  assert(srcType->getKind() == MetadataKind::ExtendedExistential);
+
+  auto srcExistentialType = cast<ExtendedExistentialTypeMetadata>(srcType);
+
+  // Unpack the existential content
+  const Metadata *srcInnerType = nullptr;
+  OpaqueValue *srcInnerValue = nullptr;
+  switch (srcExistentialType->Shape->Flags.getSpecialKind()) {
+  case ExtendedExistentialTypeShape::SpecialKind::None: {
+    auto opaqueContainer =
+        reinterpret_cast<OpaqueExistentialContainer *>(srcValue);
+    srcInnerType = opaqueContainer->Type;
+    srcInnerValue = const_cast<OpaqueValue *>(opaqueContainer->projectValue());
+    break;
+  }
+  case ExtendedExistentialTypeShape::SpecialKind::Class: {
+    auto classContainer =
+        reinterpret_cast<ClassExistentialContainer *>(srcValue);
+    srcInnerType = swift_getObjectType((HeapObject *)classContainer->Value);
+    srcInnerValue = reinterpret_cast<OpaqueValue *>(&classContainer->Value);
+    break;
+  }
+  case ExtendedExistentialTypeShape::SpecialKind::Metatype: {
+    auto srcExistentialContainer =
+        reinterpret_cast<ExistentialMetatypeContainer *>(srcValue);
+    srcInnerType = swift_getMetatypeMetadata(srcExistentialContainer->Value);
+    srcInnerValue = reinterpret_cast<OpaqueValue *>(&srcExistentialContainer->Value);
+    break;
+  }
+  case ExtendedExistentialTypeShape::SpecialKind::ExplicitLayout: {
+    swift_unreachable("Explicit layout not yet implemented");
+    break;
+  }
+  }
+
+  srcFailureType = srcInnerType;
+  return tryCast(destLocation, destType, srcInnerValue, srcInnerType,
+                 destFailureType, srcFailureType,
+                 takeOnSuccess & (srcInnerValue == srcValue), mayDeferChecks);
+}
+
 static DynamicCastResult
 tryCastUnwrappingExistentialMetatypeSource(
   OpaqueValue *destLocation, const Metadata *destType,
@@ -1722,6 +1768,134 @@ tryCastUnwrappingExistentialMetatypeSource(
                  mayDeferChecks);
 }
 
+
+static DynamicCastResult tryCastToExtendedExistential(
+    OpaqueValue *destLocation, const Metadata *destType, OpaqueValue *srcValue,
+    const Metadata *srcType, const Metadata *&destFailureType,
+    const Metadata *&srcFailureType, bool takeOnSuccess, bool mayDeferChecks) {
+  assert(srcType != destType);
+  assert(destType->getKind() == MetadataKind::ExtendedExistential);
+
+  auto destExistentialType = cast<ExtendedExistentialTypeMetadata>(destType);
+  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);
+    }
+
+    // Make sure the thing we've pulled out at the end is a dependent
+    // generic parameter.
+    if (!(node->getKind() == Demangle::Node::Kind::Type &&
+          node->getNumChildren() &&
+          node->getChild(0)->getKind() ==
+              Demangle::Node::Kind::DependentGenericParamType))
+      return DynamicCastResult::Failure;
+  }
+
+  llvm::SmallVector<const void *, 8> allGenericArgsVec;
+  unsigned witnessesMark = 0;
+  {
+    // Line up the arguments to the requirement signature.
+    auto genArgs = destExistentialType->getGeneralizationArguments();
+    allGenericArgsVec.append(genArgs, genArgs + shapeArgumentCount);
+    // Tack on the `Self` argument.
+    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.
+    witnessesMark = allGenericArgsVec.size();
+
+    SubstGenericParametersFromMetadata substitutions(destExistentialShape,
+                                                     allGenericArgsVec.data());
+    // Verify the requirements in the requirement signature against the
+    // arguments from the source value.
+    auto error = swift::_checkGenericRequirements(
+        destExistentialShape->getRequirementSignature().getRequirements(),
+        allGenericArgsVec,
+        [&substitutions](unsigned depth, unsigned index) {
+          return substitutions.getMetadata(depth, index);
+        },
+        [](const Metadata *type, unsigned index) -> const WitnessTable * {
+          swift_unreachable("Resolution of witness tables is not supported");
+        });
+    if (error)
+      return DynamicCastResult::Failure;
+  }
+
+  OpaqueValue *destBox = nullptr;
+  const WitnessTable **destWitnesses = nullptr;
+  switch (destExistentialShape->Flags.getSpecialKind()) {
+  case ExtendedExistentialTypeShape::SpecialKind::None: {
+    auto destExistential =
+        reinterpret_cast<OpaqueExistentialContainer *>(destLocation);
+
+    // Allocate a box and fill in the type information.
+    destExistential->Type = srcType;
+    destBox = srcType->allocateBoxForExistentialIn(&destExistential->Buffer);
+    destWitnesses = destExistential->getWitnessTables();
+    break;
+  }
+  case ExtendedExistentialTypeShape::SpecialKind::Class: {
+    auto destExistential =
+        reinterpret_cast<ClassExistentialContainer *>(destLocation);
+    destBox = reinterpret_cast<OpaqueValue *>(&destExistential->Value);
+    destWitnesses = destExistential->getWitnessTables();
+    break;
+  }
+  case ExtendedExistentialTypeShape::SpecialKind::Metatype: {
+    auto destExistential =
+        reinterpret_cast<ExistentialMetatypeContainer *>(destLocation);
+    destBox = reinterpret_cast<OpaqueValue *>(&destExistential->Value);
+    destWitnesses = destExistential->getWitnessTables();
+    break;
+  }
+  case ExtendedExistentialTypeShape::SpecialKind::ExplicitLayout:
+    swift_unreachable("Witnesses for explicit layout not yet implemented");
+  }
+
+  // Fill in the trailing set of witness tables.
+  const unsigned numWitnessTables = allGenericArgsVec.size() - witnessesMark;
+  assert(numWitnessTables ==
+         llvm::count_if(destExistentialShape->getRequirementSignature().getRequirements(),
+                        [](const auto &req) -> bool {
+                          return req.getKind() ==
+                                 GenericRequirementKind::Protocol;
+                        }));
+  for (unsigned i = 0; i < numWitnessTables; ++i) {
+    const auto witness = i + witnessesMark;
+    destWitnesses[i] =
+        reinterpret_cast<const WitnessTable *>(allGenericArgsVec[witness]);
+  }
+
+  if (takeOnSuccess) {
+    srcType->vw_initializeWithTake(destBox, srcValue);
+    return DynamicCastResult::SuccessViaTake;
+  } else {
+    srcType->vw_initializeWithCopy(destBox, srcValue);
+    return DynamicCastResult::SuccessViaCopy;
+  }
+}
+
 /******************************************************************************/
 /**************************** Opaque Destination ******************************/
 /******************************************************************************/
@@ -2006,12 +2180,14 @@ static tryCastFunctionType *selectCasterForDest(const Metadata *destType) {
     swift_unreachable(
       "Unknown existential type representation in dynamic cast dispatch");
   }
+  case MetadataKind::ExtendedExistential:
+    return tryCastToExtendedExistential;
   case MetadataKind::Metatype:
-   return tryCastToMetatype;
- case MetadataKind::ObjCClassWrapper:
+    return tryCastToMetatype;
+  case MetadataKind::ObjCClassWrapper:
     return tryCastToObjectiveCClass;
   case MetadataKind::ExistentialMetatype:
-   return tryCastToExistentialMetatype;
+    return tryCastToExistentialMetatype;
   case MetadataKind::HeapLocalVariable:
   case MetadataKind::HeapGenericLocalVariable:
   case MetadataKind::ErrorObject:
@@ -2169,6 +2345,15 @@ tryCast(
     break;
   }
 
+  case MetadataKind::ExtendedExistential: {
+    auto subcastResult = tryCastUnwrappingExtendedExistentialSource(
+        destLocation, destType, srcValue, srcType, destFailureType,
+        srcFailureType, takeOnSuccess, mayDeferChecks);
+    if (isSuccess(subcastResult)) {
+      return subcastResult;
+    }
+    break;
+  }
   default:
     break;
   }

stdlib/public/runtime/MetadataLookup.cpp

@@ -2269,7 +2269,7 @@ static void installGetClassHook() {
 unsigned SubstGenericParametersFromMetadata::
 buildDescriptorPath(const ContextDescriptor *context,
                     Demangler &borrowFrom) const {
-  assert(sourceIsMetadata);
+  assert(sourceKind == SourceKind::Metadata);
 
   // Terminating condition: we don't have a context.
   if (!context)
@@ -2360,20 +2360,59 @@ buildEnvironmentPath(
   return totalKeyParamCount;
 }
 
+unsigned SubstGenericParametersFromMetadata::buildShapePath(
+    const TargetExtendedExistentialTypeShape<InProcess> *shape) const {
+  unsigned totalParamCount = 0;
+
+  auto genSig = shape->getGeneralizationSignature();
+  if (!genSig.getParams().empty()) {
+    totalParamCount += genSig.getParams().size();
+    descriptorPath.push_back(PathElement{genSig.getParams(),
+                                         totalParamCount,
+                                         /*numKeyGenericParamsInParent*/ 0,
+                                         (unsigned)genSig.getParams().size(),
+                                         /*hasNonKeyGenericParams*/ false});
+  }
+
+  const unsigned genSigParamCount = genSig.getParams().size();
+  auto reqSig = shape->getRequirementSignature();
+  assert(reqSig.getParams().size() > genSig.getParams().size());
+  {
+    auto remainingParams = reqSig.getParams().drop_front(genSig.getParams().size());
+    totalParamCount += remainingParams.size();
+    descriptorPath.push_back(PathElement{remainingParams,
+                                         totalParamCount,
+                                         genSigParamCount,
+                                         (unsigned)remainingParams.size(),
+                                         /*hasNonKeyGenericParams*/ false});
+  }
+
+  // All parameters in this signature are key parameters.
+  return totalParamCount;
+}
+
 void SubstGenericParametersFromMetadata::setup() const {
   if (!descriptorPath.empty())
     return;
 
-  if (sourceIsMetadata && baseContext) {
+  switch (sourceKind) {
+  case SourceKind::Metadata: {
+    assert(baseContext);
     DemanglerForRuntimeTypeResolution<StackAllocatedDemangler<2048>> demangler;
     numKeyGenericParameters = buildDescriptorPath(baseContext, demangler);
     return;
   }
-
-  if (!sourceIsMetadata && environment) {
+  case SourceKind::Environment: {
+    assert(environment);
     numKeyGenericParameters = buildEnvironmentPath(environment);
     return;
   }
+  case SourceKind::Shape: {
+    assert(shape);
+    numKeyGenericParameters = buildShapePath(shape);
+    return;
+  }
+  }
 }
 
 const Metadata *