Type inference for `todo!()` breaks inside a tuple

[Storyyeller]

Type inference for todo!() works if it is the sole element returned from a map closure, but breaks as soon as it is placed inside a tuple. playground link: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=1cfae6d57f44f603fa2eb258d332c7ab

I tried this code:

fn foo(_: Vec<(u32, String)>) {}


fn main() {
 foo((0..6).into_iter().map(|i| (i, todo!())).collect())
}

I expected to see this happen: compiles

Instead, this happened: compile error

error[E0277]: a value of type `Vec<(u32, String)>` cannot be built from an iterator over elements of type `({integer}, !)`
 --> src/main.rs:5:50
 |
5 | foo((0..6).into_iter().map(|i| (i, todo!())).collect())
 | --- ^^^^^^^ value of type `Vec<(u32, String)>` cannot be built from `std::iter::Iterator<Item=({integer}, !)>`
 | |
 | required by a bound introduced by this call

Meta

I checked "nightly" on the playground and the same compile error happens.

[Storyyeller]

Note: This is a simplified example based on an issue I ran into in a much larger project when using todo!() as a placeholder while incrementally refactoring some code.

[edward-shen]

Smaller repro:

fn main() {
 let _: Vec<(i32,)> = [(todo!(),)].into_iter().collect();
}

repros on 1.65.0-nightly (2022-08-16 86c6ebee8fa0a5ad1e18)

[edward-shen]

Oh, this just fails with just tuples: (playground)

fn main() {
 let _: (i32,) = (todo!(),).into();
}

[compiler-errors]

For the record, changing todo!() to { todo!() } in both of these examples forces the coercion machinery to treat todo!() as having type _ and not !, which makes inference work.

That being said, in some cases adding {} to generalize things causes its problems, for example:

#![feature(never_type)]

struct A;

struct B;

trait Foo {
 type Output;

 fn foo(&self) -> Self::Output;
}

impl Foo for ! {
 type Output = A;

 fn foo(&self) -> A {
 A
 }
}

impl Foo for i32 {
 type Output = B;

 fn foo(&self) -> B {
 B
 }
}

fn main() {
 //let x = todo!().foo(); // Works
 let x = { todo!() }.foo(); // Doesn't work
}