ICE: region_obligations not empty

[bluss]

New ICE discovered (in itertools' test suite):

thread 'rustc' panicked at 'region_obligations not empty: [
    (
        NodeId(
            0
        ),  
        RegionObligation(sub_region='_#60r, sup_type=u8)
    )   
]', /checkout/src/librustc/infer/mod.rs:1160:8

(Note, the issue has been worked around in itertools, to keep CI green)

Code to reproduce

(playground link)

//! ```cargo
//! [dependencies]
//! itertools = "=0.7.2"
//! ```
extern crate itertools;

use itertools::Itertools;

fn equal_combinations_2(a: Vec<u8>) {
    a.iter().cloned().tuple_combinations::<(_, _)>();
}

Implementation links for tuple_combinations:

1. https://github.com/bluss/rust-itertools/blob/c56a69d7cc3014b04bb88bbe42040a0243168a0a/src/lib.rs#L992-L998
2. https://github.com/bluss/rust-itertools/blob/c56a69d7cc3014b04bb88bbe42040a0243168a0a/src/adaptors/mod.rs#L910-L921

Full error

error: internal compiler error: unexpected panic

note: the compiler unexpectedly panicked. this is a bug.

note: we would appreciate a bug report: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports

note: rustc 1.23.0-nightly (d0f8e2913 2017-11-16) running on x86_64-unknown-linux-gnu

thread 'rustc' panicked at 'region_obligations not empty: [
    (
        NodeId(
            0
        ),  
        RegionObligation(sub_region='_#60r, sup_type=u8)
    )   
]', /checkout/src/librustc/infer/mod.rs:1160:8

[arielb1]

Minified:

use std::iter::Fuse;

pub struct TupleCombinations<I: Iterator> {
    iter: <Fuse<I> as Iterator>::Item,
}

pub fn equal_combinations_2(
    a: TupleCombinations<std::iter::Cloned<std::slice::Iter<u8>>>
) {
}

fn main() {}

[arielb1]

even minier:

use std::iter::{Fuse, Cloned};
use std::slice::Iter;

fn main() {
    let f = 0 as *mut <Fuse<Cloned<Iter<u8>>> as Iterator>::Item;
}

[arielb1]

Similar (using upvar inference instead of specialization);

struct Foo<T>(*const T);
impl<T: 'static> Copy for Foo<T> {}
impl<T: 'static> Clone for Foo<T> {
    fn clone(&self) -> Self { *self }
}

fn main() {
    let s = 2;
    let upvar = Foo(&|| s);
    let k = || upvar;
    k();
}