[sil-combine] Refactor rewriteApplyCallee -> cloneFullApplySiteReplacingCallee and move into InstOptUtils.h.

I am going to use this in mandatory combine, and it seems like a generally
useful transformation.

I also updated the routine to construct its own SILBuilder that injects a user
passed in SILBuilderContext eliminating the bad pattern of passing in
SILBuilders.

This should be an NFC change.

Author: gottesmm

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -578,6 +578,15 @@ bool tryOptimizeApplyOfPartialApply(
     PartialApplyInst *pai, SILBuilderContext &builderCtxt,
     InstModCallbacks callbacks = InstModCallbacks());
 
+/// Clone this full apply site, replacing the callee with \p newCallee while
+/// doing so.
+///
+/// The current full apply site is used as an insertion point, so the caller
+/// must clean up this full apply site.
+FullApplySite cloneFullApplySiteReplacingCallee(FullApplySite applySite,
+                                                SILValue newCallee,
+                                                SILBuilderContext &builderCtx);
+
 } // end namespace swift
 
 #endif

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -260,8 +260,6 @@ class SILCombiner :
         });
   }
 
-  FullApplySite rewriteApplyCallee(FullApplySite apply, SILValue callee);
-
   // Build concrete existential information using findInitExistential.
   Optional<ConcreteOpenedExistentialInfo>
   buildConcreteOpenedExistentialInfo(Operand &ArgOperand);

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -1209,35 +1209,6 @@ bool SILCombiner::optimizeIdentityCastComposition(ApplyInst *FInverse,
   return true;
 }
 
-// Return a new apply with the specified callee. This creates a new apply rather
-// than simply rewriting the callee operand because the apply's SubstCalleeType,
-// derived from the callee and substitution list, may change.
-FullApplySite SILCombiner::rewriteApplyCallee(FullApplySite apply,
-                                              SILValue callee) {
-  SmallVector<SILValue, 4> arguments;
-  for (SILValue arg : apply.getArguments())
-    arguments.push_back(arg);
-
-  Builder.addOpenedArchetypeOperands(apply.getInstruction());
-  if (auto *TAI = dyn_cast<TryApplyInst>(apply)) {
-    return Builder.createTryApply(TAI->getLoc(), callee,
-                                  TAI->getSubstitutionMap(), arguments,
-                                  TAI->getNormalBB(), TAI->getErrorBB());
-  } else {
-    auto *AI = cast<ApplyInst>(apply);
-    auto fTy = callee->getType().getAs<SILFunctionType>();
-    // The optimizer can generate a thin_to_thick_function from a throwing thin
-    // to a non-throwing thick function (in case it can prove that the function
-    // is not throwing).
-    // Therefore we have to check if the new callee (= the argument of the
-    // thin_to_thick_function) is a throwing function and set the not-throwing
-    // flag in this case.
-    return Builder.createApply(apply.getLoc(), callee,
-                               apply.getSubstitutionMap(), arguments,
-                               AI->isNonThrowing() || fTy->hasErrorResult());
-  }
-}
-
 SILInstruction *SILCombiner::visitApplyInst(ApplyInst *AI) {
   if (AI->getFunction()->hasOwnership())
     return nullptr;
@@ -1289,7 +1260,9 @@ SILInstruction *SILCombiner::visitApplyInst(ApplyInst *AI) {
     // function when rewriting the callsite. This should be ok because the
     // ABI normally expects a guaranteed callee.
     if (!AI->getOrigCalleeType()->isCalleeConsumed())
-      return rewriteApplyCallee(AI, TTTFI->getOperand()).getInstruction();
+      return cloneFullApplySiteReplacingCallee(AI, TTTFI->getOperand(),
+                                               Builder.getBuilderContext())
+          .getInstruction();
   }
 
   // (apply (witness_method)) -> propagate information about
@@ -1424,7 +1397,9 @@ SILInstruction *SILCombiner::visitTryApplyInst(TryApplyInst *AI) {
     // function when rewriting the callsite. This should be ok because the
     // ABI normally expects a guaranteed callee.
     if (!AI->getOrigCalleeType()->isCalleeConsumed())
-      return rewriteApplyCallee(AI, TTTFI->getOperand()).getInstruction();
+      return cloneFullApplySiteReplacingCallee(AI, TTTFI->getOperand(),
+                                               Builder.getBuilderContext())
+          .getInstruction();
   }
 
   // (apply (witness_method)) -> propagate information about

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -14,6 +14,7 @@
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/SemanticAttrs.h"
 #include "swift/AST/SubstitutionMap.h"
+#include "swift/SIL/ApplySite.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/DynamicCasts.h"
@@ -2012,3 +2013,41 @@ AbstractFunctionDecl *swift::getBaseMethod(AbstractFunctionDecl *FD) {
   }
   return FD;
 }
+
+FullApplySite
+swift::cloneFullApplySiteReplacingCallee(FullApplySite applySite,
+                                         SILValue newCallee,
+                                         SILBuilderContext &builderCtx) {
+  SmallVector<SILValue, 16> arguments;
+  llvm::copy(applySite.getArguments(), std::back_inserter(arguments));
+
+  SILBuilderWithScope builder(applySite.getInstruction(), builderCtx);
+  builder.addOpenedArchetypeOperands(applySite.getInstruction());
+
+  switch (applySite.getKind()) {
+  case FullApplySiteKind::TryApplyInst: {
+    auto *tai = cast<TryApplyInst>(applySite.getInstruction());
+    return builder.createTryApply(tai->getLoc(), newCallee,
+                                  tai->getSubstitutionMap(), arguments,
+                                  tai->getNormalBB(), tai->getErrorBB());
+  }
+  case FullApplySiteKind::ApplyInst: {
+    auto *ai = cast<ApplyInst>(applySite);
+    auto fTy = newCallee->getType().getAs<SILFunctionType>();
+
+    // The optimizer can generate a thin_to_thick_function from a throwing thin
+    // to a non-throwing thick function (in case it can prove that the function
+    // is not throwing).
+    // Therefore we have to check if the new callee (= the argument of the
+    // thin_to_thick_function) is a throwing function and set the not-throwing
+    // flag in this case.
+    return builder.createApply(applySite.getLoc(), newCallee,
+                               applySite.getSubstitutionMap(), arguments,
+                               ai->isNonThrowing() || fTy->hasErrorResult());
+  }
+  case FullApplySiteKind::BeginApplyInst: {
+    llvm_unreachable("begin_apply support not implemented?!");
+  }
+  }
+  llvm_unreachable("Unhandled case?!");
+}