Type Inference not working when indexing with Into<usize> types

[callym]

I have an enum Dim { X, Y, Z } that I've implemented Into<usize> for, so I can use it instead of 0, 1, 2, but I get type inference errors when using it. I've narrowed it down to this playground example.

If you change the last line to let c: i32 = a[i.into()]; then it gives an error about not knowing the type for i.into(), despite there only being one type that it can be?
I can use a[i as usize] which works fine for this case, but not sure why using .into() breaks things so badly.

enum I {
    X,
    Y,
    Z,
}

impl Into<usize> for I {
    fn into(self) -> usize {
        0
    }
}

fn main() {
    let a = vec![1i32, 2, 3];
    let i = I::X;
    let c = a[0];
    let c = a[i.into()];
}

(Playground)

Errors:

   Compiling playground v0.0.1 (file:///playground)
error[E0282]: type annotations needed
  --> src/main.rs:17:9
   |
17 |     let c = a[i.into()];
   |         ^
   |         |
   |         cannot infer type for `_`
   |         consider giving `c` a type

error: aborting due to previous error

For more information about this error, try `rustc --explain E0282`.
error: Could not compile `playground`.

To learn more, run the command again with --verbose.

[cuviper]

Dim also implements Into<Dim>, due to the generic From<T> for T, so that's another candidate for i.into(). The vector can Index<usize>, but also Index<Range<usize>> and all.

In theory the compiler could still figure out that Dim as Into<usize> and Vec as Index<usize> are the only ones that match up, especially after you annotated that it must output i32, but I don't think it's smart enough for that.

IOW I think you're right that there's only one possible solution that could be inferred, but it's probably more complicated than you're imagining to get there.

[cuviper]

Actually it's even more complicated than I said, because Index for Vec is generic on SliceIndex:
https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-Index%3CI%3E

There's a whole lot of type indirection in your little example...

[Spoonbender]

Triage: no change

[estebank]

Current output:

error[E0282]: type annotations needed
  --> f71.rs:17:9
   |
17 |     let c = a[i.into()];
   |         ^
   |
help: consider giving `c` an explicit type
   |
17 |     let c: /* Type */ = a[i.into()];
   |          ++++++++++++

error[E0283]: type annotations needed
  --> f71.rs:17:17
   |
17 |     let c = a[i.into()];
   |                 ^^^^
   |
note: multiple `impl`s satisfying `I: Into<_>` found
  --> f71.rs:7:1
   |
7  | impl Into<usize> for I {
   | ^^^^^^^^^^^^^^^^^^^^^^
   = note: and another `impl` found in the `core` crate:
           - impl<T, U> Into<U> for T
             where U: From<T>;
help: try using a fully qualified path to specify the expected types
   |
17 |     let c = a[<I as Into<T>>::into(i)];
   |               +++++++++++++++++++++ ~