diff --git a/crates/musli-core/Cargo.toml b/crates/musli-core/Cargo.toml index f54c0d4d9..2edfc6f18 100644 --- a/crates/musli-core/Cargo.toml +++ b/crates/musli-core/Cargo.toml @@ -26,7 +26,7 @@ alloc = [] verbose = ["musli-macros/verbose"] [dependencies] -musli-macros = { version = "=0.0.119", path = "../musli-macros" } +musli-macros = { version = "=0.0.119", path = "../musli-macros", features = [] } [dev-dependencies] musli = { version = "=0.0.119", path = "../musli" } diff --git a/crates/musli-core/src/de/decode.rs b/crates/musli-core/src/de/decode.rs index 874870dc4..20a43fe56 100644 --- a/crates/musli-core/src/de/decode.rs +++ b/crates/musli-core/src/de/decode.rs @@ -1,9 +1,5 @@ use super::Decoder; -/// Please refer to the main [musli documentation](https://docs.rs/musli). -#[doc(inline)] -pub use musli_macros::Decode; - /// Trait governing how types are decoded. /// /// This is typically implemented automatically using the [`Decode` derive]. @@ -19,7 +15,7 @@ pub use musli_macros::Decode; /// struct MyType { /// data: [u8; 128], /// } -/// ```` +/// ``` /// /// Implementing manually: /// diff --git a/crates/musli-core/src/de/decode_bytes.rs b/crates/musli-core/src/de/decode_bytes.rs index dab3ed9c3..9660affb0 100644 --- a/crates/musli-core/src/de/decode_bytes.rs +++ b/crates/musli-core/src/de/decode_bytes.rs @@ -17,7 +17,7 @@ use super::Decoder; /// #[musli(bytes)] /// data: [u8; 128], /// } -/// ```` +/// ``` /// /// Implementing manually: /// diff --git a/crates/musli-core/src/de/decode_packed.rs b/crates/musli-core/src/de/decode_packed.rs index 20099537b..ae6b28911 100644 --- a/crates/musli-core/src/de/decode_packed.rs +++ b/crates/musli-core/src/de/decode_packed.rs @@ -20,7 +20,7 @@ use super::Decoder; /// #[musli(packed)] /// data: (u32, u32), /// } -/// ```` +/// ``` /// /// Implementing manually: /// diff --git a/crates/musli-core/src/de/decoder.rs b/crates/musli-core/src/de/decoder.rs index 9a2974631..89fee3dd9 100644 --- a/crates/musli-core/src/de/decoder.rs +++ b/crates/musli-core/src/de/decoder.rs @@ -45,7 +45,7 @@ pub trait Decoder<'de>: Sized { type DecodeVariant: VariantDecoder<'de, Cx = Self::Cx>; /// This is a type argument used to hint to any future implementor that they - /// should be using the [`#[musli::decoder]`][crate::decoder] attribute + /// should be using the [`#[musli::decoder]`][musli::decoder] attribute /// macro when implementing [`Decoder`]. #[doc(hidden)] type __UseMusliDecoderAttributeMacro; diff --git a/crates/musli-core/src/de/mod.rs b/crates/musli-core/src/de/mod.rs index 9bab7ccd4..4644ba8d1 100644 --- a/crates/musli-core/src/de/mod.rs +++ b/crates/musli-core/src/de/mod.rs @@ -6,86 +6,94 @@ //! itself. This also comes with a derive allowing you to derive high //! performance decoding associated with native Rust types. //! +//! Note that using derives directly from `musli_core` requires you to use the +//! `#[musli(crate = musli_core)]` attribute. +//! +//! # Examples +//! //! ``` -//! use musli::Decode; +//! use musli_core::Decode; //! //! #[derive(Decode)] +//! #[musli(crate = musli_core)] //! pub struct Person<'a> { //! name: &'a str, //! age: u32, //! } //! ``` -mod skip; -#[doc(inline)] -pub use self::skip::Skip; - -mod size_hint; +/// Derive which automatically implements the [`Decode` trait]. +/// +/// See the [`derives` module] for detailed documentation. +/// +/// [`derives` module]: +/// [`Decode` trait]: trait@Decode +/// +/// # Examples +/// +/// ``` +/// use musli::Decode; +/// +/// #[derive(Decode)] +/// struct MyType { +/// data: [u8; 128], +/// } +/// ``` #[doc(inline)] -pub use self::size_hint::SizeHint; +pub use musli_macros::Decode; mod as_decoder; -#[doc(inline)] pub use self::as_decoder::AsDecoder; mod decode; -#[doc(inline)] pub use self::decode::Decode; +mod decode_bytes; +pub use self::decode_bytes::DecodeBytes; + +mod decode_packed; +pub use self::decode_packed::DecodePacked; + mod decode_trace; -#[doc(inline)] pub use self::decode_trace::DecodeTrace; mod decode_unsized; -#[doc(inline)] pub use self::decode_unsized::DecodeUnsized; mod decode_unsized_bytes; -#[doc(inline)] pub use self::decode_unsized_bytes::DecodeUnsizedBytes; -mod decode_bytes; -#[doc(inline)] -pub use self::decode_bytes::DecodeBytes; - -mod decode_packed; -#[doc(inline)] -pub use self::decode_packed::DecodePacked; - mod decoder; -#[doc(inline)] pub use self::decoder::Decoder; -mod map_decoder; -#[doc(inline)] -pub use self::map_decoder::MapDecoder; - mod entries_decoder; -#[doc(inline)] pub use self::entries_decoder::EntriesDecoder; mod entry_decoder; -#[doc(inline)] pub use self::entry_decoder::EntryDecoder; +mod map_decoder; +pub use self::map_decoder::MapDecoder; + mod number_visitor; -#[doc(inline)] pub use self::number_visitor::NumberVisitor; mod sequence_decoder; -#[doc(inline)] pub use self::sequence_decoder::SequenceDecoder; +mod size_hint; +pub use self::size_hint::SizeHint; + +mod skip; +pub use self::skip::Skip; + mod value_visitor; -#[doc(inline)] pub use self::value_visitor::ValueVisitor; mod variant_decoder; -#[doc(inline)] pub use self::variant_decoder::VariantDecoder; mod visitor; -#[doc(inline)] pub use self::visitor::Visitor; /// Decode to an owned value. diff --git a/crates/musli-core/src/de/visitor.rs b/crates/musli-core/src/de/visitor.rs index ff0cf3324..aab487207 100644 --- a/crates/musli-core/src/de/visitor.rs +++ b/crates/musli-core/src/de/visitor.rs @@ -24,7 +24,7 @@ pub trait Visitor<'de, C: ?Sized + Context>: Sized { type Number: NumberVisitor<'de, C, Ok = Self::Ok>; /// This is a type argument used to hint to any future implementor that they - /// should be using the [`#[musli::visitor]`][crate::visitor] attribute + /// should be using the [`#[musli::visitor]`][musli::visitor] attribute /// macro when implementing [`Visitor`]. #[doc(hidden)] type __UseMusliVisitorAttributeMacro; diff --git a/crates/musli-core/src/en/encode.rs b/crates/musli-core/src/en/encode.rs index 6e6bb6a6c..9fae5bb5e 100644 --- a/crates/musli-core/src/en/encode.rs +++ b/crates/musli-core/src/en/encode.rs @@ -1,7 +1,5 @@ use crate::en::Encoder; -pub use musli_macros::Encode; - /// Trait governing how types are encoded. /// /// This is typically implemented automatically using the [`Encode` derive]. @@ -17,7 +15,7 @@ pub use musli_macros::Encode; /// struct MyType { /// data: [u8; 128], /// } -/// ```` +/// ``` /// /// Implementing manually: /// diff --git a/crates/musli-core/src/en/encode_bytes.rs b/crates/musli-core/src/en/encode_bytes.rs index 3eecb1550..3d4262717 100644 --- a/crates/musli-core/src/en/encode_bytes.rs +++ b/crates/musli-core/src/en/encode_bytes.rs @@ -17,7 +17,7 @@ use crate::en::Encoder; /// #[musli(bytes)] /// data: [u8; 128], /// } -/// ```` +/// ``` /// /// Implementing manually: /// diff --git a/crates/musli-core/src/en/encode_packed.rs b/crates/musli-core/src/en/encode_packed.rs index 9c84b83eb..36b8022b5 100644 --- a/crates/musli-core/src/en/encode_packed.rs +++ b/crates/musli-core/src/en/encode_packed.rs @@ -20,7 +20,7 @@ use crate::en::Encoder; /// #[musli(packed)] /// data: (u32, u32), /// } -/// ```` +/// ``` /// /// Implementing manually: /// diff --git a/crates/musli-core/src/en/encoder.rs b/crates/musli-core/src/en/encoder.rs index c229b472b..d0938eee6 100644 --- a/crates/musli-core/src/en/encoder.rs +++ b/crates/musli-core/src/en/encoder.rs @@ -43,7 +43,7 @@ pub trait Encoder: Sized { type EncodeMapVariant: MapEncoder; /// This is a type argument used to hint to any future implementor that they - /// should be using the [`#[musli::encoder]`][crate::encoder] attribute + /// should be using the [`#[musli::encoder]`][musli::encoder] attribute /// macro when implementing [`Encoder`]. #[doc(hidden)] type __UseMusliEncoderAttributeMacro; diff --git a/crates/musli-core/src/en/mod.rs b/crates/musli-core/src/en/mod.rs index d8979a17a..f1376f859 100644 --- a/crates/musli-core/src/en/mod.rs +++ b/crates/musli-core/src/en/mod.rs @@ -6,52 +6,68 @@ //! also comes with a derive allowing you to derive high performance encoding //! associated with native Rust types. //! +//! Note that using derives directly from `musli_core` requires you to use the +//! `#[musli(crate = musli_core)]` attribute. +//! +//! # Examples +//! //! ``` -//! use musli::Encode; +//! use musli_core::Encode; //! //! #[derive(Encode)] +//! #[musli(crate = musli_core)] //! pub struct Person<'a> { //! name: &'a str, //! age: u32, //! } //! ``` -mod encode; +/// Derive which automatically implements the [`Encode` trait]. +/// +/// See the [`derives` module] for detailed documentation. +/// +/// [`derives` module]: +/// [`Encode` trait]: trait@Encode +/// +/// # Examples +/// +/// ``` +/// use musli::Encode; +/// +/// #[derive(Encode)] +/// struct MyType { +/// data: [u8; 128], +/// } +/// ``` #[doc(inline)] -pub use self::encode::Encode; +pub use musli_macros::Encode; -mod encode_trace; -#[doc(inline)] -pub use self::encode_trace::EncodeTrace; +mod encode; +pub use self::encode::Encode; mod encode_bytes; -#[doc(inline)] pub use self::encode_bytes::EncodeBytes; mod encode_packed; -#[doc(inline)] pub use self::encode_packed::EncodePacked; +mod encode_trace; +pub use self::encode_trace::EncodeTrace; + mod encoder; -#[doc(inline)] pub use self::encoder::Encoder; -mod sequence_encoder; -#[doc(inline)] -pub use self::sequence_encoder::SequenceEncoder; - -mod map_encoder; -#[doc(inline)] -pub use self::map_encoder::MapEncoder; +mod entries_encoder; +pub use self::entries_encoder::EntriesEncoder; mod entry_encoder; -#[doc(inline)] pub use self::entry_encoder::EntryEncoder; -mod entries_encoder; -#[doc(inline)] -pub use self::entries_encoder::EntriesEncoder; +mod map_encoder; +pub use self::map_encoder::MapEncoder; + +mod sequence_encoder; +pub use self::sequence_encoder::SequenceEncoder; mod variant_encoder; -#[doc(inline)] pub use self::variant_encoder::VariantEncoder; diff --git a/crates/musli-core/src/lib.rs b/crates/musli-core/src/lib.rs index bbd8a1492..b0c3383ed 100644 --- a/crates/musli-core/src/lib.rs +++ b/crates/musli-core/src/lib.rs @@ -58,6 +58,9 @@ mod never; /// language level in Rust. So this attribute macro polyfills any missing types /// automatically. /// +/// Note that using derives directly from `musli_core` requires you to use the +/// `#[musli_core::encoder(crate = musli_core)]` attribute. +/// /// [not yet supported]: https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html /// /// # Examples @@ -65,15 +68,15 @@ mod never; /// ``` /// use std::fmt; /// -/// use musli::Context; -/// use musli::en::{Encoder, Encode}; +/// use musli_core::Context; +/// use musli_core::en::{Encoder, Encode}; /// /// struct MyEncoder<'a, C: ?Sized> { /// value: &'a mut Option, /// cx: &'a C, /// } /// -/// #[musli::encoder] +/// #[musli_core::encoder(crate = musli_core)] /// impl Encoder for MyEncoder<'_, C> { /// type Cx = C; /// type Ok = (); @@ -110,6 +113,9 @@ pub use musli_macros::encoder; /// language level in Rust. So this attribute macro polyfills any missing types /// automatically. /// +/// Note that using derives directly from `musli_core` requires you to use the +/// `#[musli_core::decoder(crate = musli_core)]` attribute. +/// /// [not yet supported]: https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html /// /// # Examples @@ -117,14 +123,14 @@ pub use musli_macros::encoder; /// ``` /// use std::fmt; /// -/// use musli::Context; -/// use musli::de::{Decoder, Decode}; +/// use musli_core::Context; +/// use musli_core::de::{Decoder, Decode}; /// /// struct MyDecoder<'a, C: ?Sized> { /// cx: &'a C, /// } /// -/// #[musli::decoder] +/// #[musli_core::decoder(crate = musli_core)] /// impl<'de, C: ?Sized + Context> Decoder<'de> for MyDecoder<'_, C> { /// type Cx = C; /// @@ -152,8 +158,10 @@ pub use musli_macros::decoder; /// language level in Rust. So this attribute macro polyfills any missing types /// automatically. /// -/// [not yet supported]: -/// https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html +/// Note that using derives directly from `musli_core` requires you to use the +/// `#[musli_core::visitor(crate = musli_core)]` attribute. +/// +/// [not yet supported]: https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html /// [`Visitor`]: crate::de::Visitor /// /// # Examples @@ -161,12 +169,12 @@ pub use musli_macros::decoder; /// ``` /// use std::fmt; /// -/// use musli::Context; -/// use musli::de::Visitor; +/// use musli_core::Context; +/// use musli_core::de::Visitor; /// /// struct AnyVisitor; /// -/// #[musli::visitor] +/// #[musli_core::visitor(crate = musli_core)] /// impl<'de, C: ?Sized + Context> Visitor<'de, C> for AnyVisitor { /// type Ok = (); /// diff --git a/crates/musli-macros/Cargo.toml b/crates/musli-macros/Cargo.toml index cb5010553..a4a9500e7 100644 --- a/crates/musli-macros/Cargo.toml +++ b/crates/musli-macros/Cargo.toml @@ -20,7 +20,6 @@ proc-macro = true path = "src/lib.rs" [features] -test = [] verbose = [] [dependencies] diff --git a/crates/musli-macros/src/expander.rs b/crates/musli-macros/src/expander.rs index f1a051cd4..3eb5c5f54 100644 --- a/crates/musli-macros/src/expander.rs +++ b/crates/musli-macros/src/expander.rs @@ -97,7 +97,7 @@ pub(crate) struct Expander<'a> { } impl<'a> Expander<'a> { - pub(crate) fn new(input: &'a syn::DeriveInput) -> Self { + pub(crate) fn new(input: &'a syn::DeriveInput, default_crate: &str) -> Self { fn fields<'a>(cx: &Ctxt, fields: &'a syn::Fields) -> Vec> { fields .iter() @@ -154,7 +154,7 @@ impl<'a> Expander<'a> { syn::Data::Union(..) => Data::Union, }; - let prefix = type_attr.crate_or_default(); + let prefix = type_attr.crate_or_default(default_crate); let default = vec![ ModeIdent { diff --git a/crates/musli-macros/src/internals/attr.rs b/crates/musli-macros/src/internals/attr.rs index f05ce127d..a9070947c 100644 --- a/crates/musli-macros/src/internals/attr.rs +++ b/crates/musli-macros/src/internals/attr.rs @@ -241,14 +241,14 @@ impl TypeAttr { } /// Get the configured crate, or fallback to default. - pub(crate) fn crate_or_default(&self) -> syn::Path { + pub(crate) fn crate_or_default(&self, default: &str) -> syn::Path { if let Some((_, krate)) = self.root.krate.any.as_ref() { - krate.clone() - } else { - let mut path = syn::Path::from(syn::Ident::new(ATTR, Span::call_site())); - path.leading_colon = Some(::default()); - path + return krate.clone(); } + + let mut path = syn::Path::from(syn::Ident::new(default, Span::call_site())); + path.leading_colon = Some(::default()); + path } } diff --git a/crates/musli-macros/src/lib.rs b/crates/musli-macros/src/lib.rs index d60d6aad8..1e443f0f1 100644 --- a/crates/musli-macros/src/lib.rs +++ b/crates/musli-macros/src/lib.rs @@ -10,70 +10,55 @@ #![allow(clippy::too_many_arguments)] #![allow(clippy::needless_late_init)] +#![allow(missing_docs)] -use proc_macro::TokenStream; - -#[cfg(feature = "test")] -mod benchmarker; mod de; mod en; mod expander; mod internals; -#[cfg(feature = "test")] -mod test; mod types; -/// Please refer to the main [musli `derives` documentation](https://docs.rs/musli/latest/musli/help/derives/). +use proc_macro::TokenStream; + +const CRATE_DEFAULT: &str = "musli"; + #[proc_macro_derive(Encode, attributes(musli))] -pub fn derive_encode(input: TokenStream) -> TokenStream { - let input = syn::parse_macro_input!(input as syn::DeriveInput); - let expander = expander::Expander::new(&input); +pub fn musli_derive_encode(input: TokenStream) -> TokenStream { + derive_encode(input, CRATE_DEFAULT) +} + +#[proc_macro_derive(Decode, attributes(musli))] +pub fn musli_derive_decode(input: TokenStream) -> TokenStream { + derive_decode(input, CRATE_DEFAULT) +} - let dump = std::env::var("MUSLI_DUMP_ENCODE").ok(); +fn derive_encode(input: TokenStream, crate_default: &str) -> TokenStream { + let input = syn::parse_macro_input!(input as syn::DeriveInput); + let expander = expander::Expander::new(&input, crate_default); match expander.expand_encode() { - Ok(tokens) => { - if let Some((dump, out)) = dump.as_ref().and_then(|d| d.split_once('=')) { - if input.ident.to_string().contains(dump) { - let _ = std::fs::write(out, format!("{}", tokens)); - } - } - - tokens.into() - } + Ok(tokens) => tokens.into(), Err(()) => to_compile_errors(expander.into_errors()).into(), } } -/// Please refer to the main [musli `derives` documentation](https://docs.rs/musli/latest/musli/help/derives/). -#[proc_macro_derive(Decode, attributes(musli))] -pub fn derive_decode(input: TokenStream) -> TokenStream { +fn derive_decode(input: TokenStream, crate_default: &str) -> TokenStream { let input = syn::parse_macro_input!(input as syn::DeriveInput); - let expander = expander::Expander::new(&input); - - let dump = std::env::var("MUSLI_DUMP_DECODE").ok(); + let expander = expander::Expander::new(&input, crate_default); match expander.expand_decode() { - Ok(tokens) => { - if let Some((dump, out)) = dump.as_ref().and_then(|d| d.split_once('=')) { - if input.ident.to_string().contains(dump) { - let _ = std::fs::write(out, format!("{}", tokens)); - } - } - - tokens.into() - } + Ok(tokens) => tokens.into(), Err(()) => to_compile_errors(expander.into_errors()).into(), } } -/// Please refer to the main [musli documentation](https://docs.rs/musli/). #[proc_macro_attribute] pub fn decoder(attr: TokenStream, input: TokenStream) -> TokenStream { let attr = syn::parse_macro_input!(attr as types::Attr); let input = syn::parse_macro_input!(input as types::Types); match input.expand( + CRATE_DEFAULT, &attr, "decoder", types::DECODER_TYPES, @@ -87,13 +72,13 @@ pub fn decoder(attr: TokenStream, input: TokenStream) -> TokenStream { } } -/// Please refer to the main [musli documentation](https://docs.rs/musli/). #[proc_macro_attribute] pub fn encoder(attr: TokenStream, input: TokenStream) -> TokenStream { let attr = syn::parse_macro_input!(attr as types::Attr); let input = syn::parse_macro_input!(input as types::Types); match input.expand( + CRATE_DEFAULT, &attr, "encoder", types::ENCODER_TYPES, @@ -107,13 +92,13 @@ pub fn encoder(attr: TokenStream, input: TokenStream) -> TokenStream { } } -/// Please refer to the main [musli documentation](https://docs.rs/musli/). #[proc_macro_attribute] pub fn visitor(attr: TokenStream, input: TokenStream) -> TokenStream { let attr = syn::parse_macro_input!(attr as types::Attr); let input = syn::parse_macro_input!(input as types::Types); match input.expand( + CRATE_DEFAULT, &attr, "visitor", types::VISITOR_TYPES, @@ -136,35 +121,3 @@ fn to_compile_errors(errors: Vec) -> proc_macro2::TokenStream { output } - -#[cfg(feature = "test")] -#[proc_macro_derive(Generate, attributes(generate))] -pub fn derive_generate(input: TokenStream) -> TokenStream { - let input = syn::parse_macro_input!(input as syn::DeriveInput); - - let mut cx = test::Ctxt::default(); - - if let Ok(stream) = test::expand(&mut cx, input) { - return stream.into(); - } - - let mut stream = proc_macro2::TokenStream::default(); - - for error in cx.errors { - stream.extend(error.to_compile_error()); - } - - stream.into() -} - -#[cfg(feature = "test")] -#[proc_macro_attribute] -pub fn benchmarker(attr: TokenStream, input: TokenStream) -> TokenStream { - let attrs = syn::parse_macro_input!(attr as benchmarker::Attributes); - let input = syn::parse_macro_input!(input as benchmarker::Benchmarker); - - match input.expand(&attrs) { - Ok(tokens) => tokens.into(), - Err(err) => err.to_compile_error().into(), - } -} diff --git a/crates/musli-macros/src/types.rs b/crates/musli-macros/src/types.rs index 30127178f..d5bc10f31 100644 --- a/crates/musli-macros/src/types.rs +++ b/crates/musli-macros/src/types.rs @@ -82,7 +82,7 @@ pub(super) enum Kind { } pub(super) struct Attr { - crate_path: syn::Path, + crate_path: Option, } impl Parse for Attr { @@ -110,11 +110,6 @@ impl Parse for Attr { } } - let crate_path = match crate_path { - Some(crate_path) => crate_path, - None => syn::parse_quote!(::musli), - }; - Ok(Self { crate_path }) } } @@ -135,6 +130,7 @@ impl Types { /// Expand encoder types. pub(crate) fn expand( mut self, + default_crate: &str, attr: &Attr, what: &str, types: &[(&str, Extra)], @@ -143,7 +139,15 @@ impl Types { hint: &str, kind: Kind, ) -> syn::Result { - let crate_path = &attr.crate_path; + let default_crate_path; + + let crate_path = match &attr.crate_path { + Some(path) => path, + None => { + default_crate_path = ident_path(syn::Ident::new(default_crate, Span::call_site())); + &default_crate_path + } + }; let mut missing = types .iter() @@ -213,7 +217,7 @@ impl Types { impl_type.ty = syn::Type::Path(syn::TypePath { qself: None, - path: self.never_type(&attr.crate_path, argument, extra, kind)?, + path: self.never_type(crate_path, argument, extra, kind)?, }); self.item_impl.items.push(syn::ImplItem::Type(impl_type)); @@ -299,7 +303,7 @@ impl Types { ty = syn::Type::Path(syn::TypePath { qself: None, - path: self.never_type(&attr.crate_path, argument, extra, kind)?, + path: self.never_type(crate_path, argument, extra, kind)?, }); let mut where_clause = syn::WhereClause { @@ -321,7 +325,7 @@ impl Types { _ => { ty = syn::Type::Path(syn::TypePath { qself: None, - path: self.never_type(&attr.crate_path, argument, extra, kind)?, + path: self.never_type(crate_path, argument, extra, kind)?, }); generics = syn::Generics::default(); diff --git a/crates/musli/Cargo.toml b/crates/musli/Cargo.toml index 61cc36703..f0caf2ada 100644 --- a/crates/musli/Cargo.toml +++ b/crates/musli/Cargo.toml @@ -36,6 +36,7 @@ test = ["storage", "wire", "descriptive", "json", "parse-full", "value", "serde" [dependencies] musli-core = { version = "=0.0.119", path = "../musli-core", default-features = false } +musli-macros = { version = "=0.0.119", path = "../musli-macros", default-features = false } simdutf8 = { version = "0.1.4", optional = true, default-features = false } itoa = { version = "1.0.10", optional = true } diff --git a/crates/musli/src/allocator/disabled.rs b/crates/musli/src/allocator/disabled.rs index 478bad58f..00488b321 100644 --- a/crates/musli/src/allocator/disabled.rs +++ b/crates/musli/src/allocator/disabled.rs @@ -1,7 +1,7 @@ use core::fmt::Arguments; -use musli_core::buf::Error; -use musli_core::{Allocator, Buf}; +use crate::buf::Error; +use crate::{Allocator, Buf}; /// An empty buffer. pub struct EmptyBuf; diff --git a/crates/musli/src/allocator/stack.rs b/crates/musli/src/allocator/stack.rs index 0babffa95..0c4fbf03b 100644 --- a/crates/musli/src/allocator/stack.rs +++ b/crates/musli/src/allocator/stack.rs @@ -10,8 +10,8 @@ use core::ops::{Deref, DerefMut}; use core::ptr; use core::slice; -use musli_core::buf::Error; -use musli_core::{Allocator, Buf}; +use crate::buf::Error; +use crate::{Allocator, Buf}; use super::DEFAULT_STACK_BUFFER; diff --git a/crates/musli/src/allocator/stack/tests.rs b/crates/musli/src/allocator/stack/tests.rs index 79e7b53da..fefebab38 100644 --- a/crates/musli/src/allocator/stack/tests.rs +++ b/crates/musli/src/allocator/stack/tests.rs @@ -3,7 +3,7 @@ use std::fmt::{self, Write}; use std::string::String; use std::vec::Vec; -use musli_core::{Allocator, Buf}; +use crate::{Allocator, Buf}; use super::{Header, HeaderId, Stack, StackBuffer, State}; diff --git a/crates/musli/src/allocator/system.rs b/crates/musli/src/allocator/system.rs index 01fe0519d..88d298a95 100644 --- a/crates/musli/src/allocator/system.rs +++ b/crates/musli/src/allocator/system.rs @@ -5,8 +5,8 @@ use core::ptr::NonNull; use alloc::boxed::Box; use alloc::vec::Vec; -use musli_core::buf::Error; -use musli_core::{Allocator, Buf}; +use crate::buf::Error; +use crate::{Allocator, Buf}; /// Buffer used in combination with an [`Allocator`]. pub struct System { diff --git a/crates/musli/src/allocator/tests.rs b/crates/musli/src/allocator/tests.rs index d1398234b..d3bc9be97 100644 --- a/crates/musli/src/allocator/tests.rs +++ b/crates/musli/src/allocator/tests.rs @@ -1,4 +1,4 @@ -use musli_core::{Allocator, Buf}; +use crate::{Allocator, Buf}; fn basic_allocations(alloc: &A) { let mut a = alloc.alloc().unwrap(); diff --git a/crates/musli/src/buf/buf_string.rs b/crates/musli/src/buf/buf_string.rs index b564e9687..e6cdc1c98 100644 --- a/crates/musli/src/buf/buf_string.rs +++ b/crates/musli/src/buf/buf_string.rs @@ -2,9 +2,8 @@ use core::fmt::{self, Write}; use core::ops::Deref; use core::str; -use musli_core::{Buf, Context}; - use crate::fixed::CapacityError; +use crate::{Buf, Context}; /// Wrapper around a [`Buf`], guaranteed to be a valid utf-8 string. pub struct BufString { diff --git a/crates/musli/src/buf/mod.rs b/crates/musli/src/buf/mod.rs index 8302de0cf..f4dc27bb5 100644 --- a/crates/musli/src/buf/mod.rs +++ b/crates/musli/src/buf/mod.rs @@ -5,3 +5,6 @@ mod buf_string; pub(crate) use self::buf_string::collect_string; pub use self::buf_string::BufString; + +#[doc(inline)] +pub use musli_core::buf::{Buf, Error}; diff --git a/crates/musli/src/context/mod.rs b/crates/musli/src/context/mod.rs index ac2607f5e..343e2a5a6 100644 --- a/crates/musli/src/context/mod.rs +++ b/crates/musli/src/context/mod.rs @@ -16,10 +16,9 @@ use core::cell::{Cell, UnsafeCell}; use core::fmt; use core::marker::PhantomData; -use musli_core::mode::Binary; -use musli_core::{Allocator, Context, StdError}; - use crate::buf::{self, BufString}; +use crate::mode::Binary; +use crate::{Allocator, Context, StdError}; #[cfg(feature = "alloc")] pub use self::system_context::SystemContext; diff --git a/crates/musli/src/context/stack_context.rs b/crates/musli/src/context/stack_context.rs index 495f1893d..297a8204a 100644 --- a/crates/musli/src/context/stack_context.rs +++ b/crates/musli/src/context/stack_context.rs @@ -3,10 +3,9 @@ use core::fmt::{self, Write}; use core::marker::PhantomData; use core::ops::Range; -use musli_core::{Allocator, Context}; - use crate::buf::{self, BufString}; use crate::fixed::FixedVec; +use crate::{Allocator, Context}; use super::access::{Access, Shared}; use super::rich_error::{RichError, Step}; diff --git a/crates/musli/src/context/system_context.rs b/crates/musli/src/context/system_context.rs index 579aad098..637034154 100644 --- a/crates/musli/src/context/system_context.rs +++ b/crates/musli/src/context/system_context.rs @@ -6,12 +6,12 @@ use core::ops::Range; use alloc::string::{String, ToString}; use alloc::vec::Vec; -use musli_core::{Allocator, Context}; +use crate::buf::{self, BufString}; +use crate::{Allocator, Context}; use super::access::{self, Access}; use super::rich_error::{RichError, Step}; use super::ErrorMarker; -use crate::buf::{self, BufString}; type BufTriplet = (Vec>, Range, E); diff --git a/crates/musli/src/de.rs b/crates/musli/src/de.rs new file mode 100644 index 000000000..f05b48484 --- /dev/null +++ b/crates/musli/src/de.rs @@ -0,0 +1,24 @@ +//! Traits for generically dealing with a decoding framework. +//! +//! The central traits are [Decode] and [Decoder]. +//! +//! A type implementing [Decode] can use an [Decoder] to decode an instance of +//! itself. This also comes with a derive allowing you to derive high +//! performance decoding associated with native Rust types. +//! +//! ``` +//! use musli::Decode; +//! +//! #[derive(Decode)] +//! pub struct Person<'a> { +//! name: &'a str, +//! age: u32, +//! } +//! ``` + +#[doc(inline)] +pub use musli_core::de::{ + AsDecoder, Decode, DecodeBytes, DecodeOwned, DecodePacked, DecodeTrace, DecodeUnsized, + DecodeUnsizedBytes, Decoder, EntriesDecoder, EntryDecoder, MapDecoder, NumberVisitor, + SequenceDecoder, SizeHint, Skip, ValueVisitor, VariantDecoder, Visitor, +}; diff --git a/crates/musli/src/descriptive/de.rs b/crates/musli/src/descriptive/de.rs index 9ba7bcaa1..0841339e8 100644 --- a/crates/musli/src/descriptive/de.rs +++ b/crates/musli/src/descriptive/de.rs @@ -4,18 +4,17 @@ use core::mem::take; #[cfg(feature = "alloc")] use alloc::vec::Vec; -use musli_core::de::{ +use crate::de::{ Decode, DecodeUnsized, Decoder, EntriesDecoder, EntryDecoder, MapDecoder, NumberVisitor, SequenceDecoder, SizeHint, Skip, ValueVisitor, VariantDecoder, Visitor, }; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::Context; - +use crate::hint::{MapHint, SequenceHint}; use crate::int::continuation as c; #[cfg(feature = "value")] use crate::options; use crate::reader::Limit; use crate::storage::de::StorageDecoder; +use crate::Context; use crate::{Options, Reader}; use super::integer_encoding::{decode_typed_signed, decode_typed_unsigned}; @@ -215,7 +214,7 @@ where } } -#[musli_core::decoder(crate)] +#[crate::decoder(crate)] impl<'a, 'de, R, const OPT: Options, C> Decoder<'de> for SelfDecoder<'a, R, OPT, C> where R: Reader<'de>, diff --git a/crates/musli/src/descriptive/en.rs b/crates/musli/src/descriptive/en.rs index 050ccb23e..75035d9cd 100644 --- a/crates/musli/src/descriptive/en.rs +++ b/crates/musli/src/descriptive/en.rs @@ -1,14 +1,13 @@ use core::fmt; -use musli_core::en::{ +use crate::en::{ Encoder, EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder, }; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::{Buf, Context, Encode}; - +use crate::hint::{MapHint, SequenceHint}; use crate::int::continuation as c; use crate::storage::en::StorageEncoder; use crate::writer::BufWriter; +use crate::{Buf, Context, Encode}; use crate::{Options, Writer}; use super::integer_encoding::{encode_typed_signed, encode_typed_unsigned}; @@ -50,7 +49,7 @@ impl<'a, W, B, const OPT: Options, C: ?Sized> SelfPackEncoder<'a, W, B, OPT, C> } } -#[musli_core::encoder(crate)] +#[crate::encoder(crate)] impl<'a, W, const OPT: Options, C> Encoder for SelfEncoder<'a, W, OPT, C> where W: Writer, diff --git a/crates/musli/src/descriptive/encoding.rs b/crates/musli/src/descriptive/encoding.rs index e32b0f762..138127521 100644 --- a/crates/musli/src/descriptive/encoding.rs +++ b/crates/musli/src/descriptive/encoding.rs @@ -7,12 +7,11 @@ use core::marker; #[cfg(feature = "std")] use std::io; -use musli_core::de::Decode; -use musli_core::en::Encode; -use musli_core::mode::Binary; -use musli_core::Context; - +use crate::de::Decode; +use crate::en::Encode; +use crate::mode::Binary; use crate::options; +use crate::Context; use crate::{FixedBytes, Options, Reader, Writer}; use super::de::SelfDecoder; diff --git a/crates/musli/src/descriptive/error.rs b/crates/musli/src/descriptive/error.rs index f60af77c3..0d903fdf0 100644 --- a/crates/musli/src/descriptive/error.rs +++ b/crates/musli/src/descriptive/error.rs @@ -5,7 +5,7 @@ use alloc::boxed::Box; #[cfg(feature = "alloc")] use alloc::string::ToString; -use musli_core::StdError; +use crate::StdError; /// Error raised during descriptive encoding. #[derive(Debug)] diff --git a/crates/musli/src/descriptive/integer_encoding.rs b/crates/musli/src/descriptive/integer_encoding.rs index 566e46a77..9fe46f56f 100644 --- a/crates/musli/src/descriptive/integer_encoding.rs +++ b/crates/musli/src/descriptive/integer_encoding.rs @@ -1,9 +1,7 @@ -use musli_core::Context; - use crate::int::continuation as c; use crate::int::zigzag as zig; use crate::int::{Signed, Unsigned}; -use crate::{Reader, Writer}; +use crate::{Context, Reader, Writer}; use super::tag::{Kind, NumberKind, Tag}; diff --git a/crates/musli/src/descriptive/mod.rs b/crates/musli/src/descriptive/mod.rs index e7cb0fbae..a1c9fd1e6 100644 --- a/crates/musli/src/descriptive/mod.rs +++ b/crates/musli/src/descriptive/mod.rs @@ -102,7 +102,6 @@ mod tag; #[cfg(feature = "test")] #[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] #[doc(hidden)] -#[macro_use] pub mod test; /// Convenient result alias for use with `musli::descriptive`. diff --git a/crates/musli/src/descriptive/tag.rs b/crates/musli/src/descriptive/tag.rs index 347bfc65f..5526023b5 100644 --- a/crates/musli/src/descriptive/tag.rs +++ b/crates/musli/src/descriptive/tag.rs @@ -5,7 +5,7 @@ use core::fmt; use core::mem; -use musli_core::{Decode, Decoder}; +use crate::{Decode, Decoder}; /// Variant corresponding to marks. #[derive(Debug)] diff --git a/crates/musli/src/descriptive/test.rs b/crates/musli/src/descriptive/test.rs index 6bc4a8fab..677b0f042 100644 --- a/crates/musli/src/descriptive/test.rs +++ b/crates/musli/src/descriptive/test.rs @@ -1,3 +1,3 @@ //! Helpers for writing tests. -test_fns!("descriptive", musli_core::mode::Binary, #[musli_value]); +crate::test_fns!("descriptive", crate::mode::Binary, #[musli_value]); diff --git a/crates/musli/src/en.rs b/crates/musli/src/en.rs new file mode 100644 index 000000000..36f4dd6de --- /dev/null +++ b/crates/musli/src/en.rs @@ -0,0 +1,23 @@ +//! Traits for generically dealing with an encoding framework. +//! +//! The central traits are [Encode] and [Encoder]. +//! +//! A type implementing [Encode] can use an [Encoder] to encode itself. This +//! also comes with a derive allowing you to derive high performance encoding +//! associated with native Rust types. +//! +//! ``` +//! use musli::Encode; +//! +//! #[derive(Encode)] +//! pub struct Person<'a> { +//! name: &'a str, +//! age: u32, +//! } +//! ``` + +#[doc(inline)] +pub use musli_core::en::{ + Encode, EncodeBytes, EncodePacked, EncodeTrace, Encoder, EntriesEncoder, EntryEncoder, + MapEncoder, SequenceEncoder, VariantEncoder, +}; diff --git a/crates/musli/src/fixed.rs b/crates/musli/src/fixed.rs index 2d3e6f4da..34b1f7788 100644 --- a/crates/musli/src/fixed.rs +++ b/crates/musli/src/fixed.rs @@ -9,9 +9,8 @@ use core::ops::{Deref, DerefMut}; use core::ptr; use core::slice; -use musli_core::{Buf, Context}; - use crate::writer::Writer; +use crate::{Buf, Context}; /// A fixed-size bytes storage which keeps track of how much has been /// initialized. diff --git a/crates/musli/src/int/continuation.rs b/crates/musli/src/int/continuation.rs index abcc5b7d2..3816f15df 100644 --- a/crates/musli/src/int/continuation.rs +++ b/crates/musli/src/int/continuation.rs @@ -1,11 +1,10 @@ //! A variable-length 7-bit encoder where each bit indicates if there is a //! continuation of the sequence or not. -use musli_core::Context; - use crate::int; use crate::reader::Reader; use crate::writer::Writer; +use crate::Context; const MASK_BYTE: u8 = 0b0111_1111; const CONT_BYTE: u8 = 0b1000_0000; diff --git a/crates/musli/src/int/encoding.rs b/crates/musli/src/int/encoding.rs index ad64d9a57..2394f9bf9 100644 --- a/crates/musli/src/int/encoding.rs +++ b/crates/musli/src/int/encoding.rs @@ -1,11 +1,7 @@ -use musli_core::Context; - 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::writer::Writer; +use crate::{Context, Options, Reader, Writer}; /// Governs how unsigned integers are encoded into a [`Writer`]. #[inline] diff --git a/crates/musli/src/int/tests.rs b/crates/musli/src/int/tests.rs index 463e82429..64e710589 100644 --- a/crates/musli/src/int/tests.rs +++ b/crates/musli/src/int/tests.rs @@ -36,7 +36,7 @@ fn test_continuation_encoding() { where T: PartialEq + fmt::Debug + Unsigned, { - default_allocator!(|alloc| { + crate::default_allocator!(|alloc| { let mut out = Vec::new(); let cx = crate::context::Ignore::marker(&alloc); c::encode(&cx, &mut out, expected).unwrap(); @@ -55,7 +55,7 @@ fn test_continuation_encoding() { where T: Unsigned, { - default_allocator!(|alloc| { + crate::default_allocator!(|alloc| { let mut out = Vec::new(); let cx = crate::context::Same::marker(&alloc); c::encode(&cx, crate::wrap::wrap(&mut out), value).unwrap(); diff --git a/crates/musli/src/int/traits.rs b/crates/musli/src/int/traits.rs index be16b1e69..480b70132 100644 --- a/crates/musli/src/int/traits.rs +++ b/crates/musli/src/int/traits.rs @@ -1,10 +1,7 @@ use core::ops::{BitAnd, BitXor, Neg, Shl, Shr}; -use musli_core::Context; - use crate::options::ByteOrder; -use crate::reader::Reader; -use crate::writer::Writer; +use crate::{Context, Reader, Writer}; /// Trait that encodes common behaviors of unsigned numbers. pub(crate) trait Unsigned: diff --git a/crates/musli/src/json/de/key_decoder.rs b/crates/musli/src/json/de/key_decoder.rs index 7adea9ce3..29bd801d4 100644 --- a/crates/musli/src/json/de/key_decoder.rs +++ b/crates/musli/src/json/de/key_decoder.rs @@ -1,7 +1,7 @@ use core::fmt; -use musli_core::de::{Decode, DecodeUnsized, Decoder, SizeHint, Skip, ValueVisitor, Visitor}; -use musli_core::Context; +use crate::de::{Decode, DecodeUnsized, Decoder, SizeHint, Skip, ValueVisitor, Visitor}; +use crate::Context; use super::super::parser::{Parser, Token}; use super::{JsonDecoder, KeySignedVisitor, KeyUnsignedVisitor, StringReference}; @@ -39,7 +39,7 @@ where } } -#[musli_core::decoder(crate)] +#[crate::decoder(crate)] impl<'a, 'de, P, C> Decoder<'de> for JsonKeyDecoder<'a, P, C> where P: Parser<'de>, diff --git a/crates/musli/src/json/de/key_signed_visitor.rs b/crates/musli/src/json/de/key_signed_visitor.rs index ed0b9f80c..facca3a64 100644 --- a/crates/musli/src/json/de/key_signed_visitor.rs +++ b/crates/musli/src/json/de/key_signed_visitor.rs @@ -1,11 +1,10 @@ use core::fmt; use core::marker; -use musli_core::de::ValueVisitor; -use musli_core::Context; - +use crate::de::ValueVisitor; use crate::json::parser::integer::Signed; use crate::json::parser::SliceParser; +use crate::Context; use super::parse_signed; diff --git a/crates/musli/src/json/de/key_unsigned_visitor.rs b/crates/musli/src/json/de/key_unsigned_visitor.rs index e19e829a9..c84b10d71 100644 --- a/crates/musli/src/json/de/key_unsigned_visitor.rs +++ b/crates/musli/src/json/de/key_unsigned_visitor.rs @@ -1,11 +1,10 @@ use core::fmt; use core::marker; -use musli_core::de::ValueVisitor; -use musli_core::Context; - +use crate::de::ValueVisitor; use crate::json::parser::integer::Unsigned; use crate::json::parser::SliceParser; +use crate::Context; use super::parse_unsigned; diff --git a/crates/musli/src/json/de/mod.rs b/crates/musli/src/json/de/mod.rs index 8c75a83dc..4ca11b115 100644 --- a/crates/musli/src/json/de/mod.rs +++ b/crates/musli/src/json/de/mod.rs @@ -25,16 +25,16 @@ use core::str; #[cfg(feature = "alloc")] use alloc::vec::Vec; +use crate::de::{ + Decode, DecodeUnsized, Decoder, NumberVisitor, SequenceDecoder, SizeHint, Skip, ValueVisitor, + Visitor, +}; +use crate::hint::{MapHint, SequenceHint}; #[cfg(feature = "value")] use crate::options; +use crate::Context; #[cfg(feature = "value")] use crate::Options; -use musli_core::de::{ - Decode, DecodeUnsized, Decoder, NumberVisitor, SequenceDecoder, SizeHint, Skip, ValueVisitor, - Visitor, -}; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::Context; #[cfg(not(feature = "parse-full"))] use super::parser::integer::{ @@ -105,7 +105,7 @@ where } } -#[musli_core::decoder(crate)] +#[crate::decoder(crate)] impl<'a, 'de, P, C> Decoder<'de> for JsonDecoder<'a, P, C> where P: Parser<'de>, diff --git a/crates/musli/src/json/de/object_decoder.rs b/crates/musli/src/json/de/object_decoder.rs index e33aa47fc..48a81cc1b 100644 --- a/crates/musli/src/json/de/object_decoder.rs +++ b/crates/musli/src/json/de/object_decoder.rs @@ -1,9 +1,8 @@ use core::mem::{replace, take}; -use musli_core::de::{Decoder, EntriesDecoder, EntryDecoder, MapDecoder, SizeHint}; -use musli_core::Context; - +use crate::de::{Decoder, EntriesDecoder, EntryDecoder, MapDecoder, SizeHint}; use crate::json::parser::{Parser, Token}; +use crate::Context; use super::{JsonDecoder, JsonKeyDecoder, JsonObjectPairDecoder}; diff --git a/crates/musli/src/json/de/object_pair_decoder.rs b/crates/musli/src/json/de/object_pair_decoder.rs index ac6fa6615..f4bf3e27d 100644 --- a/crates/musli/src/json/de/object_pair_decoder.rs +++ b/crates/musli/src/json/de/object_pair_decoder.rs @@ -1,7 +1,6 @@ -use musli_core::de::EntryDecoder; -use musli_core::Context; - +use crate::de::EntryDecoder; use crate::json::parser::{Parser, Token}; +use crate::Context; use super::{JsonDecoder, JsonKeyDecoder}; diff --git a/crates/musli/src/json/de/sequence_decoder.rs b/crates/musli/src/json/de/sequence_decoder.rs index dad96124f..9dec7f6c5 100644 --- a/crates/musli/src/json/de/sequence_decoder.rs +++ b/crates/musli/src/json/de/sequence_decoder.rs @@ -1,9 +1,8 @@ use core::mem; -use musli_core::de::{Decoder, SequenceDecoder, SizeHint}; -use musli_core::Context; - +use crate::de::{Decoder, SequenceDecoder, SizeHint}; use crate::json::parser::{Parser, Token}; +use crate::Context; use super::JsonDecoder; diff --git a/crates/musli/src/json/de/variant_decoder.rs b/crates/musli/src/json/de/variant_decoder.rs index af73be256..12daeacfb 100644 --- a/crates/musli/src/json/de/variant_decoder.rs +++ b/crates/musli/src/json/de/variant_decoder.rs @@ -1,7 +1,6 @@ -use musli_core::de::VariantDecoder; -use musli_core::Context; - +use crate::de::VariantDecoder; use crate::json::parser::{Parser, Token}; +use crate::Context; use super::{JsonDecoder, JsonKeyDecoder}; diff --git a/crates/musli/src/json/en/array_encoder.rs b/crates/musli/src/json/en/array_encoder.rs index 6eed5ec69..abb290ab0 100644 --- a/crates/musli/src/json/en/array_encoder.rs +++ b/crates/musli/src/json/en/array_encoder.rs @@ -1,8 +1,7 @@ use core::mem::take; -use crate::Writer; -use musli_core::en::SequenceEncoder; -use musli_core::Context; +use crate::en::SequenceEncoder; +use crate::{Context, Writer}; use super::JsonEncoder; diff --git a/crates/musli/src/json/en/mod.rs b/crates/musli/src/json/en/mod.rs index 9141a4442..c9e9dd72a 100644 --- a/crates/musli/src/json/en/mod.rs +++ b/crates/musli/src/json/en/mod.rs @@ -15,10 +15,9 @@ use self::variant_encoder::JsonVariantEncoder; use core::fmt; -use crate::Writer; -use musli_core::en::{Encoder, SequenceEncoder}; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::{Context, Encode}; +use crate::en::{Encoder, SequenceEncoder}; +use crate::hint::{MapHint, SequenceHint}; +use crate::{Context, Encode, Writer}; /// A JSON encoder for Müsli. pub(crate) struct JsonEncoder<'a, W, C: ?Sized> { @@ -34,7 +33,7 @@ impl<'a, W, C: ?Sized> JsonEncoder<'a, W, C> { } } -#[musli_core::encoder(crate)] +#[crate::encoder(crate)] impl<'a, C, W> Encoder for JsonEncoder<'a, W, C> where W: Writer, diff --git a/crates/musli/src/json/en/object_encoder.rs b/crates/musli/src/json/en/object_encoder.rs index 816b40466..4060087cb 100644 --- a/crates/musli/src/json/en/object_encoder.rs +++ b/crates/musli/src/json/en/object_encoder.rs @@ -1,6 +1,5 @@ -use crate::Writer; -use musli_core::en::{EntriesEncoder, MapEncoder}; -use musli_core::Context; +use crate::en::{EntriesEncoder, MapEncoder}; +use crate::{Context, Writer}; use super::{JsonEncoder, JsonObjectKeyEncoder, JsonObjectPairEncoder}; diff --git a/crates/musli/src/json/en/object_key_encoder.rs b/crates/musli/src/json/en/object_key_encoder.rs index d9b9cc53a..c9a75c906 100644 --- a/crates/musli/src/json/en/object_key_encoder.rs +++ b/crates/musli/src/json/en/object_key_encoder.rs @@ -1,8 +1,7 @@ use core::fmt; -use crate::Writer; -use musli_core::en::{Encode, Encoder}; -use musli_core::Context; +use crate::en::{Encode, Encoder}; +use crate::{Context, Writer}; pub(crate) struct JsonObjectKeyEncoder<'a, W, C: ?Sized> { cx: &'a C, @@ -27,7 +26,7 @@ macro_rules! format_integer { }}; } -#[musli_core::encoder(crate)] +#[crate::encoder(crate)] impl<'a, W, C> Encoder for JsonObjectKeyEncoder<'a, W, C> where W: Writer, diff --git a/crates/musli/src/json/en/object_pair_encoder.rs b/crates/musli/src/json/en/object_pair_encoder.rs index 2ced5ce97..28de16310 100644 --- a/crates/musli/src/json/en/object_pair_encoder.rs +++ b/crates/musli/src/json/en/object_pair_encoder.rs @@ -1,6 +1,5 @@ -use crate::Writer; -use musli_core::en::EntryEncoder; -use musli_core::Context; +use crate::en::EntryEncoder; +use crate::{Context, Writer}; use super::{JsonEncoder, JsonObjectKeyEncoder}; diff --git a/crates/musli/src/json/en/variant_encoder.rs b/crates/musli/src/json/en/variant_encoder.rs index 399d22474..f3e752f18 100644 --- a/crates/musli/src/json/en/variant_encoder.rs +++ b/crates/musli/src/json/en/variant_encoder.rs @@ -1,6 +1,5 @@ -use crate::Writer; -use musli_core::en::VariantEncoder; -use musli_core::Context; +use crate::en::VariantEncoder; +use crate::{Context, Writer}; use super::{JsonEncoder, JsonObjectKeyEncoder}; diff --git a/crates/musli/src/json/encoding.rs b/crates/musli/src/json/encoding.rs index 28acc4c11..1a0126822 100644 --- a/crates/musli/src/json/encoding.rs +++ b/crates/musli/src/json/encoding.rs @@ -11,11 +11,11 @@ use alloc::vec::Vec; #[cfg(feature = "std")] use std::io; -use crate::{FixedBytes, Writer}; -use musli_core::de::{Decode, Decoder}; -use musli_core::en::{Encode, Encoder}; -use musli_core::mode::Text; -use musli_core::Context; +use crate::de::{Decode, Decoder}; +use crate::default_allocator; +use crate::en::{Encode, Encoder}; +use crate::mode::Text; +use crate::{Context, FixedBytes, Writer}; use super::de::JsonDecoder; use super::en::JsonEncoder; diff --git a/crates/musli/src/json/mod.rs b/crates/musli/src/json/mod.rs index ecdab45de..0e489a9f1 100644 --- a/crates/musli/src/json/mod.rs +++ b/crates/musli/src/json/mod.rs @@ -49,7 +49,6 @@ mod parser; #[cfg(feature = "test")] #[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] #[doc(hidden)] -#[macro_use] pub mod test; /// Convenient result alias for use with `musli::json`. diff --git a/crates/musli/src/json/parser/integer.rs b/crates/musli/src/json/parser/integer.rs index 5bec0878c..003df15e4 100644 --- a/crates/musli/src/json/parser/integer.rs +++ b/crates/musli/src/json/parser/integer.rs @@ -1,7 +1,6 @@ -use musli_core::Context; - use crate::json::error::IntegerError; use crate::json::parser::Parser; +use crate::Context; use self::traits::FromUnsigned; pub(crate) use self::traits::{Float, Signed, Unsigned}; diff --git a/crates/musli/src/json/parser/parser.rs b/crates/musli/src/json/parser/parser.rs index 7a0f5ae85..f82dfc88c 100644 --- a/crates/musli/src/json/parser/parser.rs +++ b/crates/musli/src/json/parser/parser.rs @@ -1,8 +1,7 @@ -use musli_core::de::NumberVisitor; -use musli_core::{Buf, Context}; - +use crate::de::NumberVisitor; use crate::json::parser::integer::decode_signed_full; use crate::json::parser::{string, StringReference, Token}; +use crate::{Buf, Context}; mod private { pub trait Sealed {} diff --git a/crates/musli/src/json/parser/slice_parser.rs b/crates/musli/src/json/parser/slice_parser.rs index c87207392..368c73a00 100644 --- a/crates/musli/src/json/parser/slice_parser.rs +++ b/crates/musli/src/json/parser/slice_parser.rs @@ -1,7 +1,6 @@ -use musli_core::{Buf, Context}; - use crate::json::error::ErrorMessage; use crate::json::parser::{Parser, StringReference, Token}; +use crate::{Buf, Context}; use lexical::parse_float_options::JSON; diff --git a/crates/musli/src/json/parser/string.rs b/crates/musli/src/json/parser/string.rs index 943e4bb19..79c6796b1 100644 --- a/crates/musli/src/json/parser/string.rs +++ b/crates/musli/src/json/parser/string.rs @@ -1,8 +1,7 @@ #![allow(clippy::zero_prefixed_literal)] -use musli_core::{Buf, Context}; - use crate::json::parser::{Parser, SliceParser}; +use crate::{Buf, Context}; // Copied and adapter form the serde-json project under the MIT and Apache 2.0 // license. diff --git a/crates/musli/src/json/parser/tests.rs b/crates/musli/src/json/parser/tests.rs index bcd4e94fa..fe231e970 100644 --- a/crates/musli/src/json/parser/tests.rs +++ b/crates/musli/src/json/parser/tests.rs @@ -1,16 +1,16 @@ #![cfg(feature = "std")] use alloc::format; -use musli_core::mode::Binary; use crate::context; use crate::json::error::Error; use crate::json::parser::integer::{parse_signed_full, parse_unsigned_full}; use crate::json::parser::SliceParser; +use crate::mode::Binary; #[test] fn test_decode_exponent() { - default_allocator!(|alloc| { + crate::default_allocator!(|alloc| { let cx = context::Same::<_, Binary, Error>::new(alloc); macro_rules! test_number { @@ -47,7 +47,7 @@ fn test_decode_exponent() { #[test] fn test_decode_unsigned() { - default_allocator!(|alloc| { + crate::default_allocator!(|alloc| { let cx = context::Same::<_, Binary, Error>::new(alloc); macro_rules! test_number { @@ -115,7 +115,7 @@ fn test_decode_unsigned() { #[test] fn test_decode_signed() { - default_allocator!(|alloc| { + crate::default_allocator!(|alloc| { let cx = context::Same::<_, Binary, Error>::new(alloc); macro_rules! test_number { diff --git a/crates/musli/src/json/test.rs b/crates/musli/src/json/test.rs index 69e31015b..bebfa9d12 100644 --- a/crates/musli/src/json/test.rs +++ b/crates/musli/src/json/test.rs @@ -1,3 +1,3 @@ //! Helpers for writing tests. -crate::test_fns!("json", ::musli_core::mode::Text); +crate::test_fns!("json", crate::mode::Text); diff --git a/crates/musli/src/lib.rs b/crates/musli/src/lib.rs index 0f8655b14..d2adb42f0 100644 --- a/crates/musli/src/lib.rs +++ b/crates/musli/src/lib.rs @@ -407,7 +407,6 @@ extern crate alloc; #[cfg(feature = "std")] extern crate std; -#[macro_use] #[doc(hidden)] pub mod macros; @@ -416,25 +415,153 @@ mod tests; pub mod help; -#[doc(inline)] -pub use musli_core::de; -#[doc(inline)] -pub use musli_core::en; +pub mod de; +pub mod en; + #[doc(inline)] pub use musli_core::hint; #[doc(inline)] pub use musli_core::mode; #[doc(inline)] pub use musli_core::no_std; + +/// This is an attribute macro that must be used when implementing a +/// [`Encoder`]. +/// +/// It is required to use because a [`Encoder`] implementation might introduce +/// new associated types in the future, and this [not yet supported] on a +/// language level in Rust. So this attribute macro polyfills any missing types +/// automatically. +/// +/// [not yet supported]: https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html +/// +/// # Examples +/// +/// ``` +/// use std::fmt; +/// +/// use musli::Context; +/// use musli::en::{Encoder, Encode}; +/// +/// struct MyEncoder<'a, C: ?Sized> { +/// value: &'a mut Option, +/// cx: &'a C, +/// } +/// +/// #[musli::encoder] +/// impl Encoder for MyEncoder<'_, C> { +/// type Cx = C; +/// type Ok = (); +/// +/// fn cx(&self) -> &C { +/// self.cx +/// } +/// +/// fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { +/// write!(f, "32-bit unsigned integers") +/// } +/// +/// fn encode(self, value: T) -> Result +/// where +/// T: Encode, +/// { +/// value.encode(self.cx, self) +/// } +/// +/// fn encode_u32(self, value: u32) -> Result<(), Self::Error> { +/// *self.value = Some(value); +/// Ok(()) +/// } +/// } +/// ``` +#[doc(inline)] +pub use musli_core::encoder; + +/// This is an attribute macro that must be used when implementing a +/// [`Decoder`]. +/// +/// It is required to use because a [`Decoder`] implementation might introduce +/// new associated types in the future, and this is [not yet supported] on a +/// language level in Rust. So this attribute macro polyfills any missing types +/// automatically. +/// +/// [not yet supported]: https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html +/// +/// # Examples +/// +/// ``` +/// use std::fmt; +/// +/// use musli::Context; +/// use musli::de::{Decoder, Decode}; +/// +/// struct MyDecoder<'a, C: ?Sized> { +/// cx: &'a C, +/// } +/// +/// #[musli::decoder] +/// impl<'de, C: ?Sized + Context> Decoder<'de> for MyDecoder<'_, C> { +/// type Cx = C; +/// +/// fn cx(&self) -> &C { +/// self.cx +/// } +/// +/// fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { +/// write!(f, "32-bit unsigned integers") +/// } +/// +/// fn decode_u32(self) -> Result { +/// Ok(42) +/// } +/// } +/// ``` +#[doc(inline)] +pub use musli_core::decoder; + +/// This is an attribute macro that must be used when implementing a +/// [`Visitor`]. +/// +/// It is required to use because a [`Visitor`] implementation might introduce +/// new associated types in the future, and this is [not yet supported] on a +/// language level in Rust. So this attribute macro polyfills any missing types +/// automatically. +/// +/// [not yet supported]: +/// https://rust-lang.github.io/rfcs/2532-associated-type-defaults.html +/// [`Visitor`]: crate::de::Visitor +/// +/// # Examples +/// +/// ``` +/// use std::fmt; +/// +/// use musli::Context; +/// use musli::de::Visitor; +/// +/// struct AnyVisitor; +/// +/// #[musli::visitor] +/// impl<'de, C: ?Sized + Context> Visitor<'de, C> for AnyVisitor { +/// type Ok = (); +/// +/// #[inline] +/// fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { +/// write!( +/// f, +/// "value that can be decoded into dynamic container" +/// ) +/// } +/// } +/// ``` #[doc(inline)] -pub use musli_core::{decoder, encoder, visitor}; +pub use musli_core::visitor; #[doc(inline)] pub use musli_core::{Allocator, Buf, Context, Decode, Decoder, Encode, Encoder, StdError}; #[doc(hidden)] pub use musli_core::__priv; -#[macro_use] pub mod allocator; pub mod descriptive; @@ -452,7 +579,6 @@ pub mod fixed; #[doc(inline)] pub use self::fixed::FixedBytes; -#[macro_use] pub mod options; #[doc(inline)] pub use self::options::Options; diff --git a/crates/musli/src/macros.rs b/crates/musli/src/macros.rs index 60c328a42..31cae9f9a 100644 --- a/crates/musli/src/macros.rs +++ b/crates/musli/src/macros.rs @@ -212,7 +212,7 @@ macro_rules! test_fns { #[cfg(feature = "test")] pub fn rt(value: T) -> T where - T: ::musli_core::en::Encode<$mode> + ::musli_core::de::DecodeOwned<$mode>, + T: $crate::en::Encode<$mode> + $crate::de::DecodeOwned<$mode>, T: ::core::fmt::Debug + ::core::cmp::PartialEq, { const WHAT: &str = $what; @@ -239,7 +239,7 @@ macro_rules! test_fns { } } - default_allocator!(|alloc| { + $crate::default_allocator!(|alloc| { let mut cx = $crate::context::SystemContext::new(&alloc); cx.include_type(); @@ -295,9 +295,9 @@ macro_rules! test_fns { #[cfg(feature = "test")] pub fn decode<'de, T, U>(value: T, out: &'de mut ::alloc::vec::Vec, expected: &U) -> U where - T: ::musli_core::en::Encode<$mode>, + T: $crate::en::Encode<$mode>, T: ::core::fmt::Debug + ::core::cmp::PartialEq, - U: ::musli_core::de::Decode<'de, $mode>, + U: $crate::de::Decode<'de, $mode>, U: ::core::fmt::Debug + ::core::cmp::PartialEq, { const WHAT: &str = $what; @@ -324,7 +324,7 @@ macro_rules! test_fns { } } - default_allocator!(|alloc| { + $crate::default_allocator!(|alloc| { let mut cx = $crate::context::SystemContext::new(&alloc); cx.include_type(); @@ -364,14 +364,14 @@ macro_rules! test_fns { #[cfg(feature = "test")] pub fn to_vec(value: T) -> ::alloc::vec::Vec where - T: ::musli_core::en::Encode<$mode>, + T: $crate::en::Encode<$mode>, { const WHAT: &str = $what; const ENCODING: super::Encoding = super::Encoding::new(); use ::core::any::type_name; - default_allocator!(|alloc| { + $crate::default_allocator!(|alloc| { let mut cx = $crate::context::SystemContext::new(alloc); cx.include_type(); diff --git a/crates/musli/src/reader.rs b/crates/musli/src/reader.rs index 92b6d0f66..655e82878 100644 --- a/crates/musli/src/reader.rs +++ b/crates/musli/src/reader.rs @@ -7,8 +7,8 @@ use core::ops::Range; use core::ptr; use core::slice; -use musli_core::de::ValueVisitor; -use musli_core::Context; +use crate::de::ValueVisitor; +use crate::Context; /// Trait governing how a source of bytes is read. /// diff --git a/crates/musli/src/serde/deserializer.rs b/crates/musli/src/serde/deserializer.rs index 674ac3e00..1f61915f8 100644 --- a/crates/musli/src/serde/deserializer.rs +++ b/crates/musli/src/serde/deserializer.rs @@ -1,11 +1,12 @@ use core::fmt; -use musli_core::de::{ +use serde::de; + +use crate::de::{ Decoder, EntriesDecoder, MapDecoder, SequenceDecoder, SizeHint, VariantDecoder, Visitor, }; -use musli_core::hint::SequenceHint; -use musli_core::Context; -use serde::de; +use crate::hint::SequenceHint; +use crate::Context; #[cfg(feature = "alloc")] use alloc::string::String; @@ -446,7 +447,7 @@ impl BytesVisitor { } } -impl<'de, C, V> musli_core::de::ValueVisitor<'de, C, [u8]> for BytesVisitor +impl<'de, C, V> crate::de::ValueVisitor<'de, C, [u8]> for BytesVisitor where C: ?Sized + Context, C::Error: de::Error, @@ -580,7 +581,7 @@ impl StringVisitor { } } -impl<'de, C, V> musli_core::de::ValueVisitor<'de, C, str> for StringVisitor +impl<'de, C, V> crate::de::ValueVisitor<'de, C, str> for StringVisitor where C: ?Sized + Context, C::Error: de::Error, @@ -620,7 +621,7 @@ impl AnyNumberVisitor { } } -impl<'de, C, V> musli_core::de::NumberVisitor<'de, C> for AnyNumberVisitor +impl<'de, C, V> crate::de::NumberVisitor<'de, C> for AnyNumberVisitor where C: ?Sized + Context, C::Error: de::Error, @@ -826,7 +827,7 @@ impl AnyVisitor { } } -#[musli_core::visitor(crate)] +#[crate::visitor(crate)] impl<'de, C, V> Visitor<'de, C> for AnyVisitor where C: ?Sized + Context, diff --git a/crates/musli/src/serde/error.rs b/crates/musli/src/serde/error.rs index bd32b2f17..edd077c66 100644 --- a/crates/musli/src/serde/error.rs +++ b/crates/musli/src/serde/error.rs @@ -1,6 +1,6 @@ use core::fmt; -use musli_core::Context; +use crate::Context; #[cfg(feature = "alloc")] use alloc::boxed::Box; diff --git a/crates/musli/src/serde/mod.rs b/crates/musli/src/serde/mod.rs index 7c4f28d3e..e2262938f 100644 --- a/crates/musli/src/serde/mod.rs +++ b/crates/musli/src/serde/mod.rs @@ -97,13 +97,13 @@ mod serializer; use core::cell::RefCell; use core::fmt; -use musli_core::{Context, Decoder, Encoder, StdError}; use serde::{Deserialize, Serialize}; use self::deserializer::Deserializer; use self::serializer::Serializer; use crate::buf::{self, BufString}; +use crate::{Context, Decoder, Encoder, StdError}; struct SerdeContext<'a, C> where diff --git a/crates/musli/src/serde/serializer.rs b/crates/musli/src/serde/serializer.rs index 9a056b5b1..46f877502 100644 --- a/crates/musli/src/serde/serializer.rs +++ b/crates/musli/src/serde/serializer.rs @@ -1,8 +1,8 @@ use core::fmt; -use musli_core::en::{EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder}; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::{Context, Encoder}; +use crate::en::{EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder}; +use crate::hint::{MapHint, SequenceHint}; +use crate::{Context, Encoder}; use serde::ser::{self, Serialize}; diff --git a/crates/musli/src/storage/de.rs b/crates/musli/src/storage/de.rs index aca6e4c17..1b0717c57 100644 --- a/crates/musli/src/storage/de.rs +++ b/crates/musli/src/storage/de.rs @@ -3,13 +3,12 @@ use core::fmt; #[cfg(feature = "alloc")] use alloc::vec::Vec; -use crate::{Options, Reader}; -use musli_core::de::{ +use crate::de::{ DecodeUnsized, Decoder, EntriesDecoder, EntryDecoder, MapDecoder, SequenceDecoder, SizeHint, ValueVisitor, VariantDecoder, }; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::{Context, Decode}; +use crate::hint::{MapHint, SequenceHint}; +use crate::{Context, Decode, Options, Reader}; /// A very simple decoder suitable for storage decoding. pub struct StorageDecoder<'a, R, const OPT: Options, C: ?Sized> { @@ -36,7 +35,7 @@ pub struct LimitedStorageDecoder<'a, R, const OPT: Options, C: ?Sized> { reader: R, } -#[musli_core::decoder(crate)] +#[crate::decoder(crate)] impl<'a, 'de, R, const OPT: Options, C: ?Sized + Context> Decoder<'de> for StorageDecoder<'a, R, OPT, C> where diff --git a/crates/musli/src/storage/en.rs b/crates/musli/src/storage/en.rs index d7f7c9cbe..561878176 100644 --- a/crates/musli/src/storage/en.rs +++ b/crates/musli/src/storage/en.rs @@ -1,11 +1,10 @@ use core::fmt; -use crate::{Options, Writer}; -use musli_core::en::{ +use crate::en::{ Encode, Encoder, EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder, }; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::Context; +use crate::hint::{MapHint, SequenceHint}; +use crate::{Context, Options, Writer}; /// A vaery simple encoder suitable for storage encoding. pub struct StorageEncoder<'a, W, const OPT: Options, C: ?Sized> { @@ -21,7 +20,7 @@ impl<'a, W, const OPT: Options, C: ?Sized> StorageEncoder<'a, W, OPT, C> { } } -#[musli_core::encoder(crate)] +#[crate::encoder(crate)] impl<'a, W, const OPT: Options, C> Encoder for StorageEncoder<'a, W, OPT, C> where C: ?Sized + Context, diff --git a/crates/musli/src/storage/encoding.rs b/crates/musli/src/storage/encoding.rs index 7e6a9ee51..4b71c6293 100644 --- a/crates/musli/src/storage/encoding.rs +++ b/crates/musli/src/storage/encoding.rs @@ -7,12 +7,10 @@ use core::marker; #[cfg(feature = "std")] use std::io; -use musli_core::mode::Binary; -use musli_core::{Context, Decode, Encode}; - use crate::fixed::FixedBytes; -use crate::options::{self, Options}; -use crate::{Reader, Writer}; +use crate::mode::Binary; +use crate::options; +use crate::{Context, Decode, Encode, Options, Reader, Writer}; use super::de::StorageDecoder; use super::en::StorageEncoder; diff --git a/crates/musli/src/storage/test.rs b/crates/musli/src/storage/test.rs index f7eaa9d16..7bec2871e 100644 --- a/crates/musli/src/storage/test.rs +++ b/crates/musli/src/storage/test.rs @@ -1,3 +1,3 @@ //! Helpers for writing tests. -crate::test_fns!("storage", musli_core::mode::Binary); +crate::test_fns!("storage", crate::mode::Binary); diff --git a/crates/musli/src/value/de.rs b/crates/musli/src/value/de.rs index fe1681196..d5bc84171 100644 --- a/crates/musli/src/value/de.rs +++ b/crates/musli/src/value/de.rs @@ -2,18 +2,16 @@ use core::fmt; use core::slice; #[cfg(feature = "alloc")] -use musli_core::de::ValueVisitor; -use musli_core::de::{ +use crate::de::ValueVisitor; +use crate::de::{ AsDecoder, Decode, DecodeUnsized, Decoder, EntriesDecoder, EntryDecoder, MapDecoder, SequenceDecoder, SizeHint, Skip, VariantDecoder, Visitor, }; #[cfg(feature = "alloc")] -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::Context; - +use crate::hint::{MapHint, SequenceHint}; use crate::reader::SliceReader; use crate::storage::de::StorageDecoder; -use crate::Options; +use crate::{Context, Options}; use super::error::ErrorMessage; use super::type_hint::{NumberHint, TypeHint}; @@ -81,7 +79,7 @@ macro_rules! ensure { }; } -#[musli_core::decoder(crate)] +#[crate::decoder(crate)] impl<'a, 'de, C: ?Sized + Context, const OPT: Options> Decoder<'de> for ValueDecoder<'a, 'de, OPT, C> { diff --git a/crates/musli/src/value/en.rs b/crates/musli/src/value/en.rs index c9b5baba5..a81e70c59 100644 --- a/crates/musli/src/value/en.rs +++ b/crates/musli/src/value/en.rs @@ -5,20 +5,18 @@ use alloc::boxed::Box; #[cfg(feature = "alloc")] use alloc::vec::Vec; -use musli_core::en::{Encode, Encoder}; +use crate::en::{Encode, Encoder}; #[cfg(feature = "alloc")] -use musli_core::en::{EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder}; +use crate::en::{EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder}; #[cfg(feature = "alloc")] -use musli_core::hint::{MapHint, SequenceHint}; -#[cfg(feature = "alloc")] -use musli_core::Buf; -use musli_core::Context; - +use crate::hint::{MapHint, SequenceHint}; #[cfg(feature = "alloc")] use crate::storage::en::StorageEncoder; #[cfg(feature = "alloc")] use crate::writer::BufWriter; -use crate::Options; +#[cfg(feature = "alloc")] +use crate::Buf; +use crate::{Context, Options}; use super::value::{Number, Value}; @@ -71,7 +69,7 @@ impl<'a, const OPT: Options, O, C: ?Sized> ValueEncoder<'a, OPT, O, C> { } } -#[musli_core::encoder(crate)] +#[crate::encoder(crate)] impl<'a, const OPT: Options, O, C> Encoder for ValueEncoder<'a, OPT, O, C> where O: ValueOutput, diff --git a/crates/musli/src/value/mod.rs b/crates/musli/src/value/mod.rs index b4a33f60e..93c53a32b 100644 --- a/crates/musli/src/value/mod.rs +++ b/crates/musli/src/value/mod.rs @@ -22,10 +22,10 @@ pub use self::value::{AsValueDecoder, Value}; #[doc(inline)] pub use error::Error; -use crate::Options; -use en::ValueEncoder; -use musli_core::mode::Binary; -use musli_core::{Decode, Encode}; +use crate::default_allocator; +use crate::mode::Binary; +use crate::value::en::ValueEncoder; +use crate::{Decode, Encode, Options}; const OPTIONS: Options = crate::options::new().build(); @@ -34,7 +34,7 @@ pub fn encode(value: T) -> Result where T: Encode, { - use musli_core::en::Encoder; + use crate::en::Encoder; let mut output = Value::Unit; @@ -50,7 +50,7 @@ pub fn decode<'de, T>(value: &'de Value) -> Result where T: Decode<'de, Binary>, { - use musli_core::de::Decoder; + use crate::de::Decoder; default_allocator!(|alloc| { let cx = crate::context::Same::<_, Binary, Error>::new(&alloc); @@ -62,10 +62,10 @@ where /// context. pub fn decode_with<'de, C, T>(cx: &C, value: &'de Value) -> Result where - C: ?Sized + musli_core::Context, + C: ?Sized + crate::Context, T: Decode<'de, C::Mode>, { - use musli_core::de::Decoder; + use crate::de::Decoder; cx.clear(); value.decoder::(cx).decode() diff --git a/crates/musli/src/value/type_hint.rs b/crates/musli/src/value/type_hint.rs index 7231142c1..f659879ab 100644 --- a/crates/musli/src/value/type_hint.rs +++ b/crates/musli/src/value/type_hint.rs @@ -1,7 +1,7 @@ use core::fmt; #[cfg(feature = "alloc")] -use musli_core::de::SizeHint; +use crate::de::SizeHint; /// A type hint. #[derive(Debug, Clone, Copy)] diff --git a/crates/musli/src/value/value.rs b/crates/musli/src/value/value.rs index a3f2999cb..b185eecb1 100644 --- a/crates/musli/src/value/value.rs +++ b/crates/musli/src/value/value.rs @@ -7,17 +7,15 @@ use alloc::string::String; #[cfg(feature = "alloc")] use alloc::vec::Vec; -use musli_core::de::{AsDecoder, Decode, Decoder, NumberVisitor, Visitor}; +use crate::de::{AsDecoder, Decode, Decoder, NumberVisitor, Visitor}; #[cfg(feature = "alloc")] -use musli_core::de::{ +use crate::de::{ EntryDecoder, MapDecoder, SequenceDecoder, SizeHint, ValueVisitor, VariantDecoder, }; -use musli_core::en::{Encode, Encoder}; +use crate::en::{Encode, Encoder}; #[cfg(feature = "alloc")] -use musli_core::en::{MapEncoder, SequenceEncoder, VariantEncoder}; -use musli_core::Context; - -use crate::Options; +use crate::en::{MapEncoder, SequenceEncoder, VariantEncoder}; +use crate::{Context, Options}; use super::de::ValueDecoder; use super::type_hint::{NumberHint, TypeHint}; @@ -207,7 +205,7 @@ impl Number { struct AnyVisitor; -#[musli_core::visitor(crate)] +#[crate::visitor(crate)] impl<'de, C: ?Sized + Context> Visitor<'de, C> for AnyVisitor { type Ok = Value; #[cfg(feature = "alloc")] @@ -535,7 +533,7 @@ impl Encode for Value { Value::String(string) => encoder.encode_string(string), #[cfg(feature = "alloc")] Value::Sequence(values) => { - use musli_core::hint::SequenceHint; + use crate::hint::SequenceHint; let hint = SequenceHint::with_size(values.len()); @@ -549,7 +547,7 @@ impl Encode for Value { } #[cfg(feature = "alloc")] Value::Map(values) => { - use musli_core::hint::MapHint; + use crate::hint::MapHint; let hint = MapHint::with_size(values.len()); diff --git a/crates/musli/src/wire/de.rs b/crates/musli/src/wire/de.rs index 67bebbc2c..6f56d4a88 100644 --- a/crates/musli/src/wire/de.rs +++ b/crates/musli/src/wire/de.rs @@ -4,17 +4,15 @@ use core::mem::take; #[cfg(feature = "alloc")] use alloc::vec::Vec; -use musli_core::de::{ +use crate::de::{ Decode, DecodeUnsized, Decoder, EntriesDecoder, EntryDecoder, MapDecoder, SequenceDecoder, SizeHint, Skip, ValueVisitor, VariantDecoder, }; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::Context; - +use crate::hint::{MapHint, SequenceHint}; use crate::int::continuation as c; use crate::reader::Limit; use crate::storage::de::StorageDecoder; -use crate::{Options, Reader}; +use crate::{Context, Options, Reader}; use super::tag::{Kind, Tag}; @@ -204,7 +202,7 @@ where } } -#[musli_core::decoder(crate)] +#[crate::decoder(crate)] impl<'a, 'de, R, const OPT: Options, C> Decoder<'de> for WireDecoder<'a, R, OPT, C> where C: ?Sized + Context, diff --git a/crates/musli/src/wire/en.rs b/crates/musli/src/wire/en.rs index 0048d722d..5024fb050 100644 --- a/crates/musli/src/wire/en.rs +++ b/crates/musli/src/wire/en.rs @@ -1,13 +1,12 @@ use core::fmt; -use musli_core::en::{ +use crate::en::{ Encode, Encoder, EntriesEncoder, EntryEncoder, MapEncoder, SequenceEncoder, VariantEncoder, }; -use musli_core::hint::{MapHint, SequenceHint}; -use musli_core::{Buf, Context}; - +use crate::hint::{MapHint, SequenceHint}; use crate::storage::en::StorageEncoder; use crate::writer::BufWriter; +use crate::{Buf, Context}; use crate::{Options, Writer}; use super::tag::{Kind, Tag}; @@ -76,7 +75,7 @@ impl<'a, W, B, const OPT: Options, C: ?Sized> WireSequenceEncoder<'a, W, B, OPT, } } -#[musli_core::encoder(crate)] +#[crate::encoder(crate)] impl<'a, W, const OPT: Options, C> Encoder for WireEncoder<'a, W, OPT, C> where C: ?Sized + Context, diff --git a/crates/musli/src/wire/encoding.rs b/crates/musli/src/wire/encoding.rs index 1e21a5235..da3f27c01 100644 --- a/crates/musli/src/wire/encoding.rs +++ b/crates/musli/src/wire/encoding.rs @@ -8,11 +8,9 @@ use alloc::vec::Vec; #[cfg(feature = "std")] use std::io; -use musli_core::mode::Binary; -use musli_core::{Context, Decode, Encode}; - +use crate::mode::Binary; use crate::options; -use crate::{FixedBytes, Options, Reader, Writer}; +use crate::{Context, Decode, Encode, FixedBytes, Options, Reader, Writer}; use super::de::WireDecoder; use super::en::WireEncoder; diff --git a/crates/musli/src/wire/int.rs b/crates/musli/src/wire/int.rs index 8628842c2..fc77ef4b3 100644 --- a/crates/musli/src/wire/int.rs +++ b/crates/musli/src/wire/int.rs @@ -1,8 +1,7 @@ use crate::int::continuation as c; use crate::int::zigzag as zig; use crate::int::{Signed, Unsigned, UnsignedOps}; -use crate::{Options, Reader, Writer}; -use musli_core::Context; +use crate::{Context, Options, Reader, Writer}; use super::tag::{Kind, Tag, DATA_MASK}; diff --git a/crates/musli/src/wire/mod.rs b/crates/musli/src/wire/mod.rs index c16660626..54c719457 100644 --- a/crates/musli/src/wire/mod.rs +++ b/crates/musli/src/wire/mod.rs @@ -100,7 +100,6 @@ mod tag; #[cfg(feature = "test")] #[cfg_attr(doc_cfg, doc(cfg(feature = "test")))] #[doc(hidden)] -#[macro_use] pub mod test; /// Convenient result alias for use with `musli::wire`. diff --git a/crates/musli/src/wire/tag.rs b/crates/musli/src/wire/tag.rs index 18799a3ff..0cd409836 100644 --- a/crates/musli/src/wire/tag.rs +++ b/crates/musli/src/wire/tag.rs @@ -6,7 +6,7 @@ use core::fmt; use core::mem; #[cfg(feature = "test")] -use musli_core::{Decode, Encode}; +use crate::{Decode, Encode}; /// Data masked into the data type. pub(crate) const DATA_MASK: u8 = 0b00_111111; diff --git a/crates/musli/src/wire/test.rs b/crates/musli/src/wire/test.rs index 2cdd3ff2e..b2485e1fa 100644 --- a/crates/musli/src/wire/test.rs +++ b/crates/musli/src/wire/test.rs @@ -2,7 +2,7 @@ use core::fmt::Debug; -use musli_core::{Decode, Encode}; +use crate::{Decode, Encode}; use super::tag::Tag; @@ -26,4 +26,4 @@ impl Typed { } } -crate::test_fns!("wire", musli_core::mode::Binary); +crate::test_fns!("wire", crate::mode::Binary); diff --git a/crates/musli/src/wire/tests/basic.rs b/crates/musli/src/wire/tests/basic.rs index c19b61e0e..1f8993fc2 100644 --- a/crates/musli/src/wire/tests/basic.rs +++ b/crates/musli/src/wire/tests/basic.rs @@ -1,7 +1,6 @@ -use musli_core::{Decode, Encode}; - use crate::wire::tag::{Kind, Tag}; use crate::wire::MAX_INLINE_LEN; +use crate::{Decode, Encode}; #[derive(Debug, PartialEq, Encode, Decode)] #[musli(crate, name_type = usize)] diff --git a/crates/musli/src/wrap.rs b/crates/musli/src/wrap.rs index 213a14adb..96bb984fa 100644 --- a/crates/musli/src/wrap.rs +++ b/crates/musli/src/wrap.rs @@ -4,7 +4,7 @@ //! adapter around an I/O type to work with musli. #[cfg(feature = "std")] -use musli_core::{Buf, Context}; +use crate::{Buf, Context}; /// Wrap a type so that it implements [`Reader`] and [`Writer`]. /// diff --git a/crates/musli/src/writer.rs b/crates/musli/src/writer.rs index db3d1b806..00effd7f6 100644 --- a/crates/musli/src/writer.rs +++ b/crates/musli/src/writer.rs @@ -7,7 +7,7 @@ use core::fmt; use core::mem::take; -use musli_core::{Buf, Context}; +use crate::{Buf, Context}; #[cfg(feature = "alloc")] use alloc::vec::Vec; diff --git a/tests-macros/Cargo.toml b/tests-macros/Cargo.toml new file mode 100644 index 000000000..0679bc057 --- /dev/null +++ b/tests-macros/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "tests-macros" +edition = "2021" +rust-version = "1.76" +publish = false + +[lib] +proc-macro = true +path = "src/lib.rs" + +[dependencies] +proc-macro2 = "1.0.79" +quote = "1.0.35" +syn = { version = "2.0.55", features = ["full", "extra-traits"] } diff --git a/crates/musli-macros/src/benchmarker.rs b/tests-macros/src/benchmarker.rs similarity index 100% rename from crates/musli-macros/src/benchmarker.rs rename to tests-macros/src/benchmarker.rs diff --git a/tests-macros/src/lib.rs b/tests-macros/src/lib.rs new file mode 100644 index 000000000..42b768e43 --- /dev/null +++ b/tests-macros/src/lib.rs @@ -0,0 +1,37 @@ +#![allow(clippy::too_many_arguments)] +#![allow(clippy::needless_late_init)] + +mod benchmarker; +mod test; + +use proc_macro::TokenStream; + +#[proc_macro_derive(Generate, attributes(generate))] +pub fn derive_generate(input: TokenStream) -> TokenStream { + let input = syn::parse_macro_input!(input as syn::DeriveInput); + + let mut cx = test::Ctxt::default(); + + if let Ok(stream) = test::expand(&mut cx, input) { + return stream.into(); + } + + let mut stream = proc_macro2::TokenStream::default(); + + for error in cx.errors { + stream.extend(error.to_compile_error()); + } + + stream.into() +} + +#[proc_macro_attribute] +pub fn benchmarker(attr: TokenStream, input: TokenStream) -> TokenStream { + let attrs = syn::parse_macro_input!(attr as benchmarker::Attributes); + let input = syn::parse_macro_input!(input as benchmarker::Benchmarker); + + match input.expand(&attrs) { + Ok(tokens) => tokens.into(), + Err(err) => err.to_compile_error().into(), + } +} diff --git a/crates/musli-macros/src/test.rs b/tests-macros/src/test.rs similarity index 100% rename from crates/musli-macros/src/test.rs rename to tests-macros/src/test.rs diff --git a/tests/Cargo.toml b/tests/Cargo.toml index 0c414a6c9..f8de69688 100644 --- a/tests/Cargo.toml +++ b/tests/Cargo.toml @@ -64,7 +64,7 @@ miniserde = ["dep:miniserde", "alloc", "no-cstring", "no-btree", "no-map", "no-s [dependencies] musli = { path = "../crates/musli", version = "0.0.119", default-features = false, optional = true, features = [] } musli-zerocopy = { path = "../crates/musli-zerocopy", version = "0.0.119", default-features = false, features = [], optional = true } -musli-macros = { path = "../crates/musli-macros", version = "0.0.119", features = ["test"] } +tests-macros = { path = "../tests-macros" } anyhow = "1.0.81" serde = { version = "1.0.197", default-features = false, optional = true, features = ["derive"] } diff --git a/tests/src/generate.rs b/tests/src/generate.rs index 9b97dac02..d84ca0366 100644 --- a/tests/src/generate.rs +++ b/tests/src/generate.rs @@ -15,7 +15,7 @@ use alloc::vec::Vec; use rand::distributions::Distribution; use rand::distributions::Standard; -pub use musli_macros::Generate; +pub use tests_macros::Generate; #[cfg(feature = "alloc")] use alloc::collections::{BTreeMap, BTreeSet}; diff --git a/tests/src/lib.rs b/tests/src/lib.rs index a6d861f56..7f87fd6e7 100644 --- a/tests/src/lib.rs +++ b/tests/src/lib.rs @@ -9,7 +9,7 @@ extern crate std; /// Default random seed to use. pub const RNG_SEED: u64 = 2718281828459045235; -pub use musli_macros::benchmarker; +pub use tests_macros::benchmarker; #[macro_export] macro_rules! miri {