[sil-optimizer] Get rid of the InstModCallback constructors in favor of onDelete/onCreatedNewInst/etc.

Without this when constructing an InstModCallback it is hard to distinguish
which closure is meant for which operation when passed to the constructor of
InstModCallback (if this was in Swift, we could use argument labels, but we do
not have such things in c++).

This new value type sort of formulation makes it unambiguous which callback is
used for what when constructing one of these.

Author: gottesmm

include/swift/SILOptimizer/Utils/CanonicalizeInstruction.h

@@ -46,17 +46,22 @@ struct CanonicalizeInstruction {
   CanonicalizeInstruction(const char *passDebugType,
                           DeadEndBlocks &deadEndBlocks)
       : deadEndBlocks(deadEndBlocks),
-        callbacks(
-            [&](SILInstruction *toDelete) { killInstruction(toDelete); },
-            [&](SILInstruction *newInst) { notifyNewInstruction(newInst); },
-            [&](Operand *use, SILValue newValue) {
-              use->set(newValue);
-              notifyHasNewUsers(newValue);
-            }) {
+        callbacks() {
 #ifndef NDEBUG
     if (llvm::DebugFlag && !llvm::isCurrentDebugType(debugType))
       debugType = passDebugType;
 #endif
+    callbacks = InstModCallbacks()
+      .onDelete([&](SILInstruction *toDelete) {
+        killInstruction(toDelete);
+      })
+      .onCreateNewInst([&](SILInstruction *newInst) {
+        notifyNewInstruction(newInst);
+      })
+      .onSetUseValue([&](Operand *use, SILValue newValue) {
+        use->set(newValue);
+        notifyHasNewUsers(newValue);
+      });
   }
 
   virtual ~CanonicalizeInstruction();

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -99,28 +99,9 @@ class InstModCallbacks {
   bool wereAnyCallbacksInvoked = false;
 
 public:
-  InstModCallbacks(decltype(deleteInstFunc) deleteInstFunc)
-      : deleteInstFunc(deleteInstFunc) {}
-
-  InstModCallbacks(decltype(deleteInstFunc) deleteInstFunc,
-                   decltype(createdNewInstFunc) createdNewInstFunc)
-      : createdNewInstFunc(createdNewInstFunc), deleteInstFunc(deleteInstFunc) {
-  }
-
-  InstModCallbacks(decltype(deleteInstFunc) deleteInstFunc,
-                   decltype(setUseValueFunc) setUseValueFunc)
-      : setUseValueFunc(setUseValueFunc), deleteInstFunc(deleteInstFunc) {}
-
-  InstModCallbacks(decltype(deleteInstFunc) deleteInstFunc,
-                   decltype(createdNewInstFunc) createdNewInstFunc,
-                   decltype(setUseValueFunc) setUseValueFunc)
-      : createdNewInstFunc(createdNewInstFunc),
-        setUseValueFunc(setUseValueFunc), deleteInstFunc(deleteInstFunc) {}
-
   InstModCallbacks() = default;
   ~InstModCallbacks() = default;
   InstModCallbacks(const InstModCallbacks &) = default;
-  InstModCallbacks(InstModCallbacks &&) = default;
 
   /// Return a copy of self with deleteInstFunc set to \p newDeleteInstFunc.
   InstModCallbacks onDelete(decltype(deleteInstFunc) newDeleteInstFunc) const {

lib/SILOptimizer/Mandatory/MandatoryCombine.cpp

@@ -143,18 +143,22 @@ class MandatoryCombiner final
                     DeadEndBlocks &deadEndBlocks)
       : compilingWithOptimization(optimized), worklist("MC"), madeChange(false),
         iteration(0),
-        instModCallbacks(
-            [&](SILInstruction *instruction) {
-              worklist.erase(instruction);
-              instructionsPendingDeletion.push_back(instruction);
-            },
-            [&](SILInstruction *instruction) { worklist.add(instruction); },
-            [this](Operand *use, SILValue newValue) {
-              use->set(newValue);
-              worklist.add(use->getUser());
-            }),
+        instModCallbacks(),
         createdInstructions(createdInstructions),
-        deadEndBlocks(deadEndBlocks){};
+        deadEndBlocks(deadEndBlocks) {
+    instModCallbacks = InstModCallbacks()
+      .onDelete([&](SILInstruction *instruction) {
+        worklist.erase(instruction);
+        instructionsPendingDeletion.push_back(instruction);
+      })
+      .onCreateNewInst([&](SILInstruction *instruction) {
+        worklist.add(instruction);
+      })
+      .onSetUseValue([this](Operand *use, SILValue newValue) {
+        use->set(newValue);
+        worklist.add(use->getUser());
+      });
+  };
 
   void addReachableCodeToWorklist(SILFunction &function);
 

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -527,7 +527,7 @@ static bool stripOwnership(SILFunction &func) {
     auto value = visitor.instructionsToSimplify.pop_back_val();
     if (!value.hasValue())
       continue;
-    InstModCallbacks callbacks([&](SILInstruction *instToErase) {
+    auto callbacks = InstModCallbacks().onDelete([&](SILInstruction *instToErase) {
       visitor.eraseInstruction(instToErase);
     });
     // We are no longer in OSSA, so we don't need to pass in a deBlocks.

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -116,19 +116,21 @@ class SILCombiner :
             },
             /* EraseAction */
             [&](SILInstruction *I) { eraseInstFromFunction(*I); }),
-        instModCallbacks(
-            [&](SILInstruction *instToDelete) {
-              eraseInstFromFunction(*instToDelete);
-            },
-            [&](SILInstruction *newlyCreatedInst) {
-              Worklist.add(newlyCreatedInst);
-            },
-            [&](Operand *use, SILValue newValue) {
-              use->set(newValue);
-              Worklist.add(use->getUser());
-            }),
+        instModCallbacks(),
         deBlocks(&B.getFunction()),
-        ownershipFixupContext(instModCallbacks, deBlocks) {}
+        ownershipFixupContext(instModCallbacks, deBlocks) {
+    instModCallbacks = InstModCallbacks()
+      .onDelete([&](SILInstruction *instToDelete) {
+              eraseInstFromFunction(*instToDelete);
+      })
+      .onCreateNewInst([&](SILInstruction *newlyCreatedInst) {
+        Worklist.add(newlyCreatedInst);
+      })
+      .onSetUseValue([&](Operand *use, SILValue newValue) {
+        use->set(newValue);
+        Worklist.add(use->getUser());
+      });
+  }
 
   bool runOnFunction(SILFunction &F);
 

lib/SILOptimizer/SemanticARC/SemanticARCOptVisitor.h

@@ -52,9 +52,10 @@ struct LLVM_LIBRARY_VISIBILITY SemanticARCOptVisitor
   explicit SemanticARCOptVisitor(SILFunction &fn, DeadEndBlocks &deBlocks,
                                  bool onlyMandatoryOpts)
       : ctx(fn, deBlocks, onlyMandatoryOpts,
-            InstModCallbacks(
-                [this](SILInstruction *inst) { eraseInstruction(inst); },
-                [this](Operand *use, SILValue newValue) {
+            InstModCallbacks()
+                .onDelete(
+                    [this](SILInstruction *inst) { eraseInstruction(inst); })
+                .onSetUseValue([this](Operand *use, SILValue newValue) {
                   use->set(newValue);
                   worklist.insert(newValue);
                 })) {}

lib/SILOptimizer/Transforms/TempRValueElimination.cpp

@@ -783,7 +783,7 @@ void TempRValueOptPass::run() {
     }
   }
 
-  InstModCallbacks callbacks(
+  auto callbacks = InstModCallbacks().onDelete(
     [](SILInstruction *instToKill) {
       // SimplifyInstruction is not in the business of removing
       // copy_addr. If it were, then we would need to update deadCopies.