Possible to mutably borrow elements inside a Vec inside a HashMap multiple times

[tedsta]

Sorry, I'm not sure how to describe this very well in a sentence. I am able to mutably borrow the innermost values of a HashMap<u32, Vec<int>>, delete the values, then reference them after they were deleted. This code compiles, runs, and barfs out strange numbers.

use std::collections::HashMap;

fn main() {
    let mut my_stuff: HashMap<u32, Vec<int>> = HashMap::new();
    my_stuff.insert(0, vec![1, 2, 3, 4]);

    // Do bad things
    let mut stuff = vec!();
    for (_, vec) in my_stuff.mut_iter() {
        for thing in vec.mut_iter() {
            stuff.push(thing);
        }
    }

    my_stuff.clear();

    for thing in stuff.iter() {
        println!("{}", *thing);
    }
}

[krdln]

Little bit shorter example, without mutable borrows. But still fails to freeze my_stuff:

fn main() {
    let mut my_stuff = std::collections::HashMap::new();
    my_stuff.insert(0i, 42i);

    let (_, thing) = my_stuff.iter().next().unwrap();

    my_stuff.clear();

    println!("{}", *thing);
}

[pcwalton]

nominating for 1.0 P-backcompat-lang

[pcwalton]

though this may be a library issue

[Gankra]

0.o weird

This code is also valid:

    let mut my_stuff = std::collections::HashMap::new();
    my_stuff.insert(0i, 42i);

    let mut it = my_stuff.iter();
    my_stuff.swap(1, 43);

This is because the hashmap iterator just wraps the rawtable iterator, which just defers to the RawBuckets iterator, which is just a wrapper around two *mut's. That is, literally none of these iterators actually borrows the hashmap. Presumably this is fixable by taking a useless reference somewhere.

The other thing I'm seeing is that there's struct Entries<'a, K, V>, but the signature for Hashmap's iterator function is pub fn iter(&self) -> Entries<K, V>. How is this lifetime being elided? Is it doing the same thing as fn get(&self) -> &T, or is something else happening?

CC @pczarn

[Gankra]

Yep, it's eliding 'static!

fn main() {
    let mut my_stuff = std::collections::HashMap::new();

    // ok
    let foo: Entries<'static, int, int> = my_stuff.iter();

    // error: borrowed value does not live long enough
    // let bar: Items<'static, int> = vec!(1i).iter();
}

[Gankra]

So there's two bugs here: the iterator doesn't borrow the map, and the references are being yielded as 'static.

[pnkfelix]

Assigning P-backcompat-libs, 1.0