IRGen: Add DynamicTupleTypeInfo to model TupleTypes with PackExpansionType elements

For now these are completely resilient blobs, which is wrong
because it prevents us from being able to model something like
(Int, repeat each T, String).

But one step at a time...

Author: slavapestov

lib/IRGen/GenPack.cpp

@@ -30,6 +30,7 @@
 #include "IRGenFunction.h"
 #include "IRGenModule.h"
 #include "MetadataRequest.h"
+#include "ResilientTypeInfo.h"
 
 using namespace swift;
 using namespace irgen;

lib/IRGen/GenTuple.cpp

@@ -36,6 +36,7 @@
 #include "Explosion.h"
 #include "IndirectTypeInfo.h"
 #include "NonFixedTypeInfo.h"
+#include "ResilientTypeInfo.h"
 
 #include "GenTuple.h"
 
@@ -44,6 +45,33 @@
 using namespace swift;
 using namespace irgen;
 
+namespace {
+  /// A type implementation for tuple types with a dynamic number of
+  /// elements, that is, that contain pack expansion types. For now,
+  /// these are completely abstract.
+  class DynamicTupleTypeInfo
+      : public ResilientTypeInfo<DynamicTupleTypeInfo>
+  {
+  public:
+    DynamicTupleTypeInfo(llvm::Type *T,
+                         IsCopyable_t copyable)
+      : ResilientTypeInfo(T, copyable, IsABIAccessible) {}
+
+    TypeLayoutEntry
+    *buildTypeLayoutEntry(IRGenModule &IGM,
+                          SILType T,
+                          bool useStructLayouts) const override {
+      return IGM.typeLayoutCache.getOrCreateResilientEntry(T);
+    }
+  };
+} // end anonymous namespace
+
+const TypeInfo *
+TypeConverter::convertDynamicTupleType(IsCopyable_t copyable) {
+  llvm::Type *storageType = IGM.OpaqueTy;
+  return new DynamicTupleTypeInfo(storageType, copyable);
+}
+
 namespace {
   class TupleFieldInfo : public RecordField<TupleFieldInfo> {
   public:
@@ -488,6 +516,11 @@ namespace {
 } // end anonymous namespace
 
 const TypeInfo *TypeConverter::convertTupleType(TupleType *tuple) {
+  if (tuple->containsPackExpansionType()) {
+    // FIXME: Figure out if its copyable at least
+    return &getDynamicTupleTypeInfo(IsCopyable);
+  }
+
   TupleTypeBuilder builder(IGM, SILType::getPrimitiveAddressType(CanType(tuple)));
   return builder.layout(tuple->getElements());
 }

lib/IRGen/GenType.cpp

@@ -1824,6 +1824,16 @@ const LoadableTypeInfo &TypeConverter::getEmptyTypeInfo() {
   return *EmptyTI;
 }
 
+const TypeInfo &
+TypeConverter::getDynamicTupleTypeInfo(IsCopyable_t isCopyable) {
+  auto &cache = DynamicTupleTI[(unsigned)isCopyable];
+  if (cache) return *cache;
+  cache = convertDynamicTupleType(isCopyable);
+  cache->NextConverted = FirstType;
+  FirstType = cache;
+  return *cache;
+}
+
 const TypeInfo &
 TypeConverter::getResilientStructTypeInfo(IsCopyable_t isCopyable,
                                           IsABIAccessible_t isAccessible) {

lib/IRGen/GenType.h

@@ -123,6 +123,8 @@ class TypeConverter {
     {nullptr, nullptr},
     {nullptr, nullptr},
   };
+
+  const TypeInfo *DynamicTupleTI[2] = {nullptr, nullptr};
 
   llvm::DenseMap<std::pair<unsigned, unsigned>, const LoadableTypeInfo *>
     OpaqueStorageTypes;
@@ -177,6 +179,7 @@ class TypeConverter {
   const LoadableTypeInfo *convertBuiltinBridgeObject();
   const TypeInfo *convertResilientStruct(IsCopyable_t copyable,
                                          IsABIAccessible_t abiAccessible);
+  const TypeInfo *convertDynamicTupleType(IsCopyable_t copyable);
 #define REF_STORAGE(Name, ...) \
   const TypeInfo *convert##Name##StorageType(Name##StorageType *T);
 #include "swift/AST/ReferenceStorage.def"
@@ -210,6 +213,7 @@ class TypeConverter {
   const LoadableTypeInfo &getIntegerLiteralTypeInfo();
   const TypeInfo &getResilientStructTypeInfo(IsCopyable_t copyable,
                                              IsABIAccessible_t abiAccessible);
+  const TypeInfo &getDynamicTupleTypeInfo(IsCopyable_t isCopyable);
   const ProtocolInfo &getProtocolInfo(ProtocolDecl *P, ProtocolInfoKind kind);
   const LoadableTypeInfo &getOpaqueStorageTypeInfo(Size storageSize,
                                                    Alignment storageAlign);

lib/IRGen/MetadataRequest.cpp

@@ -3198,7 +3198,7 @@ class EmitTypeMetadataRefForLayout
   }
 
   CanType visitPackExpansionType(CanPackExpansionType ty) {
-    llvm_unreachable("");
+    return ty;
   }
 
   CanType visitTupleType(CanTupleType ty) {
@@ -3533,6 +3533,10 @@ namespace {
 
     llvm::Value *visitTupleType(CanTupleType type,
                                 DynamicMetadataRequest request) {
+      // Tuples containing pack expansion types are completely dynamic.
+      if (type->containsPackExpansionType())
+        return emitFromTypeMetadata(type, request);
+
       // Single-element tuples have exactly the same layout as their elements.
       if (type->getNumElements() == 1) {
         return visit(type.getElementType(0), request);

lib/IRGen/ResilientTypeInfo.h

@@ -20,6 +20,7 @@
 #define SWIFT_IRGEN_RESILIENTTYPEINFO_H
 
 #include "NonFixedTypeInfo.h"
+#include "Outlining.h"
 
 namespace swift {
 namespace irgen {