Rollup merge of #124313 - estebank:split-at-mut, r=fee1-dead

Detect borrow error involving sub-slices and suggest `split_at_mut`

```
error[E0499]: cannot borrow `foo` as mutable more than once at a time
  --> $DIR/suggest-split-at-mut.rs:13:18
   |
LL |     let a = &mut foo[..2];
   |                  --- first mutable borrow occurs here
LL |     let b = &mut foo[2..];
   |                  ^^^ second mutable borrow occurs here
LL |     a[0] = 5;
   |     ---- first borrow later used here
   |
   = help: use `.split_at_mut(position)` or similar method to obtain two mutable non-overlapping sub-slices
```

Address most of #58792.

For follow up work, we should emit a structured suggestion for cases where we can identify the exact `let (a, b) = foo.split_at_mut(2);` call that is needed.

2 files changed, 131 insertions, 5 deletions

diff --git a/tests/ui/suggestions/suggest-split-at-mut.rs b/tests/ui/suggestions/suggest-split-at-mut.rs
index d294c20b824..61704abbd36 100644
--- a/tests/ui/suggestions/suggest-split-at-mut.rs
+++ b/tests/ui/suggestions/suggest-split-at-mut.rs
@@ -1,4 +1,4 @@
-fn main() {
+fn foo() {
     let mut foo = [1, 2, 3, 4];
     let a = &mut foo[2];
     let b = &mut foo[3]; //~ ERROR cannot borrow `foo[_]` as mutable more than once at a time
@@ -6,3 +6,57 @@ fn main() {
     *b = 6;
     println!("{:?} {:?}", a, b);
 }
+
+fn bar() {
+    let mut foo = [1,2,3,4];
+    let a = &mut foo[..2];
+    let b = &mut foo[2..]; //~ ERROR cannot borrow `foo` as mutable more than once at a time
+    a[0] = 5;
+    b[0] = 6;
+    println!("{:?} {:?}", a, b);
+}
+
+fn baz() {
+    let mut foo = [1,2,3,4];
+    let a = &foo[..2];
+    let b = &mut foo[2..]; //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
+    b[0] = 6;
+    println!("{:?} {:?}", a, b);
+}
+
+fn qux() {
+    let mut foo = [1,2,3,4];
+    let a = &mut foo[..2];
+    let b = &foo[2..]; //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
+    a[0] = 5;
+    println!("{:?} {:?}", a, b);
+}
+
+fn bad() {
+    let mut foo = [1,2,3,4];
+    let a = &foo[1];
+    let b = &mut foo[2]; //~ ERROR cannot borrow `foo[_]` as mutable because it is also borrowed as immutable
+    *b = 6;
+    println!("{:?} {:?}", a, b);
+}
+
+fn bat() {
+    let mut foo = [1,2,3,4];
+    let a = &mut foo[1];
+    let b = &foo[2]; //~ ERROR cannot borrow `foo[_]` as immutable because it is also borrowed as mutable
+    *a = 5;
+    println!("{:?} {:?}", a, b);
+}
+
+fn ang() {
+    let mut foo = [1,2,3,4];
+    let a = &mut foo[0..];
+    let b = &foo[0..]; //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
+    a[0] = 5;
+    println!("{:?} {:?}", a, b);
+}
+
+fn main() {
+    foo();
+    bar();
+}
diff --git a/tests/ui/suggestions/suggest-split-at-mut.stderr b/tests/ui/suggestions/suggest-split-at-mut.stderr
index c42f09e3201..4502ec1f393 100644
--- a/tests/ui/suggestions/suggest-split-at-mut.stderr
+++ b/tests/ui/suggestions/suggest-split-at-mut.stderr
@@ -8,9 +8,81 @@ LL |     let b = &mut foo[3];
 LL |     *a = 5;
    |     ------ first borrow later used here
    |
-   = help: consider using `.split_at_mut(position)` or similar method to obtain two mutable non-overlapping sub-slices
-   = help: consider using `.swap(index_1, index_2)` to swap elements at the specified indices
+   = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
 
-error: aborting due to 1 previous error
+error[E0499]: cannot borrow `foo` as mutable more than once at a time
+  --> $DIR/suggest-split-at-mut.rs:13:18
+   |
+LL |     let a = &mut foo[..2];
+   |                  --- first mutable borrow occurs here
+LL |     let b = &mut foo[2..];
+   |                  ^^^ second mutable borrow occurs here
+LL |     a[0] = 5;
+   |     ---- first borrow later used here
+   |
+   = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
+
+error[E0502]: cannot borrow `foo` as mutable because it is also borrowed as immutable
+  --> $DIR/suggest-split-at-mut.rs:22:18
+   |
+LL |     let a = &foo[..2];
+   |              --- immutable borrow occurs here
+LL |     let b = &mut foo[2..];
+   |                  ^^^ mutable borrow occurs here
+LL |     b[0] = 6;
+LL |     println!("{:?} {:?}", a, b);
+   |                           - immutable borrow later used here
+   |
+   = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
+
+error[E0502]: cannot borrow `foo` as immutable because it is also borrowed as mutable
+  --> $DIR/suggest-split-at-mut.rs:30:14
+   |
+LL |     let a = &mut foo[..2];
+   |                  --- mutable borrow occurs here
+LL |     let b = &foo[2..];
+   |              ^^^ immutable borrow occurs here
+LL |     a[0] = 5;
+   |     ---- mutable borrow later used here
+   |
+   = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
+
+error[E0502]: cannot borrow `foo[_]` as mutable because it is also borrowed as immutable
+  --> $DIR/suggest-split-at-mut.rs:38:13
+   |
+LL |     let a = &foo[1];
+   |             ------- immutable borrow occurs here
+LL |     let b = &mut foo[2];
+   |             ^^^^^^^^^^^ mutable borrow occurs here
+LL |     *b = 6;
+LL |     println!("{:?} {:?}", a, b);
+   |                           - immutable borrow later used here
+   |
+   = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
+
+error[E0502]: cannot borrow `foo[_]` as immutable because it is also borrowed as mutable
+  --> $DIR/suggest-split-at-mut.rs:46:13
+   |
+LL |     let a = &mut foo[1];
+   |             ----------- mutable borrow occurs here
+LL |     let b = &foo[2];
+   |             ^^^^^^^ immutable borrow occurs here
+LL |     *a = 5;
+   |     ------ mutable borrow later used here
+   |
+   = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
+
+error[E0502]: cannot borrow `foo` as immutable because it is also borrowed as mutable
+  --> $DIR/suggest-split-at-mut.rs:54:14
+   |
+LL |     let a = &mut foo[0..];
+   |                  --- mutable borrow occurs here
+LL |     let b = &foo[0..];
+   |              ^^^ immutable borrow occurs here
+LL |     a[0] = 5;
+   |     ---- mutable borrow later used here
+
+error: aborting due to 7 previous errors
 
-For more information about this error, try `rustc --explain E0499`.
+Some errors have detailed explanations: E0499, E0502.
+For more information about an error, try `rustc --explain E0499`.