move_val_init causes wierd breakage

[brson]

From Blub:

fn main() {
    // this line causes the madness
    let mut _done: ~[bool] = vec::from_fn(4, |_x| { false });

    let input = io::stdin();
    let line = read_line(input);

    io::println(fmt!("got %?", line));
}

fn read_line(input: @io::Reader) -> ~str {
    let mut bytes = ~[];
    loop {
        let ch = input.read_byte();
        if ch == -1 || ch == 10 { break; }
        bytes.push(ch as u8);
    }
    str::from_bytes(bytes)
}

This is obviously wrong:

wry:tmp/ $ rustc order.rs && echo aaa | ./order
got ~"\x01\x01\x01"

It gets fixed when I move the read_line() function *above* main.
(same thing happens with input.read_line() from io::ReaderUtil btw)

removing the vec::from_fn() line fixes it too...

Also, changing the type of vec _done from ~[bool] to ~[anything else] makes it go away.

[Blub]

I replaced vec::from_fn with a my_from_fn which instead of rusti::move_val_init simply uses a = move b and this also seems to fix it. Maybe move_val_init doesn't honor the type-sizes correctly and writes out of bounds somewhere? (Without that change the copied function causes the same problem)

The function is a copy&paste from libcore/vec.rs with only the marked line exchanged

pub pure fn my_from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> ~[T] {
    unsafe {
        let mut v = vec::with_capacity(n_elts);
        do vec::as_mut_buf(v) |p, _len| {
            let mut i: uint = 0u;
            while i < n_elts {
                //vec::rusti::move_val_init(&mut(*ptr::mut_offset(p, i)), op(i)); <-- change here
                *ptr::mut_offset(p, i) = move op(i); // new code
                i += 1u;
            }
        }
        vec::raw::set_len(&mut v, n_elts);
        return move v;
    }
}

I don't know exactly rusti::move_val_init does, so, hope this information helps somehow.

[Blub]

Ah, in fact, the whole testcase can be reduced: Drop the _done and vector creation completely, here's the new minimal testcase:

use io::ReaderUtil;
fn main() {
    let mut x: bool = false;
    // this line breaks it
    vec::rusti::move_val_init(&mut x, false);

    let input = io::stdin();
    let line = input.read_line(); // use core's io again

    io::println(fmt!("got %?", line));
}

wry:tmp/ $ rustc order.rs && echo aaa | ./order
got ~"\x01\x01\x01"

[brson]

Updated title to reflect problem

[nikomatsakis]

though I don't see why it would cause this problem, this use of move_val_init is invalid. The init is supposed to mean that this intrinsic is used to initialize the memory being moved into. That is, it expects the memory to be uninitialized and hence does not drop the previous value (which is garbage). Here of course the memory is initialized, but then... this is a boolean value, so it shouldn't matter.

[pcwalton]

This is a problem with type_use.