feat(toml)!: Add no_std compatibility (#952)

This gets us `alloc` but not `core`. For `core`, see `toml_parse` /
`toml_write`

Closes #904
Fixes #360

Author: epage

crates/serde_spanned/Cargo.toml

@@ -23,8 +23,13 @@ pre-release-replacements = [
   {file="CHANGELOG.md", search="<!-- next-url -->", replace="<!-- next-url -->\n[Unreleased]: https://github.com/toml-rs/toml/compare/{{tag_name}}...HEAD", exactly=1},
 ]
 
+[features]
+default = ["std"]
+alloc = []
+std = ["alloc"]
+
 [dependencies]
-serde = { version = "1.0.145", optional = true }
+serde = { version = "1.0.145", optional = true, default-features = false }
 
 [dev-dependencies]
 serde = "1"

crates/serde_spanned/src/lib.rs

@@ -6,7 +6,10 @@
 //! [serde]: https://serde.rs/
 
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
 #![warn(missing_docs)]
+#![warn(clippy::std_instead_of_core)]
+#![warn(clippy::std_instead_of_alloc)]
 // Makes rustc abort compilation if there are any unsafe blocks in the crate.
 // Presence of this annotation is picked up by tools such as cargo-geiger
 // and lets them ensure that there is indeed no unsafe code as opposed to
@@ -15,6 +18,10 @@
 #![warn(clippy::print_stderr)]
 #![warn(clippy::print_stdout)]
 
+#[cfg(feature = "alloc")]
+#[allow(unused_extern_crates)]
+extern crate alloc;
+
 mod spanned;
 pub use crate::spanned::Spanned;
 

crates/serde_spanned/src/spanned.rs

@@ -1,5 +1,5 @@
-use std::cmp::Ordering;
-use std::hash::{Hash, Hasher};
+use core::cmp::Ordering;
+use core::hash::{Hash, Hasher};
 
 // Currently serde itself doesn't have a spanned type, so we map our `Spanned`
 // to a special value in the serde data model. Namely one with these special
@@ -29,7 +29,7 @@ pub fn is_spanned(name: &'static str, fields: &'static [&'static str]) -> bool {
 #[derive(Clone, Debug)]
 pub struct Spanned<T> {
     /// Byte range
-    span: std::ops::Range<usize>,
+    span: core::ops::Range<usize>,
     /// The spanned value.
     value: T,
 }
@@ -88,12 +88,12 @@ impl<T> Spanned<T> {
     /// #
     /// # type DetailedDependency = std::collections::BTreeMap<String, String>;
     /// ```
-    pub fn new(range: std::ops::Range<usize>, value: T) -> Self {
+    pub fn new(range: core::ops::Range<usize>, value: T) -> Self {
         Spanned { span: range, value }
     }
 
     /// Byte range
-    pub fn span(&self) -> std::ops::Range<usize> {
+    pub fn span(&self) -> core::ops::Range<usize> {
         self.span.clone()
     }
 
@@ -113,19 +113,22 @@ impl<T> Spanned<T> {
     }
 }
 
-impl<T: std::fmt::Display> std::fmt::Display for Spanned<T> {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl<T: core::fmt::Display> core::fmt::Display for Spanned<T> {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.get_ref().fmt(fmt)
     }
 }
 
-impl std::borrow::Borrow<str> for Spanned<String> {
+#[cfg(feature = "alloc")]
+#[allow(unused_qualifications)]
+impl core::borrow::Borrow<str> for Spanned<alloc::string::String> {
     fn borrow(&self) -> &str {
         self.get_ref()
     }
 }
 
-impl std::borrow::Borrow<str> for Spanned<std::borrow::Cow<'_, str>> {
+#[cfg(feature = "alloc")]
+impl core::borrow::Borrow<str> for Spanned<alloc::borrow::Cow<'_, str>> {
     fn borrow(&self) -> &str {
         self.get_ref()
     }
@@ -178,15 +181,15 @@ where
     where
         D: serde::de::Deserializer<'de>,
     {
-        struct SpannedVisitor<T>(::std::marker::PhantomData<T>);
+        struct SpannedVisitor<T>(::core::marker::PhantomData<T>);
 
         impl<'de, T> serde::de::Visitor<'de> for SpannedVisitor<T>
         where
             T: serde::de::Deserialize<'de>,
         {
             type Value = Spanned<T>;
 
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                 formatter.write_str("a spanned value")
             }
 
@@ -239,7 +242,7 @@ where
 
         static FIELDS: [&str; 3] = [START_FIELD, END_FIELD, VALUE_FIELD];
 
-        let visitor = SpannedVisitor(::std::marker::PhantomData);
+        let visitor = SpannedVisitor(::core::marker::PhantomData);
 
         deserializer.deserialize_struct(NAME, &FIELDS, visitor)
     }

crates/serde_spanned/tests/test.rs

@@ -1,4 +1,4 @@
-use std::cmp::{Ord, Ordering, PartialOrd};
+use core::cmp::{Ord, Ordering, PartialOrd};
 
 use serde_spanned::Spanned;
 

crates/toml/Cargo.toml

@@ -7,7 +7,7 @@ implementations of the standard Serialize/Deserialize traits for TOML data to
 facilitate deserializing and serializing Rust structures.
 """
 categories = ["encoding", "parser-implementations", "parsing", "config"]
-keywords = ["encoding", "toml"]
+keywords = ["encoding", "toml", "no_std"]
 repository.workspace = true
 license.workspace = true
 edition.workspace = true
@@ -29,10 +29,11 @@ pre-release-replacements = [
 
 [features]
 default = ["parse", "display"]
+std = ["indexmap?/std"]
 parse = ["dep:toml_parse", "dep:winnow"]
-display = ["dep:toml_edit", "toml_edit?/display"]
+display = ["std", "dep:toml_edit", "toml_edit?/display"]
 unsafe = ["toml_parse?/unsafe"]
-debug = ["toml_parse?/debug", "dep:anstream", "dep:anstyle"]
+debug = ["std", "toml_parse?/debug", "dep:anstream", "dep:anstyle"]
 
 # Provide a method disable_recursion_limit to parse arbitrarily deep structures
 # without any consideration for overflowing the stack. Additionally you will
@@ -44,18 +45,18 @@ unbounded = []
 # Use indexmap rather than BTreeMap as the map type of toml::Value.
 # This allows data to be read into a Value and written back to a TOML string
 # while preserving the order of map keys in the input.
-preserve_order = ["dep:indexmap"]
+preserve_order = ["dep:indexmap", "std"]
 
 [dependencies]
-serde = "1.0.145"
-indexmap = { version = "2.0.0", optional = true }
-toml_parse = { version = "0.1.0", path = "../toml_parse", optional = true }
-winnow = { version = "0.7.10", optional = true }
+serde = { version = "1.0.145", default-features = false, features = ["alloc"] }
+indexmap = { version = "2.0.0", default-features = false, optional = true }
+toml_parse = { version = "0.1.0", path = "../toml_parse", default-features = false, features = ["alloc"], optional = true }
+winnow = { version = "0.7.10", default-features = false, optional = true }
 anstream = { version = "0.6.15", optional = true }
 anstyle = { version = "1.0.8", optional = true }
 toml_edit = { version = "0.22.27", path = "../toml_edit", default-features = false, features = ["serde"], optional = true }
-toml_datetime = { version = "0.6.11", path = "../toml_datetime", features = ["serde"] }
-serde_spanned = { version = "0.6.9", path = "../serde_spanned", features = ["serde"] }
+toml_datetime = { version = "0.6.11", path = "../toml_datetime", default-features = false, features = ["serde", "alloc"] }
+serde_spanned = { version = "0.6.9", path = "../serde_spanned", default-features = false, features = ["serde", "alloc"] }
 
 [dev-dependencies]
 serde = { version = "1.0.199", features = ["derive"] }

crates/toml/src/de/array.rs

@@ -6,11 +6,11 @@ use crate::de::Error;
 
 pub(crate) struct ArrayDeserializer<'i> {
     input: DeArray<'i>,
-    span: Option<std::ops::Range<usize>>,
+    span: Option<core::ops::Range<usize>>,
 }
 
 impl<'i> ArrayDeserializer<'i> {
-    pub(crate) fn new(input: DeArray<'i>, span: Option<std::ops::Range<usize>>) -> Self {
+    pub(crate) fn new(input: DeArray<'i>, span: Option<core::ops::Range<usize>>) -> Self {
         Self { input, span }
     }
 }
@@ -59,7 +59,7 @@ impl<'de> serde::de::IntoDeserializer<'de, Error> for ArrayDeserializer<'de> {
 }
 
 pub(crate) struct ArraySeqAccess<'i> {
-    iter: std::vec::IntoIter<Spanned<DeValue<'i>>>,
+    iter: alloc::vec::IntoIter<Spanned<DeValue<'i>>>,
 }
 
 impl<'i> ArraySeqAccess<'i> {

crates/toml/src/de/datetime.rs

@@ -1,6 +1,7 @@
 use serde::de::value::BorrowedStrDeserializer;
 use serde::de::IntoDeserializer;
 
+use crate::alloc_prelude::*;
 use crate::de::Error;
 
 pub(crate) struct DatetimeDeserializer {

crates/toml/src/de/dearray.rs

@@ -1,5 +1,6 @@
 use serde_spanned::Spanned;
 
+use crate::alloc_prelude::*;
 use crate::de::DeValue;
 
 /// Type representing a TOML array, payload of the `DeValue::Array` variant
@@ -40,7 +41,7 @@ impl DeArray<'_> {
     }
 }
 
-impl<'i> std::ops::Deref for DeArray<'i> {
+impl<'i> core::ops::Deref for DeArray<'i> {
     type Target = [Spanned<DeValue<'i>>];
 
     #[inline]
@@ -49,7 +50,7 @@ impl<'i> std::ops::Deref for DeArray<'i> {
     }
 }
 
-impl<'i> std::ops::DerefMut for DeArray<'i> {
+impl<'i> core::ops::DerefMut for DeArray<'i> {
     #[inline]
     fn deref_mut(&mut self) -> &mut [Spanned<DeValue<'i>>] {
         self.items.as_mut_slice()
@@ -68,19 +69,19 @@ impl<'i> AsMut<[Spanned<DeValue<'i>>]> for DeArray<'i> {
     }
 }
 
-impl<'i> std::borrow::Borrow<[Spanned<DeValue<'i>>]> for DeArray<'i> {
+impl<'i> core::borrow::Borrow<[Spanned<DeValue<'i>>]> for DeArray<'i> {
     fn borrow(&self) -> &[Spanned<DeValue<'i>>] {
         &self.items[..]
     }
 }
 
-impl<'i> std::borrow::BorrowMut<[Spanned<DeValue<'i>>]> for DeArray<'i> {
+impl<'i> core::borrow::BorrowMut<[Spanned<DeValue<'i>>]> for DeArray<'i> {
     fn borrow_mut(&mut self) -> &mut [Spanned<DeValue<'i>>] {
         &mut self.items[..]
     }
 }
 
-impl<'i, I: std::slice::SliceIndex<[Spanned<DeValue<'i>>]>> std::ops::Index<I> for DeArray<'i> {
+impl<'i, I: core::slice::SliceIndex<[Spanned<DeValue<'i>>]>> core::ops::Index<I> for DeArray<'i> {
     type Output = I::Output;
 
     #[inline]
@@ -92,7 +93,7 @@ impl<'i, I: std::slice::SliceIndex<[Spanned<DeValue<'i>>]>> std::ops::Index<I> f
 impl<'a, 'i> IntoIterator for &'a DeArray<'i> {
     type Item = &'a Spanned<DeValue<'i>>;
 
-    type IntoIter = std::slice::Iter<'a, Spanned<DeValue<'i>>>;
+    type IntoIter = core::slice::Iter<'a, Spanned<DeValue<'i>>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
@@ -102,7 +103,7 @@ impl<'a, 'i> IntoIterator for &'a DeArray<'i> {
 impl<'i> IntoIterator for DeArray<'i> {
     type Item = Spanned<DeValue<'i>>;
 
-    type IntoIter = std::vec::IntoIter<Spanned<DeValue<'i>>>;
+    type IntoIter = alloc::vec::IntoIter<Spanned<DeValue<'i>>>;
 
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
@@ -140,9 +141,9 @@ impl PartialEq for DeArray<'_> {
 
 impl Eq for DeArray<'_> {}
 
-impl std::fmt::Debug for DeArray<'_> {
+impl core::fmt::Debug for DeArray<'_> {
     #[inline]
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.items.fmt(formatter)
     }
 }

crates/toml/src/de/detable.rs

@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use alloc::borrow::Cow;
 
 use serde_spanned::Spanned;
 
@@ -29,7 +29,7 @@ impl<'i> DeTable<'i> {
 
     /// Ensure no data is borrowed
     pub fn make_owned(&mut self) {
-        let borrowed = std::mem::take(self);
+        let borrowed = core::mem::take(self);
         let owned = borrowed
             .into_iter()
             .map(|(k, mut v)| {

crates/toml/src/de/devalue.rs

@@ -1,12 +1,13 @@
 //! Definition of a TOML [value][DeValue] for deserialization
 
-use std::borrow::Cow;
-use std::mem::discriminant;
-use std::ops;
+use alloc::borrow::Cow;
+use core::mem::discriminant;
+use core::ops;
 
 use serde_spanned::Spanned;
 use toml_datetime::Datetime;
 
+use crate::alloc_prelude::*;
 use crate::de::DeArray;
 use crate::de::DeTable;
 
@@ -49,7 +50,7 @@ impl<'i> DeValue<'i> {
     pub fn make_owned(&mut self) {
         match self {
             DeValue::String(v) => {
-                let owned = std::mem::take(v);
+                let owned = core::mem::take(v);
                 *v = Cow::Owned(owned.into_owned());
             }
             DeValue::Integer(..)