[region-isolation] Make sure to look through begin_access and don't treat it like an assignment.

If we treat a begin_access as an assignment then in cases like below we assume
that a value was used before we reassign.

```
  func testVarReassignStopActorDerived() async {
    var closure = {}
    await transferToMain(closure)

    // This re-assignment shouldn't error.
    closure = {}  // (1)
  }
```

rdar://117437299

Author: gottesmm

lib/SILOptimizer/Mandatory/SendNonSendable.cpp

@@ -885,7 +885,6 @@ class PartitionOpTranslator {
     //       treating some of these as lookthroughs in getUnderlyingTrackedValue
     //       instead of as assignments
     case SILInstructionKind::AddressToPointerInst:
-    case SILInstructionKind::BeginAccessInst:
     case SILInstructionKind::CopyValueInst:
     case SILInstructionKind::ConvertEscapeToNoEscapeInst:
     case SILInstructionKind::ConvertFunctionInst:
@@ -1070,6 +1069,25 @@ class PartitionOpTranslator {
     case SILInstructionKind::YieldInst: // TODO: yield should be handled
       return;
 
+    // We ignore begin_access since we look through them. We look through them
+    // since we want to treat the use of the begin_access as the semantic giving
+    // instruction. Otherwise, if we have a store after a consume we will emit
+    // an error on the begin_access rather than allowing for the store to
+    // overwrite the original value. This would then cause an error.
+    //
+    // Example:
+    //
+    //   %0 = alloc_stack
+    //   store %1 to %0
+    //   apply %transfer(%0)
+    //   %2 = begin_access [modify] [static] %0
+    //   store %2 to %0
+    //
+    // If we treated a begin_access as an assign, we would require %0 to not be
+    // transferred at %2 even though we are about to overwrite it.
+    case SILInstructionKind::BeginAccessInst:
+      return;
+
     default:
       break;
     }

test/Concurrency/sendnonsendable_basic.swift

@@ -174,8 +174,20 @@ extension Actor {
     let closure: () -> () = {
       print(self.klass)
     }
-    let x = (closure, 1)
+    let x = (1, closure)
     await transferToMain(x) // expected-sns-warning {{call site passes `self` or a non-sendable argument of this function to another thread, potentially yielding a race with the caller}}
+    // expected-complete-warning @-1 {{passing argument of non-sendable type '(Int, () -> ())' into main actor-isolated context may introduce data races}}
+    // expected-complete-note @-2 {{a function type must be marked '@Sendable' to conform to 'Sendable'}}
+  }
+
+  func simpleClosureCaptureSelfAndTransferThroughTupleBackwards() async {
+    let closure: () -> () = {
+      print(self.klass)
+    }
+    // NOTE: We do not error on this today since we assign into 1 and that makes
+    // x assign fresh. It will be fixed in a forthcoming commit.
+    let x = (closure, 1)
+    await transferToMain(x)
     // expected-complete-warning @-1 {{passing argument of non-sendable type '(() -> (), Int)' into main actor-isolated context may introduce data races}}
     // expected-complete-note @-2 {{a function type must be marked '@Sendable' to conform to 'Sendable'}}
   }
@@ -451,11 +463,11 @@ extension Actor {
 
     // This re-assignment shouldn't error.
     closure = {}
-    await transferToMain(closure)
+    await transferToMain(closure) // expected-sns-warning {{passing argument of non-sendable type '() -> ()' from actor-isolated context to main actor-isolated context at this call site could yield a race with accesses later in this function}}
     // expected-complete-warning @-1 {{passing argument of non-sendable type '() -> ()' into main actor-isolated context may introduce data races}}
     // expected-complete-note @-2 {{a function type must be marked '@Sendable' to conform to 'Sendable'}}
 
     // But this will error since we race.
-    closure()
+    closure() // expected-sns-note {{access here could race}}
   }
 }