Mangler: Mangle PackElementType

Author: slavapestov

docs/ABI/Mangling.rst

@@ -675,6 +675,8 @@ Types
   type ::= assoc-type-list 'QZ'                      // shortcut for 'QYz'
   type ::= opaque-type-decl-name bound-generic-args 'Qo' INDEX // opaque type
   
+  type ::= pack-type 'Qe' INDEX              // pack element type
+  
   type ::= pattern-type count-type 'Qp'      // pack expansion type
   type ::= pack-element-list 'QP'            // pack type
   type ::= pack-element-list 'QS' DIRECTNESS // SIL pack type

include/swift/Demangling/DemangleNodes.def

@@ -242,6 +242,7 @@ NODE(SILPackDirect)
 NODE(SILPackIndirect)
 NODE(PackExpansion)
 NODE(PackElement)
+NODE(PackElementLevel)
 NODE(Type)
 CONTEXT_NODE(TypeSymbolicReference)
 CONTEXT_NODE(TypeAlias)

lib/AST/ASTMangler.cpp

@@ -1289,8 +1289,9 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     case TypeKind::PackElement: {
       auto elementType = cast<PackElementType>(tybase);
       appendType(elementType->getPackType(), sig, forDecl);
-
-      // FIXME: append expansion depth
+      // If this ever changes, just mangle level 0 as a plain type parameter.
+      assert(elementType->getLevel() > 0);
+      appendOperator("Qe", Index(elementType->getLevel() - 1));
 
       return;
     }

lib/Demangling/Demangler.cpp

@@ -2511,6 +2511,17 @@ NodePointer Demangler::demangleArchetype() {
           createWithChildren(Node::Kind::PackExpansion, PatternTy, CountTy));
     return PackExpansionTy;
   }
+  case 'e': {
+    NodePointer PackTy = popTypeAndGetChild();
+    int level = demangleIndex();
+    if (level < 0)
+      return NULL;
+
+    NodePointer PackElementTy = createType(
+          createWithChildren(Node::Kind::PackElement, PackTy,
+              createNode(Node::Kind::PackElementLevel, level)));
+    return PackElementTy;
+  }
   case 'P':
     return popPack();
   case 'S':

lib/Demangling/NodePrinter.cpp

@@ -341,6 +341,7 @@ class NodePrinter {
 
     case Node::Kind::ConstrainedExistential:
     case Node::Kind::PackElement:
+    case Node::Kind::PackElementLevel:
     case Node::Kind::PackExpansion:
     case Node::Kind::ProtocolListWithClass:
     case Node::Kind::AccessorAttachedMacroExpansion:
@@ -1630,10 +1631,14 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     return nullptr;
   }
   case Node::Kind::PackElement: {
+    Printer << "/* level: " << Node->getChild(1)->getIndex() << " */ ";
     Printer << "each ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
   }
+  case Node::Kind::PackElementLevel:
+    printer_unreachable("should be handled in Node::Kind::PackElement");
+
   case Node::Kind::ReturnType:
     if (Node->getNumChildren() == 0)
       Printer << " -> " << Node->getText();

lib/Demangling/OldRemangler.cpp

@@ -1934,6 +1934,10 @@ ManglingError Remangler::manglePackElement(Node *node, unsigned depth) {
   return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
 
+ManglingError Remangler::manglePackElementLevel(Node *node, unsigned depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+
 ManglingError Remangler::mangleDependentGenericType(Node *node,
                                                     unsigned depth) {
   Buffer << 'u';

lib/Demangling/Remangler.cpp

@@ -2307,9 +2307,14 @@ ManglingError Remangler::manglePackExpansion(Node *node, unsigned depth) {
 }
 
 ManglingError Remangler::manglePackElement(Node *node, unsigned depth) {
- // FIXME
-  RETURN_IF_ERROR(mangleChildNodes(node, depth + 1));
-//  Buffer << "Qp";
+  RETURN_IF_ERROR(mangleChildNode(node, 0, depth + 1));
+  Buffer << "Qe";
+  RETURN_IF_ERROR(mangleChildNode(node, 1, depth + 1));
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::manglePackElementLevel(Node *node, unsigned depth) {
+  mangleIndex(node->getIndex());
   return ManglingError::Success;
 }
 

test/SILGen/nested_pack_expansion.swift

@@ -0,0 +1,15 @@
+// RUN: %target-swift-emit-silgen %s -disable-availability-checking | %FileCheck %s
+
+typealias A<each T, U, V> = (repeat (each T, U, V))
+
+struct G<each T> {
+  typealias B<each U, V> = (repeat A<repeat each T, each U, V>)
+
+  struct H<each U> {
+    typealias C<each V> = (repeat B<repeat each U, each V>)
+  }
+}
+
+// CHECK-LABEL: sil hidden [ossa] @$s21nested_pack_expansion2fb1tyx_q_Qe_q0_txQp_tq_Qp_t_tRvzRv_r1_lF : $@convention(thin) <each T, each U, V> (@pack_guaranteed Pack{repeat (repeat (each T, /* level: 1 */ each U, V))}) -> () {
+// CHECK: bb0(%0 : $*Pack{repeat (repeat (each T, /* level: 1 */ each U, V))}):
+func fb<each T, each U, V>(t: G<repeat each T>.B<repeat each U, V>) {}