Safe code triggering UB

[Stebalien]

When compiled with rust nightly (optimizations disabled), the following reliably segfaults:

use std::iter::FromIterator;
use std::iter::IntoIterator;

pub struct BoxedIterator<T> {
    iter: Box<Iterator<Item = T>>,
}

impl<T> Iterator for BoxedIterator<T> {
    type Item = T;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next()
    }
}

impl<T> FromIterator<T> for BoxedIterator<T> {
    fn from_iter<I>(iter: I) -> Self
        where I: IntoIterator<Item = T>,
              I::IntoIter: 'static
    {
        BoxedIterator { iter: Box::new(iter.into_iter()) }
    }
}

fn main() {
    let iter: Result<BoxedIterator<&str>, ()> =
        vec![Ok("test1"), Ok("test2")].into_iter().collect();
    let mut iter = iter.unwrap();

    println!("{:?}", iter.next());
}

When compiled with -C opt-level=3, it prints None but should print "test1".

---

Report from stackoverflow: https://stackoverflow.com/questions/38254647/why-does-calling-next-on-an-iterator-trait-object-give-me-an-out-of-memory-at
Thanks to Apanatshka for finding this.

[Stebalien]

Here's a variant that segfaults in debug mode (on play): https://is.gd/IROdsv
I couldn't get the above code to segfault on play because there's no way to compile with both optimizations and debug mode off.

[eefriedman]

This looks like the same bug as #18937.

[arielb1]

Sure. Duplicate of #18937.

[Stebalien]

I see. For anyone else coming here, the I::IntoIter: 'static bound on the FromIterator impl doesn't exist on the trait definition.