produce suggestions which remove reference patterns

This doesn't yet respect whether patterns are from macro expansions, so
it may try to suggest changes within an expansion (leading to a test
failure).

Author: dianne

compiler/rustc_hir_typeck/src/pat.rs

@@ -2798,36 +2798,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // FIXME(ref_pat_eat_one_layer_2024): The migration diagnostic doesn't know how to track the
         // default binding mode in the presence of Rule 3 or Rule 5. As a consequence, the labels it
         // gives for default binding modes are wrong, as well as suggestions based on the default
-        // binding mode. This keeps it from making those suggestions, as doing so could panic.
-        let info = table.entry(pat_id).or_insert_with(|| ty::Rust2024IncompatiblePatInfo {
-            primary_labels: Vec::new(),
-            bad_modifiers: false,
-            bad_ref_pats: false,
-            suggest_eliding_modes: !self.tcx.features().ref_pat_eat_one_layer_2024()
-                && !self.tcx.features().ref_pat_eat_one_layer_2024_structural(),
-        });
+        // binding mode.
+        let info = table.entry(pat_id).or_default();
 
-        let pat_kind = if let PatKind::Binding(user_bind_annot, _, _, _) = subpat.kind {
+        let pat_kind = if matches!(subpat.kind, PatKind::Binding(..)) {
             info.bad_modifiers = true;
-            // If the user-provided binding modifier doesn't match the default binding mode, we'll
-            // need to suggest reference patterns, which can affect other bindings.
-            // For simplicity, we opt to suggest making the pattern fully explicit.
-            info.suggest_eliding_modes &=
-                user_bind_annot == BindingMode(ByRef::Yes(def_br_mutbl), Mutability::Not);
             "binding modifier"
         } else {
             info.bad_ref_pats = true;
-            // For simplicity, we don't try to suggest eliding reference patterns. Thus, we'll
-            // suggest adding them instead, which can affect the types assigned to bindings.
-            // As such, we opt to suggest making the pattern fully explicit.
-            info.suggest_eliding_modes = false;
             "reference pattern"
         };
         // Only provide a detailed label if the problematic subpattern isn't from an expansion.
         // In the case that it's from a macro, we'll add a more detailed note in the emitter.
         let primary_label = if from_expansion {
-            // We can't suggest eliding modifiers within expansions.
-            info.suggest_eliding_modes = false;
             // NB: This wording assumes the only expansions that can produce problematic reference
             // patterns and bindings are macros. If a desugaring or AST pass is added that can do
             // so, we may want to inspect the span's source callee or macro backtrace.

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -812,14 +812,12 @@ impl<'tcx> std::fmt::Display for UserTypeKind<'tcx> {
 
 /// Information on a pattern incompatible with Rust 2024, for use by the error/migration diagnostic
 /// emitted during THIR construction.
-#[derive(TyEncodable, TyDecodable, Debug, HashStable)]
+#[derive(TyEncodable, TyDecodable, Debug, Default, HashStable)]
 pub struct Rust2024IncompatiblePatInfo {
     /// Labeled spans for `&`s, `&mut`s, and binding modifiers incompatible with Rust 2024.
     pub primary_labels: Vec<(Span, String)>,
     /// Whether any binding modifiers occur under a non-`move` default binding mode.
     pub bad_modifiers: bool,
     /// Whether any `&` or `&mut` patterns occur under a non-`move` default binding mode.
     pub bad_ref_pats: bool,
-    /// If `true`, we can give a simpler suggestion solely by eliding explicit binding modifiers.
-    pub suggest_eliding_modes: bool,
 }

compiler/rustc_mir_build/src/errors.rs

@@ -1106,22 +1106,29 @@ pub(crate) struct Rust2024IncompatiblePat<'m> {
 }
 
 pub(crate) struct Rust2024IncompatiblePatSugg<'m> {
-    /// If true, our suggestion is to elide explicit binding modifiers.
-    /// If false, our suggestion is to make the pattern fully explicit.
-    pub(crate) suggest_eliding_modes: bool,
     pub(crate) suggestion: Vec<(Span, String)>,
+    /// If `Some(..)`, we provide a suggestion about either adding or removing syntax.
+    /// If `None`, we suggest both additions and removals; use a generic wording for simplicity.
+    pub(crate) kind: Option<Rust2024IncompatiblePatSuggKind>,
     pub(crate) ref_pattern_count: usize,
     pub(crate) binding_mode_count: usize,
     /// Labels for where incompatibility-causing by-ref default binding modes were introduced.
     pub(crate) default_mode_labels: &'m FxIndexMap<Span, ty::Mutability>,
 }
 
+pub(crate) enum Rust2024IncompatiblePatSuggKind {
+    Subtractive,
+    Additive,
+}
+
 impl<'m> Subdiagnostic for Rust2024IncompatiblePatSugg<'m> {
     fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
         self,
         diag: &mut Diag<'_, G>,
         _f: &F,
     ) {
+        use Rust2024IncompatiblePatSuggKind::*;
+
         // Format and emit explanatory notes about default binding modes. Reversing the spans' order
         // means if we have nested spans, the innermost ones will be visited first.
         for (&span, &def_br_mutbl) in self.default_mode_labels.iter().rev() {
@@ -1143,17 +1150,33 @@ impl<'m> Subdiagnostic for Rust2024IncompatiblePatSugg<'m> {
             } else {
                 Applicability::MaybeIncorrect
             };
-        let msg = if self.suggest_eliding_modes {
-            let plural_modes = pluralize!(self.binding_mode_count);
-            format!("remove the unnecessary binding modifier{plural_modes}")
-        } else {
-            let plural_derefs = pluralize!(self.ref_pattern_count);
-            let and_modes = if self.binding_mode_count > 0 {
-                format!(" and variable binding mode{}", pluralize!(self.binding_mode_count))
+        let msg = if let Some(kind) = self.kind {
+            let derefs = if self.ref_pattern_count > 0 {
+                format!("reference pattern{}", pluralize!(self.ref_pattern_count))
             } else {
                 String::new()
             };
-            format!("make the implied reference pattern{plural_derefs}{and_modes} explicit")
+            let modes = if self.binding_mode_count > 0 {
+                match kind {
+                    Subtractive => {
+                        format!("binding modifier{}", pluralize!(self.binding_mode_count))
+                    }
+                    Additive => {
+                        format!("variable binding mode{}", pluralize!(self.binding_mode_count))
+                    }
+                }
+            } else {
+                String::new()
+            };
+            let and = if !derefs.is_empty() && !modes.is_empty() { " and " } else { "" };
+            match kind {
+                Subtractive => format!("remove the unnecessary {derefs}{and}{modes}"),
+                Additive => {
+                    format!("make the implied {derefs}{and}{modes} explicit")
+                }
+            }
+        } else {
+            "rewrite the pattern".to_owned()
         };
         // FIXME(dianne): for peace of mind, don't risk emitting a 0-part suggestion (that panics!)
         if !self.suggestion.is_empty() {