[region-isolation] Do not squelch errors in the unittests.

To squelch errors, we need access to functionality not available in the
unittests. The unittests do not require this functionality anyways, so just
disable squelching during the unittests.

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -875,27 +875,37 @@ struct PartitionOpEvaluator {
       apply(o);
   }
 
+  /// Provides a way for subclasses to disable the error squelching
+  /// functionality.
+  ///
+  /// Used by the unittests.
+  bool shouldTryToSquelchErrors() const {
+    return asImpl().shouldTryToSquelchErrors();
+  }
+
 private:
   // Private helper that squelches the error if our transfer instruction and our
   // use have the same isolation.
   void
   handleLocalUseAfterTransferHelper(const PartitionOp &op, Element elt,
                                     TransferringOperand *transferringOp) const {
-    if (auto isolationInfo = SILIsolationInfo::get(op.getSourceInst())) {
-      if (isolationInfo.isActorIsolated() &&
-          isolationInfo == SILIsolationInfo::get(transferringOp->getUser()))
-        return;
-    }
+    if (shouldTryToSquelchErrors()) {
+      if (auto isolationInfo = SILIsolationInfo::get(op.getSourceInst())) {
+        if (isolationInfo.isActorIsolated() &&
+            isolationInfo == SILIsolationInfo::get(transferringOp->getUser()))
+          return;
+      }
 
-    // If our instruction does not have any isolation info associated with it,
-    // it must be nonisolated. See if our function has a matching isolation to
-    // our transferring operand. If so, we can squelch this.
-    if (auto functionIsolation =
-            transferringOp->getUser()->getFunction()->getActorIsolation()) {
-      if (functionIsolation->isActorIsolated() &&
-          SILIsolationInfo::getActorIsolated(*functionIsolation) ==
-              SILIsolationInfo::get(transferringOp->getUser()))
-        return;
+      // If our instruction does not have any isolation info associated with it,
+      // it must be nonisolated. See if our function has a matching isolation to
+      // our transferring operand. If so, we can squelch this.
+      if (auto functionIsolation =
+              transferringOp->getUser()->getFunction()->getActorIsolation()) {
+        if (functionIsolation->isActorIsolated() &&
+            SILIsolationInfo::getActorIsolated(*functionIsolation) ==
+                SILIsolationInfo::get(transferringOp->getUser()))
+          return;
+      }
     }
 
     // Ok, we actually need to emit a call to the callback.
@@ -970,6 +980,9 @@ struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
   /// 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; }
+
+  /// By default squelch errors.
+  bool shouldTryToSquelchErrors() const { return true; }
 };
 
 /// A subclass of PartitionOpEvaluatorBaseImpl that doesn't have any special

unittests/SILOptimizer/PartitionUtilsTest.cpp

@@ -47,6 +47,8 @@ struct MockedPartitionOpEvaluator final
   SILIsolationInfo getIsolationRegionInfo(Element elt) const {
     return SILIsolationInfo::getDisconnected();
   }
+
+  bool shouldTryToSquelchErrors() const { return false; }
 };
 
 } // namespace
@@ -566,6 +568,8 @@ struct MockedPartitionOpEvaluatorWithFailureCallback final
   SILIsolationInfo getIsolationRegionInfo(Element elt) const {
     return SILIsolationInfo::getDisconnected();
   }
+
+  bool shouldTryToSquelchErrors() const { return false; }
 };
 
 } // namespace