GenericSpecializer: drop metatype arguments in specialized functions

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -58,17 +58,15 @@ private func optimize(function: Function, _ context: FunctionPassContext) {
     switch instruction {
     case let apply as FullApplySite:
       inlineAndDevirtualize(apply: apply, context, simplifyCtxt)
-    case let mt as MetatypeInst:
-      if mt.isTriviallyDeadIgnoringDebugUses {
-        simplifyCtxt.erase(instructionIncludingDebugUses: mt)
-      }
     default:
       break
     }
   }
 
   _ = context.specializeApplies(in: function, isMandatory: true)
 
+  removeUnusedMetatypeInstructions(in: function, context)
+
   // If this is a just specialized function, try to optimize copy_addr, etc.
   if context.optimizeMemoryAccesses(in: function) {
     _ = context.eliminateDeadAllocations(in: function)
@@ -103,6 +101,15 @@ private func inlineAndDevirtualize(apply: FullApplySite, _ context: FunctionPass
   }
 }
 
+private func removeUnusedMetatypeInstructions(in function: Function, _ context: FunctionPassContext) {
+  for inst in function.instructions {
+    if let mt = inst as? MetatypeInst,
+       mt.isTriviallyDeadIgnoringDebugUses {
+      context.erase(instructionIncludingDebugUses: mt)
+    }
+  }
+}
+
 private func shouldInline(apply: FullApplySite, callee: Function) -> Bool {
   if callee.isTransparent {
     return true

include/swift/SIL/GenericSpecializationMangler.h

@@ -88,7 +88,8 @@ class GenericSpecializationMangler : public SpecializationMangler {
       : SpecializationMangler(SpecializationPass::GenericSpecializer,
                               Serialized, F) {}
 
-  std::string mangleNotReabstracted(SubstitutionMap subs);
+  std::string mangleNotReabstracted(SubstitutionMap subs,
+                                    bool metatyeParamsRemoved);
 
   /// Mangle a generic specialization with re-abstracted parameters.
   ///

include/swift/SILOptimizer/Utils/Generics.h

@@ -157,10 +157,6 @@ class ReabstractionInfo {
     LoadableAndTrivial
   };
 
-  unsigned param2ArgIndex(unsigned ParamIdx) const  {
-    return ParamIdx + NumFormalIndirectResults;
-  }
-
   // Create a new substituted type with the updated signature.
   CanSILFunctionType createSubstitutedType(SILFunction *OrigF,
                                            SubstitutionMap SubstMap,
@@ -199,8 +195,8 @@ class ReabstractionInfo {
                     ApplySite Apply, SILFunction *Callee,
                     SubstitutionMap ParamSubs,
                     IsSerialized_t Serialized,
-                    bool ConvertIndirectToDirect = true,
-                    bool dropMetatypeArgs = false,
+                    bool ConvertIndirectToDirect,
+                    bool dropMetatypeArgs,
                     OptRemark::Emitter *ORE = nullptr);
 
   /// Constructs the ReabstractionInfo for generic function \p Callee with
@@ -214,7 +210,11 @@ class ReabstractionInfo {
   IsSerialized_t isSerialized() const {
     return Serialized;
   }
-
+
+  unsigned param2ArgIndex(unsigned ParamIdx) const  {
+    return ParamIdx + NumFormalIndirectResults;
+  }
+
   /// Returns true if the specialized function needs an alternative mangling.
   /// See hasConvertedResilientParams.
   bool needAlternativeMangling() const {
@@ -314,6 +314,8 @@ class ReabstractionInfo {
   CanSILFunctionType createSpecializedType(CanSILFunctionType SubstFTy,
                                            SILModule &M) const;
 
+  CanSILFunctionType createThunkType(PartialApplyInst *forPAI) const;
+
   SILFunction *getNonSpecializedFunction() const { return Callee; }
 
   /// Map type into a context of the specialized function.

lib/SIL/Utils/GenericSpecializationMangler.cpp

@@ -100,10 +100,15 @@ manglePrespecialized(GenericSignature sig, SubstitutionMap subs) {
 }
 
 std::string GenericSpecializationMangler::
-mangleNotReabstracted(SubstitutionMap subs) {
+mangleNotReabstracted(SubstitutionMap subs,
+                      bool metatyeParamsRemoved) {
   beginMangling();
   appendSubstitutions(getGenericSignature(), subs);
-  appendSpecializationOperator("TG");
+  if (metatyeParamsRemoved) {
+    appendSpecializationOperator("TGm");
+  } else {
+    appendSpecializationOperator("TG");
+  }
   return finalize();
 }
 

lib/SILOptimizer/IPO/CapturePropagation.cpp

@@ -492,7 +492,7 @@ static SILFunction *getSpecializedWithDeadParams(
         FuncBuilder.getModule().getSwiftModule(),
         FuncBuilder.getModule().isWholeModule(), ApplySite(), Specialized,
         PAI->getSubstitutionMap(), Specialized->isSerialized(),
-        /* ConvertIndirectToDirect */ false);
+        /* ConvertIndirectToDirect */ false, /*dropMetatypeArgs=*/ false);
     GenericFuncSpecializer FuncSpecializer(FuncBuilder,
                                            Specialized,
                                            ReInfo.getClonerParamSubstitutionMap(),

lib/SILOptimizer/IPO/UsePrespecialized.cpp

@@ -91,7 +91,9 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
       continue;
 
     ReabstractionInfo ReInfo(M.getSwiftModule(), M.isWholeModule(), AI,
-                             ReferencedF, Subs, IsNotSerialized);
+                             ReferencedF, Subs, IsNotSerialized,
+                             /*ConvertIndirectToDirect=*/ true,
+                             /*dropMetatypeArgs=*/ false);
 
     if (!ReInfo.canBeSpecialized())
       continue;

lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp

@@ -217,6 +217,8 @@ bool PerformanceDiagnostics::checkClosureValue(SILValue closure,
       closure = tfi->getOperand();
     } else if (auto *cp = dyn_cast<CopyValueInst>(closure)) {
       closure = cp->getOperand();
+    } else if (auto *cv = dyn_cast<ConvertFunctionInst>(closure)) {
+      closure = cv->getOperand();
     } else if (acceptFunctionArgs && isa<SILFunctionArgument>(closure)) {
       // We can assume that a function closure argument is already checked at
       // the call site.