Merge pull request #149 from jacob-hughes/fsa_unions

Emit FSA error for unions with manually drop fields

compiler/rustc_mir_transform/src/check_finalizers.rs

@@ -22,6 +22,8 @@ enum FinalizerErrorKind<'tcx> {
     UnsoundReference(FnInfo<'tcx>, ProjInfo<'tcx>),
     /// Uses a trait object whose concrete type is unknown
     UnknownTraitObject(FnInfo<'tcx>),
+    /// Uses a union with a drop method.
+    Union(FnInfo<'tcx>),
     /// Calls a function whose definition is unavailable, so we can't be certain it's safe.
     MissingFnDef(FnInfo<'tcx>),
     /// The drop glue contains an unsound drop method from an external crate. This will have been
@@ -217,6 +219,9 @@ impl<'tcx> FSAEntryPointCtxt<'tcx> {
                         tys.push(f)
                     }
                 }
+                ty::Adt(def, ..) if def.is_union() && def.has_dtor(self.tcx) => {
+                    errors.push(FinalizerErrorKind::Union(FnInfo::new(rustc_span::DUMMY_SP, ty)));
+                }
                 ty::Adt(def, substs) if !ty.is_copy_modulo_regions(self.tcx, self.param_env) => {
                     if def.is_box() {
                         // This is a special case because Box has an empty drop
@@ -249,6 +254,11 @@ impl<'tcx> FSAEntryPointCtxt<'tcx> {
                             _ => (),
                         }
                     }
+                    if def.is_union() {
+                        // By definition, a union's fields can never have drop glue, so we don't need
+                        // to add them.
+                        continue;
+                    }
 
                     for field in def.all_fields() {
                         let field_ty = self.tcx.type_of(field.did).instantiate(self.tcx, substs);
@@ -368,6 +378,16 @@ impl<'tcx> FSAEntryPointCtxt<'tcx> {
                     "contains a trait object whose implementation is unknown.",
                 );
             }
+            FinalizerErrorKind::Union(fi) => {
+                err = self.tcx.sess.psess.dcx.struct_span_err(
+                    self.arg_span,
+                    format!("The drop method for `{0}` cannot be safely finalized.", fi.drop_ty),
+                );
+                err.span_label(
+                    self.arg_span,
+                    "contains a union whose drop glue cannot be known at compile-time.",
+                );
+            }
             FinalizerErrorKind::UnsoundExternalDropGlue(fi) => {
                 err = self.tcx.sess.psess.dcx.struct_span_err(
                     self.arg_span,

tests/ui/static/gc/fsa/unions.rs

@@ -0,0 +1,43 @@
+#![feature(gc)]
+#![feature(negative_impls)]
+#![feature(rustc_private)]
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+use std::gc::Gc;
+use std::mem::ManuallyDrop;
+
+struct S(u8);
+struct T(u8);
+
+impl Drop for S {
+    fn drop(&mut self) {
+    }
+}
+
+
+impl Drop for T {
+    fn drop(&mut self) {
+    }
+}
+
+union U {
+    a: ManuallyDrop<S>,
+    b: ManuallyDrop<T>,
+}
+
+impl Drop for U {
+    fn drop(&mut self) {
+        let x = unsafe  { &self.a };
+    }
+}
+
+impl !Send for U {}
+impl !Send for S {}
+impl !Send for T {}
+
+fn main() {
+    let u = U { a: ManuallyDrop::new(S(1)) };
+    Gc::new(u);
+    //~^ ERROR: The drop method for `U` cannot be safely finalized.
+}

tests/ui/static/gc/fsa/unions.stderr

@@ -0,0 +1,11 @@
+error: The drop method for `U` cannot be safely finalized.
+  --> $DIR/unions.rs:41:13
+   |
+LL |     Gc::new(u);
+   |     --------^-
+   |     |       |
+   |     |       contains a union whose drop glue cannot be known at compile-time.
+   |     caused by trying to construct a `Gc<U>` here.
+
+error: aborting due to 1 previous error
+