AST: Add mangling for class-constrained existentials

Author: slavapestov

docs/ABI.rst

@@ -1044,6 +1044,7 @@ Types
   type ::= associated-type
   type ::= nominal-type
   type ::= protocol-list 'p'                 // existential type
+  type ::= protocol-list superclass 'XE'     // existential type with superclass
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0

include/swift/Demangling/DemangleNodes.def

@@ -123,6 +123,7 @@ CONTEXT_NODE(Protocol)
 NODE(ProtocolConformance)
 NODE(ProtocolDescriptor)
 NODE(ProtocolList)
+NODE(ProtocolListWithClass)
 NODE(ProtocolWitness)
 NODE(ProtocolWitnessTable)
 NODE(ProtocolWitnessTableAccessor)

lib/AST/ASTMangler.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTVisitor.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/Module.h"
@@ -631,16 +632,32 @@ void ASTMangler::appendType(Type type) {
       appendTypeList(type);
       return appendOperator("t");
 
-    case TypeKind::Protocol:
+    case TypeKind::Protocol: {
+      bool First = true;
+      appendProtocolName(cast<ProtocolType>(tybase)->getDecl());
+      appendListSeparator(First);
+      return appendOperator("p");
+    }
+
     case TypeKind::ProtocolComposition: {
       // We mangle ProtocolType and ProtocolCompositionType using the
       // same production:
       bool First = true;
-      appendProtocolList(type, First);
+      auto layout = type->getExistentialLayout();
+      for (Type protoTy : layout.getProtocols()) {
+        appendProtocolName(protoTy->castTo<ProtocolType>()->getDecl());
+        appendListSeparator(First);
+      }
       if (First)
         appendOperator("y");
+
+      if (layout.superclass) {
+        appendType(layout.superclass);
+        return appendOperator("XE");
+      }
       return appendOperator("p");
     }
+
     case TypeKind::UnboundGeneric:
     case TypeKind::Class:
     case TypeKind::Enum:

lib/Demangling/Demangler.cpp

@@ -1583,6 +1583,12 @@ NodePointer Demangler::demangleSpecialType() {
     case 'p':
       return createType(createWithChild(Node::Kind::ExistentialMetatype,
                                         popNode(Node::Kind::Type)));
+    case 'E': {
+      NodePointer Superclass = popNode(Node::Kind::Type);
+      NodePointer Protocols = demangleProtocolListType();
+      return createType(createWithChildren(Node::Kind::ProtocolListWithClass,
+                                           Protocols, Superclass));
+    }
     case 'X':
     case 'x': {
       // SIL box types.

lib/Demangling/NodePrinter.cpp

@@ -267,6 +267,7 @@ class NodePrinter {
         return true;
       return false;
 
+    case Node::Kind::ProtocolListWithClass:
     case Node::Kind::Allocator:
     case Node::Kind::ArgumentTuple:
     case Node::Kind::AssociatedTypeMetadataAccessor:
@@ -578,7 +579,8 @@ class NodePrinter {
 
 static bool isExistentialType(NodePointer node) {
   return (node->getKind() == Node::Kind::ExistentialMetatype ||
-          node->getKind() == Node::Kind::ProtocolList);
+          node->getKind() == Node::Kind::ProtocolList ||
+          node->getKind() == Node::Kind::ProtocolListWithClass);
 }
 
 /// Print the relevant parameters and return the new index.
@@ -1388,6 +1390,16 @@ void NodePrinter::print(NodePointer pointer, bool asContext, bool suppressType)
       printChildren(type_list, " & ");
     return;
   }
+  case Node::Kind::ProtocolListWithClass: {
+    if (pointer->getNumChildren() < 2)
+      return;
+    NodePointer protocols = pointer->getChild(0);
+    NodePointer superclass = pointer->getChild(1);
+    print(superclass);
+    Printer << " & ";
+    printChildren(protocols, " & ");
+    return;
+  }
   case Node::Kind::AssociatedType:
     // Don't print for now.
     return;

lib/Demangling/Remangler.cpp

@@ -249,6 +249,8 @@ class Remangler {
     mangleChildNodes(Proto);
   }
 
+  void mangleProtocolList(Node *protocols, Node *superclass);
+
   bool trySubstitution(Node *node, SubstitutionEntry &entry,
                        bool treatAsIdentifier = false);
   void addSubstitution(const SubstitutionEntry &entry);
@@ -1401,17 +1403,31 @@ void Remangler::mangleProtocolDescriptor(Node *node) {
   Buffer << "Mp";
 }
 
-void Remangler::mangleProtocolList(Node *node) {
-  node = getSingleChild(node, Node::Kind::TypeList);
+void Remangler::mangleProtocolList(Node *node, Node *superclass) {
   bool FirstElem = true;
   for (NodePointer Child : *node) {
     manglePureProtocol(Child);
     mangleListSeparator(FirstElem);
   }
   mangleEndOfList(FirstElem);
+  if (superclass) {
+    mangleType(superclass);
+    Buffer << "XE";
+    return;
+  }
   Buffer << 'p';
 }
 
+void Remangler::mangleProtocolList(Node *node) {
+  auto *protocols = getSingleChild(node, Node::Kind::TypeList);
+  mangleProtocolList(protocols, nullptr);
+}
+
+void Remangler::mangleProtocolListWithClass(Node *node) {
+  mangleProtocolList(node->getChild(0),
+                     node->getChild(1));
+}
+
 void Remangler::mangleProtocolWitness(Node *node) {
   mangleChildNodes(node);
   Buffer << "TW";