Start building the runtime demangle tree for extended existentials

Author: Azoy

include/swift/ABI/Metadata.h

@@ -2352,12 +2352,7 @@ struct TargetExtendedExistentialTypeShape
   }
 
   bool isCopyable() const {
-    if (!hasGeneralizationSignature()) {
-      return true;
-    }
-    auto *reqts = getGenSigRequirements();
-    for (unsigned i = 0, e = getNumGenSigRequirements(); i < e; ++i) {
-      auto &reqt = reqts[i];
+    for (auto &reqt : getRequirementSignature().getRequirements()) {
       if (reqt.getKind() != GenericRequirementKind::InvertedProtocols) {
         continue;
       }

stdlib/public/runtime/Demangle.cpp

@@ -465,6 +465,69 @@ _buildDemanglingForNominalType(const Metadata *type, Demangle::Demangler &Dem) {
   return _buildDemanglingForContext(description, demangledGenerics, Dem);
 }
 
+static Demangle::NodePointer
+_replaceGeneralizationArg(Demangle::NodePointer type,
+                          SubstGenericParametersFromMetadata substitutions,
+                          Demangle::Demangler &Dem) {
+  assert(type->getKind() == Node::Kind::Type);
+  auto genericParam = type->getChild(0);
+
+  if (genericParam->getKind() != Node::Kind::DependentGenericParamType)
+    return type;
+
+  auto depth = genericParam->getChild(0)->getIndex();
+  auto index = genericParam->getChild(1)->getIndex();
+
+  auto arg = substitutions.getMetadata(depth, index);
+  assert(arg.isMetadata());
+  return _swift_buildDemanglingForMetadata(arg.getMetadata(), Dem);
+}
+
+static Demangle::NodePointer
+_buildDemanglingForExtendedExistential(const Metadata *type,
+                                       Demangle::Demangler &Dem) {
+  auto ee = cast<ExtendedExistentialTypeMetadata>(type);
+
+  auto demangledExistential = Dem.demangleType(ee->Shape->ExistentialType.get(),
+                                               ResolveToDemanglingForContext(Dem));
+
+  if (!ee->Shape->hasGeneralizationSignature())
+    return demangledExistential;
+
+  SubstGenericParametersFromMetadata substitutions(ee->Shape,
+                                              ee->getGeneralizationArguments());
+
+  // Dig out the requirement list.
+  auto constrainedExistential = demangledExistential->getChild(0);
+  assert(constrainedExistential->getKind() == Node::Kind::ConstrainedExistential);
+  auto reqList = constrainedExistential->getChild(1);
+  assert(reqList->getKind() == Node::Kind::ConstrainedExistentialRequirementList);
+
+  auto newReqList = Dem.createNode(Node::Kind::ConstrainedExistentialRequirementList);
+
+  for (auto req : *reqList) {
+    // Currently, the only requirements that can create generalization arguments
+    // are same types.
+    if (req->getKind() != Node::Kind::DependentGenericSameTypeRequirement) {
+      newReqList->addChild(req, Dem);
+      continue;
+    }
+
+    auto lhs = _replaceGeneralizationArg(req->getChild(0), substitutions, Dem);
+    auto rhs = _replaceGeneralizationArg(req->getChild(1), substitutions, Dem);
+
+    auto newReq = Dem.createNode(Node::Kind::DependentGenericSameTypeRequirement);
+    newReq->addChild(lhs, Dem);
+    newReq->addChild(rhs, Dem);
+
+    newReqList->addChild(newReq, Dem);
+  }
+
+  constrainedExistential->replaceChild(1, newReqList);
+
+  return demangledExistential;
+}
+
 // Build a demangled type tree for a type.
 //
 // FIXME: This should use MetadataReader.h.
@@ -596,13 +659,7 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
     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.
-    // TODO: for clients that need to guarantee round-tripping, demangle
-    // to a SymbolicExtendedExistentialType.
-    return nullptr;
+    return _buildDemanglingForExtendedExistential(type, Dem);
   }
   case MetadataKind::ExistentialMetatype: {
     auto metatype = static_cast<const ExistentialMetatypeMetadata *>(type);

test/Interpreter/extended_existential.swift

@@ -0,0 +1,49 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -O -target arm64-apple-macos15.0 %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: OS=macosx
+// REQUIRES: executable_test
+
+protocol A<B>: ~Copyable {
+  associatedtype B
+}
+
+protocol B: ~Copyable {}
+
+let a: Any = (any ~Copyable).self
+// CHECK: any Any<Self: ~Swift.Copyable>
+print(a)
+
+let b: Any = (any ~Escapable).self
+// CHECK: any Any<Self: ~Swift.Escapable>
+print(b)
+
+let c: Any = (any ~Copyable & ~Escapable).self
+// CHECK: any Any<Self: ~Swift.Copyable, Self: ~Swift.Escapable>
+print(c)
+
+let d: Any = (any A).self
+// CHECK: A
+print(d)
+
+let e: Any = (any B).self
+// CHECK: B
+print(e)
+
+let f: Any = (any A & B).self
+// CHECK: A & B
+print(f)
+
+let g: Any = (any A & ~Copyable).self
+// CHECK: any A<Self: ~Swift.Copyable>
+print(g)
+
+let h: Any = (any B & ~Copyable).self
+// CHECK: any B<Self: ~Swift.Copyable>
+print(h)
+
+let i: Any = (any A & B & ~Copyable).self
+// CHECK: any A & B<Self: ~Swift.Copyable>
+print(i)

test/Interpreter/moveonly_existentials.swift

@@ -28,19 +28,3 @@ func mutate(_ b: inout any Boopable & ~Copyable) {
 borrow(S())
 var s = S() as any Boopable & ~Copyable
 mutate(&s)
-
-let a: Any = (any ~Copyable).self
-// CHECK: << invalid type >>
-print(a)
-
-let b: Any = (any ~Escapable).self
-// CHECK: << invalid type >>
-print(b)
-
-let c: Any = (any ~Copyable & ~Escapable).self
-// CHECK: << invalid type >>
-print(c)
-
-let d: Any = (any Boopable & ~Copyable).self
-// CHECK: << invalid type >>
-print(d)