From 0114f3c82a028b33abeb8184f533336315b616a4 Mon Sep 17 00:00:00 2001 From: John-John Tedro Date: Thu, 21 Mar 2024 20:40:40 +0100 Subject: [PATCH] Clean up documentation --- crates/musli-allocator/src/lib.rs | 3 +- crates/musli-common/src/buf/mod.rs | 2 - crates/musli-common/src/buffered_writer.rs | 2 +- crates/musli-common/src/context/mod.rs | 2 - .../musli-common/src/context/stack_context.rs | 4 +- .../src/context/system_context.rs | 6 +- crates/musli-common/src/fixed.rs | 210 +++++++++++++++++- crates/musli-common/src/fixed_bytes.rs | 208 ----------------- crates/musli-common/src/int/continuation.rs | 12 +- crates/musli-common/src/int/tests.rs | 5 +- crates/musli-common/src/lib.rs | 94 +++++++- crates/musli-common/src/macros.rs | 26 +-- crates/musli-common/src/options.rs | 8 +- crates/musli-common/src/reader.rs | 6 - crates/musli-common/src/wrap.rs | 15 +- crates/musli-common/src/writer.rs | 4 - crates/musli-descriptive/src/de.rs | 14 +- crates/musli-descriptive/src/en.rs | 4 +- crates/musli-descriptive/src/encoding.rs | 2 +- crates/musli-descriptive/src/error.rs | 2 +- .../musli-descriptive/src/integer_encoding.rs | 5 +- crates/musli-descriptive/src/lib.rs | 13 +- crates/musli-descriptive/src/test.rs | 1 + crates/musli-json/src/de/mod.rs | 2 +- crates/musli-json/src/en/array_encoder.rs | 3 +- crates/musli-json/src/en/mod.rs | 3 +- crates/musli-json/src/en/object_encoder.rs | 2 +- .../musli-json/src/en/object_key_encoder.rs | 3 +- .../musli-json/src/en/object_pair_encoder.rs | 3 +- crates/musli-json/src/en/variant_encoder.rs | 3 +- crates/musli-json/src/encoding.rs | 20 +- crates/musli-json/src/error.rs | 2 +- crates/musli-json/src/lib.rs | 11 +- crates/musli-json/src/parser/parser.rs | 2 +- crates/musli-json/src/parser/tests.rs | 18 +- crates/musli-json/src/test.rs | 1 + crates/musli-json/tests/trace_collection.rs | 4 +- crates/musli-json/tests/trace_complex.rs | 4 +- crates/musli-json/tests/trace_no_std.rs | 4 +- crates/musli-serde/src/serializer.rs | 2 +- crates/musli-storage/src/de.rs | 5 +- crates/musli-storage/src/en.rs | 5 +- crates/musli-storage/src/encoding.rs | 2 +- crates/musli-storage/src/error.rs | 2 +- crates/musli-storage/src/lib.rs | 13 +- crates/musli-storage/src/test.rs | 1 + crates/musli-storage/tests/storage_trace.rs | 4 +- crates/musli-value/src/error.rs | 2 +- crates/musli-value/src/lib.rs | 20 +- crates/musli-value/src/value.rs | 2 +- crates/musli-wire/src/de.rs | 12 +- crates/musli-wire/src/en.rs | 10 +- crates/musli-wire/src/encoding.rs | 2 +- crates/musli-wire/src/error.rs | 2 +- crates/musli-wire/src/lib.rs | 13 +- crates/musli-wire/src/test.rs | 1 + crates/musli-wire/src/wire_int.rs | 10 +- crates/musli-zerocopy/src/pointer/size.rs | 2 +- .../tests/ui/deny_sneaky_field_error.stderr | 22 +- crates/tests/src/lib.rs | 1 + 60 files changed, 487 insertions(+), 379 deletions(-) delete mode 100644 crates/musli-common/src/fixed_bytes.rs diff --git a/crates/musli-allocator/src/lib.rs b/crates/musli-allocator/src/lib.rs index 47b4d1ed8..865d73060 100644 --- a/crates/musli-allocator/src/lib.rs +++ b/crates/musli-allocator/src/lib.rs @@ -45,9 +45,9 @@ //! [Müsli]: //! [`std::alloc::System`]: https://doc.rust-lang.org/std/alloc/struct.System.html -#![allow(clippy::type_complexity)] #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg_attr(test, macro_use)] #[cfg(feature = "std")] @@ -62,6 +62,7 @@ mod tests; #[cfg(feature = "alloc")] mod system; #[cfg(feature = "alloc")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))] pub use self::system::{System, SystemBuffer}; mod disabled; diff --git a/crates/musli-common/src/buf/mod.rs b/crates/musli-common/src/buf/mod.rs index 83fc0f8ff..af4039a2c 100644 --- a/crates/musli-common/src/buf/mod.rs +++ b/crates/musli-common/src/buf/mod.rs @@ -1,4 +1,2 @@ -//! Utilitioes for working with buffers. - mod buf_string; pub use self::buf_string::BufString; diff --git a/crates/musli-common/src/buffered_writer.rs b/crates/musli-common/src/buffered_writer.rs index ffb0c081f..a5f5c0879 100644 --- a/crates/musli-common/src/buffered_writer.rs +++ b/crates/musli-common/src/buffered_writer.rs @@ -3,7 +3,7 @@ use musli::{Buf, Context}; -use crate::fixed_bytes::FixedBytes; +use crate::fixed::FixedBytes; use crate::writer::Writer; /// A writer which buffers `N` bytes inline. diff --git a/crates/musli-common/src/context/mod.rs b/crates/musli-common/src/context/mod.rs index 51b86229e..d196f7ac2 100644 --- a/crates/musli-common/src/context/mod.rs +++ b/crates/musli-common/src/context/mod.rs @@ -1,5 +1,3 @@ -//! Helper types to set up a basic Müsli [`Context`]. - mod access; mod error_marker; mod rich_error; diff --git a/crates/musli-common/src/context/stack_context.rs b/crates/musli-common/src/context/stack_context.rs index a7b934358..337448328 100644 --- a/crates/musli-common/src/context/stack_context.rs +++ b/crates/musli-common/src/context/stack_context.rs @@ -12,6 +12,8 @@ use super::access::{Access, Shared}; use super::rich_error::{RichError, Step}; use super::ErrorMarker; +type BufPair<'a, A> = (Range, BufString<::Buf<'a>>); + /// A rich context which uses allocations and tracks the exact location of every /// error. /// @@ -28,7 +30,7 @@ where access: Access, mark: Cell, alloc: &'a A, - error: UnsafeCell, BufString>)>>, + error: UnsafeCell>>, path: UnsafeCell>>, P>>, path_cap: Cell, include_type: bool, diff --git a/crates/musli-common/src/context/system_context.rs b/crates/musli-common/src/context/system_context.rs index 06c87cdac..54b64e519 100644 --- a/crates/musli-common/src/context/system_context.rs +++ b/crates/musli-common/src/context/system_context.rs @@ -12,12 +12,14 @@ use super::access::{self, Access}; use super::rich_error::{RichError, Step}; use super::ErrorMarker; +type BufTriplet = (Vec>, Range, E); + /// A rich context dynamically allocating space using the system allocator. pub struct SystemContext { access: Access, mark: Cell, alloc: A, - errors: UnsafeCell>, Range, String)>>, + errors: UnsafeCell>>, path: UnsafeCell>>, include_type: bool, _marker: PhantomData, @@ -238,7 +240,7 @@ where /// An iterator over collected errors. pub struct Errors<'a, E> { - errors: &'a [(Vec>, Range, E)], + errors: &'a [BufTriplet], index: usize, // NB: Drop order is significant, drop the shared access last. _access: access::Shared<'a>, diff --git a/crates/musli-common/src/fixed.rs b/crates/musli-common/src/fixed.rs index 61dc3d247..6916cac41 100644 --- a/crates/musli-common/src/fixed.rs +++ b/crates/musli-common/src/fixed.rs @@ -1,19 +1,219 @@ //! Fixed capacity containers. -// Parts borrowed under the MIT license from -// https://github.com/bluss/arrayvec/tree/2c92a59bed0d1669cede3806000d2e61d5994c4e - +use core::fmt; use core::mem::{self, MaybeUninit}; use core::ops::{Deref, DerefMut}; use core::ptr; use core::slice; +use musli::{Buf, Context}; + +use crate::writer::Writer; + +/// A fixed-size bytes storage which keeps track of how much has been initialized. +pub struct FixedBytes { + /// Data storage. + data: [MaybeUninit; N], + /// How many bytes have been initialized. + init: usize, +} + +impl FixedBytes { + /// Construct a new fixed bytes array storage. + #[inline] + pub const fn new() -> Self { + Self { + // SAFETY: MaybeUnint::uninit_array is not stable. + data: unsafe { MaybeUninit::<[MaybeUninit; N]>::uninit().assume_init() }, + init: 0, + } + } + + /// Get the length of the collection. + #[inline] + pub const fn len(&self) -> usize { + self.init + } + + /// Test if the current container is empty. + #[inline] + pub const fn is_empty(&self) -> bool { + self.init == 0 + } + + /// Clear the [FixedBytes] container. + #[inline] + pub fn clear(&mut self) { + self.init = 0; + } + + /// Get the remaining capacity of the [FixedBytes]. + #[inline] + pub const fn remaining(&self) -> usize { + N.saturating_sub(self.init) + } + + /// Coerce into the underlying bytes if all of them have been initialized. + #[inline] + pub fn into_bytes(self) -> Option<[u8; N]> { + if self.init == N { + // SAFETY: All of the bytes in the sequence have been initialized + // and can be safety transmuted. + // + // Method of transmuting comes from the implementation of + // `MaybeUninit::array_assume_init` which is not yet stable. + unsafe { Some((&self.data as *const _ as *const [u8; N]).read()) } + } else { + None + } + } + + /// Coerce into the slice of initialized memory which is present. + #[inline] + pub fn as_slice(&self) -> &[u8] { + if self.init == 0 { + return &[]; + } + + // SAFETY: We've asserted that `initialized` accounts for the number of + // bytes that have been initialized. + unsafe { core::slice::from_raw_parts(self.data.as_ptr().cast(), self.init) } + } + + /// Coerce into the mutable slice of initialized memory which is present. + #[inline] + pub fn as_mut_slice(&mut self) -> &[u8] { + if self.init == 0 { + return &[]; + } + + // SAFETY: We've asserted that `initialized` accounts for the number of + // bytes that have been initialized. + unsafe { core::slice::from_raw_parts_mut(self.data.as_mut_ptr().cast(), self.init) } + } + + /// Try and push a single byte. + #[inline] + pub fn push(&mut self, value: u8) -> bool { + if N.saturating_sub(self.init) == 0 { + return false; + } + + unsafe { + self.data + .as_mut_ptr() + .cast::() + .add(self.init) + .write(value) + } + + self.init += 1; + true + } + + /// Try and extend from the given slice. + #[inline] + pub fn extend_from_slice(&mut self, source: &[u8]) -> bool { + if source.len() > N.saturating_sub(self.init) { + return false; + } + + unsafe { + let dst = (self.data.as_mut_ptr() as *mut u8).add(self.init); + ptr::copy_nonoverlapping(source.as_ptr(), dst, source.len()); + } + + self.init = self.init.wrapping_add(source.len()); + true + } + + /// Try and extend from the given slice. + #[inline] + pub fn write_bytes(&mut self, cx: &C, source: &[u8]) -> Result<(), C::Error> + where + C: ?Sized + Context, + { + if !self.extend_from_slice(source) { + return Err(cx.message(FixedBytesOverflow { + at: self.init, + additional: source.len(), + capacity: N, + })); + } + + Ok(()) + } +} + +impl Default for FixedBytes { + #[inline] + fn default() -> Self { + Self::new() + } +} + +impl Writer for FixedBytes { + type Mut<'this> = &'this mut Self where Self: 'this; + + #[inline] + fn borrow_mut(&mut self) -> Self::Mut<'_> { + self + } + + #[inline] + fn write_buffer(&mut self, cx: &C, buffer: B) -> Result<(), C::Error> + where + C: ?Sized + Context, + B: Buf, + { + // SAFETY: the buffer never outlives this function call. + self.write_bytes(cx, buffer.as_slice()) + } + + #[inline] + fn write_bytes(&mut self, cx: &C, bytes: &[u8]) -> Result<(), C::Error> + where + C: ?Sized + Context, + { + FixedBytes::write_bytes(self, cx, bytes)?; + cx.advance(bytes.len()); + Ok(()) + } +} + +/// Capacity error raised by trying to write to a [FixedBytes] with no remaining +/// capacity. +#[derive(Debug)] +#[allow(missing_docs)] +#[non_exhaustive] +pub(crate) struct FixedBytesOverflow { + at: usize, + additional: usize, + capacity: usize, +} + +impl fmt::Display for FixedBytesOverflow { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let FixedBytesOverflow { + at, + additional, + capacity, + } = self; + + write!( + f, + "Tried to write {additional} bytes at {at} with capacity {capacity}" + ) + } +} + /// An error raised when we are at capacity. #[non_exhaustive] -pub struct CapacityError; +pub(crate) struct CapacityError; /// A fixed capacity vector allocated on the stack. -pub struct FixedVec { +pub(crate) struct FixedVec { data: [MaybeUninit; N], len: usize, } diff --git a/crates/musli-common/src/fixed_bytes.rs b/crates/musli-common/src/fixed_bytes.rs deleted file mode 100644 index 2396a73eb..000000000 --- a/crates/musli-common/src/fixed_bytes.rs +++ /dev/null @@ -1,208 +0,0 @@ -//! A container which can store up to a fixed number of uninitialized bytes on -//! the stack and read into and from it. - -use core::fmt; -use core::mem::MaybeUninit; -use core::ptr; - -use musli::{Buf, Context}; - -use crate::writer::Writer; - -/// Capacity error raised by trying to write to a [FixedBytes] with no remaining -/// capacity. -#[derive(Debug)] -#[allow(missing_docs)] -#[non_exhaustive] -pub(crate) struct FixedBytesOverflow { - at: usize, - additional: usize, - capacity: usize, -} - -impl fmt::Display for FixedBytesOverflow { - #[inline] - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let FixedBytesOverflow { - at, - additional, - capacity, - } = self; - - write!( - f, - "tried to write {additional} bytes at {at} with capacity {capacity}" - ) - } -} - -/// A fixed-size bytes storage which keeps track of how much has been initialized. -pub struct FixedBytes { - /// Data storage. - data: [MaybeUninit; N], - /// How many bytes have been initialized. - init: usize, -} - -impl FixedBytes { - /// Construct a new fixed bytes array storage. - #[inline] - pub const fn new() -> Self { - Self { - // SAFETY: MaybeUnint::uninit_array is not stable. - data: unsafe { MaybeUninit::<[MaybeUninit; N]>::uninit().assume_init() }, - init: 0, - } - } - - /// Get the length of the collection. - #[inline] - pub const fn len(&self) -> usize { - self.init - } - - /// Test if the current container is empty. - #[inline] - pub const fn is_empty(&self) -> bool { - self.init == 0 - } - - /// Clear the [FixedBytes] container. - #[inline] - pub fn clear(&mut self) { - self.init = 0; - } - - /// Get the remaining capacity of the [FixedBytes]. - #[inline] - pub const fn remaining(&self) -> usize { - N.saturating_sub(self.init) - } - - /// Coerce into the underlying bytes if all of them have been initialized. - #[inline] - pub fn into_bytes(self) -> Option<[u8; N]> { - if self.init == N { - // SAFETY: All of the bytes in the sequence have been initialized - // and can be safety transmuted. - // - // Method of transmuting comes from the implementation of - // `MaybeUninit::array_assume_init` which is not yet stable. - unsafe { Some((&self.data as *const _ as *const [u8; N]).read()) } - } else { - None - } - } - - /// Coerce into the slice of initialized memory which is present. - #[inline] - pub fn as_slice(&self) -> &[u8] { - if self.init == 0 { - return &[]; - } - - // SAFETY: We've asserted that `initialized` accounts for the number of - // bytes that have been initialized. - unsafe { core::slice::from_raw_parts(self.data.as_ptr().cast(), self.init) } - } - - /// Coerce into the mutable slice of initialized memory which is present. - #[inline] - pub fn as_mut_slice(&mut self) -> &[u8] { - if self.init == 0 { - return &[]; - } - - // SAFETY: We've asserted that `initialized` accounts for the number of - // bytes that have been initialized. - unsafe { core::slice::from_raw_parts_mut(self.data.as_mut_ptr().cast(), self.init) } - } - - /// Try and push a single byte. - #[inline] - pub fn push(&mut self, value: u8) -> bool { - if N.saturating_sub(self.init) == 0 { - return false; - } - - unsafe { - self.data - .as_mut_ptr() - .cast::() - .add(self.init) - .write(value) - } - - self.init += 1; - true - } - - /// Try and extend from the given slice. - #[inline] - pub fn extend_from_slice(&mut self, source: &[u8]) -> bool { - if source.len() > N.saturating_sub(self.init) { - return false; - } - - unsafe { - let dst = (self.data.as_mut_ptr() as *mut u8).add(self.init); - ptr::copy_nonoverlapping(source.as_ptr(), dst, source.len()); - } - - self.init = self.init.wrapping_add(source.len()); - true - } - - /// Try and extend from the given slice. - #[inline] - pub fn write_bytes(&mut self, cx: &C, source: &[u8]) -> Result<(), C::Error> - where - C: ?Sized + Context, - { - if !self.extend_from_slice(source) { - return Err(cx.message(FixedBytesOverflow { - at: self.init, - additional: source.len(), - capacity: N, - })); - } - - Ok(()) - } -} - -impl Default for FixedBytes { - #[inline] - fn default() -> Self { - Self::new() - } -} - -impl Writer for FixedBytes { - type Mut<'this> = &'this mut Self where Self: 'this; - - #[inline] - fn borrow_mut(&mut self) -> Self::Mut<'_> { - self - } - - #[inline] - fn write_buffer(&mut self, cx: &C, buffer: B) -> Result<(), C::Error> - where - C: ?Sized + Context, - B: Buf, - { - // SAFETY: the buffer never outlives this function call. - self.write_bytes(cx, buffer.as_slice()) - } - - #[inline] - fn write_bytes(&mut self, cx: &C, bytes: &[u8]) -> Result<(), C::Error> - where - C: ?Sized + Context, - { - FixedBytes::write_bytes(self, cx, bytes)?; - cx.advance(bytes.len()); - Ok(()) - } -} diff --git a/crates/musli-common/src/int/continuation.rs b/crates/musli-common/src/int/continuation.rs index fd4c4b647..3c82470dd 100644 --- a/crates/musli-common/src/int/continuation.rs +++ b/crates/musli-common/src/int/continuation.rs @@ -2,12 +2,12 @@ //! continuation of the sequence or not. //! //! ``` -//! use musli_common::context::Ignore; -//! use musli_common::fixed_bytes::FixedBytes; -//! use musli_common::int::continuation as c; -//! -//! let mut buf = musli_common::allocator::buffer(); -//! let alloc = musli_common::allocator::new(&mut buf); +//! # use musli_common::exports::context::Ignore; +//! # use musli_common::exports::fixed::FixedBytes; +//! # use musli_common::exports::allocator; +//! # use musli_common::int::continuation as c; +//! let mut buf = allocator::buffer(); +//! let alloc = allocator::new(&mut buf); //! //! let cx = Ignore::marker(&alloc); //! let mut bytes = FixedBytes::<8>::new(); diff --git a/crates/musli-common/src/int/tests.rs b/crates/musli-common/src/int/tests.rs index 3be5edc65..8c165c6df 100644 --- a/crates/musli-common/src/int/tests.rs +++ b/crates/musli-common/src/int/tests.rs @@ -1,12 +1,13 @@ use std::fmt; use std::vec::Vec; -use crate::allocator; -use crate::context; use crate::int::continuation as c; use crate::int::zigzag as zig; use crate::int::{Signed, Unsigned}; +use crate::context; +use crate::exports::allocator; + #[cfg(not(miri))] const ITER: usize = 10000; #[cfg(miri)] diff --git a/crates/musli-common/src/lib.rs b/crates/musli-common/src/lib.rs index ca122fddb..6c3ff1b34 100644 --- a/crates/musli-common/src/lib.rs +++ b/crates/musli-common/src/lib.rs @@ -13,9 +13,9 @@ //! [Reader]: https://docs.rs/musli-common/latest/musli-common/reader/trait.Reader.html //! [Writer]: https://docs.rs/musli-common/latest/musli-common/writer/trait.Writer.html -#![allow(clippy::type_complexity)] #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg_attr(test, macro_use)] #[cfg(feature = "std")] @@ -24,21 +24,91 @@ extern crate std; #[cfg(feature = "alloc")] extern crate alloc; -#[doc(inline)] -pub use musli_allocator as allocator; +pub(crate) mod context; +pub(crate) mod fixed; +#[macro_use] +pub(crate) mod options; +pub(crate) mod buf; +pub(crate) mod reader; +pub(crate) mod wrap; +pub(crate) mod writer; + +#[doc(hidden)] +pub mod exports { + pub mod context { + //! Helper types to set up a basic Müsli [`Context`]. + //! + //! [`Context`]: musli::Context + + #[doc(inline)] + pub use crate::context::*; + } + + pub mod fixed { + //! A container which can store up to a fixed number of uninitialized bytes on + //! the stack and read into and from it. + + #[doc(inline)] + pub use crate::fixed::FixedBytes; + } + + pub mod options { + //! Serialization options. + + #[doc(inline)] + pub use crate::options::*; + } + + pub mod buf { + //! Utilitioes for working with buffers. + + #[doc(inline)] + pub use crate::buf::*; + } + + pub mod reader { + //! Trait for governing how a particular source of bytes is read. + //! + //! `musli` requires all sources to reference the complete data being read from + //! it which allows it to make the assumption the bytes are always returned with + //! the `'de` lifetime. + #[doc(inline)] + pub use crate::reader::*; + } + + pub mod wrap { + //! Helpers for integrating musli with I/O types like [std::io] and + //! [std::io::Write]. + //! + //! The central function in this module is the [wrap] function which constructs + //! an adapter around an I/O type to work with musli. + + #[doc(inline)] + pub use crate::wrap::*; + } + + pub mod writer { + //! Trait for governing how a particular sink of bytes is written to. + //! + //! To adapt [std::io::Write] types, see the [wrap][crate::wrap::wrap] function. + + #[doc(inline)] + pub use crate::writer::*; + } + + #[doc(inline)] + pub use musli_allocator as allocator; +} + +#[doc(hidden)] pub mod buffered_writer; -pub mod context; -mod fixed; -pub mod fixed_bytes; + +#[doc(hidden)] pub mod int; -#[macro_use] -pub mod options; -pub mod buf; -pub mod reader; + +#[doc(hidden)] pub mod str; -pub mod wrap; -pub mod writer; #[macro_use] mod macros; diff --git a/crates/musli-common/src/macros.rs b/crates/musli-common/src/macros.rs index 0e6532add..e27274aeb 100644 --- a/crates/musli-common/src/macros.rs +++ b/crates/musli-common/src/macros.rs @@ -11,9 +11,9 @@ macro_rules! encode_with_extensions { W: Writer, T: ?Sized + Encode<$mode>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::new(&alloc); + let mut buf = $crate::exports::allocator::buffer(); + let alloc = $crate::exports::allocator::new(&mut buf); + let cx = $crate::exports::context::Same::new(&alloc); self.encode_with(&cx, writer, value) } @@ -26,7 +26,7 @@ macro_rules! encode_with_extensions { W: io::Write, T: ?Sized + Encode<$mode>, { - let writer = $crate::wrap::wrap(write); + let writer = $crate::exports::wrap::wrap(write); self.encode(writer, value) } @@ -65,9 +65,9 @@ macro_rules! encode_with_extensions { where T: ?Sized + Encode<$mode>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::new(&alloc); + let mut buf = $crate::exports::allocator::buffer(); + let alloc = $crate::exports::allocator::new(&mut buf); + let cx = $crate::exports::context::Same::new(&alloc); self.to_fixed_bytes_with(&cx, value) } @@ -102,9 +102,9 @@ macro_rules! encoding_from_slice_impls { where T: Decode<'de, $mode>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::new(&alloc); + let mut buf = $crate::exports::allocator::buffer(); + let alloc = $crate::exports::allocator::new(&mut buf); + let cx = $crate::exports::context::Same::new(&alloc); self.from_slice_with(&cx, bytes) } @@ -168,9 +168,9 @@ macro_rules! encoding_impls { R: Reader<'de>, T: Decode<'de, $mode>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::new(&alloc); + let mut buf = $crate::exports::allocator::buffer(); + let alloc = $crate::exports::allocator::new(&mut buf); + let cx = $crate::exports::context::Same::new(&alloc); self.decode_with(&cx, reader) } diff --git a/crates/musli-common/src/options.rs b/crates/musli-common/src/options.rs index 50e15d57f..86999a22a 100644 --- a/crates/musli-common/src/options.rs +++ b/crates/musli-common/src/options.rs @@ -1,5 +1,3 @@ -//! Serialization options. - /// Type encapsulating a static flavor of an encoding. pub struct OptionsBuilder(Options); @@ -154,13 +152,13 @@ impl ByteOrder { macro_rules! width_arm { ($width:expr, $macro:path) => { match $width { - $crate::options::Width::U8 => { + $crate::exports::options::Width::U8 => { $macro!(u8) } - $crate::options::Width::U16 => { + $crate::exports::options::Width::U16 => { $macro!(u16) } - $crate::options::Width::U32 => { + $crate::exports::options::Width::U32 => { $macro!(u32) } _ => { diff --git a/crates/musli-common/src/reader.rs b/crates/musli-common/src/reader.rs index 2f9352e95..9df74cf28 100644 --- a/crates/musli-common/src/reader.rs +++ b/crates/musli-common/src/reader.rs @@ -1,9 +1,3 @@ -//! Trait for governing how a particular source of bytes is read. -//! -//! `musli` requires all sources to reference the complete data being read from -//! it which allows it to make the assumption the bytes are always returned with -//! the `'de` lifetime. - use core::array; use core::fmt; use core::marker; diff --git a/crates/musli-common/src/wrap.rs b/crates/musli-common/src/wrap.rs index 875bcb5ea..493b47167 100644 --- a/crates/musli-common/src/wrap.rs +++ b/crates/musli-common/src/wrap.rs @@ -1,19 +1,18 @@ -//! Helpers for integrating musli with I/O types like [std::io] and -//! [std::io::Write]. -//! -//! The central function in this module is the [wrap] function which constructs -//! an adapter around an I/O type to work with musli. - #[cfg(feature = "std")] use musli::{Buf, Context}; -/// Wrapper constructed with [wrap]. +/// Wrap a type so that it implements [Reader] and [Writer]. +/// +/// [Reader]: crate::reader::Reader +/// [Writer]: crate::writer::Writer +/// +/// See [`wrap()`]. pub struct Wrap { #[cfg_attr(not(feature = "std"), allow(unused))] inner: T, } -/// Wrap a type so that it implements [Reader] or [Writer] as appropriate. +/// Wrap a type so that it implements [Reader] and [Writer]. /// /// [Reader]: crate::reader::Reader /// [Writer]: crate::writer::Writer diff --git a/crates/musli-common/src/writer.rs b/crates/musli-common/src/writer.rs index 3a88473f4..18a36e2b4 100644 --- a/crates/musli-common/src/writer.rs +++ b/crates/musli-common/src/writer.rs @@ -1,7 +1,3 @@ -//! Trait for governing how a particular sink of bytes is written to. -//! -//! To adapt [std::io::Write] types, see the [wrap][crate::wrap::wrap] function. - use core::fmt; use core::mem::take; diff --git a/crates/musli-descriptive/src/de.rs b/crates/musli-descriptive/src/de.rs index 9a4d7b62a..4fb187d11 100644 --- a/crates/musli-descriptive/src/de.rs +++ b/crates/musli-descriptive/src/de.rs @@ -9,16 +9,16 @@ use musli::de::{ TypeHint, ValueVisitor, VariantDecoder, Visitor, }; use musli::Context; +use musli_common::int::continuation as c; use musli_storage::de::StorageDecoder; -use crate::int::continuation as c; use crate::integer_encoding::{decode_typed_signed, decode_typed_unsigned}; use crate::options::Options; use crate::reader::{Limit, Reader}; use crate::tag::{Kind, Mark, Tag, F32, F64, I128, I16, I32, I64, I8, U128, U16, U32, U64, U8}; #[cfg(feature = "musli-value")] -const BUFFER_OPTIONS: musli_common::options::Options = musli_common::options::new().build(); +const BUFFER_OPTIONS: crate::options::Options = crate::options::new().build(); /// A very simple decoder. pub struct SelfDecoder { @@ -71,7 +71,7 @@ where let len = if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }; self.reader.skip(cx, len)?; @@ -84,7 +84,7 @@ where let len = if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }; for _ in 0..len { @@ -95,7 +95,7 @@ where let len = if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }; for _ in 0..len { @@ -154,7 +154,7 @@ where Ok(if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }) } @@ -170,7 +170,7 @@ where Kind::Bytes => Ok(if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }), Kind::Pack => { let Some(len) = 2usize.checked_pow(tag.data_raw() as u32) else { diff --git a/crates/musli-descriptive/src/en.rs b/crates/musli-descriptive/src/en.rs index 2f7372443..ce4ce2a6e 100644 --- a/crates/musli-descriptive/src/en.rs +++ b/crates/musli-descriptive/src/en.rs @@ -5,9 +5,9 @@ use musli::en::{ StructFieldEncoder, VariantEncoder, }; use musli::{Buf, Context, Encode}; +use musli_common::int::continuation as c; use musli_storage::en::StorageEncoder; -use crate::int::continuation as c; use crate::integer_encoding::{encode_typed_signed, encode_typed_unsigned}; use crate::options::Options; use crate::tag::{ @@ -531,7 +531,7 @@ where writer.write_byte(cx, tag.byte())?; if !embedded { - crate::int::encode_usize::<_, _, F>(cx, writer, len)?; + musli_common::int::encode_usize::<_, _, F>(cx, writer, len)?; } Ok(()) diff --git a/crates/musli-descriptive/src/encoding.rs b/crates/musli-descriptive/src/encoding.rs index a5fc79b90..c62b55a8f 100644 --- a/crates/musli-descriptive/src/encoding.rs +++ b/crates/musli-descriptive/src/encoding.rs @@ -15,7 +15,7 @@ use musli::Context; use crate::de::SelfDecoder; use crate::en::SelfEncoder; use crate::error::Error; -use crate::fixed_bytes::FixedBytes; +use crate::fixed::FixedBytes; use crate::options::{self, Options}; use crate::reader::{Reader, SliceReader}; use crate::writer::Writer; diff --git a/crates/musli-descriptive/src/error.rs b/crates/musli-descriptive/src/error.rs index 23026f798..bcf154d34 100644 --- a/crates/musli-descriptive/src/error.rs +++ b/crates/musli-descriptive/src/error.rs @@ -54,7 +54,7 @@ impl std::error::Error for Error { } } -impl musli_common::context::Error for Error { +impl crate::context::Error for Error { #[inline] #[allow(unused_variables)] fn custom(error: T) -> Self diff --git a/crates/musli-descriptive/src/integer_encoding.rs b/crates/musli-descriptive/src/integer_encoding.rs index abf1a8321..937bedb8c 100644 --- a/crates/musli-descriptive/src/integer_encoding.rs +++ b/crates/musli-descriptive/src/integer_encoding.rs @@ -3,8 +3,9 @@ use musli::Context; use musli_common::int::continuation as c; use musli_common::int::zigzag as zig; use musli_common::int::{Signed, Unsigned}; -use musli_common::reader::Reader; -use musli_common::writer::Writer; + +use crate::reader::Reader; +use crate::writer::Writer; use crate::tag::{Kind, Tag}; diff --git a/crates/musli-descriptive/src/lib.rs b/crates/musli-descriptive/src/lib.rs index 086bd7485..a43eb68d7 100644 --- a/crates/musli-descriptive/src/lib.rs +++ b/crates/musli-descriptive/src/lib.rs @@ -95,6 +95,7 @@ #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg(feature = "alloc")] extern crate alloc; @@ -112,6 +113,8 @@ mod error; mod integer_encoding; pub mod tag; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] #[macro_use] pub mod test; @@ -119,12 +122,20 @@ pub mod test; pub type Result = core::result::Result; #[cfg(feature = "alloc")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))] +#[doc(inline)] pub use self::encoding::to_vec; #[cfg(feature = "std")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] +#[doc(inline)] pub use self::encoding::to_writer; +#[doc(inline)] pub use self::encoding::{decode, encode, from_slice, to_fixed_bytes, Encoding}; +#[doc(inline)] pub use self::error::Error; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] pub use self::test::{transcode, Typed}; #[doc(inline)] -pub use musli_common::*; +pub use musli_common::exports::*; diff --git a/crates/musli-descriptive/src/test.rs b/crates/musli-descriptive/src/test.rs index c729cc991..4396be16c 100644 --- a/crates/musli-descriptive/src/test.rs +++ b/crates/musli-descriptive/src/test.rs @@ -45,6 +45,7 @@ where /// Roundtrip encode the given value. #[macro_export] +#[doc(hidden)] macro_rules! rt { ($enum:ident :: $variant:ident $($tt:tt)?) => { $crate::rt!($enum, $enum :: $variant $($tt)*) diff --git a/crates/musli-json/src/de/mod.rs b/crates/musli-json/src/de/mod.rs index 4b3fb0d90..48a70a385 100644 --- a/crates/musli-json/src/de/mod.rs +++ b/crates/musli-json/src/de/mod.rs @@ -42,7 +42,7 @@ use crate::parser::integer::{ use crate::parser::{integer, string, Parser, StringReference, Token}; #[cfg(feature = "musli-value")] -const BUFFER_OPTIONS: musli_common::options::Options = musli_common::options::new().build(); +const BUFFER_OPTIONS: crate::options::Options = crate::options::new().build(); /// A JSON decoder for Müsli. pub(crate) struct JsonDecoder

{ diff --git a/crates/musli-json/src/en/array_encoder.rs b/crates/musli-json/src/en/array_encoder.rs index 9bca042de..71bf85143 100644 --- a/crates/musli-json/src/en/array_encoder.rs +++ b/crates/musli-json/src/en/array_encoder.rs @@ -2,7 +2,8 @@ use core::mem::take; use musli::en::SequenceEncoder; use musli::Context; -use musli_common::writer::Writer; + +use crate::writer::Writer; use super::JsonEncoder; diff --git a/crates/musli-json/src/en/mod.rs b/crates/musli-json/src/en/mod.rs index 08e4cdd0b..29c26f5d1 100644 --- a/crates/musli-json/src/en/mod.rs +++ b/crates/musli-json/src/en/mod.rs @@ -17,7 +17,8 @@ use core::fmt; use musli::en::{Encoder, SequenceEncoder}; use musli::{Context, Encode}; -use musli_common::writer::Writer; + +use crate::writer::Writer; /// A JSON encoder for Müsli. pub(crate) struct JsonEncoder { diff --git a/crates/musli-json/src/en/object_encoder.rs b/crates/musli-json/src/en/object_encoder.rs index 2e710df42..eed939b77 100644 --- a/crates/musli-json/src/en/object_encoder.rs +++ b/crates/musli-json/src/en/object_encoder.rs @@ -1,8 +1,8 @@ use musli::en::{MapEncoder, MapEntriesEncoder, StructEncoder}; use musli::Context; -use musli_common::writer::Writer; use super::{JsonEncoder, JsonObjectKeyEncoder, JsonObjectPairEncoder}; +use crate::writer::Writer; /// An object encoder for JSON. pub(crate) struct JsonObjectEncoder { diff --git a/crates/musli-json/src/en/object_key_encoder.rs b/crates/musli-json/src/en/object_key_encoder.rs index c3b7e26e8..486ffeddf 100644 --- a/crates/musli-json/src/en/object_key_encoder.rs +++ b/crates/musli-json/src/en/object_key_encoder.rs @@ -2,7 +2,8 @@ use core::fmt; use musli::en::Encoder; use musli::Context; -use musli_common::writer::Writer; + +use crate::writer::Writer; pub(crate) struct JsonObjectKeyEncoder { writer: W, diff --git a/crates/musli-json/src/en/object_pair_encoder.rs b/crates/musli-json/src/en/object_pair_encoder.rs index c22a10f93..0e3bd4f5e 100644 --- a/crates/musli-json/src/en/object_pair_encoder.rs +++ b/crates/musli-json/src/en/object_pair_encoder.rs @@ -1,6 +1,7 @@ use musli::en::{MapEntryEncoder, StructFieldEncoder}; use musli::Context; -use musli_common::writer::Writer; + +use crate::writer::Writer; use super::{JsonEncoder, JsonObjectKeyEncoder}; diff --git a/crates/musli-json/src/en/variant_encoder.rs b/crates/musli-json/src/en/variant_encoder.rs index 3c133b82f..697579e8a 100644 --- a/crates/musli-json/src/en/variant_encoder.rs +++ b/crates/musli-json/src/en/variant_encoder.rs @@ -1,6 +1,7 @@ use musli::en::VariantEncoder; use musli::Context; -use musli_common::writer::Writer; + +use crate::writer::Writer; use super::{JsonEncoder, JsonObjectKeyEncoder}; diff --git a/crates/musli-json/src/encoding.rs b/crates/musli-json/src/encoding.rs index cfe6d57a5..633f2cf83 100644 --- a/crates/musli-json/src/encoding.rs +++ b/crates/musli-json/src/encoding.rs @@ -19,7 +19,7 @@ use musli::Context; use crate::de::JsonDecoder; use crate::en::JsonEncoder; use crate::error::Error; -use crate::fixed_bytes::FixedBytes; +use crate::fixed::FixedBytes; use crate::parser::{Parser, SliceParser}; use crate::writer::Writer; @@ -188,9 +188,9 @@ impl Encoding { where T: ?Sized + Encode, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::new(&alloc); + let mut buf = crate::allocator::buffer(); + let alloc = crate::allocator::new(&mut buf); + let cx = crate::context::Same::new(&alloc); self.to_string_with(&cx, value) } @@ -219,9 +219,9 @@ impl Encoding { P: Parser<'de>, T: Decode<'de, M>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::new(&alloc); + let mut buf = crate::allocator::buffer(); + let alloc = crate::allocator::new(&mut buf); + let cx = crate::context::Same::new(&alloc); self.decode_with(&cx, parser) } @@ -271,9 +271,9 @@ impl Encoding { where T: Decode<'de, M>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::<_, M, _>::new(&alloc); + let mut buf = crate::allocator::buffer(); + let alloc = crate::allocator::new(&mut buf); + let cx = crate::context::Same::<_, M, _>::new(&alloc); self.from_slice_with(&cx, bytes) } diff --git a/crates/musli-json/src/error.rs b/crates/musli-json/src/error.rs index 30b050ee2..8febddce2 100644 --- a/crates/musli-json/src/error.rs +++ b/crates/musli-json/src/error.rs @@ -40,7 +40,7 @@ impl fmt::Display for ErrorImpl { #[cfg(feature = "std")] impl std::error::Error for Error {} -impl musli_common::context::Error for Error { +impl crate::context::Error for Error { #[inline] fn custom(error: T) -> Self where diff --git a/crates/musli-json/src/lib.rs b/crates/musli-json/src/lib.rs index 85ff95df3..65e2e147f 100644 --- a/crates/musli-json/src/lib.rs +++ b/crates/musli-json/src/lib.rs @@ -43,6 +43,7 @@ #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg(feature = "alloc")] extern crate alloc; @@ -58,6 +59,8 @@ mod error; mod parser; pub use self::parser::Parser; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] #[macro_use] pub mod test; @@ -65,10 +68,16 @@ pub mod test; pub type Result = core::result::Result; #[cfg(feature = "std")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] +#[doc(inline)] pub use self::encoding::to_writer; +#[doc(inline)] pub use self::encoding::{decode, encode, from_slice, from_str, to_fixed_bytes, Encoding}; #[cfg(feature = "alloc")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))] +#[doc(inline)] pub use self::encoding::{to_string, to_vec}; +#[doc(inline)] pub use self::error::Error; #[doc(inline)] -pub use musli_common::*; +pub use musli_common::exports::*; diff --git a/crates/musli-json/src/parser/parser.rs b/crates/musli-json/src/parser/parser.rs index 1567d1f11..6d89495e3 100644 --- a/crates/musli-json/src/parser/parser.rs +++ b/crates/musli-json/src/parser/parser.rs @@ -10,7 +10,7 @@ mod private { impl<'de, R> Sealed for &mut R where R: ?Sized + super::Parser<'de> {} } -/// Parser trait for this crate. +/// Trait governing how JSON is parsed depending on the kind of buffer provided. pub trait Parser<'de>: private::Sealed { /// Reborrowed type. /// diff --git a/crates/musli-json/src/parser/tests.rs b/crates/musli-json/src/parser/tests.rs index f61ec02ba..feb0ca045 100644 --- a/crates/musli-json/src/parser/tests.rs +++ b/crates/musli-json/src/parser/tests.rs @@ -8,9 +8,9 @@ use crate::parser::SliceParser; #[test] fn test_decode_exponent() { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::<_, DefaultMode, Error>::new(&alloc); + let mut buf = crate::allocator::buffer(); + let alloc = crate::allocator::new(&mut buf); + let cx = crate::context::Same::<_, DefaultMode, Error>::new(&alloc); macro_rules! test_number { ($ty:ty, $num:expr, $expected:expr) => { @@ -45,9 +45,9 @@ fn test_decode_exponent() { #[test] fn test_decode_unsigned() { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::<_, DefaultMode, Error>::new(&alloc); + let mut buf = crate::allocator::buffer(); + let alloc = crate::allocator::new(&mut buf); + let cx = crate::context::Same::<_, DefaultMode, Error>::new(&alloc); macro_rules! test_number { ($ty:ty, $num:expr) => { @@ -113,9 +113,9 @@ fn test_decode_unsigned() { #[test] fn test_decode_signed() { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::<_, DefaultMode, Error>::new(&alloc); + let mut buf = crate::allocator::buffer(); + let alloc = crate::allocator::new(&mut buf); + let cx = crate::context::Same::<_, DefaultMode, Error>::new(&alloc); macro_rules! test_number { ($ty:ty, $num:expr) => { diff --git a/crates/musli-json/src/test.rs b/crates/musli-json/src/test.rs index a8bc9264e..67a1b8c84 100644 --- a/crates/musli-json/src/test.rs +++ b/crates/musli-json/src/test.rs @@ -7,6 +7,7 @@ use musli::{Decode, Encode}; /// Roundtrip encode the given value. #[macro_export] +#[doc(hidden)] macro_rules! rt { ($enum:ident :: $variant:ident $($tt:tt)?) => { $crate::rt!($enum, $enum :: $variant $($tt)*) diff --git a/crates/musli-json/tests/trace_collection.rs b/crates/musli-json/tests/trace_collection.rs index 6dce5ad1d..19e8bf95f 100644 --- a/crates/musli-json/tests/trace_collection.rs +++ b/crates/musli-json/tests/trace_collection.rs @@ -3,8 +3,8 @@ use std::collections::HashMap; use musli::{Decode, Encode}; -use musli_common::allocator::{System, SystemBuffer}; -use musli_common::context::SystemContext; +use musli_json::allocator::{System, SystemBuffer}; +use musli_json::context::SystemContext; #[derive(Encode)] struct From { diff --git a/crates/musli-json/tests/trace_complex.rs b/crates/musli-json/tests/trace_complex.rs index 32ae82145..f311e6bdc 100644 --- a/crates/musli-json/tests/trace_complex.rs +++ b/crates/musli-json/tests/trace_complex.rs @@ -3,8 +3,8 @@ use std::collections::HashMap; use musli::{Decode, Encode}; -use musli_common::allocator::{System, SystemBuffer}; -use musli_common::context::SystemContext; +use musli_json::allocator::{System, SystemBuffer}; +use musli_json::context::SystemContext; #[derive(Encode)] enum InnerFrom { diff --git a/crates/musli-json/tests/trace_no_std.rs b/crates/musli-json/tests/trace_no_std.rs index 1cab70b25..aa6ec7cae 100644 --- a/crates/musli-json/tests/trace_no_std.rs +++ b/crates/musli-json/tests/trace_no_std.rs @@ -3,8 +3,8 @@ use std::collections::HashMap; use musli::{Decode, Encode}; -use musli_common::allocator::{Stack, StackBuffer}; -use musli_common::context::StackContext; +use musli_json::allocator::{Stack, StackBuffer}; +use musli_json::context::StackContext; #[derive(Encode)] struct From { diff --git a/crates/musli-serde/src/serializer.rs b/crates/musli-serde/src/serializer.rs index da446d039..57b890068 100644 --- a/crates/musli-serde/src/serializer.rs +++ b/crates/musli-serde/src/serializer.rs @@ -266,7 +266,7 @@ where T: fmt::Display, { use core::fmt::Write; - use musli_common::buf::BufString; + use musli_common::exports::buf::BufString; let Some(buf) = self.cx.alloc() else { return Err(ser::Error::custom("Failed to allocate")); diff --git a/crates/musli-storage/src/de.rs b/crates/musli-storage/src/de.rs index b1c165531..db1acfe06 100644 --- a/crates/musli-storage/src/de.rs +++ b/crates/musli-storage/src/de.rs @@ -8,8 +8,9 @@ use musli::de::{ SizeHint, StructDecoder, StructFieldDecoder, StructFieldsDecoder, ValueVisitor, VariantDecoder, }; use musli::Context; -use musli_common::options::Options; -use musli_common::reader::Reader; + +use crate::options::Options; +use crate::reader::Reader; /// A very simple decoder suitable for storage decoding. pub struct StorageDecoder { diff --git a/crates/musli-storage/src/en.rs b/crates/musli-storage/src/en.rs index 29a68c00e..678a9b18a 100644 --- a/crates/musli-storage/src/en.rs +++ b/crates/musli-storage/src/en.rs @@ -5,8 +5,9 @@ use musli::en::{ StructEncoder, StructFieldEncoder, VariantEncoder, }; use musli::Context; -use musli_common::options::{self, Options}; -use musli_common::writer::Writer; + +use crate::options::{self, Options}; +use crate::writer::Writer; const DEFAULT_OPTIONS: options::Options = options::new().build(); diff --git a/crates/musli-storage/src/encoding.rs b/crates/musli-storage/src/encoding.rs index 511110d66..968de9c99 100644 --- a/crates/musli-storage/src/encoding.rs +++ b/crates/musli-storage/src/encoding.rs @@ -15,7 +15,7 @@ use musli::Context; use crate::de::StorageDecoder; use crate::en::StorageEncoder; use crate::error::Error; -use crate::fixed_bytes::FixedBytes; +use crate::fixed::FixedBytes; use crate::options::{self, Options}; use crate::reader::{Reader, SliceReader}; use crate::writer::Writer; diff --git a/crates/musli-storage/src/error.rs b/crates/musli-storage/src/error.rs index 0cbb9b4c7..4171f3480 100644 --- a/crates/musli-storage/src/error.rs +++ b/crates/musli-storage/src/error.rs @@ -40,7 +40,7 @@ impl fmt::Display for ErrorImpl { #[cfg(feature = "std")] impl std::error::Error for Error {} -impl musli_common::context::Error for Error { +impl crate::context::Error for Error { #[inline] fn custom(error: T) -> Self where diff --git a/crates/musli-storage/src/lib.rs b/crates/musli-storage/src/lib.rs index 9b5ec2efa..6184f4882 100644 --- a/crates/musli-storage/src/lib.rs +++ b/crates/musli-storage/src/lib.rs @@ -95,6 +95,7 @@ #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg(feature = "std")] extern crate std; @@ -109,18 +110,28 @@ pub mod en; pub mod encoding; mod error; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] pub mod test; /// Convenient result alias for use with `musli_storage`. pub type Result = core::result::Result; #[cfg(feature = "alloc")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))] +#[doc(inline)] pub use self::encoding::to_vec; #[cfg(feature = "std")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] +#[doc(inline)] pub use self::encoding::to_writer; +#[doc(inline)] pub use self::encoding::{decode, encode, from_slice, to_fixed_bytes, Encoding}; +#[doc(inline)] pub use self::error::Error; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] pub use self::test::transcode; #[doc(inline)] -pub use musli_common::*; +pub use musli_common::exports::*; diff --git a/crates/musli-storage/src/test.rs b/crates/musli-storage/src/test.rs index 013129c87..6c03503dd 100644 --- a/crates/musli-storage/src/test.rs +++ b/crates/musli-storage/src/test.rs @@ -7,6 +7,7 @@ use musli::{Decode, Encode}; /// Roundtrip encode the given value. #[macro_export] +#[doc(hidden)] macro_rules! rt { ($enum:ident :: $variant:ident $($tt:tt)?) => { $crate::rt!($enum, $enum :: $variant $($tt)*) diff --git a/crates/musli-storage/tests/storage_trace.rs b/crates/musli-storage/tests/storage_trace.rs index 5f3873a7e..1ddfe705a 100644 --- a/crates/musli-storage/tests/storage_trace.rs +++ b/crates/musli-storage/tests/storage_trace.rs @@ -1,8 +1,8 @@ #![allow(unused)] use musli::{Decode, Encode}; -use musli_common::allocator::{System, SystemBuffer}; -use musli_common::context::SystemContext; +use musli_storage::allocator::{System, SystemBuffer}; +use musli_storage::context::SystemContext; #[derive(Encode)] enum InnerFrom { diff --git a/crates/musli-value/src/error.rs b/crates/musli-value/src/error.rs index f9d5d0247..aa8774be8 100644 --- a/crates/musli-value/src/error.rs +++ b/crates/musli-value/src/error.rs @@ -44,7 +44,7 @@ impl fmt::Display for ErrorImpl { #[cfg(feature = "std")] impl std::error::Error for Error {} -impl musli_common::context::Error for Error { +impl crate::context::Error for Error { #[inline] fn custom(error: T) -> Self where diff --git a/crates/musli-value/src/lib.rs b/crates/musli-value/src/lib.rs index 4ab7bf73d..9c84f05b8 100644 --- a/crates/musli-value/src/lib.rs +++ b/crates/musli-value/src/lib.rs @@ -9,6 +9,7 @@ #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg(feature = "alloc")] extern crate alloc; @@ -24,15 +25,18 @@ mod value; /// Convenient result alias for use with `musli_value`. pub type Result = core::result::Result; +#[doc(inline)] pub use self::value::{AsValueDecoder, Value}; +#[doc(inline)] pub use error::Error; +#[doc(inline)] +pub use musli_common::exports::*; use en::ValueEncoder; use musli::mode::DefaultMode; use musli::{Decode, Encode}; -use musli_storage::options; -const DEFAULT_OPTIONS: options::Options = options::new().build(); +const DEFAULT_OPTIONS: crate::options::Options = crate::options::new().build(); /// Encode something that implements [Encode] into a [Value]. pub fn encode(value: T) -> Result @@ -40,9 +44,9 @@ where T: Encode, { let mut output = Value::Unit; - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::<_, DefaultMode, Error>::new(&alloc); + let mut buf = musli_common::exports::allocator::buffer(); + let alloc = musli_common::exports::allocator::new(&mut buf); + let cx = musli_common::exports::context::Same::<_, DefaultMode, Error>::new(&alloc); value.encode(&cx, ValueEncoder::new(&mut output))?; Ok(output) } @@ -52,8 +56,8 @@ pub fn decode<'de, T>(value: &'de Value) -> Result where T: Decode<'de>, { - let mut buf = musli_common::allocator::buffer(); - let alloc = musli_common::allocator::new(&mut buf); - let cx = musli_common::context::Same::<_, DefaultMode, Error>::new(&alloc); + let mut buf = musli_common::exports::allocator::buffer(); + let alloc = musli_common::exports::allocator::new(&mut buf); + let cx = musli_common::exports::context::Same::<_, DefaultMode, Error>::new(&alloc); T::decode(&cx, value.decoder::()) } diff --git a/crates/musli-value/src/value.rs b/crates/musli-value/src/value.rs index 7517ffb00..3703b49cb 100644 --- a/crates/musli-value/src/value.rs +++ b/crates/musli-value/src/value.rs @@ -16,9 +16,9 @@ use musli::en::{Encode, Encoder}; #[cfg(feature = "alloc")] use musli::en::{MapEncoder, SequenceEncoder, VariantEncoder}; use musli::Context; -use musli_common::options::Options; use crate::de::ValueDecoder; +use crate::options::Options; /// A dynamic value capable of representing any [Müsli] type whether it be /// complex or simple. diff --git a/crates/musli-wire/src/de.rs b/crates/musli-wire/src/de.rs index f44f25ed2..ec6ab7742 100644 --- a/crates/musli-wire/src/de.rs +++ b/crates/musli-wire/src/de.rs @@ -8,11 +8,11 @@ use musli::de::{ SizeHint, StructDecoder, StructFieldDecoder, StructFieldsDecoder, ValueVisitor, VariantDecoder, }; use musli::Context; -use musli_common::reader::{Limit, Reader}; +use musli_common::int::continuation as c; use musli_storage::de::StorageDecoder; -use musli_storage::int::continuation as c; use crate::options::Options; +use crate::reader::{Limit, Reader}; use crate::tag::Kind; use crate::tag::Tag; @@ -49,7 +49,7 @@ where let len = if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }; self.reader.skip(cx, len)?; @@ -58,7 +58,7 @@ where let len = if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }; for _ in 0..len { @@ -86,7 +86,7 @@ where Kind::Sequence => Ok(if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }), _ => Err(cx.message(Expected { expected: Kind::Sequence, @@ -130,7 +130,7 @@ where Kind::Prefix => Ok(if let Some(len) = tag.data() { len as usize } else { - crate::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? + musli_common::int::decode_usize::<_, _, F>(cx, self.reader.borrow_mut())? }), Kind::Pack => { let Some(len) = 2usize.checked_pow(tag.data_raw() as u32) else { diff --git a/crates/musli-wire/src/en.rs b/crates/musli-wire/src/en.rs index f3ef7c152..5dca65f4c 100644 --- a/crates/musli-wire/src/en.rs +++ b/crates/musli-wire/src/en.rs @@ -39,7 +39,7 @@ where self.writer.write_byte(cx, tag.byte())?; if !embedded { - crate::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; + musli_common::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; } Ok(()) @@ -54,7 +54,7 @@ where self.writer.write_byte(cx, tag.byte())?; if !embedded { - crate::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; + musli_common::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; } Ok(()) @@ -265,7 +265,7 @@ where self.writer.write_byte(cx, tag.byte())?; if !embedded { - crate::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; + musli_common::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; } Ok(self) @@ -298,7 +298,7 @@ where self.writer.write_byte(cx, tag.byte())?; if !embedded { - crate::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; + musli_common::int::encode_usize::<_, _, F>(cx, self.writer.borrow_mut(), len)?; } Ok(self) @@ -563,7 +563,7 @@ where writer.write_byte(cx, tag.byte())?; if !embedded { - crate::int::encode_usize::<_, _, F>(cx, writer, len)?; + musli_common::int::encode_usize::<_, _, F>(cx, writer, len)?; } Ok(()) diff --git a/crates/musli-wire/src/encoding.rs b/crates/musli-wire/src/encoding.rs index c3bbe3efd..44bf8edb3 100644 --- a/crates/musli-wire/src/encoding.rs +++ b/crates/musli-wire/src/encoding.rs @@ -16,7 +16,7 @@ use musli::Context; use crate::de::WireDecoder; use crate::en::WireEncoder; use crate::error::Error; -use crate::fixed_bytes::FixedBytes; +use crate::fixed::FixedBytes; use crate::options::{self, Options}; use crate::reader::{Reader, SliceReader}; use crate::writer::Writer; diff --git a/crates/musli-wire/src/error.rs b/crates/musli-wire/src/error.rs index bbe10c9a6..cbf6ff66f 100644 --- a/crates/musli-wire/src/error.rs +++ b/crates/musli-wire/src/error.rs @@ -40,7 +40,7 @@ impl fmt::Display for ErrorImpl { #[cfg(feature = "std")] impl std::error::Error for Error {} -impl musli_common::context::Error for Error { +impl crate::context::Error for Error { #[inline] fn custom(error: T) -> Self where diff --git a/crates/musli-wire/src/lib.rs b/crates/musli-wire/src/lib.rs index eb883226b..ae5b4be65 100644 --- a/crates/musli-wire/src/lib.rs +++ b/crates/musli-wire/src/lib.rs @@ -99,6 +99,7 @@ #![deny(missing_docs)] #![no_std] +#![cfg_attr(doc_cfg, feature(doc_cfg))] #[cfg(feature = "alloc")] extern crate alloc; @@ -117,6 +118,8 @@ pub mod tag; mod wire_int; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] #[macro_use] pub mod test; @@ -124,12 +127,20 @@ pub mod test; pub type Result = core::result::Result; #[cfg(feature = "alloc")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))] +#[doc(inline)] pub use self::encoding::to_vec; +#[doc(inline)] #[cfg(feature = "std")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] pub use self::encoding::to_writer; +#[doc(inline)] pub use self::encoding::{decode, encode, from_slice, to_fixed_bytes, Encoding}; +#[doc(inline)] pub use self::error::Error; #[cfg(feature = "test")] +#[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] +#[doc(hidden)] pub use self::test::{transcode, Typed}; #[doc(inline)] -pub use musli_common::*; +pub use musli_common::exports::*; diff --git a/crates/musli-wire/src/test.rs b/crates/musli-wire/src/test.rs index 43be29c57..6466a3c2e 100644 --- a/crates/musli-wire/src/test.rs +++ b/crates/musli-wire/src/test.rs @@ -45,6 +45,7 @@ where /// Roundtrip encode the given value. #[macro_export] +#[doc(hidden)] macro_rules! rt { ($enum:ident :: $variant:ident $($tt:tt)?) => { $crate::rt!($enum, $enum :: $variant $($tt)*) diff --git a/crates/musli-wire/src/wire_int.rs b/crates/musli-wire/src/wire_int.rs index caaf2cedd..4b4957dda 100644 --- a/crates/musli-wire/src/wire_int.rs +++ b/crates/musli-wire/src/wire_int.rs @@ -1,8 +1,8 @@ use musli::Context; +use musli_common::int::continuation as c; +use musli_common::int::zigzag as zig; +use musli_common::int::{Signed, Unsigned, UnsignedOps}; -use crate::int::continuation as c; -use crate::int::zigzag as zig; -use crate::int::{Signed, Unsigned, UnsignedOps}; use crate::options::Options; use crate::reader::Reader; use crate::tag::{Kind, Tag, DATA_MASK}; @@ -44,7 +44,7 @@ where }}; } - crate::width_arm!(width, fixed) + musli_common::width_arm!(width, fixed) } } } @@ -97,7 +97,7 @@ where }}; } - crate::width_arm!(width, fixed) + musli_common::width_arm!(width, fixed) } } } diff --git a/crates/musli-zerocopy/src/pointer/size.rs b/crates/musli-zerocopy/src/pointer/size.rs index 046823470..14099cba3 100644 --- a/crates/musli-zerocopy/src/pointer/size.rs +++ b/crates/musli-zerocopy/src/pointer/size.rs @@ -4,7 +4,7 @@ use crate::endian::ByteOrder; use crate::error::IntoRepr; use crate::traits::ZeroCopy; -/// The default [`Size`] in use by this crate. +/// The default [`Size`] to use. pub type DefaultSize = u32; #[cfg(not(any( diff --git a/crates/musli-zerocopy/tests/ui/deny_sneaky_field_error.stderr b/crates/musli-zerocopy/tests/ui/deny_sneaky_field_error.stderr index f417b1561..aa1b17e0d 100644 --- a/crates/musli-zerocopy/tests/ui/deny_sneaky_field_error.stderr +++ b/crates/musli-zerocopy/tests/ui/deny_sneaky_field_error.stderr @@ -97,18 +97,16 @@ error[E0063]: missing field `sneaky_field` in initializer of `SneakyEnumNamed` error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields --> tests/ui/deny_sneaky_field_error.rs:44:10 | -44 | #[derive(ZeroCopy)] - | ^^^^^^^^ expected 2 fields, found 1 -45 | #[repr(u8)] -46 | #[sneaky_fields(Sneaky)] - | ------ tuple variant has 2 fields -47 | enum SneakyEnumUnnamed { - | ______- -48 | | Unnamed(u32) - | | ------- --- - | |_____|_____| - | | - | tuple variant defined here +44 | #[derive(ZeroCopy)] + | ^^^^^^^^ expected 2 fields, found 1 +45 | #[repr(u8)] +46 | #[sneaky_fields(Sneaky)] + | ------ tuple variant has 2 fields +47 | enum SneakyEnumUnnamed { +48 | Unnamed(u32) + | ------- --- + | | + | tuple variant defined here | = note: this error originates in the derive macro `ZeroCopy` (in Nightly builds, run with -Z macro-backtrace for more info) help: use `_` to explicitly ignore each field diff --git a/crates/tests/src/lib.rs b/crates/tests/src/lib.rs index 1f4bf44d6..99f8852f1 100644 --- a/crates/tests/src/lib.rs +++ b/crates/tests/src/lib.rs @@ -56,6 +56,7 @@ pub mod json { /// Roundtrip the given expression through all supported formats. #[macro_export] +#[doc(hidden)] macro_rules! rt { ($enum:ident :: $variant:ident $($tt:tt)?) => { $crate::rt!($enum, $enum :: $variant $($tt)*)