Type inference incorrectly selects specialized instance of type parameter

[sfackler]

#![feature(specialization)]
use std::vec;

struct Foo<T>(T);

impl<T> Foo<T> {
    fn foo<I: IntoIterator<Item = T>>(it: I) -> Foo<T> {
        <Self as SpecExtend<_, _>>::from_iter(it.into_iter())
    }
}

trait SpecExtend<T, I> {
    fn from_iter(iter: I) -> Self;
}

impl<T, I> SpecExtend<T, I> for Foo<T>
    where I: Iterator<Item = T>
{
    default fn from_iter(iter: I) -> Self {
        panic!()
    }

}

impl<T> SpecExtend<T, vec::IntoIter<T>> for Foo<T> {
    fn from_iter(iter: vec::IntoIter<T>) -> Self {
        panic!()
    }
}

fn main() {}

rustc 1.17.0-nightly (134c4a0f0 2017-03-20)
error[E0308]: mismatched types
 --> <anon>:8:47
  |
8 |         <Self as SpecExtend<_, _>>::from_iter(it.into_iter())
  |                                               ^^^^^^^^^^^^^^ expected struct `std::vec::IntoIter`, found associated type
  |
  = note: expected type `std::vec::IntoIter<T>`
             found type `<I as std::iter::IntoIterator>::IntoIter`

error: aborting due to previous error

@aturon

[sfackler]

Minimized from sfackler@c674b23

[sfackler]

@withoutboats pointed out that if you adjust line 8 to <Self as SpecExtend<T, I::IntoIter>>::from_iter(it.into_iter()), it compiles properly, so it looks like a type inference issue.

[dodheim]

Here's another repro (I think) that I made before I came across this issue:

#![feature(specialization)]

use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};

trait Tag {}
struct TagA;
struct TagB;
struct TagC;
impl Tag for TagA {}
impl Tag for TagB {}
impl Tag for TagC {}

struct Foo<T: Tag> { data: [i32; 8], _pd: PhantomData<T> }

impl<T: Tag> Deref for Foo<T> {
    type Target = [i32];
    default fn deref(&self) -> &Self::Target { &self.data[..7] }
}
impl<T: Tag> DerefMut for Foo<T> {
    default fn deref_mut(&mut self) -> &mut Self::Target { &mut self.data[..7] }
}

impl Deref for Foo<TagA> {
    fn deref(&self) -> &Self::Target { &self.data[1..] }
}
impl DerefMut for Foo<TagA> {
    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.data[1..] }
}

trait FooBuilder: Sized
  + DerefMut<Target = [i32]> // ***
{
    fn new_foo(data: [i32; 8]) -> Self;
}
impl<T: Tag> FooBuilder for Foo<T> {
    fn new_foo(data: [i32; 8]) -> Self { Self { data, _pd: PhantomData } }
}

struct Bar<T: Tag>(Foo<T>);
impl<T: Tag> Bar<T> {
    fn new(data: [i32; 8]) -> Self { Bar(Foo::new_foo(data)) } // !!!
}

fn main() {
    let data = [0i32; 8];
    let _: Bar<TagA> = Bar::new(data);
    let _: Bar<TagB> = Bar::new(data);
    let _: Bar<TagC> = Bar::new(data);
}

Commenting the line marked *** compiles, but leaving it uncommented yields (rustc 1.19.0-nightly (03abb1b 2017-06-13)):

error[E0308]: mismatched types
  --> src/main.rs:42:42
   |
42 |     fn new(data: [i32; 8]) -> Self { Bar(Foo::new_foo(data)) } // !!!
   |                                          ^^^^^^^^^^^^^^^^^^ expected type parameter, found struct `TagA`
   |
   = note: expected type `Foo<T>`
              found type `Foo<TagA>`

Though it's redundant given the method's return type, the workaround is to change the expression involving the call to new_foo to Bar(Foo::<T>::new_foo(data)) (credit to @abonander).