Iterative mutable slicing doesn't work

[mahkoh]

    {
        let mut bytes = bytes.as_mut_slice();
        for s in i.iter() {
            std::slice::bytes::copy_memory(bytes, s.as_bytes());
            bytes[s.len()] = 0;
            bytes = bytes.slice_from_mut(s.len() + 1);
        }
    }

Where the outer bytes is a vector. This code is safe and the only alternative seems to be working with raw pointers.

[Gankra]

This appears to just be the classic borrowck mutable loop wrangling issue. The following works:

fn main() {
    let i = vec!["hello", "there", "yo"];
    let mut bytes = Vec::from_elem(1000, 0);
    {
        // We need to make the temp variable so that borrowck "gets" what we're doing.
        let mut temp = bytes.as_mut_slice();
        for s in i.iter() {
            let bytes = temp;
            std::slice::bytes::copy_memory(bytes, s.as_bytes());
            bytes[s.len()] = 0;
            temp = bytes.slice_from_mut(s.len() + 1);
        }
    }
}

playpen

[steveklabnik]

Closing as 'not a bug', then.

[mahkoh]

How is it not a bug?

[Gankra]

Depends on how you interpret the lack of non-lexical borrow-checking, I guess.

[mahkoh]

I don't see what it has to do with non-lexical borrow checking. Normally you can't work around that by introducing even more variables.

[Gankra]

Re-opening. At best, it's total butts that you need to do this.

Unclear if non-lexical scopes could actually fix this.

[inrustwetrust]

I don't think this one is related to the lexical scope of borrows. I believe it's due to how the borrow checker handles mutable borrows that are made through an already borrowed reference. This appears to place a mutable borrow restriction on the reference itself, not just the owned value.

For example:

struct Foo { val: i32 }

fn main() {
    let mut owned_foo = Foo { val: 0 };
    let mut owned_foo2 = Foo { val: 1 };

    let mut foo_ref = &mut owned_foo;

    //This makes a mutable borrow not only of
    //`owned_foo`, but also of `foo_ref` *itself*...
    let val_ref = &mut foo_ref.val;

    //...so we can't repoint foo_ref to something
    //else here, even though it would be safe (the
    //memory val_ref points to is still backed by
    //owned_foo)
    foo_ref = &mut owned_foo2;
}

The above code result in "cannot assign to foo_ref because it is borrowed" on the last line.
Interestingly, the same issue does not appear if the mutable borrows are changed to non-mutable ones.

[nikomatsakis]

fwiw, this is a dup of #10520 I believe