consider parameter sources for partial_apply with non fixed layout only

Author: meg-gupta

lib/IRGen/GenFunc.cpp

@@ -1309,9 +1309,21 @@ Optional<StackAddress> irgen::emitFunctionPartialApplication(
   SmallVector<SILType, 4> argValTypes;
   SmallVector<ParameterConvention, 4> argConventions;
 
+  bool considerParameterSources = true;
+  for (auto param : params) {
+    SILType argType = IGF.IGM.silConv.getSILType(param, origType);
+    auto argLoweringTy = getArgumentLoweringType(argType.getASTType(), param);
+    auto &ti = IGF.getTypeInfoForLowered(argLoweringTy);
+
+    if (!isa<FixedTypeInfo>(ti)) {
+      considerParameterSources = false;
+      break;
+    }
+  }
+
   // Reserve space for polymorphic bindings.
   auto bindings =
-      NecessaryBindings::forPartialApplyForwarder(IGF.IGM, origType, subs);
+      NecessaryBindings::forPartialApplyForwarder(IGF.IGM, origType, subs, considerParameterSources);
 
   if (!bindings.empty()) {
     hasSingleSwiftRefcountedContext = No;

lib/IRGen/GenProto.cpp

@@ -100,7 +100,7 @@ class PolymorphicConvention {
 
   FulfillmentMap Fulfillments;
 
-  bool ForPartialApplyForwarder;
+  bool ConsiderParameterSources;
 
   GenericSignature::ConformsToArray getConformsTo(Type t) {
     return Generics->getConformsTo(t);
@@ -113,7 +113,7 @@ class PolymorphicConvention {
   }
 
 public:
-  PolymorphicConvention(IRGenModule &IGM, CanSILFunctionType fnType, bool forPartialApplyForwarder);
+  PolymorphicConvention(IRGenModule &IGM, CanSILFunctionType fnType, bool considerParameterSources);
 
   ArrayRef<MetadataSource> getSources() const { return Sources; }
 
@@ -181,9 +181,9 @@ class PolymorphicConvention {
 
 PolymorphicConvention::PolymorphicConvention(IRGenModule &IGM,
                                              CanSILFunctionType fnType,
-                                             bool forPartialApplyForwarder = false)
+                                             bool considerParameterSources = true)
   : IGM(IGM), M(*IGM.getSwiftModule()), FnType(fnType),
-    ForPartialApplyForwarder(forPartialApplyForwarder) {
+    ConsiderParameterSources(considerParameterSources) {
   initGenerics();
 
   auto rep = fnType->getRepresentation();
@@ -221,10 +221,12 @@ PolymorphicConvention::PolymorphicConvention(IRGenModule &IGM,
       considerParameter(params[selfIndex], selfIndex, true);
     }
 
-      // Now consider the rest of the parameters.
-      for (auto index : indices(params)) {
-        if (index != selfIndex)
-          considerParameter(params[index], index, false);
+      if (ConsiderParameterSources) {
+        // Now consider the rest of the parameters.
+        for (auto index : indices(params)) {
+          if (index != selfIndex)
+            considerParameter(params[index], index, false);
+        }
       }
   }
 }
@@ -388,10 +390,10 @@ void PolymorphicConvention::considerParameter(SILParameterInfo param,
     case ParameterConvention::Direct_Owned:
     case ParameterConvention::Direct_Unowned:
     case ParameterConvention::Direct_Guaranteed:
-      // Don't consider ClassPointer source for partial_apply forwader.
+      // Don't consider ClassPointer source and Metadata source for partial_apply forwader with non fixed layout.
       // If not, we may end up with missing TypeMetadata for a type dependent generic parameter
       // while generating code for destructor of HeapLayout.
-      if (ForPartialApplyForwarder) return;
+      if (!ConsiderParameterSources) return;
       // Classes are sources of metadata.
       if (type->getClassOrBoundGenericClass()) {
         considerNewTypeSource(MetadataSource::Kind::ClassPointer,
@@ -2991,14 +2993,16 @@ NecessaryBindings::forFunctionInvocations(IRGenModule &IGM,
 NecessaryBindings
 NecessaryBindings::forPartialApplyForwarder(IRGenModule &IGM,
                                           CanSILFunctionType origType,
-                                          SubstitutionMap subs) {
+                                          SubstitutionMap subs,
+                                          bool considerParameterSources) {
   return computeBindings(IGM, origType, subs,
-                         true /*forPartialApplyForwarder*/);
+                         true  /*forPartialApplyForwarder*/,
+                         considerParameterSources);
 }
 
 NecessaryBindings NecessaryBindings::computeBindings(
     IRGenModule &IGM, CanSILFunctionType origType, SubstitutionMap subs,
-    bool forPartialApplyForwarder) {
+    bool forPartialApplyForwarder, bool considerParameterSources) {
 
   NecessaryBindings bindings;
   bindings.forPartialApply = forPartialApplyForwarder;
@@ -3008,7 +3012,7 @@ NecessaryBindings NecessaryBindings::computeBindings(
     return bindings;
 
   // Figure out what we're actually required to pass:
-  PolymorphicConvention convention(IGM, origType, forPartialApplyForwarder);
+  PolymorphicConvention convention(IGM, origType, considerParameterSources);
 
   //  - unfulfilled requirements
   convention.enumerateUnfulfilledRequirements(

lib/IRGen/NecessaryBindings.h

@@ -59,7 +59,8 @@ class NecessaryBindings {
                                                   SubstitutionMap subs);
   static NecessaryBindings forPartialApplyForwarder(IRGenModule &IGM,
                                                     CanSILFunctionType origType,
-                                                    SubstitutionMap subs);
+                                                    SubstitutionMap subs,
+                                                    bool considerParameterSources = true);
 
   /// Add whatever information is necessary to reconstruct type metadata
   /// for the given type.
@@ -98,7 +99,8 @@ class NecessaryBindings {
   static NecessaryBindings computeBindings(IRGenModule &IGM,
                                            CanSILFunctionType origType,
                                            SubstitutionMap subs,
-                                           bool forPartialApplyForwarder);
+                                           bool forPartialApplyForwarder,
+                                           bool considerParameterSources = true);
 };
 
 } // end namespace irgen