Implement Deref{Mut} for arrays

Author: Veykril

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -512,46 +512,47 @@ fn method_autoderef_steps<'tcx>(
             .include_raw_pointers()
             .silence_errors();
     let mut reached_raw_pointer = false;
-    let mut steps: Vec<_> = autoderef
-        .by_ref()
-        .map(|(ty, d)| {
+    let mut steps = Vec::new();
+    for (ty, d) in &mut autoderef {
+        let step = CandidateStep {
+            self_ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, ty),
+            autoderefs: d,
+            from_unsafe_deref: reached_raw_pointer,
+            unsize: false,
+        };
+        steps.push(step);
+        if let ty::RawPtr(_) = ty.kind() {
+            // all the subsequent steps will be from_unsafe_deref
+            reached_raw_pointer = true;
+        } else if let ty::Array(elem_ty, _) = ty.kind() {
+            // Array implements Deref/DerefMut so we would always deref instead of unsizing the
+            // array without this check. This is fine in theory, but it is currently not possible
+            // to deref in a const context on stable, while unsizing is so to keep that working
+            // we need to still special case the autoderef step handling here.
             let step = CandidateStep {
-                self_ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, ty),
+                self_ty: infcx.make_query_response_ignoring_pending_obligations(
+                    inference_vars,
+                    infcx.tcx.mk_slice(*elem_ty),
+                ),
                 autoderefs: d,
+                // this could be from an unsafe deref if we had
+                // a *mut/const [T; N]
                 from_unsafe_deref: reached_raw_pointer,
-                unsize: false,
+                unsize: true,
             };
-            if let ty::RawPtr(_) = ty.kind() {
-                // all the subsequent steps will be from_unsafe_deref
-                reached_raw_pointer = true;
-            }
-            step
-        })
-        .collect();
+            steps.push(step);
+            // We just added the slice step manually, so break out early. Slices don't deref
+            // into anything so the final type of the autoderef is set up correctly.
+            break;
+        }
+    }
 
     let final_ty = autoderef.final_ty(true);
     let opt_bad_ty = match final_ty.kind() {
         ty::Infer(ty::TyVar(_)) | ty::Error(_) => Some(MethodAutoderefBadTy {
             reached_raw_pointer,
             ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, final_ty),
         }),
-        ty::Array(elem_ty, _) => {
-            let dereferences = steps.len() - 1;
-
-            steps.push(CandidateStep {
-                self_ty: infcx.make_query_response_ignoring_pending_obligations(
-                    inference_vars,
-                    infcx.tcx.mk_slice(*elem_ty),
-                ),
-                autoderefs: dereferences,
-                // this could be from an unsafe deref if we had
-                // a *mut/const [T; N]
-                from_unsafe_deref: reached_raw_pointer,
-                unsize: true,
-            });
-
-            None
-        }
         _ => None,
     };
 

library/core/src/array/mod.rs

@@ -15,6 +15,8 @@ use crate::mem::{self, MaybeUninit};
 use crate::ops::{
     ChangeOutputType, ControlFlow, FromResidual, Index, IndexMut, NeverShortCircuit, Residual, Try,
 };
+#[cfg(not(bootstrap))]
+use crate::ops::{Deref, DerefMut};
 use crate::slice::{Iter, IterMut};
 
 mod drain;
@@ -187,6 +189,28 @@ impl<T, const N: usize> const BorrowMut<[T]> for [T; N] {
     }
 }
 
+#[cfg(not(bootstrap))]
+#[stable(feature = "array_deref", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_unstable(feature = "const_array_deref", issue = "none")]
+impl<T, const N: usize> const Deref for [T; N] {
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: self points to `N` consecutive properly initialized values of type `T`.
+        unsafe { core::slice::from_raw_parts(self as *const [T] as *const T, N) }
+    }
+}
+
+#[cfg(not(bootstrap))]
+#[stable(feature = "array_deref", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_unstable(feature = "const_array_deref", issue = "none")]
+impl<T, const N: usize> const DerefMut for [T; N] {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        // SAFETY: self points to `N` consecutive properly initialized values of type `T`.
+        unsafe { core::slice::from_raw_parts_mut(self as *mut [T] as *mut T, N) }
+    }
+}
+
 /// Tries to create an array `[T; N]` by copying from a slice `&[T]`. Succeeds if
 /// `slice.len() == N`.
 ///