Hack RefOrMut to allow use in closures.

Author: LorrensP-2158466

compiler/rustc_resolve/src/ident.rs

@@ -49,8 +49,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         parent_scope: &ParentScope<'ra>,
         ctxt: SyntaxContext,
         derive_fallback_lint_id: Option<NodeId>,
-        mut visitor: impl FnMut(
-            &mut CmResolver<'r, 'ra, 'tcx>,
+        mut visitor: impl for<'a> FnMut(
+            CmResolver<'a, 'ra, 'tcx>,
             Scope<'ra>,
             UsePrelude,
             SyntaxContext,
@@ -154,7 +154,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
             if visit {
                 let use_prelude = if use_prelude { UsePrelude::Yes } else { UsePrelude::No };
-                if let break_result @ Some(..) = visitor(&mut self, scope, use_prelude, ctxt) {
+                if let break_result @ Some(..) = visitor(self.reborrow(), scope, use_prelude, ctxt)
+                {
                     return break_result;
                 }
             }
@@ -438,7 +439,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             parent_scope,
             orig_ident.span.ctxt(),
             derive_fallback_lint_id,
-            |this, scope, use_prelude, ctxt| {
+            |mut this, scope, use_prelude, ctxt| {
                 let ident = Ident::new(orig_ident.name, orig_ident.span.with_ctxt(ctxt));
                 let result = match scope {
                     Scope::DeriveHelpers(expn_id) => {

compiler/rustc_resolve/src/imports.rs

@@ -873,7 +873,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         };
 
         let mut indeterminate_count = 0;
-        self.per_ns_cm(|this, ns| {
+        self.per_ns_cm(|mut this, ns| {
             if !type_ns_only || ns == TypeNS {
                 if bindings[ns].get() != PendingBinding::Pending {
                     return;

compiler/rustc_resolve/src/lib.rs

@@ -1835,13 +1835,13 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         f(self, MacroNS);
     }
 
-    fn per_ns_cm<'r, F: FnMut(&mut CmResolver<'r, 'ra, 'tcx>, Namespace)>(
+    fn per_ns_cm<'r, F: FnMut(CmResolver<'_, 'ra, 'tcx>, Namespace)>(
         mut self: CmResolver<'r, 'ra, 'tcx>,
         mut f: F,
     ) {
-        f(&mut self, TypeNS);
-        f(&mut self, ValueNS);
-        f(&mut self, MacroNS);
+        f(self.reborrow(), TypeNS);
+        f(self.reborrow(), ValueNS);
+        f(self.reborrow(), MacroNS);
     }
 
     fn is_builtin_macro(&self, res: Res) -> bool {
@@ -1898,7 +1898,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
 
         let scope_set = ScopeSet::All(TypeNS);
-        self.cm().visit_scopes(scope_set, parent_scope, ctxt, None, |this, scope, _, _| {
+        self.cm().visit_scopes(scope_set, parent_scope, ctxt, None, |mut this, scope, _, _| {
             match scope {
                 Scope::Module(module, _) => {
                     this.get_mut().traits_in_module(module, assoc_item, &mut found_traits);
@@ -2536,38 +2536,44 @@ use std::cell::{Cell as CacheCell, RefCell as CacheRefCell};
 mod ref_mut {
     use std::cell::{BorrowMutError, Cell, Ref, RefCell, RefMut};
     use std::fmt;
+    use std::marker::PhantomData;
     use std::ops::Deref;
 
     use crate::Resolver;
 
     /// A wrapper around a mutable reference that conditionally allows mutable access.
     pub(crate) struct RefOrMut<'a, T> {
-        p: &'a mut T,
+        // You can't actually create 2 `RefOrMut`s through `RefOrMut::new` because of the `&mut T`
+        // You can't alias it through `reborrow`, because reborrow requires a `&mut Self`
+        // You can't alias the underlying mutable reference through `get_mut` because it requires a `&mut Self`
+        // FIXME: still unsure if this is actually sound, I can't seem to create an example.
+        p: *const T,
         mutable: bool,
+        _marker: PhantomData<&'a mut ()>,
     }
 
     impl<'a, T> Deref for RefOrMut<'a, T> {
         type Target = T;
 
-        fn deref(&self) -> &Self::Target {
-            self.p
+        fn deref(&self) -> &T {
+            unsafe { self.p.as_ref_unchecked() }
         }
     }
 
     impl<'a, T> AsRef<T> for RefOrMut<'a, T> {
         fn as_ref(&self) -> &T {
-            self.p
+            unsafe { self.p.as_ref_unchecked() }
         }
     }
 
     impl<'a, T> RefOrMut<'a, T> {
         pub(crate) fn new(p: &'a mut T, mutable: bool) -> Self {
-            RefOrMut { p, mutable }
+            RefOrMut { p, mutable, _marker: PhantomData }
         }
 
         /// This is needed because this wraps a `&mut T` and is therefore not `Copy`.
         pub(crate) fn reborrow(&mut self) -> RefOrMut<'_, T> {
-            RefOrMut { p: self.p, mutable: self.mutable }
+            RefOrMut { p: self.p, mutable: self.mutable, _marker: PhantomData }
         }
 
         /// Returns a mutable reference to the inner value if allowed.
@@ -2578,14 +2584,16 @@ mod ref_mut {
         pub(crate) fn get_mut(&mut self) -> &mut T {
             match self.mutable {
                 false => panic!("Can't mutably borrow speculative resolver"),
-                true => self.p,
+                // SAFETY: you can only create a `RefOrMut` with a `&mut T`
+                true => unsafe { self.p.cast_mut().as_mut_unchecked() },
             }
         }
 
         /// Returns a mutable reference to the inner value without checking if
         /// it's in a mutable state.
         pub(crate) fn get_mut_unchecked(&mut self) -> &mut T {
-            self.p
+            // SAFETY: you can only create a `RefOrMut` with a `&mut T`
+            unsafe { self.p.cast_mut().as_mut_unchecked() }
         }
     }