AST: Mangling for primitive AnyObject

A protocol composition with an explicit 'AnyObject' member is
now mangled as <protocol list> 'Xl'. For subclass existentials,
I changed the mangling from <protocol list> <class> 'XE' to
<protocol list> <class> 'Xl'.

Not used for anything just yet.

Author: slavapestov

docs/ABI.rst

@@ -1044,7 +1044,8 @@ Types
   type ::= associated-type
   type ::= nominal-type
   type ::= protocol-list 'p'                 // existential type
-  type ::= protocol-list superclass 'XE'     // existential type with superclass
+  type ::= protocol-list superclass 'Xc'     // existential type with superclass
+  type ::= protocol-list 'Xl'                // existential type with AnyObject
   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

@@ -124,6 +124,7 @@ NODE(ProtocolConformance)
 NODE(ProtocolDescriptor)
 NODE(ProtocolList)
 NODE(ProtocolListWithClass)
+NODE(ProtocolListWithAnyObject)
 NODE(ProtocolWitness)
 NODE(ProtocolWitnessTable)
 NODE(ProtocolWitnessTableAccessor)

include/swift/Demangling/Demangler.h

@@ -447,6 +447,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleMetatypeRepresentation();
   NodePointer demangleFunctionEntity();
   NodePointer demangleEntity(Node::Kind Kind);
+  NodePointer demangleProtocolList();
   NodePointer demangleProtocolListType();
   NodePointer demangleGenericSignature(bool hasParamCounts);
   NodePointer demangleGenericRequirement();

lib/AST/ASTMangler.cpp

@@ -653,7 +653,9 @@ void ASTMangler::appendType(Type type) {
 
       if (layout.superclass) {
         appendType(layout.superclass);
-        return appendOperator("XE");
+        return appendOperator("Xc");
+      } else if (layout.requiresClass & !layout.requiresClassImplied) {
+        return appendOperator("Xl");
       }
       return appendOperator("p");
     }

lib/Demangling/Demangler.cpp

@@ -1581,12 +1581,17 @@ NodePointer Demangler::demangleSpecialType() {
     case 'p':
       return createType(createWithChild(Node::Kind::ExistentialMetatype,
                                         popNode(Node::Kind::Type)));
-    case 'E': {
+    case 'c': {
       NodePointer Superclass = popNode(Node::Kind::Type);
-      NodePointer Protocols = demangleProtocolListType();
+      NodePointer Protocols = demangleProtocolList();
       return createType(createWithChildren(Node::Kind::ProtocolListWithClass,
                                            Protocols, Superclass));
     }
+    case 'l': {
+      NodePointer Protocols = demangleProtocolList();
+      return createType(createWithChild(Node::Kind::ProtocolListWithAnyObject,
+                                        Protocols));
+    }
     case 'X':
     case 'x': {
       // SIL box types.
@@ -1738,7 +1743,7 @@ NodePointer Demangler::demangleEntity(Node::Kind Kind) {
   return createWithChildren(Kind, Context, Name, Type);
 }
 
-NodePointer Demangler::demangleProtocolListType() {
+NodePointer Demangler::demangleProtocolList() {
   NodePointer TypeList = createNode(Node::Kind::TypeList);
   NodePointer ProtoList = createWithChild(Node::Kind::ProtocolList, TypeList);
   if (!popNode(Node::Kind::EmptyList)) {
@@ -1753,6 +1758,11 @@ NodePointer Demangler::demangleProtocolListType() {
 
     TypeList->reverseChildren();
   }
+  return ProtoList;
+}
+
+NodePointer Demangler::demangleProtocolListType() {
+  NodePointer ProtoList = demangleProtocolList();
   return createType(ProtoList);
 }
 

lib/Demangling/NodePrinter.cpp

@@ -279,6 +279,7 @@ class NodePrinter {
       return Node->getChild(0)->getNumChildren() <= 1;
 
     case Node::Kind::ProtocolListWithClass:
+    case Node::Kind::ProtocolListWithAnyObject:
     case Node::Kind::Allocator:
     case Node::Kind::ArgumentTuple:
     case Node::Kind::AssociatedTypeMetadataAccessor:
@@ -1344,6 +1345,20 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     printChildren(protocols, " & ");
     return nullptr;
   }
+  case Node::Kind::ProtocolListWithAnyObject: {
+    if (Node->getNumChildren() < 1)
+      return nullptr;
+    NodePointer protocols = Node->getChild(0);
+    if (protocols->getNumChildren() < 1)
+      return nullptr;
+    if (protocols->getChild(0)->getNumChildren() == 0) {
+      Printer << "AnyObject";
+    } else {
+      printChildren(protocols->getChild(0), " & ");
+      Printer << " & AnyObject";
+    }
+    return nullptr;
+  }
   case Node::Kind::AssociatedType:
     // Don't print for now.
     return nullptr;

lib/Demangling/Remangler.cpp

@@ -249,7 +249,8 @@ class Remangler {
     mangleChildNodes(Proto);
   }
 
-  void mangleProtocolList(Node *protocols, Node *superclass);
+  void mangleProtocolList(Node *protocols, Node *superclass,
+                          bool hasExplicitAnyObject);
 
   bool trySubstitution(Node *node, SubstitutionEntry &entry,
                        bool treatAsIdentifier = false);
@@ -1403,29 +1404,38 @@ void Remangler::mangleProtocolDescriptor(Node *node) {
   Buffer << "Mp";
 }
 
-void Remangler::mangleProtocolList(Node *node, Node *superclass) {
+void Remangler::mangleProtocolList(Node *node, Node *superclass,
+                                   bool hasExplicitAnyObject) {
+  auto *protocols = getSingleChild(node, Node::Kind::TypeList);
   bool FirstElem = true;
-  for (NodePointer Child : *node) {
+  for (NodePointer Child : *protocols) {
     manglePureProtocol(Child);
     mangleListSeparator(FirstElem);
   }
   mangleEndOfList(FirstElem);
   if (superclass) {
     mangleType(superclass);
-    Buffer << "XE";
+    Buffer << "Xc";
+    return;
+  } else if (hasExplicitAnyObject) {
+    Buffer << "Xl";
     return;
   }
   Buffer << 'p';
 }
 
 void Remangler::mangleProtocolList(Node *node) {
-  auto *protocols = getSingleChild(node, Node::Kind::TypeList);
-  mangleProtocolList(protocols, nullptr);
+  mangleProtocolList(node, nullptr, false);
 }
 
 void Remangler::mangleProtocolListWithClass(Node *node) {
   mangleProtocolList(node->getChild(0),
-                     node->getChild(1));
+                     node->getChild(1),
+                     false);
+}
+
+void Remangler::mangleProtocolListWithAnyObject(Node *node) {
+  mangleProtocolList(node->getChild(0), nullptr, true);
 }
 
 void Remangler::mangleProtocolWitness(Node *node) {

test/SILGen/subclass_existentials.swift

@@ -19,7 +19,7 @@ class Derived : Base<Int>, P {
 
 protocol R {}
 
-// CHECK-LABEL: sil hidden @_T021subclass_existentials11conversionsyAA1P_AA4BaseCySiGXE8baseAndP_AA7DerivedC7derivedAA1R_AIXE0hF1RAaC_AFXEXp0eF5PTypeAIm0H4TypeAaK_AIXEXp0hF5RTypetF : $@convention(thin) (@owned Base<Int> & P, @owned Derived, @owned Derived & R, @thick (Base<Int> & P).Type, @thick Derived.Type, @thick (Derived & R).Type) -> () {
+// CHECK-LABEL: sil hidden @_T021subclass_existentials11conversionsyAA1P_AA4BaseCySiGXc8baseAndP_AA7DerivedC7derivedAA1R_AIXc0hF1RAaC_AFXcXp0eF5PTypeAIm0H4TypeAaK_AIXcXp0hF5RTypetF : $@convention(thin) (@owned Base<Int> & P, @owned Derived, @owned Derived & R, @thick (Base<Int> & P).Type, @thick Derived.Type, @thick (Derived & R).Type) -> () {
 
 func conversions(
   baseAndP: Base<Int> & P,