Implementing a trait allows changing lifetime requirements, leading to memory corruption

[alexcrichton]

This code snipped, when compiled locally on OSX segfaults on stable (1.10.0) and exhibits memory corruption on nightly:

use std::fmt;

#[derive(Debug)]
struct MyString<'a>(&'a String);

struct B {
    list: Vec<Box<fmt::Debug>>,
}

trait A<'a> {
    fn foo<F>(&mut self, f: F)
        where F: fmt::Debug + 'a,
              Self: Sized;
}

impl<'a> A<'a> for B {
    fn foo<F>(&mut self, f: F)
        where F: fmt::Debug + 'static, // note that this is 'static, not 'a
    {
        self.list.push(Box::new(f));
    }
}

fn main() {
    let mut b = B { list: Vec::new() };

    // Create a borrowed pointer, put it in `b`, then drop what's borrowing it
    let a = "hello".to_string();
    b.foo(MyString(&a));

    // Drop the data which `b` has a reference to
    drop(a);

    // Use the data, probably segfaulting
    for b in b.list.iter() {
        println!("{:?}", b);
    }
}

I believe the issue here is that the implementation of the A trait allows application of the 'static bound, enabling the implementation of that function to assume that. The trait, however, uses the 'a bound. When calling this function we can then feed in non-'static lifetimes and wind up corrupting data.

cc @nikomatsakis
cc @arielb1
cc @rust-lang/compiler

[apasel422]

Is this related to #18937?

[alexcrichton]

Aha indeed! Appears to be a dupe of that. I'll close and add a comment over there.