Move 'slice-rust' repository into the 'slicec' repo.

This PR completes the move by updating formatting, fixing various typos, and rewriting CI,
so that both the 'slicec' and 'slice-codec' crates now live in the same repository.

Author: InsertCreativityHere

.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: CI
+name: ci
 
 on:
   push:
@@ -7,68 +7,81 @@ on:
     branches: [main]
 
 env:
+  WARNINGS_AS_ERRORS: yes
   CARGO_TERM_COLOR: always
 
 jobs:
-  build_and_test:
+  slicec:
+    strategy:
+      fail-fast: false
     runs-on: ubuntu-latest
     timeout-minutes: 10
+
+    steps:
+      - name: 📐 Setup
+        run: rustup component add clippy
+      - name: 📂 Checkout Repository
+        uses: actions/checkout@v4
+      - name: 🔨 Build
+        run: cargo build --all-targets -p slicec
+      - name: 🧪 Test
+        run: cargo test -p slicec
+      - name: 🔎 Lint
+        run: cargo clippy --all-targets --no-deps -p slicec
+      - name: 📚 Generate Documentation
+        run: cargo doc --document-private-items --no-deps -p slicec
+        env:
+          RUSTDOCFLAGS: "-D warnings"
+
+  slice-codec:
     strategy:
       fail-fast: false
       matrix:
-        features:
-          [
-            "",
-            "alloc",
-            "std",
-            "tokio",
-            "std,tokio",
-            "slice2",
-            "slice2,alloc",
-            "slice2,std",
-            "slice2,tokio",
-            "slice2,std,tokio",
-          ]
+        features: [
+          "",
+          "alloc",
+          "std",
+          "tokio",
+          "slice2",
+          "slice2,alloc",
+          "slice2,std",
+          "slice2,tokio",
+        ]
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
     steps:
-      - name: 📦 Setup
-        run: echo "FEATURES=${{ matrix.features && '--features ' || '' }}${{ matrix.features }}" >> $GITHUB_ENV
-      - uses: actions/checkout@v4
-      - name: 📦 Cache
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo/bin/
-            ~/.cargo/registry/index/
-            ~/.cargo/registry/cache/
-            ~/.cargo/git/db/
-            target/
-            Cargo.lock
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
-      - name: 📦 Install
+      - name: 📐 Setup
         run: |
+          echo "FEATURES=${{ matrix.features && '--features ' || '' }}${{ matrix.features }}" >> $GITHUB_ENV
           rustup toolchain install nightly
           rustup component add clippy
           rustup component add miri --toolchain nightly
+      - name: 📂 Checkout Repository
+        uses: actions/checkout@v4
       - name: 🔨 Build
-        run: cargo build --no-default-features $FEATURES
+        run: cargo build --all-targets --no-default-features $FEATURES -p slice-codec
       - name: 🧪 Test
-        run: cargo +nightly miri test --no-default-features $FEATURES
-      - name: 📚 Docs
-        run: cargo doc --no-deps --no-default-features --document-private-items $FEATURES
+        run: cargo test --no-default-features $FEATURES -p slice-codec
+      - name: 📋 Check Soundness
+        run: cargo +nightly miri test --no-default-features $FEATURES -p slice-codec
       - name: 🔎 Lint
-        run: cargo clippy --all-targets --no-default-features $FEATURES --no-deps
+        run: cargo clippy --all-targets --no-default-features $FEATURES --no-deps -p slice-codec
+      - name: 📚 Generate Documentation
+        run: cargo doc --document-private-items --no-deps --no-default-features $FEATURES -p slice-codec
+        env:
+          RUSTDOCFLAGS: "-D warnings"
 
   format:
     runs-on: ubuntu-latest
     timeout-minutes: 5
 
     steps:
-      - uses: actions/checkout@v3
-      - name: 📦 Install nightly toolchain
+      - name: 📂 Checkout Repository
+        uses: actions/checkout@v4
+      - name: 📐 Setup
         run: |
           rustup toolchain install nightly
           rustup component add rustfmt --toolchain nightly
-      - name: 🔎 Format using rustfmt
+      - name: 🔎 Check Formatting
         run: cargo +nightly fmt --check

.vscode/cspell.json

@@ -1,6 +1,6 @@
 {
   "version": "0.2",
-  "language": "en, lorem",
+  "language": "en",
   "words": [
     "attributables",
     "bools",
@@ -11,23 +11,18 @@
     "Commentable",
     "deduped",
     "deque",
-    "dicant",
     "downcasted",
     "downcasting",
     "encodable",
-    "explicari",
     "grcov",
     "Hashable",
     "Hasher",
     "icerpc",
     "lalrpop",
-    "legimus",
     "MSRV",
     "nonoverlapping",
     "nonterminal",
     "peekable",
-    "ponderum",
-    "repudiare",
     "rfind",
     "rsplit",
     "RUSTDOCFLAGS",
@@ -54,7 +49,6 @@
     "misc",
     "en_US",
     "rust",
-    "softwareTerms",
-    "lorem"
+    "softwareTerms"
   ]
 }

rustfmt.toml

@@ -7,14 +7,13 @@
 # format_macro_matchers (https://github.com/rust-lang/rustfmt/issues/3354)
 # normalize_doc_attributes (https://github.com/rust-lang/rustfmt/issues/3351)
 # overflow_delimited_expression (https://github.com/rust-lang/rustfmt/issues/3370)
-# where_single_line (https://github.com/rust-lang/rustfmt/issues/3359)
 # wrap_comments (https://github.com/rust-lang/rustfmt/issues/3347)
 unstable_features = true
 
 max_width = 120
 comment_width = 120
+struct_lit_width = 25
 single_line_let_else_max_width = 120
-where_single_line = true
 
 format_code_in_doc_comments = true
 format_macro_matchers = true

slice-codec/Cargo.toml

@@ -1,12 +1,11 @@
 [package]
 name = "slice-codec"
-
 description = """
 Library for encoding and decoding Slice types.
 """
 homepage = "https://docs.icerpc.dev/slice2"
 documentation = "https://docs.rs/slice-codec"
-repository = "https://github.com/icerpc/slice-rust"
+repository = "https://github.com/icerpc/slicec/slice-codec"
 readme = "README.md"
 keywords = ["slice", "ice", "icerpc"]
 rust-version = "1.73"

slice-codec/src/buffer/mod.rs

@@ -42,7 +42,7 @@ pub trait InputSource {
     /// This function reads exactly `dest.len()`-many bytes, or if it's unable to, returns an error instead.
     /// If such an error occurs, no guarantees are made about how many bytes were read from the source, except that it
     /// is less than `dest.len()`.
-    fn read_bytes_into_exact(&mut self, dest: &mut [u8]) -> Result<()>;
+    fn read_bytes_into_buffer(&mut self, dest: &mut [u8]) -> Result<()>;
 }
 
 /// A trait for types that can be written to by a [Slice encoder](crate::encoder::Encoder).

slice-codec/src/buffer/slice.rs

@@ -105,7 +105,7 @@ impl InputSource for SliceInputSource<'_> {
         Ok(byte_slice)
     }
 
-    fn read_bytes_into_exact(&mut self, dst: &mut [u8]) -> Result<()> {
+    fn read_bytes_into_buffer(&mut self, dst: &mut [u8]) -> Result<()> {
         let src = self.read_byte_slice_exact(dst.len())?;
 
         // SAFETY: `read_byte_slice_exact` is guaranteed to return exactly `dst.len()` bytes, so there is enough space
@@ -120,7 +120,8 @@ impl InputSource for SliceInputSource<'_> {
 }
 
 impl<'a, T> From<&'a T> for SliceInputSource<'a>
-where T: Borrow<[u8]> + ?Sized
+where
+    T: Borrow<[u8]> + ?Sized,
 {
     /// Creates a new [`SliceInputSource`] that wraps the provided buffer.
     fn from(value: &'a T) -> Self {
@@ -135,7 +136,8 @@ where T: Borrow<[u8]> + ?Sized
 // without needing to construct an intermediate [`SliceInputSource`].
 #[cfg(feature = "slice2")]
 impl<'a, T> From<T> for crate::decoder::Decoder<SliceInputSource<'a>>
-where T: Into<SliceInputSource<'a>>
+where
+    T: Into<SliceInputSource<'a>>,
 {
     fn from(value: T) -> Self {
         crate::decoder::Decoder::new_with_inferred_encoding(value.into())
@@ -259,7 +261,8 @@ impl<'a, const N: usize> From<&'a mut [u8; N]> for SliceOutputTarget<'a> {
 // without needing to construct an intermediate [`SliceOutputTarget`].
 #[cfg(feature = "slice2")]
 impl<'a, T> From<T> for crate::encoder::Encoder<SliceOutputTarget<'a>>
-where T: Into<SliceOutputTarget<'a>>
+where
+    T: Into<SliceOutputTarget<'a>>,
 {
     fn from(value: T) -> Self {
         crate::encoder::Encoder::new_with_inferred_encoding(value.into())

slice-codec/src/buffer/vec.rs

@@ -74,7 +74,7 @@ impl OutputTarget for VecOutputTarget<'_> {
             let target_slice = self.buffer.spare_capacity_mut().get_unchecked_mut(..count);
 
             debug_assert_eq!(target_slice.len(), count);
-            // SAFETY: `MaybeUnit<T>` is guaranteed to have the same memory layout as `T`.
+            // SAFETY: `MaybeUninit<T>` is guaranteed to have the same memory layout as `T`.
             let source: &[MaybeUninit<u8>] = core::mem::transmute(bytes);
 
             core::ptr::copy_nonoverlapping(source.as_ptr(), target_slice.as_mut_ptr(), count);
@@ -145,7 +145,8 @@ impl<'a> From<&'a mut Vec<u8>> for VecOutputTarget<'a> {
 // without needing to construct an intermediate [`VecOutputTarget`].
 #[cfg(feature = "slice2")]
 impl<'a, T> From<T> for crate::encoder::Encoder<VecOutputTarget<'a>>
-where T: Into<VecOutputTarget<'a>>
+where
+    T: Into<VecOutputTarget<'a>>,
 {
     fn from(value: T) -> Self {
         crate::encoder::Encoder::new_with_inferred_encoding(value.into())

slice-codec/src/error.rs

@@ -137,9 +137,15 @@ impl Display for ErrorKind {
             Self::UnexpectedEob { requested, remaining } => {
                 write!(f, "unexpected end of buffer: attempted to read '{requested}' bytes from a buffer with only '{remaining}' bytes remaining")
             }
-            Self::InvalidReservation { buffer_len, reserved_range } => {
+            Self::InvalidReservation {
+                buffer_len,
+                reserved_range,
+            } => {
                 let Range { start, end } = reserved_range;
-                write!(f, "invalid reservation: range '[{start}..{end})' does not fit within buffer of length '{buffer_len}'")
+                write!(
+                    f,
+                    "invalid reservation: range '[{start}..{end})' does not fit within buffer of length '{buffer_len}'"
+                )
             }
             Self::InvalidData(inner) => inner.fmt(f),
             _ => todo!(),
@@ -177,12 +183,7 @@ impl Display for InvalidDataErrorKind {
                     write!(f, "illegal value: {desc}")
                 }
             }
-            Self::OutOfRange {
-                value,
-                min,
-                max,
-                typename,
-            } => {
+            Self::OutOfRange { value, min, max, typename } => {
                 write!(
                     f,
                     "value '{value}' is outside the allowed range for type '{typename}'; values must be within [{min}..{max}]"

slice-codec/src/slice2/decoding.rs

@@ -66,9 +66,9 @@ impl DecodeFrom<Slice2> for i8 {
 
 implement_decode_from_on_numeric_primitive_type! {u16, Slice2, "Decodes a [`u16`] from 2 bytes (little endian)."}
 implement_decode_from_on_numeric_primitive_type! {i16, Slice2, "Decodes a [`i16`] from 2 bytes (little endian) in two's complement form."}
-implement_decode_from_on_numeric_primitive_type! {u32, Slice2, "Decodes a [`u32`] from 2 bytes (little endian)."}
+implement_decode_from_on_numeric_primitive_type! {u32, Slice2, "Decodes a [`u32`] from 4 bytes (little endian)."}
 implement_decode_from_on_numeric_primitive_type! {i32, Slice2, "Decodes a [`i32`] from 4 bytes (little endian) in two's complement form."}
-implement_decode_from_on_numeric_primitive_type! {u64, Slice2, "Decodes a [`u64`] from 2 bytes (little endian)."}
+implement_decode_from_on_numeric_primitive_type! {u64, Slice2, "Decodes a [`u64`] from 8 bytes (little endian)."}
 implement_decode_from_on_numeric_primitive_type! {i64, Slice2, "Decodes a [`i64`] from 8 bytes (little endian) in two's complement form."}
 implement_decode_from_on_numeric_primitive_type! {f32, Slice2, "Decodes a [`f32`] from 4 bytes (little endian) using the \"binary32\" representation defined in IEEE 754-2008."}
 implement_decode_from_on_numeric_primitive_type! {f64, Slice2, "Decodes a [`f64`] from 8 bytes (little endian) using the \"binary64\" representation defined in IEEE 754-2008."}
@@ -197,7 +197,8 @@ impl DecodeFrom<Slice2> for String {
 
 #[cfg(feature = "alloc")]
 impl<T> DecodeFrom<Slice2> for Vec<T>
-where T: DecodeFrom<Slice2>
+where
+    T: DecodeFrom<Slice2>,
 {
     /// TODO
     fn decode_from(decoder: &mut Decoder<impl InputSource, Slice2>) -> Result<Self> {

slice-codec/src/slice2/encoding.rs

@@ -46,9 +46,9 @@ implement_encode_into_on_borrowed_type!(i8, Slice2);
 
 implement_encode_into_on_numeric_primitive_type! {u16, Slice2, "Encodes this [`u16`] on 2 bytes (little endian)."}
 implement_encode_into_on_numeric_primitive_type! {i16, Slice2, "Encodes this [`i16`] on 2 bytes (little endian) in two's complement form."}
-implement_encode_into_on_numeric_primitive_type! {u32, Slice2, "Encodes this [`u32`] on 2 bytes (little endian)."}
+implement_encode_into_on_numeric_primitive_type! {u32, Slice2, "Encodes this [`u32`] on 4 bytes (little endian)."}
 implement_encode_into_on_numeric_primitive_type! {i32, Slice2, "Encodes this [`i32`] on 4 bytes (little endian) in two's complement form."}
-implement_encode_into_on_numeric_primitive_type! {u64, Slice2, "Encodes this [`u64`] on 2 bytes (little endian)."}
+implement_encode_into_on_numeric_primitive_type! {u64, Slice2, "Encodes this [`u64`] on 8 bytes (little endian)."}
 implement_encode_into_on_numeric_primitive_type! {i64, Slice2, "Encodes this [`i64`] on 8 bytes (little endian) in two's complement form."}
 implement_encode_into_on_numeric_primitive_type! {f32, Slice2, "Encodes this [`f32`] on 4 bytes (little endian) using the \"binary32\" representation defined in IEEE 754-2008."}
 implement_encode_into_on_numeric_primitive_type! {f64, Slice2, "Encodes this [`f64`] on 8 bytes (little endian) using the \"binary64\" representation defined in IEEE 754-2008."}
@@ -84,7 +84,6 @@ impl<O: OutputTarget> Encoder<O, Slice2> {
     ///
     /// [varint]: https://docs.icerpc.dev/slice2/language-guide/primitive-types#variable-size-integral-types
     #[rustfmt::skip] // To keep the arms of `match required_bits` aligned for readability.
-
     pub fn encode_varint(&mut self, value: impl Into<i64>) -> Result<()> {
         let value: i64 = value.into();
 
@@ -154,7 +153,8 @@ impl EncodeInto<Slice2> for &str {
 
 /// TODO
 impl<'a, T> EncodeInto<Slice2> for &'a [T]
-where &'a T: EncodeInto<Slice2>
+where
+    &'a T: EncodeInto<Slice2>,
 {
     fn encode_into(self, encoder: &mut Encoder<impl OutputTarget, Slice2>) -> Result<()> {
         let size = u64::try_from(self.len())?;