don't suggest removing the open parenthesis in &(...)

If the inside of a `&` pattern has excess parentheses, the span for the
`&`'s subpattern in the HIR will point inside the parens. Thus, if we
suggest removing the `&`, we have to be careful about anything in
between the `&` and the subpattern in the source.

Author: dianne

compiler/rustc_mir_build/src/thir/pattern/migration.rs

@@ -7,6 +7,7 @@ use rustc_index::IndexVec;
 use rustc_lint as lint;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeckResults};
+use rustc_span::source_map::SourceMap;
 use rustc_span::{Ident, Span};
 
 use crate::errors::*;
@@ -113,7 +114,7 @@ impl<'a> PatMigration<'a> {
         for (span, label) in self.labels {
             spans.push_span_label(*span, label.clone());
         }
-        let sugg = self.build_suggestion(typeck_results);
+        let sugg = self.build_suggestion(tcx.sess.source_map(), typeck_results);
         // If a relevant span is from at least edition 2024, this is a hard error.
         let is_hard_error = spans.primary_spans().iter().any(|span| span.at_least_rust_2024());
         if is_hard_error {
@@ -135,8 +136,9 @@ impl<'a> PatMigration<'a> {
         }
     }
 
-    fn build_suggestion(
+    fn build_suggestion<'tcx>(
         &self,
+        source_map: &'tcx SourceMap,
         typeck_results: &'a TypeckResults<'_>,
     ) -> Rust2024IncompatiblePatSugg {
         let mut removed_modifiers = 0;
@@ -167,7 +169,10 @@ impl<'a> PatMigration<'a> {
             PatDerefKind::Explicit { inner_span } if !deref.suggest => {
                 // This is a ref pattern in the source but not the suggestion; suggest removing it.
                 removed_ref_pats += 1;
-                Some((deref.span.with_hi(inner_span.lo()), String::new()))
+                // Avoid eating the '(' in `&(...)`
+                let span = source_map.span_until_char(deref.span.with_hi(inner_span.lo()), '(');
+                // But *do* eat the ' ' in `&mut [...]`
+                Some((source_map.span_extend_while_whitespace(span), String::new()))
             }
             PatDerefKind::Implicit { hir_id } if deref.suggest => {
                 // This is a ref pattern in the suggestion but not the source; suggest adding it.

tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed

@@ -228,4 +228,9 @@ fn main() {
     assert_type_eq(b, &0u32);
     assert_type_eq(c, &[0u32]);
     assert_type_eq(d, 0u32);
+
+    // Test that we don't remove excess open parentheses when removing reference patterns
+    let [(_)] = &[&0];
+    //~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.rs

@@ -228,4 +228,9 @@ fn main() {
     assert_type_eq(b, &0u32);
     assert_type_eq(c, &[0u32]);
     assert_type_eq(d, 0u32);
+
+    // Test that we don't remove excess open parentheses when removing reference patterns
+    let [&(_)] = &[&0];
+    //~^ ERROR: this pattern relies on behavior which may change in edition 2024
+    //~| WARN: this changes meaning in Rust 2024
 }

tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr

@@ -380,5 +380,19 @@ LL -     let [Foo(&ref a @ [ref b]), Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
 LL +     let [&Foo(a @ [b]), &Foo(&ref c @ [d])] = [&Foo(&[0]); 2];
    |
 
-error: aborting due to 27 previous errors
+error: this pattern relies on behavior which may change in edition 2024
+  --> $DIR/migration_lint.rs:233:10
+   |
+LL |     let [&(_)] = &[&0];
+   |          ^^ cannot implicitly match against multiple layers of reference
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
+help: make the reference pattern implicit
+   |
+LL -     let [&(_)] = &[&0];
+LL +     let [(_)] = &[&0];
+   |
+
+error: aborting due to 28 previous errors