ASTDemangler: Support PackType, SILPackType, and PackExpansionType

Also stub out the corresponding entry points in the runtime's
MetadataBuilder and the Remote Mirrors TypeRefBuilder.

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,

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -689,6 +689,23 @@ class TypeRefBuilder {
     return TupleTypeRef::create(*this, elements, std::move(labels));
   }
 
+  const TypeRef *createPackType(llvm::ArrayRef<const TypeRef *> elements) {
+    // FIXME: Remote mirrors support for variadic generics.
+    return nullptr;
+  }
+
+  const TypeRef *createSILPackType(llvm::ArrayRef<const TypeRef *> elements,
+                                   bool isElementAddress) {
+    // FIXME: Remote mirrors support for variadic generics.
+    return nullptr;
+  }
+
+  const TypeRef *createPackExpansionType(const TypeRef *patternType,
+                                         const TypeRef *countType) {
+    // FIXME: Remote mirrors support for variadic generics.
+    return nullptr;
+  }
+
   const FunctionTypeRef *createFunctionType(
       llvm::ArrayRef<remote::FunctionParam<const TypeRef *>> params,
       const TypeRef *result, FunctionTypeFlags flags,

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,

stdlib/public/runtime/MetadataLookup.cpp

@@ -1761,6 +1761,24 @@ class DecodedMetadataBuilder {
         .Value;
   }
 
+  TypeLookupErrorOr<BuiltType>
+  createPackType(llvm::ArrayRef<BuiltType> elements) const {
+    // FIXME: Runtime support for variadic generics.
+    return BuiltType();
+  }
+
+  TypeLookupErrorOr<BuiltType>
+  createSILPackType(llvm::ArrayRef<BuiltType> elements, bool isElementAddress) const {
+    // FIXME: Runtime support for variadic generics.
+    return BuiltType();
+  }
+
+  TypeLookupErrorOr<BuiltType>
+  createPackExpansionType(BuiltType patternType, BuiltType countType) const {
+    // FIXME: Runtime support for variadic generics.
+    return BuiltType();
+  }
+
   TypeLookupErrorOr<BuiltType> createDependentMemberType(StringRef name,
                                                          BuiltType base) const {
     // Should not have unresolved dependent member types here.