sub-optimal completion when completing a type

Consider the following code:

fn main() {
    do_thing($0)
}

struct SomeLongNamedStruct {
    bar: usize,
}

impl SomeLongNamedStruct {
    fn new() -> Self {
        Self { bar: 0 }
    }

    fn with_bar(bar: usize) -> Self {
        Self { bar }
    }
}

fn do_thing(x: SomeLongNamedStruct) {}

The completion at $0 will suggest SomeLongNamedStruct { bar: () }. It would be much nicer if it also suggested (probably one or the other, preference towards the latter).

• SomeLongNamedStruct:: (assumes that the type itself will have some associated function that might construct it)
• SomeLongNamedStruct::new() and SomeLongNamedStruct::with_bar() - these are associated methods found within the type that construct the type.

Right now, in order to get to SomeLongNamedStruct::new(), I have to either type it out myself, or accept the completion SomeLongNamedStruct { bar: () }, and then erase { bar: () } and then type ::.

Additionally:

• supposing the completion was do_thing(wit$0) it would be cool if it could suggest SomeLongNamedStruct::with_bar as well.
• supposing SomeLongNamedStruct implemented Default, it would also suggest Default::default() as a completion option as well.

Start by locating rust-analyzer's type-completion implementation and related completion tests, then reproduce the examples from the issue. Done means completion offers suitable constructors or associated-function forms, including the partial-name case, with tests covering the requested suggestions.