Add if let, while let and match arm inlay hints

[SomeoneToIgnore]

Add more inline hints support.
Looks like while let type inference support is missing currently, so the corresponding hint tests lack the actual results.

I've also could not find a good way to distinguish between a and b pats in the following expressions:
if let Some(Test { a: None, b: y }) = &test {};

In this case we don't need to add a hint for first pat (a: None), since it's matched against the particular enum variant and need a hint for y, since it's a new variable.
But both a and b are BIND_PAT with similar contents, so looks like there's nothing I can check for to find any differences.

I don't display any hints for such cases now, to avoid confusion, but would be nice to know if there's a way to fix this behavior.

[matklad]

I've also could not find a good way to distinguish between a and b pats in the following expressions:

see #1618

[matklad]

Perhaps, instead of visiting every construction where a pattern might appear, we should just visit BindPat directly?

[matklad]

Not sure which approach will be better though!

[SomeoneToIgnore]

Is there a way to get a PatKind of a parent node from the BindPat?
I know how to get the SyntaxKind, but I need more to determine whether to add a hint or not based on the data about the Pat: for instance, for let bindings that have an ascribed type we don't display a type hint.

Otherwise it seems like a nice idea, seems to be of more or less the same complexity to the current implementation.
But I think I've covered all the cases we need the type hints for, haven't I?
If so, it might be ok to leave the code as is and refactor it after the #1618 is done, since it will help a lot with detecting the leaf BindPats.

[matklad]

Is there a way to get a PatKind of a parent node from the BindPat

pat.syntax().parent().and_then(ast::Pat::cast).map(|it| it.kind())

If so, it might be ok to leave the code as is and refactor it after the #1618 is done, since it will help a lot with detecting the leaf BindPats.

Makes sense!

[SomeoneToIgnore]

Makes sense!

@matklad , the time had come to continue the discussion :)
I'm trying to apply the

Perhaps, instead of visiting every construction where a pattern might appear, we should just visit BindPat directly?

suggestion as

ast::BindPat(it) => {
    let pat = dbg!(dbg!(it).pat())?;
    let ty = dbg!(analyzer.type_of_pat(db, &pat))?;
    if ty.is_unknown() {
        return None;
    }

    acc.push(
        InlayHint {
            range: pat.syntax().text_range(),
            kind: InlayKind::TypeHint,
            label: ty.display_truncated(db, max_inlay_hint_length).to_string().into(),
        }
    );
},

yet in every test the pat is None:

[crates/ra_ide/src/inlay_hints.rs:94] it = BindPat {
    syntax: BIND_PAT@[69; 71)
      NAME@[69; 71)
        IDENT@[69; 71) "zz"
    ,
}
[crates/ra_ide/src/inlay_hints.rs:94] dbg!(it).pat() = None
[crates/ra_ide/src/inlay_hints.rs:94] it = BindPat {
    syntax: BIND_PAT@[105; 111)
      NAME@[105; 111)
        IDENT@[105; 111) "zz_ref"
    ,
}
[crates/ra_ide/src/inlay_hints.rs:94] dbg!(it).pat() = None

Is there something that I'm missing?

[SomeoneToIgnore]

Oh, looks like let pat = ast::Pat::from(it); should be used instead of let pat =it.pat()?;
What does the latter method return then?

[flodiebold]

It returns the pattern in name @ pattern syntax.

[SomeoneToIgnore]

Hm, interesting usecase for the type hints actually, thank you.

[SomeoneToIgnore]

By the way, I start to feel like specifying all sorts of different patters in InlayKind is a mistake.
Should we instead merge all current kinds into the TypeHint or something?

[matklad]

I am fine with merging them, yes. It wouldn't be hard to add it back, if we want to, for example, filter them on the client

[matklad]

bors r+

[bors]

Build succeeded

• continuous-integration/travis-ci/push