[IRGen] Bind wtables at open_pack_element.

lib/IRGen/GenArchetype.cpp

@@ -260,6 +260,7 @@ llvm::Value *irgen::emitArchetypeWitnessTableRef(IRGenFunction &IGF,
                                        /*request*/ MetadataState::Complete,
                                        nullptr).getMetadata();
 
+  IGF.setScopedLocalTypeData(archetype, localDataKind, wtable);
   return wtable;
 }
 

lib/IRGen/GenPack.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/Types.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
@@ -50,15 +51,26 @@ emitTypeMetadataPackRef(IRGenFunction &IGF,
                         CanPackType packType,
                         DynamicMetadataRequest request);
 
-llvm::Value *emitTypeMetadataPackElementRef(IRGenFunction &IGF,
-                                            CanPackType packType,
-                                            llvm::Value *index,
-                                            DynamicMetadataRequest request);
+llvm::Value *
+emitTypeMetadataPackElementRef(IRGenFunction &IGF, CanPackType packType,
+                               ArrayRef<ProtocolDecl *> protocols,
+                               llvm::Value *index,
+                               DynamicMetadataRequest request,
+                               llvm::SmallVectorImpl<llvm::Value *> &wtables);
 
 void cleanupTypeMetadataPack(IRGenFunction &IGF,
                              StackAddress pack,
                              Optional<unsigned> elementCount);
 
+StackAddress emitWitnessTablePack(IRGenFunction &IGF, CanPackType packType,
+                                  PackConformance *conformance);
+
+llvm::Value *emitWitnessTablePackRef(IRGenFunction &IGF, CanPackType packType,
+                                     PackConformance *conformance);
+
+void cleanupWitnessTablePack(IRGenFunction &IGF, StackAddress pack,
+                             Optional<unsigned> elementCount);
+
 /// Emit the dynamic index of a particular structural component
 /// of the given pack type.  If the component is a pack expansion, this
 /// is the index of the first element of the pack (or where it would be
@@ -70,4 +82,4 @@ llvm::Value *emitIndexOfStructuralPackComponent(IRGenFunction &IGF,
 } // end namespace irgen
 } // end namespace swift
 
-#endif
+#endif

lib/IRGen/GenProto.cpp

@@ -68,6 +68,7 @@
 #include "GenHeap.h"
 #include "GenMeta.h"
 #include "GenOpaque.h"
+#include "GenPack.h"
 #include "GenPointerAuth.h"
 #include "GenPoly.h"
 #include "GenType.h"
@@ -3250,6 +3251,9 @@ llvm::Value *irgen::emitWitnessTableRef(IRGenFunction &IGF,
   // conformance info for them.  However, that conformance info might be
   // more concrete than we're expecting.
   // TODO: make a best effort to devirtualize, maybe?
+  } else if (conformance.isPack()) {
+    auto pack = cast<PackType>(srcType);
+    return emitWitnessTablePackRef(IGF, pack, conformance.getPack());
   } else {
     concreteConformance = conformance.getConcrete();
   }

lib/IRGen/IRGenSIL.cpp

@@ -6876,10 +6876,13 @@ void IRGenSILFunction::visitOpenPackElementInst(swift::OpenPackElementInst *i) {
 
   i->getOpenedGenericEnvironment()->forEachPackElementBinding(
       [&](auto *archetype, auto *pack) {
+        auto protocols = archetype->getConformsTo();
+        llvm::SmallVector<llvm::Value *, 2> wtables;
         auto *metadata = emitTypeMetadataPackElementRef(
-            *this, CanPackType(pack), index, MetadataState::Complete);
-        this->bindArchetype(CanElementArchetypeType(archetype), metadata,
-                            MetadataState::Complete, {});
+            *this, CanPackType(pack), protocols, index, MetadataState::Complete,
+            wtables);
+        bindArchetype(CanElementArchetypeType(archetype), metadata,
+                      MetadataState::Complete, wtables);
       });
 
   // The result is just used for type dependencies.

lib/IRGen/LocalTypeData.cpp

@@ -25,6 +25,7 @@
 #include "IRGenModule.h"
 #include "MetadataRequest.h"
 #include "swift/AST/IRGenOptions.h"
+#include "swift/AST/PackConformance.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/SIL/SILModule.h"
 
@@ -705,12 +706,20 @@ void LocalTypeDataKind::print(llvm::raw_ostream &out) const {
     out << "AbstractConformance("
         << getAbstractProtocolConformance()->getName()
         << ")";
+  } else if (isPackProtocolConformance()) {
+    out << "PackConformance("
+        << getPackProtocolConformance()->getType()
+        << ":"
+        << getPackProtocolConformance()->getProtocol()->getName()
+        << ")";
   } else if (Value == FormalTypeMetadata) {
     out << "FormalTypeMetadata";
   } else if (Value == RepresentationTypeMetadata) {
     out << "RepresentationTypeMetadata";
   } else if (Value == ValueWitnessTable) {
     out << "ValueWitnessTable";
+  } else if (Value == Shape) {
+    out << "Shape";
   } else {
     assert(isSingletonKind());
     if (Value >= ValueWitnessDiscriminatorBase) {

lib/IRGen/LocalTypeDataKind.h

@@ -59,9 +59,10 @@ class LocalTypeDataKind {
     ValueWitnessDiscriminatorBase = ValueWitnessBase + MaxNumValueWitnesses,
 
     FirstPayloadValue = 2048,
-    Kind_Decl = 0,
-    Kind_Conformance = 1,
-    KindMask = 0x1,
+    Kind_Decl = 0b0,
+    Kind_Conformance = 0b1,
+    Kind_PackConformance = 0b10,
+    KindMask = 0b11,
   };
 
 public:
@@ -119,10 +120,17 @@ class LocalTypeDataKind {
     return LocalTypeDataKind(uintptr_t(conformance) | Kind_Conformance);
   }
 
+  static LocalTypeDataKind forProtocolWitnessTablePack(PackConformance *pack) {
+    assert(pack && "pack conformance reference may not be null");
+    return LocalTypeDataKind(uintptr_t(pack) | Kind_PackConformance);
+  }
+
   static LocalTypeDataKind
   forProtocolWitnessTable(ProtocolConformanceRef conformance) {
     if (conformance.isConcrete()) {
       return forConcreteProtocolWitnessTable(conformance.getConcrete());
+    } else if (conformance.isPack()) {
+      return forProtocolWitnessTablePack(conformance.getPack());
     } else {
       return forAbstractProtocolWitnessTable(conformance.getAbstract());
     }
@@ -159,11 +167,24 @@ class LocalTypeDataKind {
     return reinterpret_cast<ProtocolDecl*>(Value - Kind_Decl);
   }
 
+  bool isPackProtocolConformance() const {
+    return (!isSingletonKind() &&
+            ((Value & KindMask) == Kind_PackConformance));
+  }
+
+  PackConformance *getPackProtocolConformance() const {
+    assert(isPackProtocolConformance());
+    return reinterpret_cast<PackConformance*>(Value - Kind_PackConformance);
+  }
+
   ProtocolConformanceRef getProtocolConformance() const {
     assert(!isSingletonKind());
     if ((Value & KindMask) == Kind_Decl) {
       return ProtocolConformanceRef(getAbstractProtocolConformance());
+    } else if ((Value & KindMask) == Kind_PackConformance) {
+      return ProtocolConformanceRef(getPackProtocolConformance());
     } else {
+      assert((Value & KindMask) == Kind_Conformance);
       return ProtocolConformanceRef(getConcreteProtocolConformance());
     }
   }