[isolation-regions] Rename Consume to Transfer.

Transfer is the terminology that we are using for something be transferred
across an isolation boundary, not consume. This also eliminates confusion with
consume which is a term being used around ownership.

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -44,25 +44,25 @@ struct Region {
 
 using namespace PartitionPrimitives;
 
-// PartitionOpKind represents the different kinds of PartitionOps that
-// SILInstructions can be translated to
+/// PartitionOpKind represents the different kinds of PartitionOps that
+/// SILInstructions can be translated to
 enum class PartitionOpKind : uint8_t {
-  // Assign one value to the region of another, takes two args, second arg
-  // must already be tracked with a non-consumed region
+  /// Assign one value to the region of another, takes two args, second arg
+  /// must already be tracked with a non-consumed region
   Assign,
 
-  // Assign one value to a fresh region, takes one arg.
+  /// Assign one value to a fresh region, takes one arg.
   AssignFresh,
 
-  // Consume the region of a value if not already consumed, takes one arg.
-  Consume,
-
-  // Merge the regions of two values, takes two args, both must be from
-  // non-consumed regions.
+  /// Merge the regions of two values, takes two args, both must be from
+  /// non-consumed regions.
   Merge,
 
-  // Require the region of a value to be non-consumed, takes one arg.
-  Require
+  /// Consume the region of a value if not already consumed, takes one arg.
+  Transfer,
+
+  /// Require the region of a value to be non-consumed, takes one arg.
+  Require,
 };
 
 // PartitionOp represents a primitive operation that can be performed on
@@ -108,11 +108,9 @@ class PartitionOp {
     return PartitionOp(PartitionOpKind::AssignFresh, tgt, sourceInst);
   }
 
-  static PartitionOp Consume(Element tgt,
-                             SILInstruction *sourceInst = nullptr,
-                             Expr *sourceExpr = nullptr) {
-    return PartitionOp(PartitionOpKind::Consume, tgt,
-                       sourceInst, sourceExpr);
+  static PartitionOp Transfer(Element tgt, SILInstruction *sourceInst = nullptr,
+                              Expr *sourceExpr = nullptr) {
+    return PartitionOp(PartitionOpKind::Transfer, tgt, sourceInst, sourceExpr);
   }
 
   static PartitionOp Merge(Element tgt1, Element tgt2,
@@ -164,7 +162,7 @@ class PartitionOp {
     case PartitionOpKind::AssignFresh:
       os << "assign_fresh %%" << OpArgs[0] << "\n";
       break;
-    case PartitionOpKind::Consume:
+    case PartitionOpKind::Transfer:
       os << "consume %%" << OpArgs[0] << "\n";
       break;
     case PartitionOpKind::Merge:
@@ -425,7 +423,7 @@ class Partition {
       fresh_label = Region(fresh_label + 1);
       canonical = false;
       break;
-    case PartitionOpKind::Consume:
+    case PartitionOpKind::Transfer:
       assert(op.OpArgs.size() == 1 &&
              "Consume PartitionOp should be passed 1 argument");
       assert(labels.count(op.OpArgs[0]) &&

lib/SILOptimizer/Mandatory/SendNonSendable.cpp

@@ -239,12 +239,12 @@ struct PartitionOpBuilder {
         lookupValueID(tgt), lookupValueID(src), currentInst));
   }
 
-  void addConsume(SILValue value, Expr *sourceExpr = nullptr) {
+  void addTransfer(SILValue value, Expr *sourceExpr = nullptr) {
     assert(valueHasID(value) &&
            "consumed value should already have been encountered");
 
     currentInstPartitionOps.emplace_back(
-        PartitionOp::Consume(lookupValueID(value), currentInst, sourceExpr));
+        PartitionOp::Transfer(lookupValueID(value), currentInst, sourceExpr));
   }
 
   void addMerge(SILValue fst, SILValue snd) {
@@ -655,14 +655,14 @@ class PartitionOpTranslator {
       int argNum = 0;
       for (auto arg : ops) {
         if (auto value = trackIfNonSendable(arg))
-          builder.addConsume(value->getRepresentative(), getSourceArg(argNum));
+          builder.addTransfer(value->getRepresentative(), getSourceArg(argNum));
         argNum++;
       }
     };
 
     auto handleSILSelf = [&](SILValue self) {
       if (auto value = trackIfNonSendable(self))
-        builder.addConsume(value->getRepresentative(), getSourceSelf());
+        builder.addTransfer(value->getRepresentative(), getSourceSelf());
     };
 
     if (applySite.hasSelfArgument()) {
@@ -1201,7 +1201,7 @@ struct LocalConsumedReason {
   std::optional<PartitionOp> localInst;
 
   static LocalConsumedReason ConsumeInst(PartitionOp localInst) {
-    assert(localInst.getKind() == PartitionOpKind::Consume);
+    assert(localInst.getKind() == PartitionOpKind::Transfer);
     return LocalConsumedReason(LocalConsumedReasonKind::LocalConsumeInst, localInst);
   }
 
@@ -1262,7 +1262,7 @@ class ConsumedReason {
   }
 
   void addConsumeOp(PartitionOp consumeOp, unsigned distance) {
-    assert(consumeOp.getKind() == PartitionOpKind::Consume);
+    assert(consumeOp.getKind() == PartitionOpKind::Transfer);
     // duplicates should not arise
     if (!containsOp(consumeOp))
       consumeOps[distance].push_back(consumeOp);
@@ -1509,7 +1509,7 @@ class RaceTracer {
       workingPartition.apply(partitionOp);
       if (workingPartition.isConsumed(consumedVal) && !consumedReason) {
         // this partitionOp consumes the target value
-        if (partitionOp.getKind() == PartitionOpKind::Consume)
+        if (partitionOp.getKind() == PartitionOpKind::Transfer)
           consumedReason = LocalConsumedReason::ConsumeInst(partitionOp);
         else
           // a merge or assignment invalidated this, but that will be a separate

unittests/SIL/PartitionUtilsTest.cpp

@@ -194,9 +194,9 @@ TEST(PartitionUtilsTest, TestConsumeAndRequire) {
 
   //expected: p: ((0 1 2) (3 4 5) (6 7) (8 9) (Element(10)) (Element(11)))
 
-  p.apply(PartitionOp::Consume(Element(2)));
-  p.apply(PartitionOp::Consume(Element(7)));
-  p.apply(PartitionOp::Consume(Element(10)));
+  p.apply(PartitionOp::Transfer(Element(2)));
+  p.apply(PartitionOp::Transfer(Element(7)));
+  p.apply(PartitionOp::Transfer(Element(10)));
 
   // expected: p: ({0 1 2 6 7 10} (3 4 5) (8 9) (Element(11)))
 
@@ -236,7 +236,7 @@ TEST(PartitionUtilsTest, TestCopyConstructor) {
   Partition p1;
   p1.apply(PartitionOp::AssignFresh(Element(0)));
   Partition p2 = p1;
-  p1.apply(PartitionOp::Consume(Element(0)));
+  p1.apply(PartitionOp::Transfer(Element(0)));
   bool failure = false;
   p1.apply(PartitionOp::Require(Element(0)), [&](const PartitionOp &, unsigned) {
       failure = true;