[IRGen] Metadata collector collects generic params

When collecting the metadata required for an outlined value function,
if the type on behalf of which metadata is being collected is a value
type with a deinit, include the generic arguments for that value type.
They will be needed by deinit which will be called within.

Author: nate-chandler

lib/IRGen/Outlining.cpp

@@ -45,6 +45,12 @@ void OutliningMetadataCollector::collectTypeMetadataForLayout(SILType type) {
   auto formalType = type.getASTType();
   auto &ti = IGF.IGM.getTypeInfoForLowered(formalType);
 
+  auto *nominal = type.getASTType()->getAnyNominal();
+  if (nominal && nominal->getValueTypeDestructor()) {
+    assert(type.isMoveOnly());
+    collectTypeMetadataForEnvironment(type);
+  }
+
   // We don't need the metadata for fixed size types or types that are not ABI
   // accessible. Outlining will call the value witness of the enclosing type of
   // non ABI accessible field/element types.
@@ -67,18 +73,24 @@ void OutliningMetadataCollector::collectTypeMetadataForLayout(SILType type) {
   Values.insert({key, metadata});
 }
 
-void OutliningMetadataCollector::collectFormalTypeMetadata(CanType type) {
-  // If the type has no archetypes, we can emit it from scratch in the callee.
-  assert(type->hasArchetype());
+void OutliningMetadataCollector::collectTypeMetadataForEnvironment(SILType ty) {
+  auto bgt = dyn_cast<BoundGenericType>(ty.getASTType());
+  if (!bgt) {
+    return;
+  }
+  for (auto arg : bgt.getGenericArgs()) {
+    collectFormalTypeMetadata(arg);
+  }
+}
 
+void OutliningMetadataCollector::collectFormalTypeMetadata(CanType type) {
   auto key = LocalTypeDataKey(type, LocalTypeDataKind::forFormalTypeMetadata());
   if (Values.count(key)) return;
 
   auto metadata = IGF.emitTypeMetadataRef(type);
   Values.insert({key, metadata});
 }
 
-
 void OutliningMetadataCollector::addMetadataArguments(
                                     SmallVectorImpl<llvm::Value*> &args) const {
   for (auto &pair : Values) {

lib/IRGen/Outlining.h

@@ -60,6 +60,7 @@ class OutliningMetadataCollector {
 
   void collectFormalTypeMetadata(CanType type);
   void collectTypeMetadataForLayout(SILType type);
+  void collectTypeMetadataForEnvironment(SILType ty);
 
   void emitCallToOutlinedCopy(Address dest, Address src,
                               SILType T, const TypeInfo &ti,

test/IRGen/moveonly_enum_deinits.swift

@@ -1,9 +1,49 @@
-// RUN: %target-swift-emit-irgen \
+// RUN: %target-swift-emit-irgen                             \
 // RUN:     -enable-experimental-feature NoncopyableGenerics \
-// RUN:     %s \
-// RUN: | \
+// RUN:     -disable-type-layout                             \
+// RUN:     %s                                               \
+// RUN: |                                                    \
 // RUN: %FileCheck %s
 
+struct FIFO<T>: ~Copyable {
+    private var data: UnsafeManualArray<T>
+
+    private(set) public var count: Int
+
+    private var head: Int
+
+    init(withCapacity: Int) {
+        self.head = 0
+        self.count = 0
+        self.data = .init(capacity: withCapacity)
+    }
+
+    deinit {
+    }
+}
+
+// Check that the outlined retain function has a parameter for the type's
+// generic parameter and that it's passed along to the deinit.
+// CHECK-LABEL: define{{.*}} ptr @"$s21moveonly_enum_deinits17UnsafeManualArrayVyxGlWOs"(
+// CHECK-SAME:      ptr %0, 
+// CHECK-SAME:      ptr %T)
+// CHECK-SAME:  {
+// CHECK:         call swiftcc void @"$s21moveonly_enum_deinits17UnsafeManualArrayVfD"(
+// CHECK-SAME:        ptr %T)
+// CHECK:       }
+struct UnsafeManualArray<T>: ~Copyable {
+    init(capacity: Int) {
+        self.data = .allocate(capacity: capacity)
+    }
+
+    deinit {
+    }
+
+    private let data: UnsafeMutableBufferPointer<T>
+
+    var elementAllocated: [Bool] = []
+}
+
 // CHECK-LABEL: define{{.*}} void @"$s21moveonly_enum_deinits4ListOwxx"(
 // CHECK-SAME:      ptr noalias %object, 
 // CHECK-SAME:      ptr %List)