Relax From<array> for SmallVec to allow different length arrays.

Author: zachs18

src/lib.rs

@@ -1909,9 +1909,25 @@ impl<'a, T: Clone, const N: usize> From<&'a [T]> for SmallVec<T, N> {
         slice.iter().cloned().collect()
     }
 }
-impl<T, const N: usize> From<[T; N]> for SmallVec<T, N> {
-    fn from(array: [T; N]) -> Self {
-        Self::from_buf(array)
+
+impl<T, const N: usize, const M: usize> From<[T; M]> for SmallVec<T, N> {
+    fn from(array: [T; M]) -> Self {
+        if M > N {
+            // If M > N, we'd have to heap allocate anyway,
+            // so delegate for Vec for the allocation
+            Self::from(Vec::from(array))
+        } else {
+            // M <= N
+            let mut this = Self::new();
+            debug_assert!(M <= this.capacity());
+            let array = ManuallyDrop::new(array);
+            // SAFETY: M <= this.capacity()
+            unsafe {
+                copy_nonoverlapping(array.as_ptr(), this.as_mut_ptr(), M);
+                this.set_len(M);
+            }
+            this
+        }
     }
 }
 impl<T, const N: usize> From<Vec<T>> for SmallVec<T, N> {

src/tests.rs

@@ -656,6 +656,16 @@ fn test_from() {
     let small_vec: SmallVec<NoClone, 1> = SmallVec::from(vec);
     assert_eq!(&*small_vec, &[NoClone(42)]);
     drop(small_vec);
+
+    let array = [1; 128];
+    let small_vec: SmallVec<u8, 1> = SmallVec::from(array);
+    assert_eq!(&*small_vec, vec![1; 128].as_slice());
+    drop(small_vec);
+
+    let array = [99];
+    let small_vec: SmallVec<u8, 128> = SmallVec::from(array);
+    assert_eq!(&*small_vec, &[99u8]);
+    drop(small_vec);
 }
 
 #[test]