ASTDemangler: Support PackType, SILPackType, and PackExpansionType

Author: slavapestov

include/swift/AST/ASTDemangler.h

@@ -111,6 +111,12 @@ class ASTBuilder {
 
   Type createTupleType(ArrayRef<Type> eltTypes, StringRef labels);
 
+  Type createPackType(ArrayRef<Type> eltTypes);
+
+  Type createSILPackType(ArrayRef<Type> eltTypes, bool isElementAddress);
+
+  Type createPackExpansionType(Type patternType, Type countType);
+
   Type createFunctionType(
       ArrayRef<Demangle::FunctionParam<Type>> params,
       Type output, FunctionTypeFlags flags,

include/swift/Demangling/TypeDecoder.h

@@ -1072,6 +1072,46 @@ class TypeDecoder {
       return decodeMangledType(Node->getChild(0), depth + 1,
                                /*forRequirement=*/false);
 
+    case NodeKind::Pack:
+    case NodeKind::SILPackDirect:
+    case NodeKind::SILPackIndirect: {
+      llvm::SmallVector<BuiltType, 8> elements;
+
+      for (auto &element : *Node) {
+        // Decode the element type.
+        auto elementType =
+            decodeMangledType(element, depth + 1, /*forRequirement=*/false);
+        if (elementType.isError())
+          return elementType;
+
+        elements.push_back(elementType.getType());
+      }
+
+      switch (Node->getKind()) {
+      case NodeKind::Pack:
+        return Builder.createPackType(elements);
+      case NodeKind::SILPackDirect:
+        return Builder.createSILPackType(elements, /*isElementAddress=*/false);
+      case NodeKind::SILPackIndirect:
+        return Builder.createSILPackType(elements, /*isElementAddress=*/true);
+      default:
+        llvm_unreachable("Bad kind");
+      }
+    }
+
+    case NodeKind::PackExpansion: {
+      if (Node->getNumChildren() < 2)
+        return MAKE_NODE_TYPE_ERROR(Node,
+                                    "fewer children (%zu) than required (2)",
+                                    Node->getNumChildren());
+
+      auto patternType = decodeMangledType(Node->getChild(0), depth + 1);
+      auto countType = decodeMangledType(Node->getChild(1), depth + 1);
+
+      return Builder.createPackExpansionType(patternType.getType(),
+                                             countType.getType());
+    }
+
     case NodeKind::DependentGenericType: {
       if (Node->getNumChildren() < 2)
         return MAKE_NODE_TYPE_ERROR(Node,

lib/AST/ASTDemangler.cpp

@@ -344,6 +344,25 @@ Type ASTBuilder::createTupleType(ArrayRef<Type> eltTypes, StringRef labels) {
   return TupleType::get(elements, Ctx);
 }
 
+Type ASTBuilder::createPackType(ArrayRef<Type> eltTypes) {
+  return PackType::get(Ctx, eltTypes);
+}
+
+Type ASTBuilder::createSILPackType(ArrayRef<Type> eltTypes,
+                                   bool isElementAddress) {
+  auto extInfo = SILPackType::ExtInfo(isElementAddress);
+
+  SmallVector<CanType, 4> elements;
+  for (auto eltType : eltTypes)
+    elements.push_back(eltType->getCanonicalType());
+
+  return SILPackType::get(Ctx, extInfo, elements);
+}
+
+Type ASTBuilder::createPackExpansionType(Type patternType, Type countType) {
+  return PackExpansionType::get(patternType, countType);
+}
+
 Type ASTBuilder::createFunctionType(
     ArrayRef<Demangle::FunctionParam<Type>> params,
     Type output, FunctionTypeFlags flags,