Odd loaning errors when similar code works

[alexcrichton]

For this code

use core::hashmap::linear::LinearMap;

fn fun1() {
  let mut map = LinearMap::new();
  map.insert(1, 2);
  // ok
  let size;
  size = *map.get(&1);
  map.insert(2, size);
}

fn fun2() {
  let mut map = LinearMap::new();
  map.insert(1, 2);
  let size = *map.get(&1); // note: prior loan of immutable granted here
  map.insert(2, size); // error: loan of mutable local variable as mutable conflicts with prior loan
}

fn fun3() {
  let mut map = LinearMap::new();
  map.insert(1, 2);
  // more bad, same as fun2
  map.insert(2, *map.get(&1));
}

fn main() {}

fun1 passes through the compiler, but both fun2 and fun3 generate an error (listed in fun2) and I'm not sure why fun2 is invalid while fun1 is valid.

[nikomatsakis]

This is probably caused by #3850

[erickt]

I may or may be running into this same problem with this code:

struct A { a: int }

struct B { a: &A }

impl B {
    fn next1(&mut self) { }
    fn next2(self) -> B/&self { let B { a: a } = self; B { a: a } }
}

fn main() {
    let a = A { a: 0 };
    let mut b = B { a: &a };
    //b.next1(); b.next1();
    //for uint::range(0, 1) |_| { b.next1(); }
    //b = b.next2(); b = b.next2();
}

This errors with:

test.rs:13:15: 13:16 error: loan of mutable local variable as mutable conflicts with prior loan
test.rs:13     b.next1(); b.next1();
                          ^
test.rs:13:4: 13:5 note: prior loan as mutable granted here
test.rs:13     b.next1(); b.next1();
               ^
error: aborting due to previous error

However, if instead I use the commented out closure, it compiles fine. Likewise, if I move out of self, it also compiles fine.

[Dretch]

I think I may be having the same issue.

I think this code should compile, but it doesn't:

struct MyStruct {}

impl MyStruct {

    fn takes_mut_self(&mut self, _x:int) {}

    fn takes_self(&self) -> int { 42 }

    fn also_takes_mut_self(&mut self) {
        self.takes_mut_self(self.takes_self());
    }

}

fn main() {}

The error rustc produces is:

mut-self-issues.rs:12:28: 12:32 error: loan of dereference of mutable & pointer as immutable conflicts with prior loan
mut-self-issues.rs:12         self.takes_mut_self(self.takes_self());
                                                  ^~~~
mut-self-issues.rs:12:8: 12:12 note: prior loan as mutable granted here
mut-self-issues.rs:12         self.takes_mut_self(self.takes_self());
                              ^~~~
error: aborting due to previous error

[jdm]

That's the general flow-control problem that currently exists. It's going away with the borrowchecker changes that haven't landed yet; until then, you can work around it by assigning the result of the takes_self calls to temporaries and passing those instead.

[nikomatsakis]

Part of #5074 (fix coming soon)