Implement cromulent copy closure captures

Implements RFC 4011.

Author: Jules-Bertholet

compiler/rustc_hir_typeck/src/coercion.rs

@@ -505,26 +505,6 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             }
         };
 
-        if coerced_a == a && mt_a.mutbl.is_not() && autoderef.step_count() == 1 {
-            // As a special case, if we would produce `&'a *x`, that's
-            // a total no-op. We end up with the type `&'a T` just as
-            // we started with. In that case, just skip it altogether.
-            //
-            // Unfortunately, this can actually effect capture analysis
-            // which in turn means this effects borrow checking. This can
-            // also effect diagnostics.
-            // FIXME(BoxyUwU): we should always emit reborrow coercions
-            //
-            // Note that for `&mut`, we DO want to reborrow --
-            // otherwise, this would be a move, which might be an
-            // error. For example `foo(self.x)` where `self` and
-            // `self.x` both have `&mut `type would be a move of
-            // `self.x`, but we auto-coerce it to `foo(&mut *self.x)`,
-            // which is a borrow.
-            assert!(mutbl_b.is_not()); // can only coerce &T -> &U
-            return success(vec![], coerced_a, obligations);
-        }
-
         let InferOk { value: mut adjustments, obligations: o } =
             self.adjust_steps_as_infer_ok(&autoderef);
         obligations.extend(o);
@@ -536,10 +516,31 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             coerced_a
         );
 
-        // Now apply the autoref
-        let mutbl = AutoBorrowMutability::new(mutbl_b, self.allow_two_phase);
-        adjustments
-            .push(Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(mutbl)), target: coerced_a });
+        if let Some(Adjustment { kind: Adjust::Deref(DerefAdjustKind::Builtin), .. }) =
+            adjustments.last()
+            && let ty::Ref(_, _, ty::Mutability::Not) = if adjustments.len() >= 2 {
+                *adjustments[adjustments.len() - 2].target.kind()
+            } else {
+                ty::Ref(r_a, mt_a.ty, mt_a.mutbl)
+            }
+            && mutbl_b.is_not()
+        {
+            // As a special case, if we would produce `&'a *x`, that's
+            // a total no-op. We end up with the type `&'a T` just as
+            // we started with. In that case, just skip it altogether.
+            //
+            // FIXME: Ideally we would also skip `&mut` -> `&mut` reborrow,
+            // and handle that in MIR. But unfortunately that would affect
+            // closure capture inference, which affects borrowcheck
+            adjustments.pop();
+        } else {
+            // Now apply the autoref
+            let mutbl = AutoBorrowMutability::new(mutbl_b, self.allow_two_phase);
+            adjustments.push(Adjustment {
+                kind: Adjust::Borrow(AutoBorrow::Ref(mutbl)),
+                target: coerced_a,
+            });
+        }
 
         debug!("coerce_to_ref: succeeded coerced_a={:?} adjustments={:?}", coerced_a, adjustments);
 

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -1099,6 +1099,9 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                                 upvar_borrow,
                             );
                         }
+                        ty::UpvarCapture::ByCopy => {
+                            self.delegate.borrow_mut().copy(&place_with_id, place_with_id.hir_id);
+                        }
                     }
                 }
             }

compiler/rustc_hir_typeck/src/upvar.rs

@@ -126,7 +126,6 @@ impl<'tcx> Place<'tcx> {
     /// Returns the type of this `Place` immediately before `projection_index`th projection
     /// is applied.
     pub fn ty_before_projection(&self, projection_index: usize) -> Ty<'tcx> {
-        assert!(projection_index < self.projections.len());
         if projection_index == 0 { self.base_ty } else { self.projections[projection_index - 1].ty }
     }
 }

compiler/rustc_middle/src/hir/place.rs

@@ -47,6 +47,9 @@ impl UpvarId {
 #[derive(Eq, PartialEq, Clone, Debug, Copy, TyEncodable, TyDecodable, StableHash, Hash)]
 #[derive(TypeFoldable, TypeVisitable)]
 pub enum UpvarCapture {
+    /// Like `ByValue`, but dominated by all the other modes instead of dominating them.
+    ByCopy,
+
     /// Upvar is captured by reference.
     ByRef(BorrowKind),
 
@@ -64,11 +67,15 @@ impl PartialOrd for UpvarCapture {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         match (self, other) {
-            (Self::ByValue, Self::ByValue) | (Self::ByUse, Self::ByUse) => {
-                Some(cmp::Ordering::Equal)
+            (Self::ByCopy, Self::ByCopy)
+            | (Self::ByValue, Self::ByValue)
+            | (Self::ByUse, Self::ByUse) => Some(cmp::Ordering::Equal),
+            (_, Self::ByCopy) | (Self::ByValue | Self::ByUse, Self::ByRef(_)) => {
+                Some(cmp::Ordering::Greater)
+            }
+            (Self::ByCopy, _) | (Self::ByRef(_), Self::ByValue | Self::ByUse) => {
+                Some(cmp::Ordering::Less)
             }
-            (Self::ByValue | Self::ByUse, Self::ByRef(_)) => Some(cmp::Ordering::Greater),
-            (Self::ByRef(_), Self::ByValue | Self::ByUse) => Some(cmp::Ordering::Less),
             (Self::ByRef(left), Self::ByRef(right)) => Some(left.cmp(&right)),
             (Self::ByUse, Self::ByValue) | (Self::ByValue, Self::ByUse) => None,
         }
@@ -202,7 +209,7 @@ impl<'tcx> CapturedPlace<'tcx> {
 
     pub fn is_by_ref(&self) -> bool {
         match self.info.capture_kind {
-            ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => false,
+            ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse | ty::UpvarCapture::ByCopy => false,
             ty::UpvarCapture::ByRef(..) => true,
         }
     }

compiler/rustc_middle/src/ty/closure.rs

@@ -53,7 +53,9 @@ pub(crate) fn closure_saved_names_of_captured_variables<'tcx>(
         .map(|captured_place| {
             let name = captured_place.to_symbol();
             match captured_place.info.capture_kind {
-                ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => name,
+                ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse | ty::UpvarCapture::ByCopy => {
+                    name
+                }
                 ty::UpvarCapture::ByRef(..) => Symbol::intern(&format!("_ref__{name}")),
             }
         })
@@ -916,7 +918,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let mut projs = closure_env_projs.clone();
                 projs.push(ProjectionElem::Field(FieldIdx::new(i), ty));
                 match capture {
-                    ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {}
+                    ty::UpvarCapture::ByValue
+                    | ty::UpvarCapture::ByUse
+                    | ty::UpvarCapture::ByCopy => {}
                     ty::UpvarCapture::ByRef(..) => {
                         projs.push(ProjectionElem::Deref);
                     }

compiler/rustc_mir_build/src/builder/mod.rs

@@ -1647,7 +1647,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
         let temp_scope_id = closure_expr.hir_id.local_id;
 
         match upvar_capture {
-            ty::UpvarCapture::ByValue => captured_place_expr,
+            ty::UpvarCapture::ByValue | ty::UpvarCapture::ByCopy => captured_place_expr,
             ty::UpvarCapture::ByUse => {
                 let span = captured_place_expr.span;
                 let expr_id = self.thir.exprs.push(captured_place_expr);

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -170,7 +170,9 @@ pub(crate) fn coroutine_by_move_body_def_id<'tcx>(
             // this when building the field projection in the MIR body later on.
             let mut parent_capture_ty = parent_capture.place.ty();
             parent_capture_ty = match parent_capture.info.capture_kind {
-                ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => parent_capture_ty,
+                ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse | ty::UpvarCapture::ByCopy => {
+                    parent_capture_ty
+                }
                 ty::UpvarCapture::ByRef(kind) => Ty::new_ref(
                     tcx,
                     tcx.lifetimes.re_erased,

compiler/rustc_mir_transform/src/coroutine/by_move_body.rs

@@ -1244,18 +1244,6 @@ fn build_construct_coroutine_by_move_shim<'tcx>(
 
     for (idx, ty) in args.as_coroutine_closure().upvar_tys().iter().enumerate() {
         if receiver_by_ref {
-            // The only situation where it's possible is when we capture immuatable references,
-            // since those don't need to be reborrowed with the closure's env lifetime. Since
-            // references are always `Copy`, just emit a copy.
-            if !matches!(ty.kind(), ty::Ref(_, _, hir::Mutability::Not)) {
-                // This copy is only sound if it's a `&T`. This may be
-                // reachable e.g. when eagerly computing the `Fn` instance
-                // of an async closure that doesn't borrowck.
-                tcx.dcx().delayed_bug(format!(
-                    "field should be captured by immutable ref if we have \
-                    an `Fn` instance, but it was: {ty}"
-                ));
-            }
             fields.push(Operand::Copy(tcx.mk_place_field(
                 self_local,
                 FieldIdx::from_usize(idx),

compiler/rustc_mir_transform/src/shim.rs

@@ -1120,10 +1120,9 @@ impl<'a> Builder<'a> {
             Subcommand::Run { .. } => (Kind::Run, &paths[..]),
             Subcommand::Clean { .. } => (Kind::Clean, &paths[..]),
             Subcommand::Format { .. } => (Kind::Format, &[][..]),
-            Subcommand::Setup { profile: ref path } => (
-                Kind::Setup,
-                path.as_ref().map_or([].as_slice(), |path| std::slice::from_ref(path)),
-            ),
+            Subcommand::Setup { profile: ref path } => {
+                (Kind::Setup, path.as_ref().map_or([].as_slice(), std::slice::from_ref))
+            }
             Subcommand::Vendor { .. } => (Kind::Vendor, &paths[..]),
             Subcommand::Perf { .. } => (Kind::Perf, &paths[..]),
         };