fix dynamic drop for unions

Moving out of a union is now treated like moving out of its parent type. Fixes #36246

Author: arielb1

src/librustc_borrowck/borrowck/mir/gather_moves.rs

@@ -12,7 +12,6 @@
 use rustc::ty::{self, TyCtxt, ParameterEnvironment};
 use rustc::mir::repr::*;
 use rustc::util::nodemap::FnvHashMap;
-use rustc::util::common::ErrorReported;
 use rustc_data_structures::indexed_vec::{IndexVec};
 
 use syntax::codemap::DUMMY_SP;
@@ -198,6 +197,11 @@ struct MoveDataBuilder<'a, 'tcx: 'a> {
  data: MoveData<'tcx>,
 }
 
+pub enum MovePathError {
+ IllegalMove,
+ UnionMove { path: MovePathIndex },
+}
+
 impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
  fn new(mir: &'a Mir<'tcx>,
  tcx: TyCtxt<'a, 'tcx, 'tcx>,
@@ -256,23 +260,23 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
  move_path
  }
 
- /// This creates a MovePath for a given lvalue, returning an `ErrorReported`
+ /// This creates a MovePath for a given lvalue, returning an `MovePathError`
  /// if that lvalue can't be moved from.
  ///
  /// NOTE: lvalues behind references *do not* get a move path, which is
  /// problematic for borrowck.
  ///
  /// Maybe we should have seperate "borrowck" and "moveck" modes.
  fn move_path_for(&mut self, lval: &Lvalue<'tcx>)
- -> Result<MovePathIndex, ErrorReported>
+ -> Result<MovePathIndex, MovePathError>
  {
  debug!("lookup({:?})", lval);
  match *lval {
  Lvalue::Var(var) => Ok(self.data.rev_lookup.vars[var]),
  Lvalue::Arg(arg) => Ok(self.data.rev_lookup.args[arg]),
  Lvalue::Temp(temp) => Ok(self.data.rev_lookup.temps[temp]),
  // error: can't move out of a static
- Lvalue::Static(..) => Err(ErrorReported),
+ Lvalue::Static(..) => Err(MovePathError::IllegalMove),
  Lvalue::ReturnPointer => match self.data.rev_lookup.return_ptr {
  Some(ptr) => Ok(ptr),
  ref mut ptr @ None => {
@@ -300,21 +304,28 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
  fn move_path_for_projection(&mut self,
  lval: &Lvalue<'tcx>,
  proj: &LvalueProjection<'tcx>)
- -> Result<MovePathIndex, ErrorReported>
+ -> Result<MovePathIndex, MovePathError>
  {
  let base = try!(self.move_path_for(&proj.base));
  let lv_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
  match lv_ty.sty {
  // error: can't move out of borrowed content
- ty::TyRef(..) | ty::TyRawPtr(..) => return Err(ErrorReported),
+ ty::TyRef(..) | ty::TyRawPtr(..) => return Err(MovePathError::IllegalMove),
  // error: can't move out of struct with destructor
- ty::TyStruct(adt, _) | ty::TyEnum(adt, _) if adt.has_dtor() =>
- return Err(ErrorReported),
-
- ty::TyArray(..) | ty::TySlice(..) => match proj.elem {
+ ty::TyAdt(adt, _) if adt.has_dtor() =>
+ return Err(MovePathError::IllegalMove),
+ // move out of union - always move the entire union
+ ty::TyAdt(adt, _) if adt.is_union() =>
+ return Err(MovePathError::UnionMove { path: base }),
+ // error: can't move out of a slice
+ ty::TySlice(..) =>
+ return Err(MovePathError::IllegalMove),
+ ty::TyArray(..) => match proj.elem {
  // error: can't move out of an array
- ProjectionElem::Index(..) => return Err(ErrorReported),
- _ => {}
+ ProjectionElem::Index(..) => return Err(MovePathError::IllegalMove),
+ _ => {
+ // FIXME: still badly broken
+ }
  },
  _ => {}
  };
@@ -521,13 +532,16 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
  return
  }
 
- let path = self.move_path_for(lval).unwrap_or_else(|_| {
- // Moving out of a bad path. Eventually, this should be a MIR
- // borrowck error instead of a bug.
- span_bug!(self.mir.span,
- "Broken MIR: moving out of lvalue {:?}: {:?} at {:?}",
- lval, lv_ty, loc);
- });
+ let path = match self.move_path_for(lval) {
+ Ok(path) | Err(MovePathError::UnionMove { path }) => path,
+ Err(MovePathError::IllegalMove) => {
+ // Moving out of a bad path. Eventually, this should be a MIR
+ // borrowck error instead of a bug.
+ span_bug!(self.mir.span,
+ "Broken MIR: moving out of lvalue {:?}: {:?} at {:?}",
+ lval, lv_ty, loc);
+ }
+ };
  let move_out = self.data.moves.push(MoveOut { path: path, source: loc });
 
  debug!("gather_move({:?}, {:?}): adding move {:?} of {:?}",

src/librustc_borrowck/borrowck/mir/mod.rs

@@ -256,12 +256,12 @@ fn lvalue_contents_drop_state_cannot_differ<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx
  let ty = lv.ty(mir, tcx).to_ty(tcx);
  match ty.sty {
  ty::TyArray(..) | ty::TySlice(..) | ty::TyRef(..) | ty::TyRawPtr(..) => {
- debug!("lvalue_contents_drop_state_cannot_differ lv: {:?} ty: {:?} refd => false",
+ debug!("lvalue_contents_drop_state_cannot_differ lv: {:?} ty: {:?} refd => true",
  lv, ty);
  true
  }
- ty::TyAdt(def, _) if def.has_dtor() => {
- debug!("lvalue_contents_drop_state_cannot_differ lv: {:?} ty: {:?} Drop => false",
+ ty::TyAdt(def, _) if def.has_dtor() || def.is_union() => {
+ debug!("lvalue_contents_drop_state_cannot_differ lv: {:?} ty: {:?} Drop => true",
  lv, ty);
  true
  }

src/test/run-pass/dynamic-drop.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(rustc_attrs)]
+#![feature(untagged_unions)]
 
 use std::cell::{Cell, RefCell};
 use std::panic;
@@ -111,6 +111,20 @@ fn assignment1(a: &Allocator, c0: bool) {
  _v = _w;
 }
 
+#[allow(unions_with_drop_fields)]
+union Boxy<T> {
+ a: T,
+ b: T,
+}
+
+fn union1(a: &Allocator) {
+ unsafe {
+ let mut u = Boxy { a: a.alloc() };
+ u.b = a.alloc();
+ drop(u.a);
+ }
+}
+
 fn run_test<F>(mut f: F)
  where F: FnMut(&Allocator)
 {
@@ -136,6 +150,13 @@ fn run_test<F>(mut f: F)
  }
 }
 
+fn run_test_nopanic<F>(mut f: F)
+ where F: FnMut(&Allocator)
+{
+ let first_alloc = Allocator::new(usize::MAX);
+ f(&first_alloc);
+}
+
 fn main() {
  run_test(|a| dynamic_init(a, false));
  run_test(|a| dynamic_init(a, true));
@@ -149,4 +170,6 @@ fn main() {
 
  run_test(|a| assignment1(a, false));
  run_test(|a| assignment1(a, true));
+
+ run_test_nopanic(|a| union1(a));
 }