Unsafe behaviour without unsafe code, bug in lifetime checker / shared memory restrictions?

[ztdwu]

#![feature( if_let )]
use std::io::BufReader;

fn main() {
    let text = b"the
                 quick
                 brown
                 fox
                 jumps
                 over";
    let mut reader = BufReader::new(text);

    let (tx, rx) = channel();

    spawn(proc() {
        for line in reader.lines() {
            let line = line.unwrap();
            let line = line.trim_chars(|c: char| c.is_whitespace());
            let list = vec![ line ];
            if let [ word ] = &*list {
                tx.send(word);
            }
        }
    });

    for word in rx.iter() {
        println!("{}", word);
    }
}

One would expect the output to be

the
quick
brown
fox
jumps
over

But the actual output is:

the
overs
overs
ove
overs
over

It looks like the memory location at word is overwritten.
The program will behave correctly if word is deep copied before being sent, i.e. changing tx.send(word) to tx.send(word.to_string())

[sfackler]

cc @luqmana looks like it could be that by-val match optimization issue?

[nikomatsakis]

cc me

[ftxqxd]

On 0.12.0 this fails to compile because line does not fulfil the 'static lifetime required by Sender/Receiver. I think that this might be #19261?

[nikomatsakis]

I'm not sure. This program runs fine for me. The byte literal is typed as &'static [u8] and, from inspecting the output, does appear to be placed into a static constant. Basically everything seems to be...going correctly here?

[ztdwu]

This is most likely a race condition. The output always seems correct in the playpen, and it's sometimes correct on my 1-core VM. But running it on a multicore machine always gives me jumbled up output. I tested it on the latest nightly on both Windows and Linux.

[brson]

P-backcompat-lang 1.0

[nikomatsakis]

@alexcrichton and I need to look more closely. I'm not yet sure what's going wrong.

[alexcrichton]

Minimized version:

fn assert_send<T: Send>(_t: T) {}

fn main() {
    let line = String::new();
    match [line.as_slice()] {
        [ word ] => { assert_send(word); }
    }
}

[nikomatsakis]

Seems to be tied to vector patterns. Should have guessed.