[NFC] Avoid repeatedly instantiating std::function

Author: beccadax

include/swift/AST/PrintOptions.h

@@ -380,10 +380,13 @@ struct PrintOptions {
   /// has no associated doc-comment by itself.
   bool CascadeDocComment = false;
 
+  static const std::function<bool(const ExtensionDecl *)>
+      defaultPrintExtensionContentAsMembers;
+
   /// Whether to print the content of an extension decl inside the type decl where it
   /// extends from.
   std::function<bool(const ExtensionDecl *)> printExtensionContentAsMembers =
-    [] (const ExtensionDecl *) { return false; };
+    PrintOptions::defaultPrintExtensionContentAsMembers;
 
   /// How to print the keyword argument and parameter name in functions.
   ArgAndParamPrintingMode ArgAndParamPrinting =

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -308,32 +308,30 @@ bool tryCheckedCastBrJumpThreading(
 /// A structure containing callbacks that are called when an instruction is
 /// removed or added.
 struct InstModCallbacks {
-  std::function<void(SILInstruction *)> deleteInst = [](SILInstruction *inst) {
-    inst->eraseFromParent();
-  };
-  std::function<void(SILInstruction *)> createdNewInst = [](SILInstruction *) {
-  };
-  std::function<void(SILValue, SILValue)> replaceValueUsesWith =
-      [](SILValue oldValue, SILValue newValue) {
-        oldValue->replaceAllUsesWith(newValue);
-      };
+  static const std::function<void(SILInstruction *)> defaultDeleteInst;
+  static const std::function<void(SILInstruction *)> defaultCreatedNewInst;
+  static const std::function<void(SILValue, SILValue)> defaultReplaceValueUsesWith;
+  static const std::function<void(SingleValueInstruction *, SILValue)>
+      defaultEraseAndRAUWSingleValueInst;
+
+  std::function<void(SILInstruction *)> deleteInst =
+      InstModCallbacks::defaultDeleteInst;
+  std::function<void(SILInstruction *)> createdNewInst =
+      InstModCallbacks::defaultCreatedNewInst;
+  std::function<void(SILValue, SILValue)>
+      replaceValueUsesWith =
+          InstModCallbacks::defaultReplaceValueUsesWith;
   std::function<void(SingleValueInstruction *, SILValue)>
       eraseAndRAUWSingleValueInst =
-          [](SingleValueInstruction *i, SILValue newValue) {
-            i->replaceAllUsesWith(newValue);
-            i->eraseFromParent();
-          };
+          InstModCallbacks::defaultEraseAndRAUWSingleValueInst;
 
   InstModCallbacks(decltype(deleteInst) deleteInst,
                    decltype(createdNewInst) createdNewInst,
                    decltype(replaceValueUsesWith) replaceValueUsesWith)
       : deleteInst(deleteInst), createdNewInst(createdNewInst),
         replaceValueUsesWith(replaceValueUsesWith),
         eraseAndRAUWSingleValueInst(
-            [](SingleValueInstruction *i, SILValue newValue) {
-              i->replaceAllUsesWith(newValue);
-              i->eraseFromParent();
-            }) {}
+            InstModCallbacks::defaultEraseAndRAUWSingleValueInst) {}
 
   InstModCallbacks(
       decltype(deleteInst) deleteInst, decltype(createdNewInst) createdNewInst,

lib/AST/ASTPrinter.cpp

@@ -58,6 +58,11 @@
 
 using namespace swift;
 
+// Defined here to avoid repeatedly paying the price of template instantiation.
+const std::function<bool(const ExtensionDecl *)>
+    PrintOptions::defaultPrintExtensionContentAsMembers
+        = [] (const ExtensionDecl *) { return false; };
+
 void PrintOptions::setBaseType(Type T) {
   if (T->is<ErrorType>())
     return;

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -48,6 +48,27 @@ static llvm::cl::opt<bool> KeepWillThrowCall(
     llvm::cl::desc(
       "Keep calls to swift_willThrow, even if the throw is optimized away"));
 
+// Defined here to avoid repeatedly paying the price of template instantiation.
+const std::function<void(SILInstruction *)>
+    InstModCallbacks::defaultDeleteInst
+        = [](SILInstruction *inst) {
+          inst->eraseFromParent();
+        };
+const std::function<void(SILInstruction *)>
+    InstModCallbacks::defaultCreatedNewInst
+        = [](SILInstruction *) {};
+const std::function<void(SILValue, SILValue)>
+    InstModCallbacks::defaultReplaceValueUsesWith
+        = [](SILValue oldValue, SILValue newValue) {
+          oldValue->replaceAllUsesWith(newValue);
+        };
+const std::function<void(SingleValueInstruction *, SILValue)>
+    InstModCallbacks::defaultEraseAndRAUWSingleValueInst
+        = [](SingleValueInstruction *i, SILValue newValue) {
+          i->replaceAllUsesWith(newValue);
+          i->eraseFromParent();
+        };
+
 /// Creates an increment on \p Ptr before insertion point \p InsertPt that
 /// creates a strong_retain if \p Ptr has reference semantics itself or a
 /// retain_value if \p Ptr is a non-trivial value without reference-semantics.