SIL optimizer: fix a compile time performance problem in UpdatingInstructionIteratorRegistry

C++ closures can implicitly malloc.
Avoid this by just capturing `this` and nothing else.

Reduces the time spent in the SIL pass pipeline by 25% when compiling the stdlib core.

rdar://88567996

Author: eeckstein

include/swift/SILOptimizer/Utils/UpdatingInstructionIterator.h

@@ -169,31 +169,33 @@ class UpdatingInstructionIteratorRegistry {
   SmallVector<UpdatingInstructionIterator *, 4> forwardIterators;
   SmallVector<UpdatingReverseInstructionIterator *, 4> reverseIterators;
 
+  std::function<void(SILInstruction *)> chainedDelete;
+  std::function<void(SILInstruction *)> chainedNew;
+
   /// Callbacks used when adding/deleting instructions.
   InstModCallbacks callbacks;
 
-public:
-  UpdatingInstructionIteratorRegistry(
-      InstModCallbacks chainedCallbacks = InstModCallbacks()) {
-    rechainCallbacks(chainedCallbacks);
-  }
-
-  // The callbacks capture 'this'. So copying is invalid.
-  UpdatingInstructionIteratorRegistry(
-      const UpdatingInstructionIteratorRegistry &) = delete;
-
-  UpdatingInstructionIteratorRegistry &
-  operator=(const UpdatingInstructionIteratorRegistry &) = delete;
 
-  InstModCallbacks &getCallbacks() { return callbacks; }
+public:
+  UpdatingInstructionIteratorRegistry() :
+    callbacks(InstModCallbacks()
+                    .onDelete([this](SILInstruction *toDelete) {
+                      notifyDelete(toDelete);
+                      toDelete->eraseFromParent();
+                    })
+                    .onCreateNewInst(
+                        [this](SILInstruction *newlyCreatedInst) {
+                          notifyNew(newlyCreatedInst);
+                        }))
+  {}
 
-  void rechainCallbacks(InstModCallbacks chainedCallbacks) {
+  UpdatingInstructionIteratorRegistry(InstModCallbacks &&chainedCallbacks) :
     // Copy the two std::functions that we need. The rest of the callbacks are
     // copied implicitly by assignment.
-    auto chainedDelete = chainedCallbacks.deleteInstFunc;
-    auto chainedNew = chainedCallbacks.createdNewInstFunc;
-    callbacks = chainedCallbacks
-                    .onDelete([this, chainedDelete](SILInstruction *toDelete) {
+    chainedDelete(std::move(chainedCallbacks.deleteInstFunc)),
+    chainedNew(std::move(chainedCallbacks.createdNewInstFunc)),
+    callbacks(std::move(chainedCallbacks
+                    .onDelete([this](SILInstruction *toDelete) {
                       notifyDelete(toDelete);
                       if (chainedDelete) {
                         chainedDelete(toDelete);
@@ -202,13 +204,22 @@ class UpdatingInstructionIteratorRegistry {
                       toDelete->eraseFromParent();
                     })
                     .onCreateNewInst(
-                        [this, chainedNew](SILInstruction *newlyCreatedInst) {
+                        [this](SILInstruction *newlyCreatedInst) {
                           notifyNew(newlyCreatedInst);
                           if (chainedNew) {
                             chainedNew(newlyCreatedInst);
                           }
-                        });
-  }
+                        })))
+  {}
+
+  // The callbacks capture 'this'. So copying is invalid.
+  UpdatingInstructionIteratorRegistry(
+      const UpdatingInstructionIteratorRegistry &) = delete;
+
+  UpdatingInstructionIteratorRegistry &
+  operator=(const UpdatingInstructionIteratorRegistry &) = delete;
+
+  InstModCallbacks &getCallbacks() { return callbacks; }
 
   void registerIterator(UpdatingInstructionIterator *i) {
     forwardIterators.push_back(i);