feat(toml)!: Replace toml_edit with toml_parse

crates/benchmarks/Cargo.toml

@@ -25,6 +25,7 @@ toml_old = { version = "0.5.10", package = "toml" }
 serde_json = "1.0.116"
 lexopt = "0.3.0"
 divan = "0.1.14"
+serde_spanned = { path = "../serde_spanned" }
 
 [[bench]]
 name = "0-cargo"

crates/benchmarks/benches/0-cargo.rs

@@ -97,6 +97,21 @@ mod toml_edit {
 mod toml {
     use toml_benchmarks::{manifest, Data, MANIFESTS};
 
+    #[divan::bench(args=MANIFESTS)]
+    fn detable(sample: &Data<'static>) -> serde_spanned::Spanned<::toml::de::DeTable<'static>> {
+        let table = toml::de::DeTable::parse(sample.content()).unwrap();
+        table
+    }
+
+    #[divan::bench(args=MANIFESTS)]
+    fn detable_owned(
+        sample: &Data<'static>,
+    ) -> serde_spanned::Spanned<::toml::de::DeTable<'static>> {
+        let mut table = toml::de::DeTable::parse(sample.content()).unwrap();
+        table.get_mut().make_owned();
+        table
+    }
+
     #[divan::bench(args=MANIFESTS)]
     fn document(sample: &Data<'static>) -> ::toml::Table {
         sample.content().parse().unwrap()

crates/benchmarks/benches/1-map.rs

@@ -117,6 +117,26 @@ mod toml {
     use crate::gen;
     use crate::NUM_ENTRIES;
 
+    #[divan::bench(args = NUM_ENTRIES)]
+    fn detable_owned(bencher: divan::Bencher, num_entries: usize) {
+        bencher
+            .with_inputs(|| gen(num_entries))
+            .input_counter(divan::counter::BytesCount::of_str)
+            .bench_values(|sample| {
+                let mut table = toml::de::DeTable::parse(&sample).unwrap();
+                table.get_mut().make_owned();
+                // SAFETY: `make`_owned` removes references to `sample` and lifetimes don't affect
+                // layout
+                let table = unsafe {
+                    std::mem::transmute::<
+                        serde_spanned::Spanned<toml::de::DeTable<'_>>,
+                        serde_spanned::Spanned<toml::de::DeTable<'static>>,
+                    >(table)
+                };
+                table
+            });
+    }
+
     #[divan::bench(args = NUM_ENTRIES)]
     fn document(bencher: divan::Bencher, num_entries: usize) {
         bencher

crates/benchmarks/benches/2-array.rs

@@ -117,6 +117,26 @@ mod toml {
     use crate::gen;
     use crate::NUM_ENTRIES;
 
+    #[divan::bench(args = NUM_ENTRIES)]
+    fn detable_owned(bencher: divan::Bencher, num_entries: usize) {
+        bencher
+            .with_inputs(|| gen(num_entries))
+            .input_counter(divan::counter::BytesCount::of_str)
+            .bench_values(|sample| {
+                let mut table = toml::de::DeTable::parse(&sample).unwrap();
+                table.get_mut().make_owned();
+                // SAFETY: `make`_owned` removes references to `sample` and lifetimes don't affect
+                // layout
+                let table = unsafe {
+                    std::mem::transmute::<
+                        serde_spanned::Spanned<toml::de::DeTable<'_>>,
+                        serde_spanned::Spanned<toml::de::DeTable<'static>>,
+                    >(table)
+                };
+                table
+            });
+    }
+
     #[divan::bench(args = NUM_ENTRIES)]
     fn document(bencher: divan::Bencher, num_entries: usize) {
         bencher

crates/benchmarks/examples/bench.rs

@@ -76,6 +76,13 @@ fn main() -> Result<(), lexopt::Error> {
             #[cfg(debug_assertions)] // Don't interfere with profiling
             println!("{_doc:?}");
         }
+        Parser::DeTable => {
+            let mut _doc = toml::de::DeTable::parse(args.data.content()).unwrap();
+            _doc.get_mut().make_owned();
+            let _doc = std::hint::black_box(_doc);
+            #[cfg(debug_assertions)] // Don't interfere with profiling
+            println!("{_doc:?}");
+        }
         Parser::Table => {
             let _doc = args.data.content().parse::<toml::Table>().unwrap();
             let _doc = std::hint::black_box(_doc);
@@ -109,6 +116,7 @@ impl Args {
                         Some("decoded") => Parser::Decoded,
                         Some("document") => Parser::Document,
                         Some("de") => Parser::De,
+                        Some("detable") => Parser::DeTable,
                         Some("table") => Parser::Table,
                         _ => {
                             return Err(lexopt::Error::UnexpectedValue {
@@ -145,5 +153,6 @@ enum Parser {
     Decoded,
     Document,
     De,
+    DeTable,
     Table,
 }

crates/toml/Cargo.toml

@@ -29,17 +29,17 @@ pre-release-replacements = [
 
 [features]
 default = ["parse", "display"]
-parse = ["dep:toml_edit", "toml_edit?/parse"]
+parse = ["dep:toml_parse", "dep:winnow"]
 display = ["dep:toml_edit", "toml_edit?/display"]
-unsafe = ["toml_edit?/unsafe"]
-debug = ["toml_edit?/debug"]
+unsafe = ["toml_parse?/unsafe"]
+debug = ["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
 # need to be careful around other recursive operations on the parsed result
 # which may overflow the stack after deserialization has completed, including,
 # but not limited to, Display and Debug and Drop impls.
-unbounded = ["toml_edit?/unbounded"]
+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
@@ -49,6 +49,10 @@ preserve_order = ["indexmap"]
 [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 }
+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"] }

crates/toml/src/de/array.rs

@@ -0,0 +1,90 @@
+use serde_spanned::Spanned;
+
+use crate::de::DeArray;
+use crate::de::DeValue;
+use crate::de::Error;
+
+pub(crate) struct ArrayDeserializer<'i> {
+    input: DeArray<'i>,
+    span: Option<std::ops::Range<usize>>,
+}
+
+impl<'i> ArrayDeserializer<'i> {
+    pub(crate) fn new(input: DeArray<'i>, span: Option<std::ops::Range<usize>>) -> Self {
+        Self { input, span }
+    }
+}
+
+impl<'de> serde::Deserializer<'de> for ArrayDeserializer<'de> {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: serde::de::Visitor<'de>,
+    {
+        visitor.visit_seq(ArraySeqAccess::new(self.input))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Error>
+    where
+        V: serde::de::Visitor<'de>,
+    {
+        if serde_spanned::__unstable::is_spanned(name, fields) {
+            if let Some(span) = self.span.clone() {
+                return visitor.visit_map(super::SpannedDeserializer::new(self, span));
+            }
+        }
+
+        self.deserialize_any(visitor)
+    }
+
+    serde::forward_to_deserialize_any! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+        bytes byte_buf map option unit newtype_struct
+        ignored_any unit_struct tuple_struct tuple enum identifier
+    }
+}
+
+impl<'de> serde::de::IntoDeserializer<'de, Error> for ArrayDeserializer<'de> {
+    type Deserializer = Self;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        self
+    }
+}
+
+pub(crate) struct ArraySeqAccess<'i> {
+    iter: std::vec::IntoIter<Spanned<DeValue<'i>>>,
+}
+
+impl<'i> ArraySeqAccess<'i> {
+    pub(crate) fn new(input: DeArray<'i>) -> Self {
+        Self {
+            iter: input.into_iter(),
+        }
+    }
+}
+
+impl<'de> serde::de::SeqAccess<'de> for ArraySeqAccess<'de> {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+    where
+        T: serde::de::DeserializeSeed<'de>,
+    {
+        match self.iter.next() {
+            Some(v) => {
+                let span = v.span();
+                let v = v.into_inner();
+                seed.deserialize(crate::de::ValueDeserializer::new(v, Some(span)))
+                    .map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+}

crates/toml/src/de/datetime.rs

@@ -0,0 +1,43 @@
+use serde::de::value::BorrowedStrDeserializer;
+use serde::de::IntoDeserializer;
+
+use crate::de::Error;
+
+pub(crate) struct DatetimeDeserializer {
+    date: Option<crate::Datetime>,
+}
+
+impl DatetimeDeserializer {
+    pub(crate) fn new(date: crate::Datetime) -> Self {
+        Self { date: Some(date) }
+    }
+}
+
+impl<'de> serde::de::MapAccess<'de> for DatetimeDeserializer {
+    type Error = Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+    where
+        K: serde::de::DeserializeSeed<'de>,
+    {
+        if self.date.is_some() {
+            seed.deserialize(BorrowedStrDeserializer::new(
+                toml_datetime::__unstable::FIELD,
+            ))
+            .map(Some)
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+    where
+        V: serde::de::DeserializeSeed<'de>,
+    {
+        if let Some(date) = self.date.take() {
+            seed.deserialize(date.to_string().into_deserializer())
+        } else {
+            panic!("next_value_seed called before next_key_seed")
+        }
+    }
+}