coerce_to_ref: no structural identity reliance

Author: BoxyUwU

compiler/rustc_hir_typeck/src/coercion.rs

@@ -251,8 +251,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             ty::RawPtr(_, b_mutbl) => {
                 return self.coerce_to_raw_ptr(a, b, b_mutbl);
             }
-            ty::Ref(_, _, mutbl_b) => {
-                return self.coerce_to_ref(a, b, mutbl_b);
+            ty::Ref(r_b, _, mutbl_b) => {
+                return self.coerce_to_ref(a, b, mutbl_b, r_b);
             }
             ty::Adt(pin, _)
                 if self.tcx.features().pin_ergonomics()
@@ -343,15 +343,16 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         a: Ty<'tcx>,
         b: Ty<'tcx>,
         mutbl_b: hir::Mutability,
+        r_b: ty::Region<'tcx>,
     ) -> CoerceResult<'tcx> {
         debug!("coerce_to_ref(a={:?}, b={:?})", a, b);
         debug_assert!(self.shallow_resolve(a) == a);
         debug_assert!(self.shallow_resolve(b) == b);
 
-        let mt_a = match *a.kind() {
-            ty::Ref(_, ty, mutbl) => {
+        let (r_a, mt_a) = match *a.kind() {
+            ty::Ref(r_a, ty, mutbl) => {
                 coerce_mutbls(mutbl, mutbl_b)?;
-                ty::TypeAndMut { ty, mutbl }
+                (r_a, ty::TypeAndMut { ty, mutbl })
             }
             _ => return self.unify(a, b),
         };
@@ -368,6 +369,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         // 3. `[T]`, autoref'd ty: `&M [T]`
         //     - `&M [T]` does unify with `&M [T]`
         let mut first_error = None;
+        let mut r_borrow_var = None;
         let mut autoderef = self.autoderef(self.cause.span, a);
         let found = autoderef.by_ref().find_map(|(deref_ty, autoderefs)| {
             if autoderefs == 0 {
@@ -376,9 +378,28 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 return None;
             }
 
-            let coercion = RegionVariableOrigin::Coercion(self.cause.span);
-            let r_borrow = self.next_region_var(coercion);
-            let autorefd_deref_ty = Ty::new_ref(self.tcx, r_borrow, deref_ty, mutbl_b);
+            // The logic here really shouldn't exist. We don't care about free
+            // lifetimes during HIR typeck. Unfortunately later parts of this
+            // function rely on structural identity of the autoref'd deref'd ty.
+            //
+            // This means that what region we use here actually impacts whether
+            // we emit a reborrow coercion or not which can affect diagnostics
+            // and capture analysis (which in turn affects borrowck).
+            let r = if !self.use_lub {
+                r_b
+            } else if autoderefs == 1 {
+                r_a
+            } else {
+                if r_borrow_var.is_none() {
+                    // create var lazily, at most once
+                    let coercion = RegionVariableOrigin::Coercion(self.cause.span);
+                    let r = self.next_region_var(coercion);
+                    r_borrow_var = Some(r);
+                }
+                r_borrow_var.unwrap()
+            };
+
+            let autorefd_deref_ty = Ty::new_ref(self.tcx, r, deref_ty, mutbl_b);
 
             // Note that we unify the autoref'd `Target` type with `b` rather than
             // the `Target` type with the pointee of `b`. This is necessary
@@ -417,8 +438,12 @@ 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. This is just an optimization.
+            // 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

tests/ui/coercion/structural_identity_dependent_reborrows.rs

@@ -0,0 +1,24 @@
+//@ edition: 2024
+
+// We avoid emitting reborrow coercions if it seems like it would
+// not result in a different lifetime on the borrow. This can effect
+// capture analysis resulting in borrow checking errors.
+
+fn foo<'a>(b: &'a ()) -> impl Fn() {
+    || {
+        expected::<&()>(b);
+    }
+}
+
+// No reborrow of `b` is emitted which means our closure captures
+// `b` by ref resulting in an upvar of `&&'a ()`
+fn bar<'a>(b: &'a ()) -> impl Fn() {
+    || {
+        //~^ ERROR: closure may outlive the current function
+        expected::<&'a ()>(b);
+    }
+}
+
+fn expected<T>(_: T) {}
+
+fn main() {}

tests/ui/coercion/structural_identity_dependent_reborrows.stderr

@@ -0,0 +1,25 @@
+error[E0373]: closure may outlive the current function, but it borrows `b`, which is owned by the current function
+  --> $DIR/structural_identity_dependent_reborrows.rs:16:5
+   |
+LL |     || {
+   |     ^^ may outlive borrowed value `b`
+LL |
+LL |         expected::<&'a ()>(b);
+   |                            - `b` is borrowed here
+   |
+note: closure is returned here
+  --> $DIR/structural_identity_dependent_reborrows.rs:16:5
+   |
+LL | /     || {
+LL | |
+LL | |         expected::<&'a ()>(b);
+LL | |     }
+   | |_____^
+help: to force the closure to take ownership of `b` (and any other referenced variables), use the `move` keyword
+   |
+LL |     move || {
+   |     ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0373`.