Fix drop elaboration and move analysis for unsafe binders

Author: compiler-errors

compiler/rustc_borrowck/src/lib.rs

@@ -1945,13 +1945,16 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 ProjectionElem::OpaqueCast(_) |
                 ProjectionElem::ConstantIndex { .. } |
                 // assigning to P[i] requires P to be valid.
-                ProjectionElem::Downcast(_/*adt_def*/, _/*variant_idx*/) |
-                ProjectionElem::UnsafeBinderCast(..) =>
+                ProjectionElem::Downcast(_/*adt_def*/, _/*variant_idx*/) =>
                 // assigning to (P->variant) is okay if assigning to `P` is okay
                 //
                 // FIXME: is this true even if P is an adt with a dtor?
                 { }
 
+                ProjectionElem::UnsafeBinderCast(..) => {
+                    check_parent_of_field(self, location, place_base, span, state);
+                }
+
                 // assigning to (*P) requires P to be initialized
                 ProjectionElem::Deref => {
                     self.check_if_full_path_is_moved(

compiler/rustc_borrowck/src/prefixes.rs

@@ -66,12 +66,15 @@ impl<'tcx> Iterator for Prefixes<'tcx> {
                             self.next = Some(cursor_base);
                             return Some(cursor);
                         }
+                        ProjectionElem::UnsafeBinderCast(..) => {
+                            self.next = Some(cursor_base);
+                            return Some(cursor);
+                        }
                         ProjectionElem::Downcast(..)
                         | ProjectionElem::Subslice { .. }
                         | ProjectionElem::OpaqueCast { .. }
                         | ProjectionElem::ConstantIndex { .. }
-                        | ProjectionElem::Index(_)
-                        | ProjectionElem::UnsafeBinderCast(..) => {
+                        | ProjectionElem::Index(_) => {
                             cursor = cursor_base;
                         }
                         ProjectionElem::Subtype(..) => {

compiler/rustc_mir_dataflow/src/elaborate_drops.rs

@@ -1,6 +1,7 @@
 use std::{fmt, iter};
 
 use rustc_abi::{FIRST_VARIANT, FieldIdx, VariantIdx};
+use rustc_hir::UnsafeBinderCastKind;
 use rustc_hir::lang_items::LangItem;
 use rustc_index::Idx;
 use rustc_middle::mir::patch::MirPatch;
@@ -151,6 +152,11 @@ pub trait DropElaborator<'a, 'tcx>: fmt::Debug {
     ///
     /// This is only relevant for array patterns, which can move out of individual array elements.
     fn array_subpath(&self, path: Self::Path, index: u64, size: u64) -> Option<Self::Path>;
+
+    /// Returns the subpath of casting an unsafe binder.
+    ///
+    /// If this returns `None`, elements of `path` will not get a dedicated drop flag.
+    fn unsafe_binder_subpath(&self, path: Self::Path) -> Option<Self::Path>;
 }
 
 #[derive(Debug)]
@@ -846,7 +852,7 @@ where
     /// ADT, both in the success case or if one of the destructors fail.
     fn open_drop(&mut self) -> BasicBlock {
         let ty = self.place_ty(self.place);
-        match ty.kind() {
+        match *ty.kind() {
             ty::Closure(_, args) => self.open_drop_for_tuple(args.as_closure().upvar_tys()),
             ty::CoroutineClosure(_, args) => {
                 self.open_drop_for_tuple(args.as_coroutine_closure().upvar_tys())
@@ -859,13 +865,26 @@ where
             // See librustc_body/transform/coroutine.rs for more details.
             ty::Coroutine(_, args) => self.open_drop_for_tuple(args.as_coroutine().upvar_tys()),
             ty::Tuple(fields) => self.open_drop_for_tuple(fields),
-            ty::Adt(def, args) => self.open_drop_for_adt(*def, args),
+            ty::Adt(def, args) => self.open_drop_for_adt(def, args),
             ty::Dynamic(..) => self.complete_drop(self.succ, self.unwind),
             ty::Array(ety, size) => {
                 let size = size.try_to_target_usize(self.tcx());
-                self.open_drop_for_array(*ety, size)
+                self.open_drop_for_array(ety, size)
+            }
+            ty::Slice(ety) => self.drop_loop_pair(ety),
+            ty::UnsafeBinder(binder) => {
+                let ty = self.tcx().instantiate_bound_regions_with_erased(binder.into());
+                let fields = vec![(
+                    self.place.project_deeper(
+                        &[ProjectionElem::UnsafeBinderCast(UnsafeBinderCastKind::Unwrap, ty)],
+                        self.tcx(),
+                    ),
+                    self.elaborator.unsafe_binder_subpath(self.path),
+                )];
+
+                let (succ, unwind) = self.drop_ladder_bottom();
+                self.drop_ladder(fields, succ, unwind).0
             }
-            ty::Slice(ety) => self.drop_loop_pair(*ety),
 
             _ => span_bug!(self.source_info.span, "open drop from non-ADT `{:?}`", ty),
         }

compiler/rustc_mir_dataflow/src/move_paths/builder.rs

@@ -1,5 +1,6 @@
 use std::mem;
 
+use rustc_hir::UnsafeBinderCastKind;
 use rustc_index::IndexVec;
 use rustc_middle::mir::tcx::{PlaceTy, RvalueInitializationState};
 use rustc_middle::mir::*;
@@ -208,7 +209,7 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     | ty::Infer(_)
                     | ty::Error(_)
                     | ty::Placeholder(_) => bug!(
-                        "When Place contains ProjectionElem::Field it's type shouldn't be {place_ty:#?}"
+                        "When Place contains ProjectionElem::Field its type shouldn't be {place_ty:#?}"
                     ),
                 },
                 ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. } => {
@@ -226,15 +227,18 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                     }
                     _ => bug!("Unexpected type {place_ty:#?}"),
                 },
+                ProjectionElem::UnsafeBinderCast(UnsafeBinderCastKind::Unwrap, _) => {}
+                ProjectionElem::UnsafeBinderCast(UnsafeBinderCastKind::Wrap, _) => {
+                    union_path.get_or_insert(base);
+                }
                 // `OpaqueCast`:Only transmutes the type, so no moves there.
                 // `Downcast`  :Only changes information about a `Place` without moving.
                 // `Subtype`   :Only transmutes the type, so moves.
                 // `UnsafeBinderCast`: Only transmutes the place without moving.
                 // So it's safe to skip these.
                 ProjectionElem::OpaqueCast(_)
                 | ProjectionElem::Subtype(_)
-                | ProjectionElem::Downcast(_, _)
-                | ProjectionElem::UnsafeBinderCast(_, _) => (),
+                | ProjectionElem::Downcast(_, _) => (),
             }
             let elem_ty = PlaceTy::from_ty(place_ty).projection_ty(tcx, elem).ty;
             if !(self.filter)(elem_ty) {

compiler/rustc_mir_transform/src/elaborate_drops.rs

@@ -221,6 +221,12 @@ impl<'a, 'tcx> DropElaborator<'a, 'tcx> for ElaborateDropsCtxt<'a, 'tcx> {
         })
     }
 
+    fn unsafe_binder_subpath(&self, path: Self::Path) -> Option<Self::Path> {
+        rustc_mir_dataflow::move_path_children_matching(self.move_data(), path, |e| {
+            matches!(e, ProjectionElem::UnsafeBinderCast(..))
+        })
+    }
+
     fn get_drop_flag(&mut self, path: Self::Path) -> Option<Operand<'tcx>> {
         self.drop_flag(path).map(Operand::Copy)
     }

compiler/rustc_mir_transform/src/gvn.rs

@@ -931,6 +931,9 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             ProjectionElem::Downcast(symbol, idx) => ProjectionElem::Downcast(symbol, idx),
             ProjectionElem::OpaqueCast(idx) => ProjectionElem::OpaqueCast(idx),
             ProjectionElem::Subtype(idx) => ProjectionElem::Subtype(idx),
+            ProjectionElem::UnsafeBinderCast(kind, ty) => {
+                ProjectionElem::UnsafeBinderCast(kind, ty)
+            }
         })
     }
 

compiler/rustc_mir_transform/src/shim.rs

@@ -393,6 +393,9 @@ impl<'a, 'tcx> DropElaborator<'a, 'tcx> for DropShimElaborator<'a, 'tcx> {
     fn array_subpath(&self, _path: Self::Path, _index: u64, _size: u64) -> Option<Self::Path> {
         None
     }
+    fn unsafe_binder_subpath(&self, _path: Self::Path) -> Option<Self::Path> {
+        None
+    }
 }
 
 fn build_thread_local_shim<'tcx>(

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -2357,8 +2357,8 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Never
             | ty::Char => ty::Binder::dummy(Vec::new()),
 
-            // TODO: binder needs opening
-            ty::UnsafeBinder(_) => todo!(),
+            // FIXME(unsafe_binders): Squash the double binder for now, I guess.
+            ty::UnsafeBinder(_) => return Err(SelectionError::Unimplemented),
 
             // Treat this like `struct str([u8]);`
             ty::Str => ty::Binder::dummy(vec![Ty::new_slice(self.tcx(), self.tcx().types.u8)]),

compiler/rustc_ty_utils/src/instance.rs

@@ -49,7 +49,8 @@ fn resolve_instance_raw<'tcx>(
                     | ty::Adt(..)
                     | ty::Dynamic(..)
                     | ty::Array(..)
-                    | ty::Slice(..) => {}
+                    | ty::Slice(..)
+                    | ty::UnsafeBinder(..) => {}
                     // Drop shims can only be built from ADTs.
                     _ => return Ok(None),
                 }