MoveOnlyAddressChecker: Treat opaque accesses consistently in CopiedLoadBorrowEliminationVisitor.

lib/SILGen/SILGenDecl.cpp

@@ -1726,8 +1726,7 @@ void SILGenFunction::emitStmtCondition(StmtCondition Cond, JumpDest FalseDest,
           // Begin a new binding scope, which is popped when the next innermost debug
           // scope ends. The cleanup location loc isn't the perfect source location
           // but it's close enough.
-          B.getSILGenFunction().enterDebugScope(loc,
-                                                      /*isBindingScope=*/true);
+          B.getSILGenFunction().enterDebugScope(loc, /*isBindingScope=*/true);
         InitializationPtr initialization =
           emitPatternBindingInitialization(elt.getPattern(), FalseDest);
 

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1573,6 +1573,19 @@ struct CopiedLoadBorrowEliminationState {
   }
 };
 
+static bool shouldVisitAsEndPointUse(Operand *op) {
+  // If an access is static and marked as "no nested conflict", we use that
+  // in switch codegen to mark an opaque sub-access that move-only checking
+  // should not look through.
+  if (auto ba = dyn_cast<BeginAccessInst>(op->getUser())) {
+    if (ba->getEnforcement() == SILAccessEnforcement::Static
+        && ba->hasNoNestedConflict()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /// An early transform that we run to convert any load_borrow that are copied
 /// directly or that have any subelement that is copied to a load [copy]. This
 /// lets the rest of the optimization handle these as appropriate.
@@ -1583,6 +1596,10 @@ struct CopiedLoadBorrowEliminationVisitor
   CopiedLoadBorrowEliminationVisitor(CopiedLoadBorrowEliminationState &state)
       : state(state) {}
 
+  bool visitTransitiveUseAsEndPointUse(Operand *op) {
+    return shouldVisitAsEndPointUse(op);
+  }
+
   bool visitUse(Operand *op) {
     LLVM_DEBUG(llvm::dbgs() << "CopiedLBElim visiting ";
                llvm::dbgs() << " User: " << *op->getUser());
@@ -1978,16 +1995,7 @@ struct GatherUsesVisitor : public TransitiveAddressWalker<GatherUsesVisitor> {
 } // end anonymous namespace
 
 bool GatherUsesVisitor::visitTransitiveUseAsEndPointUse(Operand *op) {
-  // If an access is static and marked as "no nested conflict", we use that
-  // in switch codegen to mark an opaque sub-access that move-only checking
-  // should not look through.
-  if (auto ba = dyn_cast<BeginAccessInst>(op->getUser())) {
-    if (ba->getEnforcement() == SILAccessEnforcement::Static
-        && ba->hasNoNestedConflict()) {
-      return true;
-    }
-  }
-  return false;
+  return shouldVisitAsEndPointUse(op);
 }
 
 // Filter out recognized uses that do not write to memory.

test/SILOptimizer/moveonly_borrowing_switch_load_borrow.swift

@@ -0,0 +1,27 @@
+// RUN: %target-swift-frontend -enable-experimental-feature BorrowingSwitch -enable-experimental-feature NoncopyableGenerics -emit-sil -verify %s
+
+struct Box<Wrapped: ~Copyable>: ~Copyable {
+    init(_ element: consuming Wrapped) { }
+}
+
+struct Tree<Element>: ~Copyable {
+    struct Node: ~Copyable { }
+
+    enum Branch: ~Copyable {
+        case empty
+        case more(Box<Node>)
+    }
+    var root: Branch = .empty
+}
+
+extension Tree {
+    mutating func insert(_ element: consuming Element) {
+        root =
+            switch root {
+            case .empty:
+                    .more(Box(Node()))
+            case .more:
+                fatalError()
+            }
+    }
+}