ICE when assigning to a union with fields implementing Drop

[Thinkofname]

#![feature(untagged_unions)]

union Test {
    a: A,
    b: B
}

#[derive(Debug)]
struct A(i32);
impl Drop for A {
    fn drop(&mut self) { println!("A"); }
}

#[derive(Debug)]
struct B(f32);
impl Drop for B {
    fn drop(&mut self) { println!("B"); }
}

fn main() {
    let mut test = Test { a: A(3) };
    println!("{:?}", unsafe { test.b });
    unsafe { test.b = B(0.5); }
}

error: internal compiler error: /checkout/src/librustc_borrowck/borrowck/mir/elaborate_drops.rs:313: drop of untracked, uninitialized value bb8, lv (_1.1: B) (Parent(Some(mp1)))
  --> <anon>:23:14
   |
23 |     unsafe { test.b = B(0.5); }
   |      

Full backtrace can be seen on the playground

https://play.rust-lang.org/?gist=bc93f5b222b09b31d3fd286cfc10858a&version=nightly&backtrace=2

[petrochenkov]

cc #36246 @arielb1

[arielb1]

Should this drop test.b or not? I can't figure that out from the RFC.

[petrochenkov]

That println is distracting, so I reworded the example a bit:

{
    let mut test = Test { a: A(3) }; // test.a is initialized -> test.b is initialized, test is initialized 
    {
        let tmp_b = test.b; // test.b is uninitialized (moved out) -> test.a is uninitialized, test is uninitialized
                            // tmp_b is initialized 
    } // tmp_b is dropped, B is printed
    test.b = B(0.5); // test.b is initialized -> test.a is initialized, test is initialized
                     // test.b is not dropped on assignment because it was uninitialized 
} // test is dropped (noop)

[arielb1]

And if you move out a subfield?

#![feature(untagged_unions)]
union U {
    x: (Box<u32>, Box<u32>),
    y: Vec<u32>,
    raw: [u64; 4]
}

fn main() {
    let mut u = U { raw: [0; 4] };
    unsafe {
        drop(u.x.1);
        if true {
            u.y = Vec::new(); // what does this drop?
        } else if true {
            u.x = (Box::new(0), Box::new(1));
        } else {
            u.x.0 = Box::new(0); // and this?
        }
    }
}

[petrochenkov]

@arielb1

#![feature(untagged_unions)]
union U {
    x: (Box<u32>, Box<u32>),
    y: Vec<u32>,
    raw: [u64; 4]
}

fn main() {
    // init u.raw -> init (u.x, u.y) -> init u
    let mut u = U { raw: [0; 4] };
    unsafe {
        // uninit u.x.1 -> uninit u.x -> uninit (u.y, u.raw) -> uninit u
        // u.x.0 is still initialized
        drop(u.x.1);
        if true {
            // init u.y -> init (u.x, u.raw) -> init u
            // u.y was uninitialized, not dropped on assignment
            u.y = Vec::new(); // what does this drop?
        } else if true {
            // init u.x -> init (u.y, u.raw) -> init u
            // u.x was uninitialized, not dropped on assignment
            u.x = (Box::new(0), Box::new(1));
        } else {
            // assign u.x.0
            // u.x.0 was initialized, dropped on assignment
            u.x.0 = Box::new(0); // and this?
        }
    }
}

I tried to describe the scheme in https://github.com/petrochenkov/rfcs/blob/e5266bd105f592f7408b8592c5c3deaccba7f1ec/text/1444-union.md#initialization-state and https://github.com/petrochenkov/rfcs/blob/e5266bd105f592f7408b8592c5c3deaccba7f1ec/text/1444-union.md#move-and-initialization-checking

[arielb1]

@petrochenkov

That... sounds like something that would be fun to implement.

[arielb1]

I think people will be confused by these run-time semantics. Should we prohibit replacing into partially-initialized unions?

[nikomatsakis]

Quite likely a duplicate of #48962

[nikomatsakis]

cc @retep007 -- can you quickly test if this is a duplicate of #48962 ?