Optimizer: improve the SpecializationCloner

* add `cloneFunctionBody` without an `entryBlockArguments` argument
* remove the `swift::ClosureSpecializationCloner` from the bridging code and replace it with a more general `SpecializationCloner`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/SpecializationCloner.swift

@@ -46,4 +46,7 @@ struct SpecializationCloner {
     }
   }
 
-}
+  func cloneFunctionBody(from originalFunction: Function) {
+    bridged.cloneFunctionBody(originalFunction.bridged)
+  }
+}

include/swift/SIL/SILCloner.h

@@ -216,6 +216,18 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
                          ArrayRef<SILValue> entryArgs,
                          bool replaceOriginalFunctionInPlace = false);
 
+  /// Clone all blocks in this function and all instructions in those
+  /// blocks.
+  ///
+  /// This is used to clone an entire function without mutating the original
+  /// function.
+  ///
+  /// The new function is expected to be completely empty. Clone the entry
+  /// blocks arguments here. The cloned arguments become the inputs to the
+  /// general SILCloner, which expects the new entry block to be ready to emit
+  /// instructions into.
+  void cloneFunction(SILFunction *origF);
+
   /// The same as clone function body, except the caller can provide a callback
   /// that allows for an entry arg to be assigned to a custom old argument. This
   /// is useful if one re-arranges parameters when converting from inout to out.
@@ -703,32 +715,6 @@ class SILFunctionCloner : public SILClonerWithScopes<SILFunctionCloner> {
 
 public:
   SILFunctionCloner(SILFunction *newF) : SILClonerWithScopes(*newF) {}
-
-  /// Clone all blocks in this function and all instructions in those
-  /// blocks.
-  ///
-  /// This is used to clone an entire function without mutating the original
-  /// function.
-  ///
-  /// The new function is expected to be completely empty. Clone the entry
-  /// blocks arguments here. The cloned arguments become the inputs to the
-  /// general SILCloner, which expects the new entry block to be ready to emit
-  /// instructions into.
-  void cloneFunction(SILFunction *origF) {
-    SILFunction *newF = &Builder.getFunction();
-
-    auto *newEntryBB = newF->createBasicBlock();
-    newEntryBB->cloneArgumentList(origF->getEntryBlock());
-
-    // Copy the new entry block arguments into a separate vector purely to
-    // resolve the type mismatch between SILArgument* and SILValue.
-    SmallVector<SILValue, 8> entryArgs;
-    entryArgs.reserve(newF->getArguments().size());
-    llvm::transform(newF->getArguments(), std::back_inserter(entryArgs),
-                    [](SILArgument *arg) -> SILValue { return arg; });
-
-    SuperTy::cloneFunctionBody(origF, newEntryBB, entryArgs);
-  }
 };
 
 template<typename ImplClass>
@@ -848,6 +834,23 @@ void SILCloner<ImplClass>::cloneFunctionBody(SILFunction *F,
   commonFixUp(F);
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::cloneFunction(SILFunction *origF) {
+  SILFunction *newF = &Builder.getFunction();
+
+  auto *newEntryBB = newF->createBasicBlock();
+  newEntryBB->cloneArgumentList(origF->getEntryBlock());
+
+  // Copy the new entry block arguments into a separate vector purely to
+  // resolve the type mismatch between SILArgument* and SILValue.
+  SmallVector<SILValue, 8> entryArgs;
+  entryArgs.reserve(newF->getArguments().size());
+  llvm::transform(newF->getArguments(), std::back_inserter(entryArgs),
+                  [](SILArgument *arg) -> SILValue { return arg; });
+
+  cloneFunctionBody(origF, newEntryBB, entryArgs);
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::cloneFunctionBody(
     SILFunction *F, SILBasicBlock *clonedEntryBB, ArrayRef<SILValue> entryArgs,

include/swift/SILOptimizer/OptimizerBridging.h

@@ -53,7 +53,7 @@ class SwiftPassInvocation;
 class FixedSizeSlabPayload;
 class FixedSizeSlab;
 class SILVTable;
-class ClosureSpecializationCloner;
+class SpecializationCloner;
 }
 
 struct BridgedPassContext;
@@ -182,12 +182,14 @@ struct BridgedCloner {
 };
 
 struct BridgedSpecializationCloner {
-  swift::ClosureSpecializationCloner * _Nonnull closureSpecCloner;
+  swift::SpecializationCloner * _Nonnull cloner;
 
   SWIFT_IMPORT_UNSAFE BridgedSpecializationCloner(BridgedFunction emptySpecializedFunction);
   SWIFT_IMPORT_UNSAFE BridgedFunction getCloned() const;
   SWIFT_IMPORT_UNSAFE BridgedBasicBlock getClonedBasicBlock(BridgedBasicBlock originalBasicBlock) const;
-  void cloneFunctionBody(BridgedFunction originalFunction, BridgedBasicBlock clonedEntryBlock, BridgedValueArray clonedEntryBlockArgs) const;
+  void cloneFunctionBody(BridgedFunction originalFunction, BridgedBasicBlock clonedEntryBlock,
+                         BridgedValueArray clonedEntryBlockArgs) const;
+  void cloneFunctionBody(BridgedFunction originalFunction) const;
 };
 
 struct BridgedPassContext {

lib/SILOptimizer/Utils/OptimizerBridging.cpp

@@ -649,30 +649,34 @@ void BridgedCloner::recordFoldedValue(BridgedValue origValue, BridgedValue mappe
 }
 
 namespace swift {
-  class ClosureSpecializationCloner: public SILClonerWithScopes<ClosureSpecializationCloner> {
-    friend class SILInstructionVisitor<ClosureSpecializationCloner>;
-    friend class SILCloner<ClosureSpecializationCloner>;
-  public: 
-    using SuperTy = SILClonerWithScopes<ClosureSpecializationCloner>;
-    ClosureSpecializationCloner(SILFunction &emptySpecializedFunction): SuperTy(emptySpecializedFunction) {}
+  class SpecializationCloner: public SILClonerWithScopes<SpecializationCloner> {
+    friend class SILInstructionVisitor<SpecializationCloner>;
+    friend class SILCloner<SpecializationCloner>;
+  public:
+    using SuperTy = SILClonerWithScopes<SpecializationCloner>;
+    SpecializationCloner(SILFunction &emptySpecializedFunction): SuperTy(emptySpecializedFunction) {}
   };
 } // namespace swift
 
 BridgedSpecializationCloner::BridgedSpecializationCloner(BridgedFunction emptySpecializedFunction): 
-  closureSpecCloner(new ClosureSpecializationCloner(*emptySpecializedFunction.getFunction())) {}
+  cloner(new SpecializationCloner(*emptySpecializedFunction.getFunction())) {}
 
 BridgedFunction BridgedSpecializationCloner::getCloned() const {
-  return { &closureSpecCloner->getBuilder().getFunction() };
+  return { &cloner->getBuilder().getFunction() };
 }
 
 BridgedBasicBlock BridgedSpecializationCloner::getClonedBasicBlock(BridgedBasicBlock originalBasicBlock) const {
-  return { closureSpecCloner->getOpBasicBlock(originalBasicBlock.unbridged()) };
+  return { cloner->getOpBasicBlock(originalBasicBlock.unbridged()) };
 }
 
 void BridgedSpecializationCloner::cloneFunctionBody(BridgedFunction originalFunction, BridgedBasicBlock clonedEntryBlock, BridgedValueArray clonedEntryBlockArgs) const {
   llvm::SmallVector<swift::SILValue, 16> clonedEntryBlockArgsStorage;
   auto clonedEntryBlockArgsArrayRef = clonedEntryBlockArgs.getValues(clonedEntryBlockArgsStorage);
-  closureSpecCloner->cloneFunctionBody(originalFunction.getFunction(), clonedEntryBlock.unbridged(), clonedEntryBlockArgsArrayRef);
+  cloner->cloneFunctionBody(originalFunction.getFunction(), clonedEntryBlock.unbridged(), clonedEntryBlockArgsArrayRef);
+}
+
+void BridgedSpecializationCloner::cloneFunctionBody(BridgedFunction originalFunction) const {
+  cloner->cloneFunction(originalFunction.getFunction());
 }
 
 void BridgedBuilder::destroyCapturedArgs(BridgedInstruction partialApply) const {