Auto completion should use fully qualified syntax in case of ambiguity

[PRO-2684]

rust-analyzer version: 0.3.2257-standalone

rustc version: 1.83.0 (90b35a623 2024-11-26)

editor or extension: VSCode, with [email protected]

relevant settings: N/A

repository link (if public, optional): N/A

code snippet to reproduce:

fn main() {
    trait Animal {
        fn baby_name() -> String;
    }
    struct Dog;
    impl Dog {
        fn baby_name() -> String {
            "Spot".into()
        }
    }
    impl Animal for Dog {
        fn baby_name() -> String {
            "puppy".into()
        }
    }
    // Try typing: `println!("{}", Dog::);`, and here's the top-2 suggestions RA gave me:
    // 1. `baby_name()`
    // 2. `baby_name()` (as `Animal`)
    // After choosing the second one, this is what RA auto-completed:
    println!("{}", Dog::baby_name()); // Prints "Spot"
    // While I expected:
    println!("{}", <Dog as Animal>::baby_name()); // Prints "puppy"
}

[ChayimFriedman2]

The code completed is correct, why should we prefer UFCS?

[lnicola]

I think the point is that we should use UFCS if the user picks a trait method that's shadowed by an inherent one?

[ChayimFriedman2]

Ah yes sorry, I thought there wasn't ambiguity.

[PRO-2684]

This issue can also be observed from methods with &self. For example:

fn main() {
    trait Pilot {
        fn fly(&self);
    }
    trait Wizard {
        fn fly(&self);
    }
    struct Human;
    impl Pilot for Human {
        fn fly(&self) {
            println!("This is your captain speaking.");
        }
    }
    impl Wizard for Human {
        fn fly(&self) {
            println!("Up!");
        }
    }
    let person = Human;
    // Try typing: `person.f`, and RA will suggest: `fly()` (as `Wizard`)
    // Note that it doesn't provide suggestion for (as `Pilot`)
    // When I accept the auto-completion, it gave me:
    person.fly(); // `rustc` would complain: multiple applicable items in scope
    // The expected behavior should be suggesting all applicable items:
    // 1. `fly()` (as `Wizard`)
    // 2. `fly()` (as `Pilot`)
    // And use the following syntax to avoid ambiguity:
    Pilot::fly(&person);
    Wizard::fly(&person);
}

[Veykril]

Note that we have some construction logic for this in the qualify assist (so there should be possibility of code sharing for the completions)

[davidsemakula]

@rustbot claim