mut struct member var(ref) bind to new obj still hint: does not live long enough

[sosotan]

#[derive(Debug)]
struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let mut root = ImportantExcerpt {part: "abc"};
    {
        let novel = String::from("Call me Ishmael. Some years ago...");
        let first_sentence = novel.split('.').next().expect("Could not find a '.'");
        root = ImportantExcerpt {part: first_sentence};
        root.part = "1234";  // bind to new static str
    }
    println!("{:?}", root);  // error does not live long enough
}

[tgross35]

Could you add some more context about what is going wrong vs. what you expect to happen?

[theemathas]

Here's my understanding of what issue is being reported.

This code doesn't compile:

struct Wrap<'a>(&'a i32);

static TWO: i32 = 2;

fn main() {
    let mut x;
    {
        let y = 1;
        x = Wrap(&y);
        x.0 = &TWO;
    }
    let _z = x;
}

Error message

error[E0597]: `y` does not live long enough
  --> src/main.rs:9:18
   |
8  |         let y = 1;
   |             - binding `y` declared here
9  |         x = Wrap(&y);
   |                  ^^ borrowed value does not live long enough
10 |         x.0 = &TWO;
11 |     }
   |     - `y` dropped here while still borrowed
12 |     let _z = x;
   |              - borrow later used here

For more information about this error, try `rustc --explain E0597`.

But this code compiles fine:

struct Wrap<'a>(&'a i32);

static TWO: i32 = 2;

fn main() {
    let mut x;
    {
        let y = 1;
        x = Wrap(&y);
        x = Wrap(&TWO);
    }
    let _z = x;
}

Weird. I would expect either both to compile or neither to compile.

[sosotan]

Here's my understanding of what issue is being reported.

This code doesn't compile:

struct Wrap<'a>(&'a i32);

static TWO: i32 = 2;

fn main() {
    let mut x;
    {
        let y = 1;
        x = Wrap(&y);
        x.0 = &TWO;
    }
    let _z = x;
}

Error message
But this code compiles fine:

struct Wrap<'a>(&'a i32);

static TWO: i32 = 2;

fn main() {
    let mut x;
    {
        let y = 1;
        x = Wrap(&y);
        x = Wrap(&TWO);
    }
    let _z = x;
}

Weird. I would expect either both to compile or neither to compile.

Yes, that's exactly what I want to say.
In the first code snippet, x.0 was rebind, and won't become dangling.
I expect the first can be compile without error.

[RalfJung]

I expect the first can be compile without error.

That would be UB, as it would assign a value that does not satisfy its validity invariant. So the first must be rejected.

[theemathas]

What value and what validity invariant are you talking about? Miri doesn't complain about this code:

struct Wrap<'a>(&'a i32);

static TWO: i32 = 2;

fn main() {
    let mut x;
    {
        let y = 1;
        x = Wrap(unsafe { std::mem::transmute(&y) });
        x = Wrap(&TWO);
    }
    let _z = x;
}

[RalfJung]

Ah sorry I misread the code, I thought it was

struct Wrap<'a>(&'a i32);

static TWO: i32 = 2;

fn main() {
    let mut x;
    {
        let y = 1;
        x = Wrap(&y);
    }
    let _z = x;
}

That must be rejected for sure. I should not post before I am properly awake. ;)

The actual issue may just be explained by strong (type-changing) assignments. That would also explain why it does not work when changing just the field of a type.