Update array::split_array_*() methods to never panic

This turns invalid split indices into post-mono errors. In the future, these will return e.g.
(&[T; M], &[T; N-M]) so that an invalid index becomes a type error.

Author: Xiretza

library/core/src/array/mod.rs

@@ -631,10 +631,6 @@ impl<T, const N: usize> [T; N] {
     /// the index `M` itself) and the second will contain all
     /// indices from `[M, N)` (excluding the index `N` itself).
     ///
-    /// # Panics
-    ///
-    /// Panics if `M > N`.
-    ///
     /// # Examples
     ///
     /// ```
@@ -667,6 +663,8 @@ impl<T, const N: usize> [T; N] {
     )]
     #[inline]
     pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T]) {
+        // FIXME: remove once constraint is encoded in return type
+        const { assert!(M <= N) }
         (&self[..]).split_array_ref::<M>().unwrap()
     }
 
@@ -676,10 +674,6 @@ impl<T, const N: usize> [T; N] {
     /// the index `M` itself) and the second will contain all
     /// indices from `[M, N)` (excluding the index `N` itself).
     ///
-    /// # Panics
-    ///
-    /// Panics if `M > N`.
-    ///
     /// # Examples
     ///
     /// ```
@@ -700,6 +694,8 @@ impl<T, const N: usize> [T; N] {
     )]
     #[inline]
     pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T]) {
+        // FIXME: remove once constraint is encoded in return type
+        const { assert!(M <= N) }
         (&mut self[..]).split_array_mut::<M>().unwrap()
     }
 
@@ -709,10 +705,6 @@ impl<T, const N: usize> [T; N] {
     /// the index `N - M` itself) and the second will contain all
     /// indices from `[N - M, N)` (excluding the index `N` itself).
     ///
-    /// # Panics
-    ///
-    /// Panics if `M > N`.
-    ///
     /// # Examples
     ///
     /// ```
@@ -745,6 +737,8 @@ impl<T, const N: usize> [T; N] {
     )]
     #[inline]
     pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M]) {
+        // FIXME: remove once constraint is encoded in return type
+        const { assert!(M <= N) }
         (&self[..]).rsplit_array_ref::<M>().unwrap()
     }
 
@@ -754,10 +748,6 @@ impl<T, const N: usize> [T; N] {
     /// the index `N - M` itself) and the second will contain all
     /// indices from `[N - M, N)` (excluding the index `N` itself).
     ///
-    /// # Panics
-    ///
-    /// Panics if `M > N`.
-    ///
     /// # Examples
     ///
     /// ```
@@ -778,6 +768,8 @@ impl<T, const N: usize> [T; N] {
     )]
     #[inline]
     pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M]) {
+        // FIXME: remove once constraint is encoded in return type
+        const { assert!(M <= N) }
         (&mut self[..]).rsplit_array_mut::<M>().unwrap()
     }
 }

library/core/tests/array.rs

@@ -488,38 +488,6 @@ fn array_rsplit_array_mut() {
     }
 }
 
-#[should_panic]
-#[test]
-fn array_split_array_ref_out_of_bounds() {
-    let v = [1, 2, 3, 4, 5, 6];
-
-    v.split_array_ref::<7>();
-}
-
-#[should_panic]
-#[test]
-fn array_split_array_mut_out_of_bounds() {
-    let mut v = [1, 2, 3, 4, 5, 6];
-
-    v.split_array_mut::<7>();
-}
-
-#[should_panic]
-#[test]
-fn array_rsplit_array_ref_out_of_bounds() {
-    let v = [1, 2, 3, 4, 5, 6];
-
-    v.rsplit_array_ref::<7>();
-}
-
-#[should_panic]
-#[test]
-fn array_rsplit_array_mut_out_of_bounds() {
-    let mut v = [1, 2, 3, 4, 5, 6];
-
-    v.rsplit_array_mut::<7>();
-}
-
 #[test]
 fn array_intoiter_advance_by() {
     use std::cell::Cell;