In "specify type" suggestion, skip type params that are already known

[estebank]

When we suggest specifying a type for an expression or pattern, like in a let binding, we previously would print the entire type as the type system knew it. We now look at the params that have no inference variables, so they are fully known to the type system which means that they don't need to be specified.

This helps in suggestions for types that are really long, because we can usually skip most of the type params and make the annotation as short as possible:

error[E0282]: type annotations needed for `Result<_, ((..., ..., ..., ...), ..., ..., ...)>`
  --> $DIR/really-long-type-in-let-binding-without-sufficient-type-info.rs:7:9
   |
LL |     let y = Err(x);
   |         ^   ------ type must be known at this point
   |
help: consider giving `y` an explicit type, where the type for type parameter `T` is specified
   |
LL |     let y: Result<T, _> = Err(x);
   |          ++++++++++++++

Fix #135919.

[rustbot]

r? @petrochenkov

rustbot has assigned @petrochenkov.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

[rustbot]

Some changes occurred in need_type_info.rs

cc @lcnr

[petrochenkov]

r? compiler

[lcnr]

U've got an infcx here, use that instead of an inference var with index 0 as that one may actually be resolved at this point, breaking any (theoretical) later calls to resolve_vars_if_possible.

I also don't fully udnerstand the point of skip and why it's necessary. Please add a comment and more descriptive name for it

[lcnr]

r? @lcnr

[estebank]

@lcnr added explanations in the comments. Hopefully it's easier to follow now. The only thing I'd like to change is the name of the Folder, but can't think of a good name for it now that it does two things. It should be something that conveys "we take a Ty<'_> and make it suitable for presentation in a suggestion", and can't come up with something short to mean that :)

[estebank]

If there's a way to fold each param individually at this stage, then we could make it so we only avoid the type params like Vec<_, Alloc> and nothing else and we can likely get rid of the bool flag on self (if we can also make it so that consts don't get type erased too).

[lcnr]

if i understand u correctly, u can zip the generics with the ty::Adt(_, args) for that 🤔 you can then fold each arg manually and use Ty::new_adt instead of relying on super_fold_with

[estebank]

Let me know if this is the right approach for building that param list.

[lcnr]

why set all_infer to false here? if you've got Foo<T = u32>(T) and then encounter Foo<u32> as the inferred type, you can just replace Foo with _ here.

Given that all_infer only matters for whether we replace the whole adt with infer, I'd expect that we only replace the whole adt if it does not contain any infer vars, so you could make that check an early return and then not track all_infer at all?

[estebank]

Good catch. It was a mistake from faulty boolean logic caused by decaffeination :)

[estebank]

I had to change the order of the check because cont params are considered to be defaulted and infered, and that could replace things like struct S<const N: i32>; with _ incorrectly if I checked for defaults first. This seems to be intentional https://github.com/rust-lang/rust/blob/3594a19f2ae792cf99a1a78a5454e52cfd7affde/tests/ui/const-generics/defaults/doesnt_infer.rs, but doesn't sound entirely correct to me at first glance.

[lcnr]

This matches the behavior for type parameters:

struct Foo<T = u32>(T);

impl<T> Foo<T> {
    fn foo() -> Self {
        loop {}
    }
}

fn main() {
    let foo = Foo::<u32>::foo();
    let foo = Foo::foo(); // error
}

We only use generic arg defaults when specifying the non-defaulted generic args (modulo buggy behavior imo #136488)

Please use ty.has_infer() to decide whether the whole type should be replaced with infer before walking the adt args.

Also, you could look at what we do in the actual printing logic to decide whether to print default args:

struct Foo<T = u32, U = T>(T, U);

impl<T, U> Foo<T, U> {
    fn foo() -> Self {
        loop {}
    }
}

fn main() {
    let b = Foo::<Vec<_>>::foo(); // does not print `U`
}

[lcnr]

@bors r+ rollup

[bors]

📌 Commit 576db13 has been approved by lcnr

It is now in the queue for this repository.