RemoteInspection: Support for parameter packs

Author: slavapestov

include/swift/RemoteInspection/TypeRef.h

@@ -416,6 +416,65 @@ class TupleTypeRef final : public TypeRef {
   }
 };
 
+class PackTypeRef final : public TypeRef {
+protected:
+  std::vector<const TypeRef *> Elements;
+
+  static TypeRefID Profile(const std::vector<const TypeRef *> &Elements) {
+    TypeRefID ID;
+    for (auto Element : Elements)
+      ID.addPointer(Element);
+    return ID;
+  }
+
+public:
+  PackTypeRef(std::vector<const TypeRef *> Elements)
+      : TypeRef(TypeRefKind::Pack), Elements(std::move(Elements)) {}
+
+  template <typename Allocator>
+  static const PackTypeRef *create(Allocator &A,
+                                    std::vector<const TypeRef *> Elements) {
+    FIND_OR_CREATE_TYPEREF(A, PackTypeRef, Elements);
+  }
+
+  const std::vector<const TypeRef *> &getElements() const { return Elements; };
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::Pack;
+  }
+};
+
+class PackExpansionTypeRef final : public TypeRef {
+protected:
+  const TypeRef *Pattern;
+  const TypeRef *Count;
+
+  static TypeRefID Profile(const TypeRef *Pattern, const TypeRef *Count) {
+    TypeRefID ID;
+    ID.addPointer(Pattern);
+    ID.addPointer(Count);
+    return ID;
+  }
+
+public:
+  PackExpansionTypeRef( const TypeRef *Pattern, const TypeRef *Count)
+      : TypeRef(TypeRefKind::PackExpansion), Pattern(Pattern), Count(Count) {}
+
+  template <typename Allocator>
+  static const PackExpansionTypeRef *create(Allocator &A,
+                                 const TypeRef *Pattern, const TypeRef *Count) {
+    FIND_OR_CREATE_TYPEREF(A, PackExpansionTypeRef, Pattern, Count);
+  }
+
+  const TypeRef *getPattern() const { return Pattern; }
+
+  const TypeRef *getCount() const { return Count; }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::PackExpansion;
+  }
+};
+
 class OpaqueArchetypeTypeRef final : public TypeRef {
   std::string ID;
   std::string Description;

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -414,6 +414,15 @@ class TypeRefBuilder {
 
   std::vector<std::unique_ptr<const GenericSignatureRef>> SignatureRefPool;
 
+  /// This builder doesn't perform "on the fly" substitutions, so we preserve
+  /// all pack expansions. We still need an active expansion stack though,
+  /// for the dummy implementation of these methods:
+  /// - beginPackExpansion()
+  /// - advancePackExpansion()
+  /// - createExpandedPackElement()
+  /// - endPackExpansion()
+  std::vector<const TypeRef *> ActivePackExpansions;
+
   TypeConverter TC;
 
 #define TYPEREF(Id, Parent) \
@@ -1133,8 +1142,7 @@ class TypeRefBuilder {
   }
 
   const TypeRef *createPackType(llvm::ArrayRef<const TypeRef *> elements) {
-    // FIXME: Remote mirrors support for variadic generics.
-    return nullptr;
+    return PackTypeRef::create(*this, elements);
   }
 
   const TypeRef *createSILPackType(llvm::ArrayRef<const TypeRef *> elements,
@@ -1144,21 +1152,22 @@ class TypeRefBuilder {
   }
 
   size_t beginPackExpansion(const TypeRef *countType) {
-    // FIXME: Remote mirrors support for variadic generics.
-    return 0;
+    ActivePackExpansions.push_back(countType);
+    return 1;
   }
 
   void advancePackExpansion(size_t index) {
-    // FIXME: Remote mirrors support for variadic generics.
+    assert(index == 0);
   }
 
   const TypeRef *createExpandedPackElement(const TypeRef *patternType) {
-    // FIXME: Remote mirrors support for variadic generics.
-    return nullptr;
+    assert(!ActivePackExpansions.empty());
+    auto countType = ActivePackExpansions.back();
+    return PackExpansionTypeRef::create(*this, patternType, countType);
   }
 
   void endPackExpansion() {
-    // FIXME: Remote mirrors support for variadic generics.
+    ActivePackExpansions.pop_back();
   }
 
   const FunctionTypeRef *createFunctionType(

include/swift/RemoteInspection/TypeRefs.def

@@ -39,5 +39,7 @@ TYPEREF(SILBox, TypeRef)
 TYPEREF(SILBoxTypeWithLayout, TypeRef)
 TYPEREF(Integer, TypeRef)
 TYPEREF(BuiltinFixedArray, TypeRef)
+TYPEREF(Pack, TypeRef)
+TYPEREF(PackExpansion, TypeRef)
 
 #undef TYPEREF

stdlib/public/RemoteInspection/TypeLowering.cpp

@@ -1744,6 +1744,15 @@ class HasFixedSize
     return true;
   }
 
+  bool visitPackTypeRef(const PackTypeRef *P) {
+    return false;
+  }
+
+  bool visitPackExpansionTypeRef(const PackExpansionTypeRef *PE) {
+    DEBUG_LOG(fprintf(stderr, "Cannot have pack expansion type here: "); PE->dump());
+    return false;
+  }
+
   bool visitFunctionTypeRef(const FunctionTypeRef *F) {
     return true;
   }
@@ -1879,6 +1888,20 @@ class HasSingletonMetatype
     return result;
   }
 
+  MetatypeRepresentation visitPackTypeRef(const PackTypeRef *P) {
+    auto result = MetatypeRepresentation::Thin;
+    for (auto Element : P->getElements())
+      result = combineRepresentations(result, visit(Element));
+    return result;
+  }
+
+  MetatypeRepresentation visitPackExpansionTypeRef(const PackExpansionTypeRef *PE) {
+    auto result = MetatypeRepresentation::Thin;
+    result = combineRepresentations(result, visit(PE->getPattern()));
+    result = combineRepresentations(result, visit(PE->getCount()));
+    return result;
+  }
+
   MetatypeRepresentation visitFunctionTypeRef(const FunctionTypeRef *F) {
     auto result = visit(F->getResult());
     for (const auto &Param : F->getParameters())
@@ -2421,6 +2444,16 @@ class LowerType
     return builder.build();
   }
 
+  const TypeInfo *visitPackTypeRef(const PackTypeRef *P) {
+    DEBUG_LOG(fprintf(stderr, "Cannot have pack type here: "); P->dump());
+    return nullptr;
+  }
+
+  const TypeInfo *visitPackExpansionTypeRef(const PackExpansionTypeRef *PE) {
+    DEBUG_LOG(fprintf(stderr, "Cannot have pack expansion type here: "); PE->dump());
+    return nullptr;
+  }
+
   const TypeInfo *visitFunctionTypeRef(const FunctionTypeRef *F) {
     switch (F->getFlags().getConvention()) {
     case FunctionMetadataConvention::Swift: