Always reborrow mutable reference receiver in methods

Author: HKalbasi

crates/hir-ty/src/method_resolution.rs

@@ -610,7 +610,6 @@ pub(crate) fn iterate_method_candidates<T>(
         name,
         mode,
         &mut |adj, item, visible| {
-            assert!(slot.is_none());
             if let Some(it) = callback(adj, item, visible) {
                 slot = Some(it);
                 return ControlFlow::Break(());
@@ -894,6 +893,7 @@ pub fn iterate_method_candidates_dyn(
             let mut table = InferenceTable::new(db, env.clone());
             let ty = table.instantiate_canonical(ty.clone());
             let deref_chain = autoderef_method_receiver(&mut table, ty);
+            let mut is_reborrowing = false;
 
             let result = deref_chain.into_iter().try_for_each(|(receiver_ty, adj)| {
                 iterate_method_candidates_with_autoref(
@@ -904,6 +904,7 @@ pub fn iterate_method_candidates_dyn(
                     traits_in_scope,
                     visible_from_module,
                     name,
+                    &mut is_reborrowing,
                     callback,
                 )
             });
@@ -932,6 +933,7 @@ fn iterate_method_candidates_with_autoref(
     traits_in_scope: &FxHashSet<TraitId>,
     visible_from_module: VisibleFromModule,
     name: Option<&Name>,
+    is_reborrowing: &mut bool,
     mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
 ) -> ControlFlow<()> {
     if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) {
@@ -952,7 +954,21 @@ fn iterate_method_candidates_with_autoref(
         )
     };
 
-    iterate_method_candidates_by_receiver(receiver_ty, first_adjustment.clone())?;
+    // If `is_reborrowing` is true, it means that there is a reborrow in progress, so we should
+    // directly go to the autoref step.
+    if !*is_reborrowing {
+        let without_autoref =
+            iterate_method_candidates_by_receiver(receiver_ty, first_adjustment.clone());
+        if without_autoref.is_break()
+            && matches!(receiver_ty.value.kind(Interner), TyKind::Ref(_, _, _))
+        {
+            // if `&&T` and `&T` are both applicable, we should prefer `&*&&T` to `&*&T`, so this
+            // flag exists
+            *is_reborrowing = true;
+            return ControlFlow::Continue(());
+        }
+        without_autoref?;
+    }
 
     let refed = Canonical {
         value: TyKind::Ref(Mutability::Not, static_lifetime(), receiver_ty.value.clone())

crates/hir-ty/src/tests/method_resolution.rs

@@ -388,6 +388,24 @@ mod bar_test {
     );
 }
 
+#[test]
+fn infer_trait_method_multiple_mutable_reference() {
+    check_types(
+        r#"
+trait Trait {
+    fn method(&mut self) -> i32 { 5 }
+}
+struct S;
+impl Trait for &mut &mut S {}
+fn test() {
+    let s = &mut &mut &mut S;
+    s.method();
+  //^^^^^^^^^^ i32
+}
+        "#,
+    );
+}
+
 #[test]
 fn infer_trait_method_generic_1() {
     // the trait implementation is intentionally incomplete -- it shouldn't matter
@@ -1722,7 +1740,7 @@ fn test() {
     Foo.foo();
   //^^^ adjustments: Borrow(Ref(Not))
     (&Foo).foo();
-  // ^^^^ adjustments: ,
+  // ^^^^ adjustments: Deref(None), Borrow(Ref(Not))
 }
 "#,
     );

crates/ide/src/inlay_hints/adjustment.rs

@@ -315,13 +315,17 @@ fn main() {
     (&Struct).consume();
    //^^^^^^^*
     (&Struct).by_ref();
+   //^^^^^^^&
+   //^^^^^^^*
 
     (&mut Struct).consume();
    //^^^^^^^^^^^*
     (&mut Struct).by_ref();
    //^^^^^^^^^^^&
    //^^^^^^^^^^^*
     (&mut Struct).by_ref_mut();
+   //^^^^^^^^^^^&mut $
+   //^^^^^^^^^^^*
 
     // Check that block-like expressions don't duplicate hints
     let _: &mut [u32] = (&mut []);
@@ -414,6 +418,10 @@ fn main() {
    //^^^^^^^)
    //^^^^^^^.*
     (&Struct).by_ref();
+   //^^^^^^^(
+   //^^^^^^^)
+   //^^^^^^^.*
+   //^^^^^^^.&
 
     (&mut Struct).consume();
    //^^^^^^^^^^^(
@@ -425,6 +433,10 @@ fn main() {
    //^^^^^^^^^^^.*
    //^^^^^^^^^^^.&
     (&mut Struct).by_ref_mut();
+   //^^^^^^^^^^^(
+   //^^^^^^^^^^^)
+   //^^^^^^^^^^^.*
+   //^^^^^^^^^^^.&mut
 
     // Check that block-like expressions don't duplicate hints
     let _: &mut [u32] = (&mut []);