[region-isolation] Make PartitionOpEvaluator use CRTP instead of std::function callbacks.

Just a fixup requested by reviewers of incoming code that I wanted to do in a
follow on commit.

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -934,115 +934,73 @@ class Partition {
 /// A data structure that applies a series of PartitionOps to a single Partition
 /// that it modifies.
 ///
-/// Apply the passed PartitionOp to this partition, performing its action.  A
-/// `handleFailure` closure can optionally be passed in that will be called if
-/// a transferred region is required. The closure is given the PartitionOp
-/// that failed, and the index of the SIL value that was required but
-/// transferred. Additionally, a list of "nontransferrable" indices can be
-/// passed in along with a handleTransferNonTransferrable closure. In the
-/// event that a region containing one of the nontransferrable indices is
-/// transferred, the closure will be called with the offending transfer.
+/// Callers use CRTP to modify its behavior. Please see the definition below of
+/// a "blank" subclass PartitionOpEvaluatorBaseImpl for a description of the
+/// methods needing to be implemented by other CRTP subclasses.
+template <typename Impl>
 struct PartitionOpEvaluator {
+private:
+  Impl &asImpl() { return *reinterpret_cast<Impl *>(this); }
+  const Impl &asImpl() const { return *reinterpret_cast<const Impl *>(this); }
+
+public:
   using Element = PartitionPrimitives::Element;
   using Region = PartitionPrimitives::Region;
   using TransferringOperandSetFactory =
       Partition::TransferringOperandSetFactory;
 
+protected:
   TransferringOperandSetFactory &ptrSetFactory;
 
   Partition &p;
 
-  /// If this PartitionOp evaluator should emit log statements.
-  bool emitLog = true;
-
-  /// If set to a non-null function, then this callback will be called if we
-  /// discover a transferred value was used after it was transferred.
-  ///
-  /// The arguments passed to the closure are:
-  ///
-  /// 1. The PartitionOp that required the element to be alive.
-  ///
-  /// 2. The element in the PartitionOp that was asked to be alive.
-  ///
-  /// 3. The operand of the instruction that originally transferred the
-  /// region. Can be used to get the immediate value transferred or the
-  /// transferring instruction.
-  std::function<void(const PartitionOp &, Element, TransferringOperand)>
-      failureCallback = nullptr;
-
-  /// A list of elements that cannot be transferred. Whenever we transfer, we
-  /// check this list to see if we are transferring the element and then call
-  /// transferNonTransferrableCallback. This should consist only of function
-  /// arguments.
-  ArrayRef<Element> nonTransferrableElements = {};
-
-  /// If set to a non-null function_ref, this is called if we detect a never
-  /// transferred element that was passed to a transfer instruction.
-  std::function<void(const PartitionOp &, Element)>
-      transferredNonTransferrableCallback = nullptr;
-
-  /// If set to a non-null function_ref, then this is used to determine if an
-  /// element is actor derived. If we determine that a region containing such an
-  /// element is transferred, we emit an error since actor regions cannot be
-  /// transferred.
-  std::function<bool(Element)> isActorDerivedCallback = nullptr;
-
-  /// Check if the representative value of \p elt is closure captured at \p
-  /// op.
-  ///
-  /// NOTE: We actually just use the user of \p op in our callbacks. The reason
-  /// why we do not just pass in that SILInstruction is that then we would need
-  /// to access the instruction in the evaluator which creates a problem when
-  /// since the operand we pass in is a dummy operand.
-  std::function<bool(Element elt, Operand *op)> isClosureCapturedCallback =
-      nullptr;
-
+public:
   PartitionOpEvaluator(Partition &p,
                        TransferringOperandSetFactory &ptrSetFactory)
       : ptrSetFactory(ptrSetFactory), p(p) {}
 
-  /// A wrapper around the failure callback that checks if it is nullptr.
+  /// Call shouldEmitVerboseLogging on our CRTP subclass.
+  bool shouldEmitVerboseLogging() const {
+    return asImpl().shouldEmitVerboseLogging();
+  }
+
+  /// Call handleFailure on our CRTP subclass.
   void handleFailure(const PartitionOp &op, Element elt,
                      TransferringOperand transferringOp) const {
-    if (!failureCallback)
-      return;
-    failureCallback(op, elt, transferringOp);
+    return asImpl().handleFailure(op, elt, transferringOp);
   }
 
-  /// A wrapper around transferNonTransferrableCallback that only calls it if it
-  /// is not null.
+  /// Call handleTransferNonTransferrable on our CRTP subclass.
   void handleTransferNonTransferrable(const PartitionOp &op,
                                       Element elt) const {
-    if (!transferredNonTransferrableCallback)
-      return;
-    transferredNonTransferrableCallback(op, elt);
+    return asImpl().handleTransferNonTransferrable(op, elt);
   }
 
-  /// A wrapper around isActorDerivedCallback that returns false if
-  /// isActorDerivedCallback is nullptr and otherwise returns
-  /// isActorDerivedCallback().
+  /// Call isActorDerived on our CRTP subclass.
   bool isActorDerived(Element elt) const {
-    return bool(isActorDerivedCallback) && isActorDerivedCallback(elt);
+    return asImpl().isActorDerived(elt);
   }
 
-  /// A wraper around isClosureCapturedCallback that returns false if
-  /// isClosureCapturedCallback is nullptr and otherwise returns
-  /// isClosureCapturedCallback.
+  /// Call isClosureCaptured on our CRTP subclass.
   bool isClosureCaptured(Element elt, Operand *op) const {
-    return bool(isClosureCapturedCallback) &&
-           isClosureCapturedCallback(elt, op);
+    return asImpl().isClosureCaptured(elt, op);
+  }
+
+  /// Call getNonTransferrableElements() on our CRTP subclass.
+  ArrayRef<Element> getNonTransferrableElements() const {
+    return asImpl().getNonTransferrableElements();
   }
 
   /// Apply \p op to the partition op.
   void apply(const PartitionOp &op) const {
-    if (emitLog) {
+    if (shouldEmitVerboseLogging()) {
       REGIONBASEDISOLATION_VERBOSE_LOG(llvm::dbgs() << "Applying: ";
                                        op.print(llvm::dbgs()));
       REGIONBASEDISOLATION_VERBOSE_LOG(llvm::dbgs() << "    Before: ";
                                        p.print(llvm::dbgs()));
     }
     SWIFT_DEFER {
-      if (emitLog) {
+      if (shouldEmitVerboseLogging()) {
         REGIONBASEDISOLATION_VERBOSE_LOG(llvm::dbgs() << "    After:  ";
                                          p.print(llvm::dbgs()));
       }
@@ -1078,7 +1036,7 @@ struct PartitionOpEvaluator {
 
       // check if any nontransferrables are transferred here, and handle the
       // failure if so
-      for (Element nonTransferrable : nonTransferrableElements) {
+      for (Element nonTransferrable : getNonTransferrableElements()) {
         assert(
             p.isTrackingElement(nonTransferrable) &&
             "nontransferrables should be function args and self, and therefore"
@@ -1167,6 +1125,75 @@ struct PartitionOpEvaluator {
   }
 };
 
+/// A base implementation that can be used to default initialize CRTP
+/// subclasses. Only used to implement base functionality for subclass
+/// CRTPs. For true basic evaluation, use PartitionOpEvaluatorBasic below.
+template <typename Subclass>
+struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
+  using Element = PartitionPrimitives::Element;
+  using Region = PartitionPrimitives::Region;
+  using TransferringOperandSetFactory =
+      Partition::TransferringOperandSetFactory;
+  using Super = PartitionOpEvaluator<Subclass>;
+
+  PartitionOpEvaluatorBaseImpl(Partition &workingPartition,
+                               TransferringOperandSetFactory &ptrSetFactory)
+      : Super(workingPartition, ptrSetFactory) {}
+
+  /// Should we emit extra verbose logging statements when evaluating
+  /// PartitionOps.
+  bool shouldEmitVerboseLogging() const { return true; }
+
+  /// A function called if we discover a transferred value was used after it
+  /// was transferred.
+  ///
+  /// The arguments passed to the closure are:
+  ///
+  /// 1. The PartitionOp that required the element to be alive.
+  ///
+  /// 2. The element in the PartitionOp that was asked to be alive.
+  ///
+  /// 3. The operand of the instruction that originally transferred the
+  /// region. Can be used to get the immediate value transferred or the
+  /// transferring instruction.
+  void handleFailure(const PartitionOp &op, Element elt,
+                     TransferringOperand transferringOp) const {}
+
+  /// A list of elements that cannot be transferred. Whenever we transfer, we
+  /// check this list to see if we are transferring the element and then call
+  /// transferNonTransferrableCallback. This should consist only of function
+  /// arguments.
+  ArrayRef<Element> getNonTransferrableElements() const { return {}; }
+
+  /// This is called if we detect a never transferred element that was passed to
+  /// a transfer instruction.
+  void handleTransferNonTransferrable(const PartitionOp &op,
+                                      Element elt) const {}
+
+  /// This is used to determine if an element is actor derived. If we determine
+  /// that a region containing such an element is transferred, we emit an error
+  /// since actor regions cannot be transferred.
+  bool isActorDerived(Element elt) const { return false; }
+
+  /// Check if the representative value of \p elt is closure captured at \p
+  /// op.
+  ///
+  /// NOTE: We actually just use the user of \p op in our callbacks. The reason
+  /// why we do not just pass in that SILInstruction is that then we would need
+  /// to access the instruction in the evaluator which creates a problem when
+  /// since the operand we pass in is a dummy operand.
+  bool isClosureCaptured(Element elt, Operand *op) const { return false; }
+};
+
+/// A subclass of PartitionOpEvaluatorBaseImpl that doesn't have any special
+/// behavior.
+struct PartitionOpEvaluatorBasic final
+    : PartitionOpEvaluatorBaseImpl<PartitionOpEvaluatorBasic> {
+  PartitionOpEvaluatorBasic(Partition &workingPartition,
+                            TransferringOperandSetFactory &ptrSetFactory)
+      : PartitionOpEvaluatorBaseImpl(workingPartition, ptrSetFactory) {}
+};
+
 } // namespace swift
 
 #endif // SWIFT_PARTITIONUTILS_H