Fix suggestions for nested refs and muts

Author: JohnTitor

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -2577,10 +2577,32 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                     && matches!(parent_pat.kind, hir::PatKind::Ref(..)) =>
                             {
                                 err.span_label(span, "you must specify a type for this binding");
+
+                                let mut ref_muts = Vec::new();
+                                let mut current_node = parent_node;
+
+                                while let Node::Pat(parent_pat) = current_node {
+                                    if let hir::PatKind::Ref(_, mutability) = parent_pat.kind {
+                                        ref_muts.push(mutability);
+                                        current_node = self.tcx.parent_hir_node(parent_pat.hir_id);
+                                    } else {
+                                        break;
+                                    }
+                                }
+
+                                let mut type_annotation = String::new();
+                                for mutability in ref_muts.iter().rev() {
+                                    match mutability {
+                                        hir::Mutability::Mut => type_annotation.push_str("&mut "),
+                                        hir::Mutability::Not => type_annotation.push('&'),
+                                    }
+                                }
+                                type_annotation.push_str(&concrete_type);
+
                                 err.span_suggestion_verbose(
                                     pat.span.shrink_to_hi(),
                                     "specify the type in the closure argument list",
-                                    format!(": &{concrete_type}"),
+                                    format!(": {type_annotation}"),
                                     Applicability::MaybeIncorrect,
                                 );
                             }

tests/ui/inference/ambiguous-numeric-in-closure-ref.fixed

@@ -6,4 +6,9 @@ fn main() {
     let _ = (0..10).filter(|&v: &i32| v.pow(2) > 0);
     //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
     //~| SUGGESTION &i32
+
+    let v = vec![0, 1, 2];
+    let _ = v.iter().filter(|&&v: &&i32| v.pow(2) > 0);
+    //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
+    //~| SUGGESTION &&i32
 }

tests/ui/inference/ambiguous-numeric-in-closure-ref.rs

@@ -6,4 +6,9 @@ fn main() {
     let _ = (0..10).filter(|&v| v.pow(2) > 0);
     //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
     //~| SUGGESTION &i32
+
+    let v = vec![0, 1, 2];
+    let _ = v.iter().filter(|&&v| v.pow(2) > 0);
+    //~^ ERROR can't call method `pow` on ambiguous numeric type `{integer}`
+    //~| SUGGESTION &&i32
 }

tests/ui/inference/ambiguous-numeric-in-closure-ref.stderr

@@ -11,6 +11,19 @@ help: specify the type in the closure argument list
 LL |     let _ = (0..10).filter(|&v: &i32| v.pow(2) > 0);
    |                               ++++++
 
-error: aborting due to 1 previous error
+error[E0689]: can't call method `pow` on ambiguous numeric type `{integer}`
+  --> $DIR/ambiguous-numeric-in-closure-ref.rs:11:37
+   |
+LL |     let _ = v.iter().filter(|&&v| v.pow(2) > 0);
+   |                                -    ^^^
+   |                                |
+   |                                you must specify a type for this binding
+   |
+help: specify the type in the closure argument list
+   |
+LL |     let _ = v.iter().filter(|&&v: &&i32| v.pow(2) > 0);
+   |                                 +++++++
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0689`.