Inconsistent life time behavior between BorrowMut::borrow_mut() and AsMut::as_mut()

[FabianEmmes]

The following code shows inconsistent behavior in lifetime checking:

use std::convert::AsMut;
use std::borrow::BorrowMut;

trait T {}

impl T for u8 {}

fn main() {
    // A (AsMut and Primitive Type):
    {
        let mut r: Box<u8> = Box::new(23u8);
        let _: &mut u8 = r.as_mut();
    }

    // B (AsMut and Trait Objects):
    {
        let mut r: Box<T> = Box::new(23u8);
        let _: &mut T = r.as_mut();
    }

    // C (BorrowMut and Primitive Type):
    {
        let mut r: Box<u8> = Box::new(23u8);
        let _: &mut u8 = r.borrow_mut();
    }

    // D (BorrowMut and Trait Object):
    {
        let mut r: Box<T> = Box::new(23u8);
        let _: &mut T = r.borrow_mut();
    }
}

Using the stable compiler 1.14.0, case B and D yield a lifetime error:

$ rustc --version
rustc 1.14.0 (e8a012324 2016-12-16)

$ rustc test.rs 
error: `r` does not live long enough
  --> test.rs:19:5
   |
18 |         let _: &mut T = r.as_mut();
   |                         - borrow occurs here
19 |     }
   |     ^ `r` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

error: `r` does not live long enough
  --> test.rs:31:5
   |
30 |         let _: &mut T = r.borrow_mut();
   |                         - borrow occurs here
31 |     }
   |     ^ `r` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

error: aborting due to 2 previous errors

return code: 101

A nightly rustc from last week shows only an error in case D.

$ rustc --version
rustc 1.15.0-nightly (71c06a56a 2016-12-18)

$ rustc test.rs 
error: `r` does not live long enough
  --> test.rs:31:5
   |
30 |         let _: &mut T = r.borrow_mut();
   |                         - borrow occurs here
31 |     }
   |     ^ `r` dropped here while still borrowed
   |
   = note: values in a scope are dropped in the opposite order they are created

error: aborting due to previous error

return code: 101

This is strange, as BorrowMut::borrow_mut() and AsMut::as_mut() have the same type signature. So cases B and D should give the same result.

Furthermore, I am not sure why case A and B (or, for that matter, case C and D) behave differently. The only difference is that they use trait objects instead of primitive types, and as far as I understand, this should have no influence on the lifetime behavior.

[FabianEmmes]

There is some discussion of this issue at https://users.rust-lang.org/t/trait-objects-and-borrowmut/8520

[shepmaster]

Likewise, there is a related Stack Overflow question. The code there boiled down to:

use std::borrow::BorrowMut;

trait Foo {}

fn repro(mut foo: Box<Foo>) {
    let borrowed: &mut Foo = foo.borrow_mut();
}

fn main() {}

error: `foo` does not live long enough
 --> src/main.rs:6:30
  |
6 |     let borrowed: &mut Foo = foo.borrow_mut();
  |                              ^^^ does not live long enough
7 | }
  | - borrowed value only lives until here
  |
  = note: borrowed value must be valid for the static lifetime...

This isn't related to the 'static lifetime; using fn repro<'a>(mut foo: Box<Foo + 'a>) also has the failure.

[withoutboats]

@rust-lang/compiler Any insight? This looks pretty baffling to me.

[nikomatsakis]

The change from stable to nightly feels like potentially a regression. I'm not sure of the cause. I'm also not 100% sure of the cause of the original error, although I agree that trait object lifetime defaults is likely part of it.

(I'll note that &mut (T+'static) seems to work.)

[nikomatsakis]

Nominating for prioritization, in case we don't get to it before.

[shepmaster]

(I'll note that &mut (T+'static) seems to work.)

In code, this is:

fn repro<'a>(mut foo: Box<Foo + 'a>) {
    let borrowed: &mut (Foo + 'a) = foo.borrow_mut();
}

fn repro2(mut foo: Box<Foo>) {
    let borrowed: &mut (Foo + 'static) = foo.borrow_mut();
}

[nikomatsakis]

To be clear, I'm mostly concerned about the change in nightly behavior.

[nikomatsakis]

(Yes, so, per some conversation with @eddyb, and in line with the earlier comments on the thread, I think the reason an error is reported in the first place is that &mut T is expanded to &'a mut (T + 'a), where 'a is a fresh inference variable. This must then be assigned from with &mut (T + 'static). The 'static arises because Box<T> is expanded to Box<T + 'static>. Hence 'a = 'static, which then leads to the error because you have a borrow of lifetime 'static.)

[eddyb]

I believe there should be a coercion but it's not triggering for some reason.

[withoutboats]

Ought it not be 'static <: 'a (or the other way around possibly, I get confused)?

[eddyb]

&mut Foo<'a> is always invariant over 'a so without a coercion it can't be anything else.