Implement reflection support for Symbolic Extended Existential types.

adrian-prantl · adrian-prantl · commit f7a4c6d02f06 · 2025-06-27T10:49:41.000-07:00
diff --git a/include/swift/Demangling/TypeDecoder.h b/include/swift/Demangling/TypeDecoder.h
@@ -555,6 +555,43 @@ void decodeRequirement(
   }
 }
 
+/// Extract the protocol and requirement nodes from a shape symbol.
+static inline std::pair<NodePointer, NodePointer>
+decodeShape(NodePointer Node) {
+  if (!Node || Node->getKind() != Node::Kind::Global ||
+      Node->getNumChildren() != 1)
+    return {nullptr, nullptr};
+  Node = Node->getChild(0);
+  if (Node && (Node->getKind() == Node::Kind::Uniquable) &&
+      Node->getNumChildren() == 1)
+    Node = Node->getChild(0);
+  if (!Node || Node->getKind() != Node::Kind::ExtendedExistentialTypeShape ||
+      Node->getNumChildren() != 2)
+    return {nullptr, nullptr};
+  Node = Node->getChild(1);
+  if (!Node || Node->getKind() != Node::Kind::Type ||
+      Node->getNumChildren() != 1)
+    return {nullptr, nullptr};
+  Node = Node->getChild(0);
+  if (!Node || Node->getKind() != Node::Kind::ConstrainedExistential ||
+      Node->getNumChildren() != 2)
+    return {nullptr, nullptr};
+  NodePointer Requirements = Node->getChild(1);
+  if (!Requirements || Requirements->getKind() !=
+                           Node::Kind::ConstrainedExistentialRequirementList)
+    return {nullptr, nullptr};
+
+  Node = Node->getChild(0);
+  if (!Node || Node->getKind() != Node::Kind::Type ||
+      Node->getNumChildren() != 1)
+    return {nullptr, nullptr};
+  NodePointer Protocol = Node;
+  if (!Protocol)
+    return {nullptr, nullptr};
+
+  return {Protocol, Requirements};
+}
+
 #define MAKE_NODE_TYPE_ERROR(Node, Fmt, ...)                                   \
   TYPE_LOOKUP_ERROR_FMT("TypeDecoder.h:%u: Node kind %u \"%.*s\" - " Fmt,      \
                         __LINE__, (unsigned)Node->getKind(),                   \
diff --git a/include/swift/RemoteInspection/TypeRef.h b/include/swift/RemoteInspection/TypeRef.h
@@ -731,6 +731,64 @@ class ConstrainedExistentialTypeRef final : public TypeRef {
   }
 };
 
+class SymbolicExtendedExistentialTypeRef final : public TypeRef {
+  const ProtocolCompositionTypeRef *Protocol;
+  std::vector<TypeRefRequirement> Requirements;
+  std::vector<const TypeRef *> Arguments;
+  ExtendedExistentialTypeShapeFlags Flags;
+
+  static TypeRefID Profile(const ProtocolCompositionTypeRef *Protocol,
+                           llvm::ArrayRef<TypeRefRequirement> Requirements,
+                           llvm::ArrayRef<const TypeRef *> Arguments,
+                           ExtendedExistentialTypeShapeFlags Flags) {
+    TypeRefID ID;
+    ID.addPointer(Protocol);
+    for (auto reqt : Requirements) {
+      ID.addPointer(reqt.getFirstType());
+      if (reqt.getKind() != RequirementKind::Layout)
+        ID.addPointer(reqt.getSecondType());
+      else
+        ID.addInteger(
+            unsigned(0)); // FIXME: Layout constraints aren't implemented yet
+      ID.addInteger(unsigned(reqt.getKind()));
+    }
+
+    for (auto &Arg : Arguments)
+      ID.addPointer(Arg);
+    return ID;
+  }
+
+public:
+  SymbolicExtendedExistentialTypeRef(
+      const ProtocolCompositionTypeRef *Protocol,
+      llvm::ArrayRef<TypeRefRequirement> Requirements,
+      llvm::ArrayRef<const TypeRef *> Args,
+      ExtendedExistentialTypeShapeFlags Flags)
+      : TypeRef(TypeRefKind::SymbolicExtendedExistential), Protocol(Protocol),
+        Requirements(Requirements), Arguments(Args), Flags(Flags) {}
+
+  template <typename Allocator>
+  static const SymbolicExtendedExistentialTypeRef *
+  create(Allocator &A, const ProtocolCompositionTypeRef *Protocol,
+         llvm::ArrayRef<TypeRefRequirement> Requirements,
+         llvm::ArrayRef<const TypeRef *> Args,
+         ExtendedExistentialTypeShapeFlags Flags) {
+    FIND_OR_CREATE_TYPEREF(A, SymbolicExtendedExistentialTypeRef, Protocol,
+                           Requirements, Args, Flags);
+  }
+
+  const ProtocolCompositionTypeRef *getProtocol() const { return Protocol; }
+  llvm::ArrayRef<TypeRefRequirement> getRequirements() const {
+    return Requirements;
+  }
+  llvm::ArrayRef<const TypeRef *> getArguments() const { return Arguments; }
+  ExtendedExistentialTypeShapeFlags getFlags() const { return Flags; }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::SymbolicExtendedExistential;
+  }
+};
+
 class MetatypeTypeRef final : public TypeRef {
   const TypeRef *InstanceType;
   bool WasAbstract;
diff --git a/include/swift/RemoteInspection/TypeRefBuilder.h b/include/swift/RemoteInspection/TypeRefBuilder.h
@@ -1283,8 +1283,32 @@ class TypeRefBuilder {
   const TypeRef *
   createSymbolicExtendedExistentialType(NodePointer shapeNode,
                                         llvm::ArrayRef<const TypeRef *> args) {
-    // Can't handle this here.
-    return nullptr;
+    remote::RemoteAddress shape(shapeNode->getIndex());
+    auto symbol = OpaquePointerSymbolResolver(shape);
+    if (!symbol)
+      return nullptr;
+    auto bytes = OpaqueByteReader(shape, 4);
+    if (!bytes)
+      return nullptr;
+    ExtendedExistentialTypeShapeFlags flags(*(const uint32_t *)bytes.get());
+
+    Demangler Dem;
+    NodePointer node = Dem.demangleSymbol(symbol->getSymbol());
+    auto [protocolNode, requirementNode] = decodeShape(node);
+    if (!protocolNode || !requirementNode)
+      return nullptr;
+
+    auto *protocol = llvm::dyn_cast_or_null<ProtocolCompositionTypeRef>(
+        decodeMangledType(protocolNode));
+
+    llvm::SmallVector<BuiltRequirement, 8> requirements;
+    llvm::SmallVector<BuiltInverseRequirement, 8> inverseRequirements;
+    decodeRequirement<BuiltType, BuiltRequirement, BuiltInverseRequirement,
+                      BuiltLayoutConstraint, TypeRefBuilder>(
+        requirementNode, requirements, inverseRequirements, *this);
+
+    return SymbolicExtendedExistentialTypeRef::create(
+        *this, protocol, requirements, args, flags);
   }
 
   const ExistentialMetatypeTypeRef *createExistentialMetatypeType(
@@ -1312,8 +1336,7 @@ class TypeRefBuilder {
 
   const DependentMemberTypeRef *
   createDependentMemberType(const std::string &member, const TypeRef *base) {
-    // Should not have unresolved dependent member types here.
-    return nullptr;
+    return DependentMemberTypeRef::create(*this, member, base, "");
   }
 
   const DependentMemberTypeRef *
@@ -1479,6 +1502,9 @@ class TypeRefBuilder {
   using PointerReader =
       std::function<std::optional<remote::RemoteAbsolutePointer>(
           remote::RemoteAddress, unsigned)>;
+  using PointerSymbolResolver =
+      std::function<std::optional<remote::RemoteAbsolutePointer>(
+          remote::RemoteAddress)>;
   using DynamicSymbolResolver =
       std::function<std::optional<remote::RemoteAbsolutePointer>(
           remote::RemoteAddress)>;
@@ -1511,6 +1537,7 @@ class TypeRefBuilder {
   ByteReader OpaqueByteReader;
   StringReader OpaqueStringReader;
   PointerReader OpaquePointerReader;
+  PointerSymbolResolver OpaquePointerSymbolResolver;
   DynamicSymbolResolver OpaqueDynamicSymbolResolver;
   IntVariableReader OpaqueIntVariableReader;
 
@@ -1549,6 +1576,11 @@ class TypeRefBuilder {
                 -> std::optional<remote::RemoteAbsolutePointer> {
               return reader.Reader->readPointer(address, size);
             }),
+        OpaquePointerSymbolResolver(
+            [&reader](remote::RemoteAddress address)
+                -> std::optional<remote::RemoteAbsolutePointer> {
+              return reader.Reader->resolvePointerAsSymbol(address);
+            }),
         OpaqueDynamicSymbolResolver(
             [&reader](remote::RemoteAddress address)
                 -> std::optional<remote::RemoteAbsolutePointer> {
diff --git a/include/swift/RemoteInspection/TypeRefs.def b/include/swift/RemoteInspection/TypeRefs.def
@@ -23,6 +23,7 @@ TYPEREF(Tuple, TypeRef)
 TYPEREF(Function, TypeRef)
 TYPEREF(ProtocolComposition, TypeRef)
 TYPEREF(ConstrainedExistential, TypeRef)
+TYPEREF(SymbolicExtendedExistential, TypeRef)
 TYPEREF(Metatype, TypeRef)
 TYPEREF(ExistentialMetatype, TypeRef)
 TYPEREF(GenericTypeParameter, TypeRef)
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -767,8 +767,12 @@ Type ASTBuilder::createExistentialMetatypeType(
 Type ASTBuilder::createConstrainedExistentialType(
     Type base, ArrayRef<BuiltRequirement> constraints,
     ArrayRef<BuiltInverseRequirement> inverseRequirements) {
+  llvm::SmallDenseMap<Identifier, Type> primaryAssociatedTypeNames;
   llvm::SmallDenseMap<AssociatedTypeDecl *, Type> primaryAssociatedTypes;
   llvm::SmallDenseSet<AssociatedTypeDecl *> claimed;
+  llvm::SmallDenseSet<Identifier> claimedNames;
+  unsigned duplicates = 0;
+  bool ambiguousName = false;
 
   for (const auto &req : constraints) {
     switch (req.getKind()) {
@@ -782,7 +786,18 @@ Type ASTBuilder::createConstrainedExistentialType(
       if (auto *memberTy = req.getFirstType()->getAs<DependentMemberType>()) {
         if (memberTy->getBase()->is<GenericTypeParamType>()) {
           // This is the only case we understand so far.
-          primaryAssociatedTypes[memberTy->getAssocType()] = req.getSecondType();
+          if (auto *assocTy = memberTy->getAssocType())
+            primaryAssociatedTypes[assocTy] = req.getSecondType();
+          else {
+            auto &ty = primaryAssociatedTypeNames[memberTy->getName()];
+            if (!ty)
+              ty = req.getSecondType();
+            else if (ty.getPointer() == req.getSecondType().getPointer())
+              ++duplicates;
+            else
+              ambiguousName = true;
+          }
+
           continue;
         }
       }
@@ -799,11 +814,24 @@ Type ASTBuilder::createConstrainedExistentialType(
 
     llvm::SmallVector<Type, 4> args;
     for (auto *assocTy : proto->getPrimaryAssociatedTypes()) {
-      auto found = primaryAssociatedTypes.find(assocTy);
-      if (found == primaryAssociatedTypes.end())
-        return protoTy;
-      args.push_back(found->second);
-      claimed.insert(found->first);
+      {
+        auto found = primaryAssociatedTypes.find(assocTy);
+        if (found != primaryAssociatedTypes.end()) {
+          args.push_back(found->second);
+          claimed.insert(found->first);
+          continue;
+        }
+      }
+      {
+        if (ambiguousName)
+          return protoTy;
+        auto found = primaryAssociatedTypeNames.find(assocTy->getName());
+        if (found != primaryAssociatedTypeNames.end()) {
+          args.push_back(found->second);
+          claimedNames.insert(found->first);
+          continue;
+        }
+      }
     }
 
     // We may not have any arguments because the constrained existential is a
@@ -839,6 +867,7 @@ Type ASTBuilder::createConstrainedExistentialType(
 
   // Make sure that all arguments were actually used.
   ASSERT(claimed.size() == primaryAssociatedTypes.size());
+  ASSERT(claimedNames.size() + duplicates == primaryAssociatedTypeNames.size());
 
   // Handle inverse requirements.
   if (!inverseRequirements.empty()) {
diff --git a/stdlib/public/RemoteInspection/TypeLowering.cpp b/stdlib/public/RemoteInspection/TypeLowering.cpp
@@ -1154,6 +1154,7 @@ class ExistentialTypeInfoBuilder {
   TypeConverter &TC;
   std::vector<const TypeRef *> Protocols;
   const TypeRef *Superclass = nullptr;
+  remote::RemoteAbsolutePointer Shape;
   ExistentialTypeRepresentation Representation;
   ReferenceCounting Refcounting;
   bool ObjC;
@@ -1258,6 +1259,8 @@ class ExistentialTypeInfoBuilder {
     }
   }
 
+  void examineShape() {}
+
 public:
   ExistentialTypeInfoBuilder(TypeConverter &TC)
     : TC(TC), Representation(ExistentialTypeRepresentation::Opaque),
@@ -1321,8 +1324,27 @@ class ExistentialTypeInfoBuilder {
     Representation = ExistentialTypeRepresentation::Class;
   }
 
+  void addShape(const ProtocolCompositionTypeRef *Protocol,
+                ExtendedExistentialTypeShapeFlags Flags) {
+    switch (Flags.getSpecialKind()) {
+    case ExtendedExistentialTypeShapeFlags::SpecialKind::Class:
+      Representation = ExistentialTypeRepresentation::Class;
+      break;
+    case ExtendedExistentialTypeShapeFlags::SpecialKind::Metatype:
+    case ExtendedExistentialTypeShapeFlags::SpecialKind::ExplicitLayout:
+    case ExtendedExistentialTypeShapeFlags::SpecialKind::None:
+      Representation = ExistentialTypeRepresentation::Opaque;
+      break;
+    }
+
+    if (Protocol)
+      for (auto *Protocol : Protocol->getProtocols())
+        addProtocol(Protocol);
+  }
+
   const TypeInfo *build(remote::TypeInfoProvider *ExternalTypeInfo) {
     examineProtocols();
+    examineShape();
 
     if (Invalid)
       return nullptr;
@@ -1780,6 +1802,11 @@ class HasFixedSize
     return true;
   }
 
+  bool visitSymbolicExtendedExistentialTypeRef(
+      const SymbolicExtendedExistentialTypeRef *SEET) {
+    return true;
+  }
+
   bool
   visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
     return true;
@@ -1923,6 +1950,11 @@ class HasSingletonMetatype
     return MetatypeRepresentation::Thin;
   }
 
+  MetatypeRepresentation visitSymbolicExtendedExistentialTypeRef(
+      const SymbolicExtendedExistentialTypeRef *SEET) {
+    return MetatypeRepresentation::Thin;
+  }
+
   MetatypeRepresentation visitMetatypeTypeRef(const MetatypeTypeRef *M) {
     if (M->wasAbstract())
       return MetatypeRepresentation::Thick;
@@ -2520,6 +2552,13 @@ class LowerType
     return builder.buildMetatype(ExternalTypeInfo);
   }
 
+  const TypeInfo *visitSymbolicExtendedExistentialTypeRef(
+      const SymbolicExtendedExistentialTypeRef *SEET) {
+    ExistentialTypeInfoBuilder builder(TC);
+    builder.addShape(SEET->getProtocol(), SEET->getFlags());
+    return builder.build(ExternalTypeInfo);
+  }
+
   const TypeInfo *
   visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP) {
     DEBUG_LOG(fprintf(stderr, "Unresolved generic TypeRef: "); GTP->dump());
diff --git a/stdlib/public/RemoteInspection/TypeRef.cpp b/stdlib/public/RemoteInspection/TypeRef.cpp
