feat(byte_array): add ByteSpan::into and bytes31_slice

When slicing bytespans, the first data word can have a start-offset, this has to be split-off before
casting into `ByteArray`, which has no concept of start-offset of a bytes31 word.

Note: when slicing bytespans that are included in `remainder_word`, the upcoming `slice`
logic will remove the start-offset while slicing (for simplicity and consistency), hence we only
need to split off the start-offset if the first word is in the data span.

Author: Gilad Chase

corelib/src/byte_array.cairo

@@ -43,6 +43,7 @@
 //! ```
 
 use crate::array::{ArrayTrait, Span, SpanTrait};
+use crate::bytes_31::split_bytes31;
 #[allow(unused_imports)]
 use crate::bytes_31::{
     BYTES_IN_BYTES31, Bytes31Trait, POW_2_128, POW_2_8, U128IntoBytes31, U8IntoBytes31,
@@ -648,6 +649,14 @@ pub impl ByteArraySpanImpl of ByteSpanTrait {
     }
 }
 
+impl ByteSpanDefault of Default<ByteSpan> {
+    fn default() -> ByteSpan {
+        ByteSpan {
+            data: [].span(), first_char_start_offset: 0, remainder_word: 0, remainder_len: 0,
+        }
+    }
+}
+
 pub trait ToByteSpanTrait<C> {
     #[must_use]
     fn span(self: @C) -> ByteSpan;
@@ -669,3 +678,30 @@ impl ByteSpanToByteSpan of ToByteSpanTrait<ByteSpan> {
         *self
     }
 }
+
+impl ByteSpanIntoByteArray of Into<ByteSpan, ByteArray> {
+    fn into(mut self: ByteSpan) -> ByteArray {
+        // Span is aligned to word boundaries.
+        // Note: byte-spans smaller than 31 bytes trim off their start-offset when sliced.
+        if self.first_char_start_offset == 0 || self.data.is_empty() {
+            return ByteArray {
+                data: self.data.into(),
+                pending_word: self.remainder_word,
+                pending_word_len: upcast(self.remainder_len),
+            };
+        }
+
+        let mut ba = Default::default();
+        // Remove the start offset from the first data word.
+        let first_word = self.data.pop_front().expect('data non-empty checked above');
+        let n_bytes_to_append = BYTES_IN_BYTES31 - upcast(self.first_char_start_offset);
+        let (first_word_no_offset, _) = split_bytes31(
+            (*first_word).into(), BYTES_IN_BYTES31, n_bytes_to_append,
+        );
+        ba.append_word(first_word_no_offset, n_bytes_to_append);
+
+        ba.data.append_span(self.data); // Contains everything after the first word.
+        ba.append_word(self.remainder_word, upcast(self.remainder_len));
+        ba
+    }
+}

corelib/src/test/byte_array_test.cairo

@@ -546,9 +546,29 @@ fn test_span_copy() {
 
     let other_span = span;
     assert_eq!(other_span.len(), 2);
+    assert_eq!(ba, span.into());
+
     let span_again = span.span();
-    assert_eq!(span_again.len(), span.len());
+    assert_eq!(ba, span_again.into());
+    assert_eq!(ba, span.into());
+
     let even_more_span_again = other_span.span();
-    assert_eq!(even_more_span_again.len(), other_span.len());
-    // TODO(giladchase): verify span content once we add `into` or `PartialEq`.
+    assert_eq!(ba, even_more_span_again.into());
+    assert_eq!(ba, other_span.into());
+    assert_eq!(ba, span.into());
+}
+
+#[test]
+fn test_span_into_bytearray() {
+    let empty_ba: ByteArray = "";
+    assert_eq!(empty_ba.span().into(), empty_ba);
+
+    // Only remainder.
+    let small_ba: ByteArray = "hello";
+    assert_eq!(small_ba.span().into(), small_ba);
+
+    // Data word and remainder.
+    let large_ba: ByteArray = "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW"; // 40 bytes
+    assert_eq!(large_ba.span().into(), large_ba);
+    // TODO(giladchase): test with slice.
 }