Merge pull request #64199 from slavapestov/nfc-variadic-generic-types-work

IRGen: Preliminary refactoring to support dynamic layout of variadic generic types

Author: slavapestov

include/swift/AST/Types.h

@@ -6355,8 +6355,6 @@ class PackArchetypeType final
     return T->getKind() == TypeKind::PackArchetype;
   }
 
-  CanTypeWrapper<PackType> getSingletonPackType();
-
 private:
   PackArchetypeType(const ASTContext &Ctx, GenericEnvironment *GenericEnv,
                     Type InterfaceType, ArrayRef<ProtocolDecl *> ConformsTo,
@@ -6831,6 +6829,9 @@ BEGIN_CAN_TYPE_WRAPPER(PackType, Type)
   static CanPackType get(const ASTContext &ctx, ArrayRef<CanType> elements);
   static CanPackType get(const ASTContext &ctx, CanTupleEltTypeArrayRef elts);
 
+  static CanTypeWrapper<PackType>
+  getSingletonPackExpansion(CanType packParameter);
+
   CanType getElementType(unsigned elementNo) const {
     return CanType(getPointer()->getElementType(elementNo));
   }

lib/AST/ASTContext.cpp

@@ -3293,11 +3293,6 @@ PackType *PackType::getEmpty(const ASTContext &C) {
   return cast<PackType>(CanType(C.TheEmptyPackType));
 }
 
-PackType *PackType::getSingletonPackExpansion(Type param) {
-  assert(param->isParameterPack() || param->is<PackArchetypeType>());
-  return get(param->getASTContext(), {PackExpansionType::get(param, param)});
-}
-
 CanPackType CanPackType::get(const ASTContext &C, ArrayRef<CanType> elements) {
   SmallVector<Type, 8> ncElements(elements.begin(), elements.end());
   return CanPackType(PackType::get(C, ncElements));

lib/AST/ParameterPack.cpp

@@ -460,10 +460,13 @@ PackType *PackType::get(const ASTContext &C,
   return get(C, wrappedArgs)->flattenPackTypes();
 }
 
-CanPackType PackArchetypeType::getSingletonPackType() {
-  SmallVector<Type, 1> types;
-  types.push_back(PackExpansionType::get(this, getReducedShape()));
-  return CanPackType(PackType::get(getASTContext(), types));
+PackType *PackType::getSingletonPackExpansion(Type param) {
+  assert(param->isParameterPack() || param->is<PackArchetypeType>());
+  return get(param->getASTContext(), {PackExpansionType::get(param, param)});
+}
+
+CanPackType CanPackType::getSingletonPackExpansion(CanType param) {
+  return CanPackType(PackType::getSingletonPackExpansion(param));
 }
 
 bool SILPackType::containsPackExpansionType() const {

lib/AST/RequirementMachine/RuleBuilder.cpp

@@ -444,8 +444,8 @@ void RuleBuilder::addReferencedProtocol(const ProtocolDecl *proto) {
 }
 
 /// Compute the transitive closure of the set of all protocols referenced from
-/// the right hand sides of conformance requirements, and convert their
-/// requirements to rewrite rules.
+/// the right hand sides of conformance requirements, and import the rewrite
+/// rules from the requirement machine for each protocol component.
 void RuleBuilder::collectRulesFromReferencedProtocols() {
   // Compute the transitive closure.
   unsigned i = 0;
@@ -462,12 +462,9 @@ void RuleBuilder::collectRulesFromReferencedProtocols() {
   // if this is a rewrite system for a connected component of the protocol
   // dependency graph, add rewrite rules for each referenced protocol not part
   // of this connected component.
-
-  // First, collect all unique requirement machines, one for each connected
-  // component of each referenced protocol.
   llvm::DenseSet<RequirementMachine *> machines;
 
-  // Now visit each subordinate requirement machine pull in its rules.
+  // Now visit each protocol component requirement machine and pull in its rules.
   for (auto *proto : ProtocolsToImport) {
     // This will trigger requirement signature computation for this protocol,
     // if necessary, which will cause us to re-enter into a new RuleBuilder
@@ -478,13 +475,13 @@ void RuleBuilder::collectRulesFromReferencedProtocols() {
 
     auto *machine = Context.getRequirementMachine(proto);
     if (!machines.insert(machine).second) {
-      // We've already seen this connected component.
+      // We've already seen this protocol component.
       continue;
     }
 
     // We grab the machine's local rules, not *all* of its rules, to avoid
     // duplicates in case multiple machines share a dependency on a downstream
-    // protocol connected component.
+    // protocol component.
     auto localRules = machine->getLocalRules();
     ImportedRules.insert(ImportedRules.end(),
                          localRules.begin(),

lib/IRGen/Fulfillment.h

@@ -37,10 +37,10 @@ struct Fulfillment {
     : SourceIndex(sourceIndex), State(unsigned(state)), Path(std::move(path)) {}
 
   /// The source index.
-  unsigned SourceIndex : 30;
+  uint64_t SourceIndex : 56;
 
   /// The state of the metadata at the fulfillment.
-  unsigned State : 2;
+  uint64_t State : 8;
 
   /// The path from the source metadata.
   MetadataPath Path;

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;
@@ -176,7 +177,7 @@ irgen::emitPackArchetypeMetadataRef(IRGenFunction &IGF,
   if (auto result = IGF.tryGetLocalTypeMetadata(type, request))
     return result;
 
-  auto packType = type->getSingletonPackType();
+  auto packType = CanPackType::getSingletonPackExpansion(type);
   auto response = emitTypeMetadataPackRef(IGF, packType, request);
 
   IGF.setScopedLocalTypeMetadata(type, response);
@@ -216,8 +217,13 @@ static llvm::Value *bindMetadataAtIndex(IRGenFunction &IGF,
   if (auto response = IGF.tryGetLocalTypeMetadata(elementArchetype, request))
     return response.getMetadata();
 
+  // If the pack is on the heap, the LSB is set, so mask it off.
   patternPack =
-      IGF.Builder.CreatePointerCast(patternPack, IGF.IGM.TypeMetadataPtrPtrTy);
+      IGF.Builder.CreatePtrToInt(patternPack, IGF.IGM.SizeTy);
+  patternPack =
+      IGF.Builder.CreateAnd(patternPack, llvm::ConstantInt::get(IGF.IGM.SizeTy, -2));
+  patternPack =
+      IGF.Builder.CreateIntToPtr(patternPack, IGF.IGM.TypeMetadataPtrPtrTy);
 
   Address patternPackAddress(patternPack, IGF.IGM.TypeMetadataPtrTy,
                              IGF.IGM.getPointerAlignment());
@@ -244,8 +250,14 @@ static llvm::Value *bindWitnessTableAtIndex(IRGenFunction &IGF,
   auto key = LocalTypeDataKind::forProtocolWitnessTable(conf);
   if (auto *wtable = IGF.tryGetLocalTypeData(elementArchetype, key))
     return wtable;
+
+  // If the pack is on the heap, the LSB is set, so mask it off.
+  wtablePack =
+      IGF.Builder.CreatePtrToInt(wtablePack, IGF.IGM.SizeTy);
+  wtablePack =
+      IGF.Builder.CreateAnd(wtablePack, llvm::ConstantInt::get(IGF.IGM.SizeTy, -2));
   wtablePack =
-      IGF.Builder.CreatePointerCast(wtablePack, IGF.IGM.WitnessTablePtrPtrTy);
+      IGF.Builder.CreateIntToPtr(wtablePack, IGF.IGM.WitnessTablePtrPtrTy);
 
   Address patternPackAddress(wtablePack, IGF.IGM.WitnessTablePtrTy,
                              IGF.IGM.getPointerAlignment());

lib/IRGen/GenRecord.h

@@ -542,7 +542,6 @@ class RecordTypeInfo<Impl, Base, FieldImpl,
   }
 
 private:
-  /// Scan the given field info
   static unsigned findUniqueNonEmptyField(ArrayRef<FieldImpl> fields) {
     unsigned result = 0;
     for (auto &field : fields) {

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);