IRGen: Capture NecessaryBindings in fixed boxes that may invoke deinits.

Noncopyable types may have user-defined code in their `deinit`s that requires
passing the type's generic parameters, so a box for a captured noncopyable type
needs to capture the generic environment even when the captured type is fixed-
layout. Fixes rdar://138958210.

Author: jckarter

lib/IRGen/GenHeap.cpp

@@ -568,8 +568,10 @@ llvm::Value *IRGenFunction::emitUnmanagedAlloc(const HeapLayout &layout,
                                                const llvm::Twine &name,
                                            llvm::Constant *captureDescriptor,
                                            const HeapNonFixedOffsets *offsets) {
-  if (layout.isKnownEmpty())
+  if (layout.isKnownEmpty()
+      && layout.isTriviallyDestroyable()) {
     return IGM.RefCountedNull;
+  }
 
   llvm::Value *metadata = layout.getPrivateMetadata(IGM, captureDescriptor);
   llvm::Value *size, *alignMask;
@@ -1470,7 +1472,7 @@ class BoxTypeInfo : public HeapTypeInfo<BoxTypeInfo> {
 
   /// Allocate a box of the given type.
   virtual OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType, GenericEnvironment *env,
+  allocate(IRGenFunction &IGF, GenericEnvironment *env, SILBoxType *box,
            const llvm::Twine &name) const = 0;
 
   /// Deallocate an uninitialized box.
@@ -1488,8 +1490,11 @@ class EmptyBoxTypeInfo final : public BoxTypeInfo {
   EmptyBoxTypeInfo(IRGenModule &IGM) : BoxTypeInfo(IGM) {}
 
   OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType, GenericEnvironment *env,
+  allocate(IRGenFunction &IGF, GenericEnvironment *env, SILBoxType *box,
            const llvm::Twine &name) const override {
+    auto boxedType = getSILBoxFieldType(
+          IGF.IGM.getMaximalTypeExpansionContext(),
+          box, IGF.IGM.getSILModule().Types, 0);
     return OwnedAddress(IGF.getTypeInfo(boxedType).getUndefAddress(),
                         IGF.emitAllocEmptyBoxCall());
   }
@@ -1513,8 +1518,11 @@ class NonFixedBoxTypeInfo final : public BoxTypeInfo {
   NonFixedBoxTypeInfo(IRGenModule &IGM) : BoxTypeInfo(IGM) {}
 
   OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType, GenericEnvironment *env,
+  allocate(IRGenFunction &IGF, GenericEnvironment *env, SILBoxType *boxType,
            const llvm::Twine &name) const override {
+    auto boxedType = getSILBoxFieldType(
+          IGF.IGM.getMaximalTypeExpansionContext(),
+          boxType, IGF.IGM.getSILModule().Types, 0);
     auto &ti = IGF.getTypeInfo(boxedType);
     // Use the runtime to allocate a box of the appropriate size.
     auto metadata = IGF.emitTypeMetadataRefForLayout(boxedType);
@@ -1552,14 +1560,18 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
   FixedBoxTypeInfoBase(IRGenModule &IGM, HeapLayout &&layout)
     : BoxTypeInfo(IGM), layout(std::move(layout))
   {
-    // Empty layouts should always use EmptyBoxTypeInfo instead
-    assert(!layout.isKnownEmpty());
+    // Trivial empty layouts should always use EmptyBoxTypeInfo instead
+    assert(!layout.isKnownEmpty()
+           || !layout.isTriviallyDestroyable());
   }
 
   OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType, GenericEnvironment *env,
+  allocate(IRGenFunction &IGF, GenericEnvironment *env, SILBoxType *box,
            const llvm::Twine &name)
   const override {
+    auto boxedType = getSILBoxFieldType(
+          IGF.IGM.getMaximalTypeExpansionContext(),
+          box, IGF.IGM.getSILModule().Types, 0);
     // Allocate a new object using the layout.
     auto boxedInterfaceType = boxedType;
     if (env) {
@@ -1581,13 +1593,21 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
       boxedInterfaceType = SILType::getPrimitiveType(
           astType, boxedInterfaceType.getCategory());
     }
-
+    
     auto boxDescriptor = IGF.IGM.getAddrOfBoxDescriptor(
         boxedInterfaceType,
         env ? env->getGenericSignature().getCanonicalSignature()
             : CanGenericSignature());
     llvm::Value *allocation = IGF.emitUnmanagedAlloc(layout, name,
                                                      boxDescriptor);
+    // Store metadata for the necessary bindings if present.
+    if (layout.hasBindings()) {
+      auto allocationAddr = layout.emitCastTo(IGF, allocation);
+      auto bindingsAddr = layout.getElement(layout.getBindingsIndex())
+        .project(IGF, allocationAddr, nullptr);
+      layout.getBindings().save(IGF, bindingsAddr, box->getSubstitutions());
+    }
+
     Address rawAddr = project(IGF, allocation, boxedType);
     return {rawAddr, allocation};
   }
@@ -1637,22 +1657,87 @@ class SingleRefcountedBoxTypeInfo final : public FixedBoxTypeInfoBase {
 
 /// Implementation of a box for a specific type.
 class FixedBoxTypeInfo final : public FixedBoxTypeInfoBase {
+  static SILType getFieldType(IRGenModule &IGM, SILBoxType *T) {
+    return getSILBoxFieldType(IGM.getMaximalTypeExpansionContext(),
+                              T, IGM.getSILModule().Types, 0);
+  }
+  
+  static HeapLayout getHeapLayout(IRGenModule &IGM, SILBoxType *T) {
+    SmallVector<SILType> fieldTypes;
+    fieldTypes.push_back(getFieldType(IGM, T));
+    
+    auto bindings = NecessaryBindings::forFixedBox(IGM, T);
+    unsigned bindingsIndex = 0;
+    SmallVector<const TypeInfo *, 4> fields;
+    fields.push_back(&IGM.getTypeInfo(fieldTypes[0]));
+    
+    if (!bindings.empty()) {
+      bindingsIndex = 1;
+      auto bindingsSize = bindings.getBufferSize(IGM);
+      auto &bindingsTI = IGM.getOpaqueStorageTypeInfo(bindingsSize,
+                                                    IGM.getPointerAlignment());
+      fieldTypes.push_back(SILType());
+      fields.push_back(&bindingsTI);
+    }
+    
+    return HeapLayout(IGM, LayoutStrategy::Optimal,
+                      fieldTypes, fields,
+                      /* type to fill */ nullptr,
+                      std::move(bindings), bindingsIndex);
+  }
+
 public:
-  FixedBoxTypeInfo(IRGenModule &IGM, SILType T)
-    : FixedBoxTypeInfoBase(IGM,
-       HeapLayout(IGM, LayoutStrategy::Optimal, T, &IGM.getTypeInfo(T)))
+  FixedBoxTypeInfo(IRGenModule &IGM, SILBoxType *T)
+    : FixedBoxTypeInfoBase(IGM, getHeapLayout(IGM, T))
   {}
 };
 
 } // end anonymous namespace
 
+NecessaryBindings
+NecessaryBindings::forFixedBox(IRGenModule &IGM, SILBoxType *box) {
+  // Don't need to bind metadata if the type is concrete.
+  if (!box->hasArchetype() && !box->hasTypeParameter()) {
+    return {};
+  }
+
+  auto fieldTy = getSILBoxFieldType(IGM.getMaximalTypeExpansionContext(),
+                                    box, IGM.getSILModule().Types, 0);
+  auto fieldTI = cast<FixedTypeInfo>(&IGM.getTypeInfo(fieldTy));
+
+  // If the type is trivially destroyable, or it's fixed-layout and copyable,
+  // then we can always destroy it without binding type metadata.
+  if (fieldTI->isTriviallyDestroyable(ResilienceExpansion::Maximal)
+      || fieldTI->isCopyable(ResilienceExpansion::Maximal)) {
+    return {};
+  }
+
+  NecessaryBindings bindings(box->getSubstitutions(),
+                             /*no escape*/ false);
+
+  // Collect bindings needed by a deinit-shaped function.
+  auto deinitParam = SILParameterInfo(
+    box->getLayout()->getFields()[0].getLoweredType(),
+    ParameterConvention::Indirect_In);
+  auto deinitFnTy = SILFunctionType::get(box->getLayout()->getGenericSignature(),
+                                         SILExtInfo(),
+                                         SILCoroutineKind::None,
+                                         ParameterConvention::Direct_Guaranteed,
+                                         deinitParam,
+                                         {}, {}, std::nullopt,
+                                         {}, {}, IGM.Context);
+  bindings.computeBindings(IGM, deinitFnTy, /*consider param sources*/ false);
+  return bindings;
+}
+
 const TypeInfo *TypeConverter::convertBoxType(SILBoxType *T) {
   // We can share a type info for all dynamic-sized heap metadata.
   // TODO: Multi-field boxes
   assert(T->getLayout()->getFields().size() == 1
          && "multi-field boxes not implemented yet");
-  auto &eltTI = IGM.getTypeInfoForLowered(getSILBoxFieldLoweredType(
-      IGM.getMaximalTypeExpansionContext(), T, IGM.getSILModule().Types, 0));
+  auto eltTy = getSILBoxFieldLoweredType(
+    IGM.getMaximalTypeExpansionContext(), T, IGM.getSILModule().Types, 0);
+  auto &eltTI = IGM.getTypeInfoForLowered(eltTy);
   if (!eltTI.isFixedSize()) {
     if (!NonFixedBoxTI)
       NonFixedBoxTI = new NonFixedBoxTypeInfo(IGM);
@@ -1662,12 +1747,16 @@ const TypeInfo *TypeConverter::convertBoxType(SILBoxType *T) {
   // For fixed-sized types, we can emit concrete box metadata.
   auto &fixedTI = cast<FixedTypeInfo>(eltTI);
 
-  // Because we assume in enum's that payloads with a Builtin.NativeReference
+  // Because we assume in enums that payloads with a Builtin.NativeReference
   // which is also the type for indirect enum cases have extra inhabitants of
   // pointers we can't have a nil pointer as a representation for an empty box
   // type -- nil conflicts with the extra inhabitants. We return a static
   // singleton empty box object instead.
-  if (fixedTI.isKnownEmpty(ResilienceExpansion::Maximal)) {
+  //
+  // (If the box needs no storage, but the type still carries a deinit,
+  // then we still need to trigger that deinit when the box is freed.)
+  if (fixedTI.isKnownEmpty(ResilienceExpansion::Maximal)
+      && fixedTI.isTriviallyDestroyable(ResilienceExpansion::Maximal)) {
     if (!EmptyBoxTI)
       EmptyBoxTI = new EmptyBoxTypeInfo(IGM);
     return EmptyBoxTI;
@@ -1701,9 +1790,8 @@ const TypeInfo *TypeConverter::convertBoxType(SILBoxType *T) {
   // Produce a tailored box metadata for the type.
   assert(T->getLayout()->getFields().size() == 1
          && "multi-field boxes not implemented yet");
-  return new FixedBoxTypeInfo(
-      IGM, getSILBoxFieldType(IGM.getMaximalTypeExpansionContext(),
-                              T, IGM.getSILModule().Types, 0));
+  
+  return new FixedBoxTypeInfo(IGM, T);
 }
 
 OwnedAddress
@@ -1713,12 +1801,7 @@ irgen::emitAllocateBox(IRGenFunction &IGF, CanSILBoxType boxType,
   auto &boxTI = IGF.getTypeInfoForLowered(boxType).as<BoxTypeInfo>();
   assert(boxType->getLayout()->getFields().size() == 1
          && "multi-field boxes not implemented yet");
-  return boxTI.allocate(
-      IGF,
-      getSILBoxFieldType(
-          IGF.IGM.getMaximalTypeExpansionContext(),
-          boxType, IGF.IGM.getSILModule().Types, 0),
-      env, name);
+  return boxTI.allocate(IGF, env, boxType, name);
 }
 
 void irgen::emitDeallocateBox(IRGenFunction &IGF,
@@ -1751,7 +1834,7 @@ Address irgen::emitAllocateExistentialBoxInBuffer(
   // Get a box for the boxed value.
   auto boxType = SILBoxType::get(boxedType.getASTType());
   auto &boxTI = IGF.getTypeInfoForLowered(boxType).as<BoxTypeInfo>();
-  OwnedAddress owned = boxTI.allocate(IGF, boxedType, env, name);
+  OwnedAddress owned = boxTI.allocate(IGF, env, boxType, name);
   Explosion box;
   box.add(owned.getOwner());
   boxTI.initialize(IGF, box,

lib/IRGen/GenProto.cpp

@@ -3648,9 +3648,13 @@ void NecessaryBindings::restore(IRGenFunction &IGF, Address buffer,
                                     metadataState, SubMap);
 }
 
-void NecessaryBindings::save(IRGenFunction &IGF, Address buffer) const {
+void NecessaryBindings::save(IRGenFunction &IGF, Address buffer,
+                std::optional<SubstitutionMap> replacementSubstitutions) const {
+  SubstitutionMap subsToPass = replacementSubstitutions.has_value()
+    ? replacementSubstitutions.value()
+    : SubMap;
   emitInitOfGenericRequirementsBuffer(IGF, getRequirements(), buffer,
-                                      MetadataState::Complete, SubMap,
+                                      MetadataState::Complete, subsToPass,
                                       /*onHeapPacks=*/!NoEscape);
 }
 

lib/IRGen/NecessaryBindings.h

@@ -63,6 +63,11 @@ class NecessaryBindings {
                                                     bool noEscape,
                                                     bool considerParameterSources);
 
+  /// Collect the necessary bindings to be able to destroy a value inside of a
+  /// fixed-layout boxed allocation.
+  static NecessaryBindings forFixedBox(IRGenModule &IGM,
+                                       SILBoxType *box);
+
   void addRequirement(GenericRequirement requirement) {
     auto type = requirement.getTypeParameter().subst(SubMap);
     if (!type->hasArchetype())
@@ -86,7 +91,12 @@ class NecessaryBindings {
   Size getBufferSize(IRGenModule &IGM) const;
 
   /// Save the necessary bindings to the given buffer.
-  void save(IRGenFunction &IGF, Address buffer) const;
+  ///
+  /// If `replacementSubs` has a value, then the bindings saved are taken from
+  /// the given substitution map instead of the substitutions
+  void save(IRGenFunction &IGF, Address buffer,
+            std::optional<SubstitutionMap> replacementSubs = std::nullopt)
+            const;
 
   /// Restore the necessary bindings from the given buffer.
   void restore(IRGenFunction &IGF, Address buffer, MetadataState state) const;

lib/IRGen/StructLayout.cpp

@@ -190,23 +190,32 @@ StructLayout::StructLayout(IRGenModule &IGM, std::optional<CanType> type,
       Ty = (typeToFill ? typeToFill : IGM.OpaqueTy);
     }
   } else {
+    // A heap object containing an empty but non-trivially-destroyable
+    // noncopyable type needs to exist in order to run deinits when the
     bool nonEmpty = builder.addFields(Elements, strategy);
 
+    IsKnownTriviallyDestroyable
+      = triviallyDestroyable & builder.isTriviallyDestroyable();
+    IsKnownCopyable = copyable & builder.isCopyable();
+
     // Special-case: there's nothing to store.
     // In this case, produce an opaque type;  this tends to cause lovely
     // assertions.
-    if (!nonEmpty) {
+    //
+    // If a heap object contains an empty but non-trivially-destroyable type,
+    // then we still want to create a non-empty heap object, since the heap
+    // object's destructor will run deinits for the value.
+    if (!nonEmpty
+        && (IsKnownTriviallyDestroyable || !requiresHeapHeader(layoutKind))) {
       assert(!builder.empty() == requiresHeapHeader(layoutKind));
       MinimumAlign = Alignment(1);
       MinimumSize = Size(0);
       headerSize = builder.getHeaderSize();
       SpareBits.clear();
       IsFixedLayout = true;
       IsLoadable = true;
-      IsKnownTriviallyDestroyable = triviallyDestroyable & builder.isTriviallyDestroyable();
       IsKnownBitwiseTakable = builder.isBitwiseTakable();
       IsKnownAlwaysFixedSize = builder.isAlwaysFixedSize();
-      IsKnownCopyable = copyable & builder.isCopyable();
       Ty = (typeToFill ? typeToFill : IGM.OpaqueTy);
     } else {
       MinimumAlign = builder.getAlignment();
@@ -215,10 +224,8 @@ StructLayout::StructLayout(IRGenModule &IGM, std::optional<CanType> type,
       SpareBits = builder.getSpareBits();
       IsFixedLayout = builder.isFixedLayout();
       IsLoadable = builder.isLoadable();
-      IsKnownTriviallyDestroyable = triviallyDestroyable & builder.isTriviallyDestroyable();
       IsKnownBitwiseTakable = bitwiseTakable & builder.isBitwiseTakable();
       IsKnownAlwaysFixedSize = builder.isAlwaysFixedSize();
-      IsKnownCopyable = copyable & builder.isCopyable();
       if (typeToFill) {
         builder.setAsBodyOfStruct(typeToFill);
         Ty = typeToFill;