[Remote Mirrors] Support Extended Existential Type Metadata

Teach Remote Mirrors to read extended existential type metadata.

Author: CodaFi

include/swift/ABI/GenericContext.h

@@ -191,8 +191,27 @@ using GenericRequirementDescriptor =
 extern const GenericParamDescriptor
 ImplicitGenericParamDescriptors[MaxNumImplicitGenericParamDescriptors];
 
+inline const GenericParamDescriptor *
+externalTargetImplicitGenericParamDescriptors() {
+  static const GenericParamDescriptor
+      buffer[MaxNumImplicitGenericParamDescriptors] = {
+#define D GenericParamDescriptor::implicit()
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
+          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D
+#undef D
+      };
+  return buffer;
+}
+
 template <class Runtime>
-const GenericParamDescriptor *targetImplicitGenericParamDescriptors();
+const GenericParamDescriptor *targetImplicitGenericParamDescriptors() {
+  return externalTargetImplicitGenericParamDescriptors();
+}
+template <>
+inline const GenericParamDescriptor *targetImplicitGenericParamDescriptors<InProcess>() {
+  return ImplicitGenericParamDescriptors;
+}
 
 /// A runtime description of a generic signature.
 template<typename Runtime>

include/swift/Remote/MetadataReader.h

@@ -929,6 +929,85 @@ class MetadataReader {
       TypeCache[MetadataAddress] = BuiltExist;
       return BuiltExist;
     }
+    case MetadataKind::ExtendedExistential: {
+      auto Exist = cast<TargetExtendedExistentialTypeMetadata<Runtime>>(Meta);
+
+      // Read the shape for this existential.
+      StoredPointer shapeAddress = stripSignedPointer(Exist->Shape);
+      ShapeRef Shape = readShape(shapeAddress);
+      if (!Shape)
+        return BuiltType();
+
+      const unsigned shapeArgumentCount
+          = Shape->getGenSigArgumentLayoutSizeInWords();
+      // Pull out the arguments to the generalization signature.
+      assert(Shape->hasGeneralizationSignature());
+      std::vector<BuiltType> builtArgs;
+      for (unsigned i = 0; i < shapeArgumentCount; ++i) {
+        auto remoteArg = Exist->getGeneralizationArguments()[i];
+        auto builtArg = readTypeFromMetadata(remoteArg);
+        if (!builtArg)
+          return BuiltType();
+        builtArgs.push_back(builtArg);
+      }
+
+      // Pull out the existential type from the mangled type name.
+      Demangler dem;
+      auto mangledExistentialAddr =
+          resolveRelativeField(Shape, Shape->ExistentialType);
+      auto node = readMangledName(RemoteAddress(mangledExistentialAddr),
+                                  MangledNameKind::Type, dem);
+      if (!node)
+        return BuiltType();
+
+      BuiltType builtProto = decodeMangledType(node).getType();
+      if (!builtProto)
+        return BuiltType();
+
+      // Build up a substitution map for the generalized signature.
+      BuiltGenericSignature sig =
+          decodeRuntimeGenericSignature(Shape,
+                                        Shape->getGeneralizationSignature())
+              .getType();
+      if (!sig)
+        return BuiltType();
+
+      BuiltSubstitutionMap subst =
+          Builder.createSubstitutionMap(sig, builtArgs);
+      if (subst.empty())
+        return BuiltType();
+
+      builtProto = Builder.subst(builtProto, subst);
+      if (!builtProto)
+        return BuiltType();
+
+      // Read the type expression to build up any remaining layers of
+      // existential metatype.
+      if (Shape->Flags.hasTypeExpression()) {
+        Demangler dem;
+
+        // Read the mangled name.
+        auto mangledContextName = Shape->getTypeExpression();
+        auto mangledNameAddress =
+            resolveRelativeField(Shape, mangledContextName->name);
+        auto node = readMangledName(RemoteAddress(mangledNameAddress),
+                                    MangledNameKind::Type, dem);
+        if (!node)
+          return BuiltType();
+
+        while (node->getKind() == Demangle::Node::Kind::Type &&
+               node->getNumChildren() &&
+               node->getChild(0)->getKind() == Demangle::Node::Kind::Metatype &&
+               node->getChild(0)->getNumChildren()) {
+          builtProto = Builder.createExistentialMetatypeType(builtProto);
+          node = node->getChild(0)->getChild(0);
+        }
+      }
+
+      TypeCache[MetadataAddress] = builtProto;
+      return builtProto;
+    }
+
     case MetadataKind::Metatype: {
       auto Metatype = cast<TargetMetatypeMetadata<Runtime>>(Meta);
       auto Instance = readTypeFromMetadata(Metatype->InstanceType);
@@ -1044,7 +1123,7 @@ class MetadataReader {
         break;
       }
       case GenericRequirementKind::Protocol: {
-        /// Resolver to turn a protocol reference into a protocol declaration.
+        /// Resolver to turn a protocol reference into an existential type.
         struct ProtocolReferenceResolver {
           using Result = BuiltType;
 
@@ -1895,6 +1974,8 @@ class MetadataReader {
       }
       case MetadataKind::ExistentialMetatype:
         return _readMetadata<TargetExistentialMetatypeMetadata>(address);
+      case MetadataKind::ExtendedExistential:
+        return _readMetadata<TargetExtendedExistentialTypeMetadata>(address);
       case MetadataKind::ForeignClass:
         return _readMetadata<TargetForeignClassMetadata>(address);
       case MetadataKind::Function: {

lib/RemoteAST/RemoteAST.cpp

@@ -51,19 +51,6 @@ using namespace swift::remoteAST;
 using irgen::Alignment;
 using irgen::Size;
 
-template <class Runtime>
-const GenericParamDescriptor *swift::targetImplicitGenericParamDescriptors() {
-  static const GenericParamDescriptor
-      buffer[MaxNumImplicitGenericParamDescriptors] = {
-#define D GenericParamDescriptor::implicit()
-          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
-          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
-          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D
-#undef D
-      };
-  return buffer;
-}
-
 static inline RemoteAddress operator+(RemoteAddress address, Size offset) {
   return RemoteAddress(address.getAddressData() + offset.getValue());
 }

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -43,19 +43,6 @@ using Runtime = External<NoObjCInterop<RuntimeTarget<sizeof(uintptr_t)>>>;
 #endif
 using NativeReflectionContext = swift::reflection::ReflectionContext<Runtime>;
 
-template <class Runtime>
-const GenericParamDescriptor *swift::targetImplicitGenericParamDescriptors() {
-  static const GenericParamDescriptor
-      buffer[MaxNumImplicitGenericParamDescriptors] = {
-#define D GenericParamDescriptor::implicit()
-          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
-          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D,
-          D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D, D
-#undef D
-      };
-  return buffer;
-}
-
 struct SwiftReflectionContext {
   NativeReflectionContext *nativeContext;
   std::vector<std::function<void()>> freeFuncs;

stdlib/public/runtime/Metadata.cpp

@@ -86,12 +86,6 @@ swift::ImplicitGenericParamDescriptors[MaxNumImplicitGenericParamDescriptors] =
 };
 static_assert(MaxNumImplicitGenericParamDescriptors == 64, "length mismatch");
 
-template <>
-const GenericParamDescriptor *
-swift::targetImplicitGenericParamDescriptors<InProcess>() {
-  return ImplicitGenericParamDescriptors;
-}
-
 static ClassMetadata *
 _swift_relocateClassMetadata(const ClassDescriptor *description,
                              const ResilientClassMetadataPattern *pattern);

stdlib/public/runtime/ReflectionMirror.cpp

@@ -1076,6 +1076,8 @@ const char *swift_OpaqueSummary(const Metadata *T) {
       return "(Heap Generic Local Variable)";
     case MetadataKind::ErrorObject:
       return "(ErrorType Object)";
+    case MetadataKind::ExtendedExistential:
+      return "(Extended Existential)";
     default:
       return "(Unknown)";
   }

test/RemoteAST/parameterized_existentials.swift

@@ -0,0 +1,81 @@
+// RUN: %target-swift-remoteast-test -enable-parameterized-existential-types %s | %FileCheck %s
+
+// REQUIRES: swift-remoteast-test
+
+@_silgen_name("printDynamicTypeAndAddressForExistential")
+func printDynamicTypeAndAddressForExistential<T>(_: T)
+
+@_silgen_name("stopRemoteAST")
+func stopRemoteAST()
+
+protocol Paddock<Animal> {
+  associatedtype Animal
+}
+
+struct Chicken {}
+struct Coop: Paddock {
+  typealias Animal = Chicken
+}
+
+struct Pig {}
+struct Pen: Paddock {
+  typealias Animal = Pig
+}
+
+struct Field<Animal>: Paddock {}
+
+protocol SharedYard<Animal1, Animal2, Animal3, Animal4> {
+  associatedtype Animal1
+  associatedtype Animal2
+  associatedtype Animal3
+  associatedtype Animal4
+}
+
+class Lea: SharedYard {
+  typealias Animal1 = Chicken
+  typealias Animal2 = Pig
+  typealias Animal3 = Chicken
+  typealias Animal4 = Pig
+
+  init() {}
+}
+
+let coop = Coop()
+// CHECK: Coop
+printDynamicTypeAndAddressForExistential(coop as any Paddock)
+
+// CHECK-NEXT: Coop
+printDynamicTypeAndAddressForExistential(coop as any Paddock<Chicken>)
+
+// CHECK-NEXT: Coop.Type
+printDynamicTypeAndAddressForExistential(Coop.self as (any Paddock<Chicken>.Type))
+
+// CHECK-NEXT: Coop.Type.Type.Type.Type
+printDynamicTypeAndAddressForExistential(Coop.Type.Type.Type.self as (any Paddock<Chicken>.Type.Type.Type.Type))
+
+let pen = Pen()
+// CHECK-NEXT: Pen
+printDynamicTypeAndAddressForExistential(pen as any Paddock)
+
+// CHECK-NEXT: Pen
+printDynamicTypeAndAddressForExistential(pen as any Paddock<Pig>)
+
+let lea = Lea()
+// CHECK-NEXT: Lea
+printDynamicTypeAndAddressForExistential(lea as any SharedYard)
+
+// CHECK-NEXT: Lea
+printDynamicTypeAndAddressForExistential(lea as any SharedYard<Chicken, Pig, Chicken, Pig>)
+
+
+func freeRange<Animal>(_ x: Animal.Type) {
+  printDynamicTypeAndAddressForExistential(Field<Animal>() as any Paddock<Animal>)
+}
+
+// CHECK-NEXT: Field<Chicken>
+freeRange(Chicken.self)
+// CHECK-NEXT: Field<Pig>
+freeRange(Pig.self)
+
+
+stopRemoteAST()