Idea: Insert type names, or type-aware placeholders, in "Fill struct fields"

Right now, the “Fill struct fields” assist produces this result:

struct Foo {
    a: i32,
    b: Vec<i32>,
    c: Option<String>,
}

fn make() -> Foo {
    Foo {
        a: todo!(),            // generated code
        b: todo!(),            //
        c: todo!(),            //
    }
}

I think it would be useful if the placeholders indicated the type of the value that is needed. This would help guide filling in the blanks in situations where the value needed is obvious enough, but the type, the particular choice of representation, is not. (Maybe you're using an unfamiliar type, or maybe you just forgot which fields are Optional and which are not.)

One maybe-elegant way to do this would be to fill in todo!() arguments:

    Foo {
        a: todo!("need i32"),
        b: todo!("need Vec<i32>"),
        c: todo!("need Option<String>),
    }

It would also be frequently useful to fill in certain fields with their obvious default constructors (e.g. Option fields could be initialized with None). That is of course more hazardous since the user might forget to put in a non-placeholder value, but perhaps it could be offered as an alternative version of the assist to be used explicitly (much like creating modules offers options for foo.rs and foo/mod.rs). This would be harder, since it needs to know what idiomatic code to generate, if it doesn't resort to T::default().

    Foo {
        a: 0,
        b: vec![],
        c: None,
    }

Start by locating the rust-analyzer implementation and tests for the “Fill struct fields” assist, then inspect how it derives each field’s type. Compare the existing todo!() output with the proposed type-aware and default-constructor alternatives; done requires a decided behavior and tests covering the generated result.