question mark and try! obscure type inference errors

[tinaun]

use std::num::ParseIntError;

fn run() -> Result<(), ParseIntError> {
    let v = vec![1,2,3];

    let x = "1".parse()?;
    
    println!("{:?}", v[x]);    
    Ok(())
}

fn main() {
    let _ = run();
}

has the confusing error message

error[E0277]: the trait bound `(): std::str::FromStr` is not satisfied
 --> <anon>:6:17
  |
6 |     let x = "1".parse()?;
  |                 ^^^^^ the trait `std::str::FromStr` is not implemented for `()`

error[E0277]: the trait bound `std::vec::Vec<i32>: std::ops::Index<()>` is not satisfied
 --> <anon>:8:22
  |
8 |     println!("{:?}", v[x]);
  |                      ^^^^ the trait `std::ops::Index<()>` is not implemented for `std::vec::Vec<i32>`
  |
  = note: the type `std::vec::Vec<i32>` cannot be indexed by `()`

replacing the ? with .unwrap() gives a nicer explanation of the problem (try! gives the same error message as ?)

error[E0282]: unable to infer enough type information about `_`
 --> <anon>:6:9
  |
6 |     let x = "1".parse().unwrap();
  |         ^ cannot infer type for `_`
  |
  = note: type annotations or generic parameter binding required

[estebank]

Triage: no change.

[estebank]

Current output:

error[E0277]: the type `[i32]` cannot be indexed by `()`
 --> f71.rs:8:22
  |
8 |     println!("{:?}", v[x]);    
  |                      ^^^^ slice indices are of type `usize` or ranges of `usize`
  |
  = help: the trait `SliceIndex<[i32]>` is not implemented for `()`
  = help: the following other types implement trait `SliceIndex<T>`:
            <(Bound<usize>, Bound<usize>) as SliceIndex<str>>
            <(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>
  = note: required for `Vec<i32>` to implement `Index<()>`

error[E0277]: the trait bound `(): FromStr` is not satisfied
    --> f71.rs:6:17
     |
6    |     let x = "1".parse()?;
     |                 ^^^^^ the trait `FromStr` is not implemented for `()`
     |
     = help: the following other types implement trait `FromStr`:
               bool
               char
               isize
               i8
               i16
               i32
               i64
               i128
             and 29 others
note: required by a bound in `core::str::<impl str>::parse`
    --> /home/gh-estebank/rust/library/core/src/str/mod.rs:2310:21
     |
2310 |     pub fn parse<F: FromStr>(&self) -> Result<F, F::Err> {
     |                     ^^^^^^^ required by this bound in `core::str::<impl str>::parse`

[estebank]

Cases from #71685

fn fn2(s: &str) -> Result<(), ()> {
    let s = s.parse().map_err(|_| ())?;
    Ok(())
}

#![feature(associated_type_bounds)]
struct S;
fn fn1<I: IntoIterator<Item: AsRef<S>>>(_iter: I) -> Result<(), ()> {
    Ok(())
}

async fn fn2(s: &str) -> Result<(), ()> {
    let s = s.parse().map_err(|_| ())?; // <- Spurious type deduced
    fn1(std::iter::once(s)).map_err(|e| ())?;
    Ok(())
}