Implement reflection support for Symbolic Extended Existential types.

include/swift/Demangling/Demangle.h

@@ -193,6 +193,7 @@ class Node {
   };
 
   using IndexType = uint64_t;
+  using RemoteAddressType = std::pair<uint64_t, uint8_t>;
 
   friend class NodeFactory;
 
@@ -209,14 +210,15 @@ class Node {
     IndexType Index;
     NodePointer InlineChildren[2];
     NodeVector Children;
+    RemoteAddressType RemoteAddress;
   };
 
 
   Kind NodeKind;
 
   enum class PayloadKind : uint8_t {
     None = 0, OneChild = 1, TwoChildren = 2,
-    Text, Index, ManyChildren
+    Text, Index, ManyChildren, RemoteAddress
   };
   PayloadKind NodePayloadKind;
 
@@ -231,6 +233,10 @@ class Node {
       : NodeKind(k), NodePayloadKind(PayloadKind::Index) {
     Index = index;
   }
+  Node(Kind k, uint64_t remoteAddress, uint8_t addressSpace)
+      : NodeKind(k), NodePayloadKind(PayloadKind::RemoteAddress) {
+    RemoteAddress = {remoteAddress, addressSpace};
+  }
   Node(const Node &) = delete;
   Node &operator=(const Node &) = delete;
 
@@ -284,6 +290,14 @@ class Node {
     return Index;
   }
 
+  bool hasRemoteAddress() const {
+    return NodePayloadKind == PayloadKind::RemoteAddress;
+  }
+  std::pair<uint64_t, uint8_t> getRemoteAddress() const {
+    assert(hasRemoteAddress());
+    return RemoteAddress;
+  }
+
   using iterator = const NodePointer *;
 
   size_t getNumChildren() const {

include/swift/Demangling/Demangler.h

@@ -249,6 +249,10 @@ class NodeFactory {
   /// Creates a node of kind \p K with an \p Index payload.
   NodePointer createNode(Node::Kind K, Node::IndexType Index);
 
+  /// Creates a node of kind \p K with an \p RemoteAddress payload.
+  NodePointer createNode(Node::Kind K, uint64_t RemoteAddress,
+                         uint8_t AddressSpace);
+
   /// Creates a node of kind \p K with a \p Text payload.
   ///
   /// The \p Text string must be already allocated with the Factory and therefore

include/swift/Demangling/TypeDecoder.h

@@ -573,6 +573,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(),                   \