toml/
de.rs

1//! Deserializing TOML into Rust structures.
2//!
3//! This module contains all the Serde support for deserializing TOML documents
4//! into Rust structures. Note that some top-level functions here are also
5//! provided at the top of the crate.
6
7use std::borrow::Cow;
8use std::collections::HashMap;
9use std::error;
10use std::f64;
11use std::fmt;
12use std::iter;
13use std::marker::PhantomData;
14use std::mem::discriminant;
15use std::str;
16use std::vec;
17
18use serde::de;
19use serde::de::value::BorrowedStrDeserializer;
20use serde::de::IntoDeserializer;
21
22use crate::datetime;
23use crate::spanned;
24use crate::tokens::{Error as TokenError, Span, Token, Tokenizer};
25
26/// Type Alias for a TOML Table pair
27type TablePair<'a> = ((Span, Cow<'a, str>), Value<'a>);
28
29/// Deserializes a byte slice into a type.
30///
31/// This function will attempt to interpret `bytes` as UTF-8 data and then
32/// deserialize `T` from the TOML document provided.
33pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T, Error>
34where
35    T: de::Deserialize<'de>,
36{
37    match str::from_utf8(bytes) {
38        Ok(s) => from_str(s),
39        Err(e) => Err(Error::custom(None, e.to_string())),
40    }
41}
42
43/// Deserializes a string into a type.
44///
45/// This function will attempt to interpret `s` as a TOML document and
46/// deserialize `T` from the document.
47///
48/// # Examples
49///
50/// ```
51/// use serde_derive::Deserialize;
52///
53/// #[derive(Deserialize)]
54/// struct Config {
55///     title: String,
56///     owner: Owner,
57/// }
58///
59/// #[derive(Deserialize)]
60/// struct Owner {
61///     name: String,
62/// }
63///
64/// fn main() {
65///     let config: Config = toml::from_str(r#"
66///         title = 'TOML Example'
67///
68///         [owner]
69///         name = 'Lisa'
70///     "#).unwrap();
71///
72///     assert_eq!(config.title, "TOML Example");
73///     assert_eq!(config.owner.name, "Lisa");
74/// }
75/// ```
76pub fn from_str<'de, T>(s: &'de str) -> Result<T, Error>
77where
78    T: de::Deserialize<'de>,
79{
80    let mut d = Deserializer::new(s);
81    let ret = T::deserialize(&mut d)?;
82    d.end()?;
83    Ok(ret)
84}
85
86/// Errors that can occur when deserializing a type.
87#[derive(Debug, PartialEq, Eq, Clone)]
88pub struct Error {
89    inner: Box<ErrorInner>,
90}
91
92#[derive(Debug, PartialEq, Eq, Clone)]
93struct ErrorInner {
94    kind: ErrorKind,
95    line: Option<usize>,
96    col: usize,
97    at: Option<usize>,
98    message: String,
99    key: Vec<String>,
100}
101
102/// Errors that can occur when deserializing a type.
103#[derive(Debug, PartialEq, Eq, Clone)]
104enum ErrorKind {
105    /// EOF was reached when looking for a value
106    UnexpectedEof,
107
108    /// An invalid character not allowed in a string was found
109    InvalidCharInString(char),
110
111    /// An invalid character was found as an escape
112    InvalidEscape(char),
113
114    /// An invalid character was found in a hex escape
115    InvalidHexEscape(char),
116
117    /// An invalid escape value was specified in a hex escape in a string.
118    ///
119    /// Valid values are in the plane of unicode codepoints.
120    InvalidEscapeValue(u32),
121
122    /// A newline in a string was encountered when one was not allowed.
123    NewlineInString,
124
125    /// An unexpected character was encountered, typically when looking for a
126    /// value.
127    Unexpected(char),
128
129    /// An unterminated string was found where EOF was found before the ending
130    /// EOF mark.
131    UnterminatedString,
132
133    /// A newline was found in a table key.
134    NewlineInTableKey,
135
136    /// A number failed to parse
137    NumberInvalid,
138
139    /// A date or datetime was invalid
140    DateInvalid,
141
142    /// Wanted one sort of token, but found another.
143    Wanted {
144        /// Expected token type
145        expected: &'static str,
146        /// Actually found token type
147        found: &'static str,
148    },
149
150    /// An array was decoded but the types inside of it were mixed, which is
151    /// disallowed by TOML.
152    MixedArrayType,
153
154    /// A duplicate table definition was found.
155    DuplicateTable(String),
156
157    /// A previously defined table was redefined as an array.
158    RedefineAsArray,
159
160    /// An empty table key was found.
161    EmptyTableKey,
162
163    /// Multiline strings are not allowed for key
164    MultilineStringKey,
165
166    /// A custom error which could be generated when deserializing a particular
167    /// type.
168    Custom,
169
170    /// A tuple with a certain number of elements was expected but something
171    /// else was found.
172    ExpectedTuple(usize),
173
174    /// Expected table keys to be in increasing tuple index order, but something
175    /// else was found.
176    ExpectedTupleIndex {
177        /// Expected index.
178        expected: usize,
179        /// Key that was specified.
180        found: String,
181    },
182
183    /// An empty table was expected but entries were found
184    ExpectedEmptyTable,
185
186    /// Dotted key attempted to extend something that is not a table.
187    DottedKeyInvalidType,
188
189    /// An unexpected key was encountered.
190    ///
191    /// Used when deserializing a struct with a limited set of fields.
192    UnexpectedKeys {
193        /// The unexpected keys.
194        keys: Vec<String>,
195        /// Keys that may be specified.
196        available: &'static [&'static str],
197    },
198
199    #[doc(hidden)]
200    __Nonexhaustive,
201}
202
203/// Deserialization implementation for TOML.
204pub struct Deserializer<'a> {
205    require_newline_after_table: bool,
206    allow_duplciate_after_longer_table: bool,
207    input: &'a str,
208    tokens: Tokenizer<'a>,
209}
210
211impl<'de, 'b> de::Deserializer<'de> for &'b mut Deserializer<'de> {
212    type Error = Error;
213
214    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
215    where
216        V: de::Visitor<'de>,
217    {
218        let mut tables = self.tables()?;
219        let table_indices = build_table_indices(&tables);
220        let table_pindices = build_table_pindices(&tables);
221
222        let res = visitor.visit_map(MapVisitor {
223            values: Vec::new().into_iter().peekable(),
224            next_value: None,
225            depth: 0,
226            cur: 0,
227            cur_parent: 0,
228            max: tables.len(),
229            table_indices: &table_indices,
230            table_pindices: &table_pindices,
231            tables: &mut tables,
232            array: false,
233            de: self,
234        });
235        res.map_err(|mut err| {
236            // Errors originating from this library (toml), have an offset
237            // attached to them already. Other errors, like those originating
238            // from serde (like "missing field") or from a custom deserializer,
239            // do not have offsets on them. Here, we do a best guess at their
240            // location, by attributing them to the "current table" (the last
241            // item in `tables`).
242            err.fix_offset(|| tables.last().map(|table| table.at));
243            err.fix_linecol(|at| self.to_linecol(at));
244            err
245        })
246    }
247
248    // Called when the type to deserialize is an enum, as opposed to a field in the type.
249    fn deserialize_enum<V>(
250        self,
251        _name: &'static str,
252        _variants: &'static [&'static str],
253        visitor: V,
254    ) -> Result<V::Value, Error>
255    where
256        V: de::Visitor<'de>,
257    {
258        let (value, name) = self.string_or_table()?;
259        match value.e {
260            E::String(val) => visitor.visit_enum(val.into_deserializer()),
261            E::InlineTable(values) => {
262                if values.len() != 1 {
263                    Err(Error::from_kind(
264                        Some(value.start),
265                        ErrorKind::Wanted {
266                            expected: "exactly 1 element",
267                            found: if values.is_empty() {
268                                "zero elements"
269                            } else {
270                                "more than 1 element"
271                            },
272                        },
273                    ))
274                } else {
275                    visitor.visit_enum(InlineTableDeserializer {
276                        values: values.into_iter(),
277                        next_value: None,
278                    })
279                }
280            }
281            E::DottedTable(_) => visitor.visit_enum(DottedTableDeserializer {
282                name: name.expect("Expected table header to be passed."),
283                value,
284            }),
285            e => Err(Error::from_kind(
286                Some(value.start),
287                ErrorKind::Wanted {
288                    expected: "string or table",
289                    found: e.type_name(),
290                },
291            )),
292        }
293    }
294
295    fn deserialize_struct<V>(
296        self,
297        name: &'static str,
298        fields: &'static [&'static str],
299        visitor: V,
300    ) -> Result<V::Value, Error>
301    where
302        V: de::Visitor<'de>,
303    {
304        if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
305            let start = 0;
306            let end = self.input.len();
307
308            let res = visitor.visit_map(SpannedDeserializer {
309                phantom_data: PhantomData,
310                start: Some(start),
311                value: Some(self),
312                end: Some(end),
313            });
314            return res;
315        }
316
317        self.deserialize_any(visitor)
318    }
319
320    serde::forward_to_deserialize_any! {
321        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
322        bytes byte_buf map unit newtype_struct
323        ignored_any unit_struct tuple_struct tuple option identifier
324    }
325}
326
327// Builds a datastructure that allows for efficient sublinear lookups.
328// The returned HashMap contains a mapping from table header (like [a.b.c])
329// to list of tables with that precise name. The tables are being identified
330// by their index in the passed slice. We use a list as the implementation
331// uses this data structure for arrays as well as tables,
332// so if any top level [[name]] array contains multiple entries,
333// there are multiple entires in the list.
334// The lookup is performed in the `SeqAccess` implementation of `MapVisitor`.
335// The lists are ordered, which we exploit in the search code by using
336// bisection.
337fn build_table_indices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
338    let mut res = HashMap::new();
339    for (i, table) in tables.iter().enumerate() {
340        let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
341        res.entry(header).or_insert(Vec::new()).push(i);
342    }
343    res
344}
345
346// Builds a datastructure that allows for efficient sublinear lookups.
347// The returned HashMap contains a mapping from table header (like [a.b.c])
348// to list of tables whose name at least starts with the specified
349// name. So searching for [a.b] would give both [a.b.c.d] as well as [a.b.e].
350// The tables are being identified by their index in the passed slice.
351//
352// A list is used for two reasons: First, the implementation also
353// stores arrays in the same data structure and any top level array
354// of size 2 or greater creates multiple entries in the list with the
355// same shared name. Second, there can be multiple tables sharing
356// the same prefix.
357//
358// The lookup is performed in the `MapAccess` implementation of `MapVisitor`.
359// The lists are ordered, which we exploit in the search code by using
360// bisection.
361fn build_table_pindices<'de>(tables: &[Table<'de>]) -> HashMap<Vec<Cow<'de, str>>, Vec<usize>> {
362    let mut res = HashMap::new();
363    for (i, table) in tables.iter().enumerate() {
364        let header = table.header.iter().map(|v| v.1.clone()).collect::<Vec<_>>();
365        for len in 0..=header.len() {
366            res.entry(header[..len].to_owned())
367                .or_insert(Vec::new())
368                .push(i);
369        }
370    }
371    res
372}
373
374fn headers_equal<'a, 'b>(hdr_a: &[(Span, Cow<'a, str>)], hdr_b: &[(Span, Cow<'b, str>)]) -> bool {
375    if hdr_a.len() != hdr_b.len() {
376        return false;
377    }
378    hdr_a.iter().zip(hdr_b.iter()).all(|(h1, h2)| h1.1 == h2.1)
379}
380
381struct Table<'a> {
382    at: usize,
383    header: Vec<(Span, Cow<'a, str>)>,
384    values: Option<Vec<TablePair<'a>>>,
385    array: bool,
386}
387
388struct MapVisitor<'de, 'b> {
389    values: iter::Peekable<vec::IntoIter<TablePair<'de>>>,
390    next_value: Option<TablePair<'de>>,
391    depth: usize,
392    cur: usize,
393    cur_parent: usize,
394    max: usize,
395    table_indices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
396    table_pindices: &'b HashMap<Vec<Cow<'de, str>>, Vec<usize>>,
397    tables: &'b mut [Table<'de>],
398    array: bool,
399    de: &'b mut Deserializer<'de>,
400}
401
402impl<'de, 'b> de::MapAccess<'de> for MapVisitor<'de, 'b> {
403    type Error = Error;
404
405    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
406    where
407        K: de::DeserializeSeed<'de>,
408    {
409        if self.cur_parent == self.max || self.cur == self.max {
410            return Ok(None);
411        }
412
413        loop {
414            assert!(self.next_value.is_none());
415            if let Some((key, value)) = self.values.next() {
416                let ret = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
417                self.next_value = Some((key, value));
418                return Ok(Some(ret));
419            }
420
421            let next_table = {
422                let prefix_stripped = self.tables[self.cur_parent].header[..self.depth]
423                    .iter()
424                    .map(|v| v.1.clone())
425                    .collect::<Vec<_>>();
426                self.table_pindices
427                    .get(&prefix_stripped)
428                    .and_then(|entries| {
429                        let start = entries.binary_search(&self.cur).unwrap_or_else(|v| v);
430                        if start == entries.len() || entries[start] < self.cur {
431                            return None;
432                        }
433                        entries[start..]
434                            .iter()
435                            .filter_map(|i| if *i < self.max { Some(*i) } else { None })
436                            .map(|i| (i, &self.tables[i]))
437                            .find(|(_, table)| table.values.is_some())
438                            .map(|p| p.0)
439                    })
440            };
441
442            let pos = match next_table {
443                Some(pos) => pos,
444                None => return Ok(None),
445            };
446            self.cur = pos;
447
448            // Test to see if we're duplicating our parent's table, and if so
449            // then this is an error in the toml format
450            if self.cur_parent != pos {
451                if headers_equal(
452                    &self.tables[self.cur_parent].header,
453                    &self.tables[pos].header,
454                ) {
455                    let at = self.tables[pos].at;
456                    let name = self.tables[pos]
457                        .header
458                        .iter()
459                        .map(|k| k.1.to_owned())
460                        .collect::<Vec<_>>()
461                        .join(".");
462                    return Err(self.de.error(at, ErrorKind::DuplicateTable(name)));
463                }
464
465                // If we're here we know we should share the same prefix, and if
466                // the longer table was defined first then we want to narrow
467                // down our parent's length if possible to ensure that we catch
468                // duplicate tables defined afterwards.
469                if !self.de.allow_duplciate_after_longer_table {
470                    let parent_len = self.tables[self.cur_parent].header.len();
471                    let cur_len = self.tables[pos].header.len();
472                    if cur_len < parent_len {
473                        self.cur_parent = pos;
474                    }
475                }
476            }
477
478            let table = &mut self.tables[pos];
479
480            // If we're not yet at the appropriate depth for this table then we
481            // just next the next portion of its header and then continue
482            // decoding.
483            if self.depth != table.header.len() {
484                let key = &table.header[self.depth];
485                let key = seed.deserialize(StrDeserializer::spanned(key.clone()))?;
486                return Ok(Some(key));
487            }
488
489            // Rule out cases like:
490            //
491            //      [[foo.bar]]
492            //      [[foo]]
493            if table.array {
494                let kind = ErrorKind::RedefineAsArray;
495                return Err(self.de.error(table.at, kind));
496            }
497
498            self.values = table
499                .values
500                .take()
501                .expect("Unable to read table values")
502                .into_iter()
503                .peekable();
504        }
505    }
506
507    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
508    where
509        V: de::DeserializeSeed<'de>,
510    {
511        if let Some((k, v)) = self.next_value.take() {
512            match seed.deserialize(ValueDeserializer::new(v)) {
513                Ok(v) => return Ok(v),
514                Err(mut e) => {
515                    e.add_key_context(&k.1);
516                    return Err(e);
517                }
518            }
519        }
520
521        let array =
522            self.tables[self.cur].array && self.depth == self.tables[self.cur].header.len() - 1;
523        self.cur += 1;
524        let res = seed.deserialize(MapVisitor {
525            values: Vec::new().into_iter().peekable(),
526            next_value: None,
527            depth: self.depth + if array { 0 } else { 1 },
528            cur_parent: self.cur - 1,
529            cur: 0,
530            max: self.max,
531            array,
532            table_indices: &*self.table_indices,
533            table_pindices: &*self.table_pindices,
534            tables: &mut *self.tables,
535            de: &mut *self.de,
536        });
537        res.map_err(|mut e| {
538            e.add_key_context(&self.tables[self.cur - 1].header[self.depth].1);
539            e
540        })
541    }
542}
543
544impl<'de, 'b> de::SeqAccess<'de> for MapVisitor<'de, 'b> {
545    type Error = Error;
546
547    fn next_element_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
548    where
549        K: de::DeserializeSeed<'de>,
550    {
551        assert!(self.next_value.is_none());
552        assert!(self.values.next().is_none());
553
554        if self.cur_parent == self.max {
555            return Ok(None);
556        }
557
558        let header_stripped = self.tables[self.cur_parent]
559            .header
560            .iter()
561            .map(|v| v.1.clone())
562            .collect::<Vec<_>>();
563        let start_idx = self.cur_parent + 1;
564        let next = self
565            .table_indices
566            .get(&header_stripped)
567            .and_then(|entries| {
568                let start = entries.binary_search(&start_idx).unwrap_or_else(|v| v);
569                if start == entries.len() || entries[start] < start_idx {
570                    return None;
571                }
572                entries[start..]
573                    .iter()
574                    .filter_map(|i| if *i < self.max { Some(*i) } else { None })
575                    .map(|i| (i, &self.tables[i]))
576                    .find(|(_, table)| table.array)
577                    .map(|p| p.0)
578            })
579            .unwrap_or(self.max);
580
581        let ret = seed.deserialize(MapVisitor {
582            values: self.tables[self.cur_parent]
583                .values
584                .take()
585                .expect("Unable to read table values")
586                .into_iter()
587                .peekable(),
588            next_value: None,
589            depth: self.depth + 1,
590            cur_parent: self.cur_parent,
591            max: next,
592            cur: 0,
593            array: false,
594            table_indices: &*self.table_indices,
595            table_pindices: &*self.table_pindices,
596            tables: &mut self.tables,
597            de: &mut self.de,
598        })?;
599        self.cur_parent = next;
600        Ok(Some(ret))
601    }
602}
603
604impl<'de, 'b> de::Deserializer<'de> for MapVisitor<'de, 'b> {
605    type Error = Error;
606
607    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
608    where
609        V: de::Visitor<'de>,
610    {
611        if self.array {
612            visitor.visit_seq(self)
613        } else {
614            visitor.visit_map(self)
615        }
616    }
617
618    // `None` is interpreted as a missing field so be sure to implement `Some`
619    // as a present field.
620    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
621    where
622        V: de::Visitor<'de>,
623    {
624        visitor.visit_some(self)
625    }
626
627    fn deserialize_newtype_struct<V>(
628        self,
629        _name: &'static str,
630        visitor: V,
631    ) -> Result<V::Value, Error>
632    where
633        V: de::Visitor<'de>,
634    {
635        visitor.visit_newtype_struct(self)
636    }
637
638    fn deserialize_struct<V>(
639        mut self,
640        name: &'static str,
641        fields: &'static [&'static str],
642        visitor: V,
643    ) -> Result<V::Value, Error>
644    where
645        V: de::Visitor<'de>,
646    {
647        if name == spanned::NAME
648            && fields == [spanned::START, spanned::END, spanned::VALUE]
649            && !(self.array && !self.values.peek().is_none())
650        {
651            // TODO we can't actually emit spans here for the *entire* table/array
652            // due to the format that toml uses. Setting the start and end to 0 is
653            // *detectable* (and no reasonable span would look like that),
654            // it would be better to expose this in the API via proper
655            // ADTs like Option<T>.
656            let start = 0;
657            let end = 0;
658
659            let res = visitor.visit_map(SpannedDeserializer {
660                phantom_data: PhantomData,
661                start: Some(start),
662                value: Some(self),
663                end: Some(end),
664            });
665            return res;
666        }
667
668        self.deserialize_any(visitor)
669    }
670
671    fn deserialize_enum<V>(
672        self,
673        _name: &'static str,
674        _variants: &'static [&'static str],
675        visitor: V,
676    ) -> Result<V::Value, Error>
677    where
678        V: de::Visitor<'de>,
679    {
680        if self.tables.len() != 1 {
681            return Err(Error::custom(
682                Some(self.cur),
683                "enum table must contain exactly one table".into(),
684            ));
685        }
686        let table = &mut self.tables[0];
687        let values = table.values.take().expect("table has no values?");
688        if table.header.len() == 0 {
689            return Err(self.de.error(self.cur, ErrorKind::EmptyTableKey));
690        }
691        let name = table.header[table.header.len() - 1].1.to_owned();
692        visitor.visit_enum(DottedTableDeserializer {
693            name,
694            value: Value {
695                e: E::DottedTable(values),
696                start: 0,
697                end: 0,
698            },
699        })
700    }
701
702    serde::forward_to_deserialize_any! {
703        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
704        bytes byte_buf map unit identifier
705        ignored_any unit_struct tuple_struct tuple
706    }
707}
708
709struct StrDeserializer<'a> {
710    span: Option<Span>,
711    key: Cow<'a, str>,
712}
713
714impl<'a> StrDeserializer<'a> {
715    fn spanned(inner: (Span, Cow<'a, str>)) -> StrDeserializer<'a> {
716        StrDeserializer {
717            span: Some(inner.0),
718            key: inner.1,
719        }
720    }
721    fn new(key: Cow<'a, str>) -> StrDeserializer<'a> {
722        StrDeserializer { span: None, key }
723    }
724}
725
726impl<'a, 'b> de::IntoDeserializer<'a, Error> for StrDeserializer<'a> {
727    type Deserializer = Self;
728
729    fn into_deserializer(self) -> Self::Deserializer {
730        self
731    }
732}
733
734impl<'de> de::Deserializer<'de> for StrDeserializer<'de> {
735    type Error = Error;
736
737    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
738    where
739        V: de::Visitor<'de>,
740    {
741        match self.key {
742            Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
743            Cow::Owned(s) => visitor.visit_string(s),
744        }
745    }
746
747    fn deserialize_struct<V>(
748        self,
749        name: &'static str,
750        fields: &'static [&'static str],
751        visitor: V,
752    ) -> Result<V::Value, Error>
753    where
754        V: de::Visitor<'de>,
755    {
756        if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
757            if let Some(span) = self.span {
758                return visitor.visit_map(SpannedDeserializer {
759                    phantom_data: PhantomData,
760                    start: Some(span.start),
761                    value: Some(StrDeserializer::new(self.key)),
762                    end: Some(span.end),
763                });
764            }
765        }
766        self.deserialize_any(visitor)
767    }
768
769    serde::forward_to_deserialize_any! {
770        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
771        bytes byte_buf map option unit newtype_struct
772        ignored_any unit_struct tuple_struct tuple enum identifier
773    }
774}
775
776struct ValueDeserializer<'a> {
777    value: Value<'a>,
778    validate_struct_keys: bool,
779}
780
781impl<'a> ValueDeserializer<'a> {
782    fn new(value: Value<'a>) -> ValueDeserializer<'a> {
783        ValueDeserializer {
784            value,
785            validate_struct_keys: false,
786        }
787    }
788
789    fn with_struct_key_validation(mut self) -> Self {
790        self.validate_struct_keys = true;
791        self
792    }
793}
794
795impl<'de> de::Deserializer<'de> for ValueDeserializer<'de> {
796    type Error = Error;
797
798    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
799    where
800        V: de::Visitor<'de>,
801    {
802        let start = self.value.start;
803        let res = match self.value.e {
804            E::Integer(i) => visitor.visit_i64(i),
805            E::Boolean(b) => visitor.visit_bool(b),
806            E::Float(f) => visitor.visit_f64(f),
807            E::String(Cow::Borrowed(s)) => visitor.visit_borrowed_str(s),
808            E::String(Cow::Owned(s)) => visitor.visit_string(s),
809            E::Datetime(s) => visitor.visit_map(DatetimeDeserializer {
810                date: s,
811                visited: false,
812            }),
813            E::Array(values) => {
814                let mut s = de::value::SeqDeserializer::new(values.into_iter());
815                let ret = visitor.visit_seq(&mut s)?;
816                s.end()?;
817                Ok(ret)
818            }
819            E::InlineTable(values) | E::DottedTable(values) => {
820                visitor.visit_map(InlineTableDeserializer {
821                    values: values.into_iter(),
822                    next_value: None,
823                })
824            }
825        };
826        res.map_err(|mut err| {
827            // Attribute the error to whatever value returned the error.
828            err.fix_offset(|| Some(start));
829            err
830        })
831    }
832
833    fn deserialize_struct<V>(
834        self,
835        name: &'static str,
836        fields: &'static [&'static str],
837        visitor: V,
838    ) -> Result<V::Value, Error>
839    where
840        V: de::Visitor<'de>,
841    {
842        if name == datetime::NAME && fields == [datetime::FIELD] {
843            if let E::Datetime(s) = self.value.e {
844                return visitor.visit_map(DatetimeDeserializer {
845                    date: s,
846                    visited: false,
847                });
848            }
849        }
850
851        if self.validate_struct_keys {
852            match self.value.e {
853                E::InlineTable(ref values) | E::DottedTable(ref values) => {
854                    let extra_fields = values
855                        .iter()
856                        .filter_map(|key_value| {
857                            let (ref key, ref _val) = *key_value;
858                            if !fields.contains(&&*(key.1)) {
859                                Some(key.clone())
860                            } else {
861                                None
862                            }
863                        })
864                        .collect::<Vec<_>>();
865
866                    if !extra_fields.is_empty() {
867                        return Err(Error::from_kind(
868                            Some(self.value.start),
869                            ErrorKind::UnexpectedKeys {
870                                keys: extra_fields
871                                    .iter()
872                                    .map(|k| k.1.to_string())
873                                    .collect::<Vec<_>>(),
874                                available: fields,
875                            },
876                        ));
877                    }
878                }
879                _ => {}
880            }
881        }
882
883        if name == spanned::NAME && fields == [spanned::START, spanned::END, spanned::VALUE] {
884            let start = self.value.start;
885            let end = self.value.end;
886
887            return visitor.visit_map(SpannedDeserializer {
888                phantom_data: PhantomData,
889                start: Some(start),
890                value: Some(self.value),
891                end: Some(end),
892            });
893        }
894
895        self.deserialize_any(visitor)
896    }
897
898    // `None` is interpreted as a missing field so be sure to implement `Some`
899    // as a present field.
900    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
901    where
902        V: de::Visitor<'de>,
903    {
904        visitor.visit_some(self)
905    }
906
907    fn deserialize_enum<V>(
908        self,
909        _name: &'static str,
910        _variants: &'static [&'static str],
911        visitor: V,
912    ) -> Result<V::Value, Error>
913    where
914        V: de::Visitor<'de>,
915    {
916        match self.value.e {
917            E::String(val) => visitor.visit_enum(val.into_deserializer()),
918            E::InlineTable(values) => {
919                if values.len() != 1 {
920                    Err(Error::from_kind(
921                        Some(self.value.start),
922                        ErrorKind::Wanted {
923                            expected: "exactly 1 element",
924                            found: if values.is_empty() {
925                                "zero elements"
926                            } else {
927                                "more than 1 element"
928                            },
929                        },
930                    ))
931                } else {
932                    visitor.visit_enum(InlineTableDeserializer {
933                        values: values.into_iter(),
934                        next_value: None,
935                    })
936                }
937            }
938            e => Err(Error::from_kind(
939                Some(self.value.start),
940                ErrorKind::Wanted {
941                    expected: "string or inline table",
942                    found: e.type_name(),
943                },
944            )),
945        }
946    }
947
948    fn deserialize_newtype_struct<V>(
949        self,
950        _name: &'static str,
951        visitor: V,
952    ) -> Result<V::Value, Error>
953    where
954        V: de::Visitor<'de>,
955    {
956        visitor.visit_newtype_struct(self)
957    }
958
959    serde::forward_to_deserialize_any! {
960        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
961        bytes byte_buf map unit identifier
962        ignored_any unit_struct tuple_struct tuple
963    }
964}
965
966impl<'de, 'b> de::IntoDeserializer<'de, Error> for MapVisitor<'de, 'b> {
967    type Deserializer = MapVisitor<'de, 'b>;
968
969    fn into_deserializer(self) -> Self::Deserializer {
970        self
971    }
972}
973
974impl<'de, 'b> de::IntoDeserializer<'de, Error> for &'b mut Deserializer<'de> {
975    type Deserializer = Self;
976
977    fn into_deserializer(self) -> Self::Deserializer {
978        self
979    }
980}
981
982impl<'de> de::IntoDeserializer<'de, Error> for Value<'de> {
983    type Deserializer = ValueDeserializer<'de>;
984
985    fn into_deserializer(self) -> Self::Deserializer {
986        ValueDeserializer::new(self)
987    }
988}
989
990struct SpannedDeserializer<'de, T: de::IntoDeserializer<'de, Error>> {
991    phantom_data: PhantomData<&'de ()>,
992    start: Option<usize>,
993    end: Option<usize>,
994    value: Option<T>,
995}
996
997impl<'de, T> de::MapAccess<'de> for SpannedDeserializer<'de, T>
998where
999    T: de::IntoDeserializer<'de, Error>,
1000{
1001    type Error = Error;
1002
1003    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1004    where
1005        K: de::DeserializeSeed<'de>,
1006    {
1007        if self.start.is_some() {
1008            seed.deserialize(BorrowedStrDeserializer::new(spanned::START))
1009                .map(Some)
1010        } else if self.end.is_some() {
1011            seed.deserialize(BorrowedStrDeserializer::new(spanned::END))
1012                .map(Some)
1013        } else if self.value.is_some() {
1014            seed.deserialize(BorrowedStrDeserializer::new(spanned::VALUE))
1015                .map(Some)
1016        } else {
1017            Ok(None)
1018        }
1019    }
1020
1021    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1022    where
1023        V: de::DeserializeSeed<'de>,
1024    {
1025        if let Some(start) = self.start.take() {
1026            seed.deserialize(start.into_deserializer())
1027        } else if let Some(end) = self.end.take() {
1028            seed.deserialize(end.into_deserializer())
1029        } else if let Some(value) = self.value.take() {
1030            seed.deserialize(value.into_deserializer())
1031        } else {
1032            panic!("next_value_seed called before next_key_seed")
1033        }
1034    }
1035}
1036
1037struct DatetimeDeserializer<'a> {
1038    visited: bool,
1039    date: &'a str,
1040}
1041
1042impl<'de> de::MapAccess<'de> for DatetimeDeserializer<'de> {
1043    type Error = Error;
1044
1045    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1046    where
1047        K: de::DeserializeSeed<'de>,
1048    {
1049        if self.visited {
1050            return Ok(None);
1051        }
1052        self.visited = true;
1053        seed.deserialize(DatetimeFieldDeserializer).map(Some)
1054    }
1055
1056    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1057    where
1058        V: de::DeserializeSeed<'de>,
1059    {
1060        seed.deserialize(StrDeserializer::new(self.date.into()))
1061    }
1062}
1063
1064struct DatetimeFieldDeserializer;
1065
1066impl<'de> de::Deserializer<'de> for DatetimeFieldDeserializer {
1067    type Error = Error;
1068
1069    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1070    where
1071        V: de::Visitor<'de>,
1072    {
1073        visitor.visit_borrowed_str(datetime::FIELD)
1074    }
1075
1076    serde::forward_to_deserialize_any! {
1077        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
1078        bytes byte_buf map struct option unit newtype_struct
1079        ignored_any unit_struct tuple_struct tuple enum identifier
1080    }
1081}
1082
1083struct DottedTableDeserializer<'a> {
1084    name: Cow<'a, str>,
1085    value: Value<'a>,
1086}
1087
1088impl<'de> de::EnumAccess<'de> for DottedTableDeserializer<'de> {
1089    type Error = Error;
1090    type Variant = TableEnumDeserializer<'de>;
1091
1092    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1093    where
1094        V: de::DeserializeSeed<'de>,
1095    {
1096        let (name, value) = (self.name, self.value);
1097        seed.deserialize(StrDeserializer::new(name))
1098            .map(|val| (val, TableEnumDeserializer { value }))
1099    }
1100}
1101
1102struct InlineTableDeserializer<'a> {
1103    values: vec::IntoIter<TablePair<'a>>,
1104    next_value: Option<Value<'a>>,
1105}
1106
1107impl<'de> de::MapAccess<'de> for InlineTableDeserializer<'de> {
1108    type Error = Error;
1109
1110    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
1111    where
1112        K: de::DeserializeSeed<'de>,
1113    {
1114        let (key, value) = match self.values.next() {
1115            Some(pair) => pair,
1116            None => return Ok(None),
1117        };
1118        self.next_value = Some(value);
1119        seed.deserialize(StrDeserializer::spanned(key)).map(Some)
1120    }
1121
1122    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
1123    where
1124        V: de::DeserializeSeed<'de>,
1125    {
1126        let value = self.next_value.take().expect("Unable to read table values");
1127        seed.deserialize(ValueDeserializer::new(value))
1128    }
1129}
1130
1131impl<'de> de::EnumAccess<'de> for InlineTableDeserializer<'de> {
1132    type Error = Error;
1133    type Variant = TableEnumDeserializer<'de>;
1134
1135    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1136    where
1137        V: de::DeserializeSeed<'de>,
1138    {
1139        let (key, value) = match self.values.next() {
1140            Some(pair) => pair,
1141            None => {
1142                return Err(Error::from_kind(
1143                    None, // FIXME: How do we get an offset here?
1144                    ErrorKind::Wanted {
1145                        expected: "table with exactly 1 entry",
1146                        found: "empty table",
1147                    },
1148                ));
1149            }
1150        };
1151
1152        seed.deserialize(StrDeserializer::new(key.1))
1153            .map(|val| (val, TableEnumDeserializer { value }))
1154    }
1155}
1156
1157/// Deserializes table values into enum variants.
1158struct TableEnumDeserializer<'a> {
1159    value: Value<'a>,
1160}
1161
1162impl<'de> de::VariantAccess<'de> for TableEnumDeserializer<'de> {
1163    type Error = Error;
1164
1165    fn unit_variant(self) -> Result<(), Self::Error> {
1166        match self.value.e {
1167            E::InlineTable(values) | E::DottedTable(values) => {
1168                if values.is_empty() {
1169                    Ok(())
1170                } else {
1171                    Err(Error::from_kind(
1172                        Some(self.value.start),
1173                        ErrorKind::ExpectedEmptyTable,
1174                    ))
1175                }
1176            }
1177            e => Err(Error::from_kind(
1178                Some(self.value.start),
1179                ErrorKind::Wanted {
1180                    expected: "table",
1181                    found: e.type_name(),
1182                },
1183            )),
1184        }
1185    }
1186
1187    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
1188    where
1189        T: de::DeserializeSeed<'de>,
1190    {
1191        seed.deserialize(ValueDeserializer::new(self.value))
1192    }
1193
1194    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
1195    where
1196        V: de::Visitor<'de>,
1197    {
1198        match self.value.e {
1199            E::InlineTable(values) | E::DottedTable(values) => {
1200                let tuple_values = values
1201                    .into_iter()
1202                    .enumerate()
1203                    .map(|(index, (key, value))| match key.1.parse::<usize>() {
1204                        Ok(key_index) if key_index == index => Ok(value),
1205                        Ok(_) | Err(_) => Err(Error::from_kind(
1206                            Some(key.0.start),
1207                            ErrorKind::ExpectedTupleIndex {
1208                                expected: index,
1209                                found: key.1.to_string(),
1210                            },
1211                        )),
1212                    })
1213                    // Fold all values into a `Vec`, or return the first error.
1214                    .fold(Ok(Vec::with_capacity(len)), |result, value_result| {
1215                        result.and_then(move |mut tuple_values| match value_result {
1216                            Ok(value) => {
1217                                tuple_values.push(value);
1218                                Ok(tuple_values)
1219                            }
1220                            // `Result<de::Value, Self::Error>` to `Result<Vec<_>, Self::Error>`
1221                            Err(e) => Err(e),
1222                        })
1223                    })?;
1224
1225                if tuple_values.len() == len {
1226                    de::Deserializer::deserialize_seq(
1227                        ValueDeserializer::new(Value {
1228                            e: E::Array(tuple_values),
1229                            start: self.value.start,
1230                            end: self.value.end,
1231                        }),
1232                        visitor,
1233                    )
1234                } else {
1235                    Err(Error::from_kind(
1236                        Some(self.value.start),
1237                        ErrorKind::ExpectedTuple(len),
1238                    ))
1239                }
1240            }
1241            e => Err(Error::from_kind(
1242                Some(self.value.start),
1243                ErrorKind::Wanted {
1244                    expected: "table",
1245                    found: e.type_name(),
1246                },
1247            )),
1248        }
1249    }
1250
1251    fn struct_variant<V>(
1252        self,
1253        fields: &'static [&'static str],
1254        visitor: V,
1255    ) -> Result<V::Value, Self::Error>
1256    where
1257        V: de::Visitor<'de>,
1258    {
1259        de::Deserializer::deserialize_struct(
1260            ValueDeserializer::new(self.value).with_struct_key_validation(),
1261            "", // TODO: this should be the variant name
1262            fields,
1263            visitor,
1264        )
1265    }
1266}
1267
1268impl<'a> Deserializer<'a> {
1269    /// Creates a new deserializer which will be deserializing the string
1270    /// provided.
1271    pub fn new(input: &'a str) -> Deserializer<'a> {
1272        Deserializer {
1273            tokens: Tokenizer::new(input),
1274            input,
1275            require_newline_after_table: true,
1276            allow_duplciate_after_longer_table: false,
1277        }
1278    }
1279
1280    /// The `Deserializer::end` method should be called after a value has been
1281    /// fully deserialized.  This allows the `Deserializer` to validate that the
1282    /// input stream is at the end or that it only has trailing
1283    /// whitespace/comments.
1284    pub fn end(&mut self) -> Result<(), Error> {
1285        Ok(())
1286    }
1287
1288    /// Historical versions of toml-rs accidentally allowed a newline after a
1289    /// table definition, but the TOML spec requires a newline after a table
1290    /// definition header.
1291    ///
1292    /// This option can be set to `false` (the default is `true`) to emulate
1293    /// this behavior for backwards compatibility with older toml-rs versions.
1294    pub fn set_require_newline_after_table(&mut self, require: bool) {
1295        self.require_newline_after_table = require;
1296    }
1297
1298    /// Historical versions of toml-rs accidentally allowed a duplicate table
1299    /// header after a longer table header was previously defined. This is
1300    /// invalid according to the TOML spec, however.
1301    ///
1302    /// This option can be set to `true` (the default is `false`) to emulate
1303    /// this behavior for backwards compatibility with older toml-rs versions.
1304    pub fn set_allow_duplicate_after_longer_table(&mut self, allow: bool) {
1305        self.allow_duplciate_after_longer_table = allow;
1306    }
1307
1308    fn tables(&mut self) -> Result<Vec<Table<'a>>, Error> {
1309        let mut tables = Vec::new();
1310        let mut cur_table = Table {
1311            at: 0,
1312            header: Vec::new(),
1313            values: None,
1314            array: false,
1315        };
1316
1317        while let Some(line) = self.line()? {
1318            match line {
1319                Line::Table {
1320                    at,
1321                    mut header,
1322                    array,
1323                } => {
1324                    if !cur_table.header.is_empty() || cur_table.values.is_some() {
1325                        tables.push(cur_table);
1326                    }
1327                    cur_table = Table {
1328                        at,
1329                        header: Vec::new(),
1330                        values: Some(Vec::new()),
1331                        array,
1332                    };
1333                    loop {
1334                        let part = header.next().map_err(|e| self.token_error(e));
1335                        match part? {
1336                            Some(part) => cur_table.header.push(part),
1337                            None => break,
1338                        }
1339                    }
1340                }
1341                Line::KeyValue(key, value) => {
1342                    if cur_table.values.is_none() {
1343                        cur_table.values = Some(Vec::new());
1344                    }
1345                    self.add_dotted_key(key, value, cur_table.values.as_mut().unwrap())?;
1346                }
1347            }
1348        }
1349        if !cur_table.header.is_empty() || cur_table.values.is_some() {
1350            tables.push(cur_table);
1351        }
1352        Ok(tables)
1353    }
1354
1355    fn line(&mut self) -> Result<Option<Line<'a>>, Error> {
1356        loop {
1357            self.eat_whitespace()?;
1358            if self.eat_comment()? {
1359                continue;
1360            }
1361            if self.eat(Token::Newline)? {
1362                continue;
1363            }
1364            break;
1365        }
1366
1367        match self.peek()? {
1368            Some((_, Token::LeftBracket)) => self.table_header().map(Some),
1369            Some(_) => self.key_value().map(Some),
1370            None => Ok(None),
1371        }
1372    }
1373
1374    fn table_header(&mut self) -> Result<Line<'a>, Error> {
1375        let start = self.tokens.current();
1376        self.expect(Token::LeftBracket)?;
1377        let array = self.eat(Token::LeftBracket)?;
1378        let ret = Header::new(self.tokens.clone(), array, self.require_newline_after_table);
1379        if self.require_newline_after_table {
1380            self.tokens.skip_to_newline();
1381        } else {
1382            loop {
1383                match self.next()? {
1384                    Some((_, Token::RightBracket)) => {
1385                        if array {
1386                            self.eat(Token::RightBracket)?;
1387                        }
1388                        break;
1389                    }
1390                    Some((_, Token::Newline)) | None => break,
1391                    _ => {}
1392                }
1393            }
1394            self.eat_whitespace()?;
1395        }
1396        Ok(Line::Table {
1397            at: start,
1398            header: ret,
1399            array,
1400        })
1401    }
1402
1403    fn key_value(&mut self) -> Result<Line<'a>, Error> {
1404        let key = self.dotted_key()?;
1405        self.eat_whitespace()?;
1406        self.expect(Token::Equals)?;
1407        self.eat_whitespace()?;
1408
1409        let value = self.value()?;
1410        self.eat_whitespace()?;
1411        if !self.eat_comment()? {
1412            self.eat_newline_or_eof()?;
1413        }
1414
1415        Ok(Line::KeyValue(key, value))
1416    }
1417
1418    fn value(&mut self) -> Result<Value<'a>, Error> {
1419        let at = self.tokens.current();
1420        let value = match self.next()? {
1421            Some((Span { start, end }, Token::String { val, .. })) => Value {
1422                e: E::String(val),
1423                start,
1424                end,
1425            },
1426            Some((Span { start, end }, Token::Keylike("true"))) => Value {
1427                e: E::Boolean(true),
1428                start,
1429                end,
1430            },
1431            Some((Span { start, end }, Token::Keylike("false"))) => Value {
1432                e: E::Boolean(false),
1433                start,
1434                end,
1435            },
1436            Some((span, Token::Keylike(key))) => self.number_or_date(span, key)?,
1437            Some((span, Token::Plus)) => self.number_leading_plus(span)?,
1438            Some((Span { start, .. }, Token::LeftBrace)) => {
1439                self.inline_table().map(|(Span { end, .. }, table)| Value {
1440                    e: E::InlineTable(table),
1441                    start,
1442                    end,
1443                })?
1444            }
1445            Some((Span { start, .. }, Token::LeftBracket)) => {
1446                self.array().map(|(Span { end, .. }, array)| Value {
1447                    e: E::Array(array),
1448                    start,
1449                    end,
1450                })?
1451            }
1452            Some(token) => {
1453                return Err(self.error(
1454                    at,
1455                    ErrorKind::Wanted {
1456                        expected: "a value",
1457                        found: token.1.describe(),
1458                    },
1459                ))
1460            }
1461            None => return Err(self.eof()),
1462        };
1463        Ok(value)
1464    }
1465
1466    fn number_or_date(&mut self, span: Span, s: &'a str) -> Result<Value<'a>, Error> {
1467        if s.contains('T')
1468            || s.contains('t')
1469            || (s.len() > 1 && s[1..].contains('-') && !s.contains("e-") && !s.contains("E-"))
1470        {
1471            self.datetime(span, s, false)
1472                .map(|(Span { start, end }, d)| Value {
1473                    e: E::Datetime(d),
1474                    start,
1475                    end,
1476                })
1477        } else if self.eat(Token::Colon)? {
1478            self.datetime(span, s, true)
1479                .map(|(Span { start, end }, d)| Value {
1480                    e: E::Datetime(d),
1481                    start,
1482                    end,
1483                })
1484        } else {
1485            self.number(span, s)
1486        }
1487    }
1488
1489    /// Returns a string or table value type.
1490    ///
1491    /// Used to deserialize enums. Unit enums may be represented as a string or a table, all other
1492    /// structures (tuple, newtype, struct) must be represented as a table.
1493    fn string_or_table(&mut self) -> Result<(Value<'a>, Option<Cow<'a, str>>), Error> {
1494        match self.peek()? {
1495            Some((span, Token::LeftBracket)) => {
1496                let tables = self.tables()?;
1497                if tables.len() != 1 {
1498                    return Err(Error::from_kind(
1499                        Some(span.start),
1500                        ErrorKind::Wanted {
1501                            expected: "exactly 1 table",
1502                            found: if tables.is_empty() {
1503                                "zero tables"
1504                            } else {
1505                                "more than 1 table"
1506                            },
1507                        },
1508                    ));
1509                }
1510
1511                let table = tables
1512                    .into_iter()
1513                    .next()
1514                    .expect("Expected exactly one table");
1515                let header = table
1516                    .header
1517                    .last()
1518                    .expect("Expected at least one header value for table.");
1519
1520                let start = table.at;
1521                let end = table
1522                    .values
1523                    .as_ref()
1524                    .and_then(|values| values.last())
1525                    .map(|&(_, ref val)| val.end)
1526                    .unwrap_or_else(|| header.1.len());
1527                Ok((
1528                    Value {
1529                        e: E::DottedTable(table.values.unwrap_or_else(Vec::new)),
1530                        start,
1531                        end,
1532                    },
1533                    Some(header.1.clone()),
1534                ))
1535            }
1536            Some(_) => self.value().map(|val| (val, None)),
1537            None => Err(self.eof()),
1538        }
1539    }
1540
1541    fn number(&mut self, Span { start, end }: Span, s: &'a str) -> Result<Value<'a>, Error> {
1542        let to_integer = |f| Value {
1543            e: E::Integer(f),
1544            start,
1545            end,
1546        };
1547        if s.starts_with("0x") {
1548            self.integer(&s[2..], 16).map(to_integer)
1549        } else if s.starts_with("0o") {
1550            self.integer(&s[2..], 8).map(to_integer)
1551        } else if s.starts_with("0b") {
1552            self.integer(&s[2..], 2).map(to_integer)
1553        } else if s.contains('e') || s.contains('E') {
1554            self.float(s, None).map(|f| Value {
1555                e: E::Float(f),
1556                start,
1557                end,
1558            })
1559        } else if self.eat(Token::Period)? {
1560            let at = self.tokens.current();
1561            match self.next()? {
1562                Some((Span { start, end }, Token::Keylike(after))) => {
1563                    self.float(s, Some(after)).map(|f| Value {
1564                        e: E::Float(f),
1565                        start,
1566                        end,
1567                    })
1568                }
1569                _ => Err(self.error(at, ErrorKind::NumberInvalid)),
1570            }
1571        } else if s == "inf" {
1572            Ok(Value {
1573                e: E::Float(f64::INFINITY),
1574                start,
1575                end,
1576            })
1577        } else if s == "-inf" {
1578            Ok(Value {
1579                e: E::Float(f64::NEG_INFINITY),
1580                start,
1581                end,
1582            })
1583        } else if s == "nan" {
1584            Ok(Value {
1585                e: E::Float(f64::NAN),
1586                start,
1587                end,
1588            })
1589        } else if s == "-nan" {
1590            Ok(Value {
1591                e: E::Float(-f64::NAN),
1592                start,
1593                end,
1594            })
1595        } else {
1596            self.integer(s, 10).map(to_integer)
1597        }
1598    }
1599
1600    fn number_leading_plus(&mut self, Span { start, .. }: Span) -> Result<Value<'a>, Error> {
1601        let start_token = self.tokens.current();
1602        match self.next()? {
1603            Some((Span { end, .. }, Token::Keylike(s))) => self.number(Span { start, end }, s),
1604            _ => Err(self.error(start_token, ErrorKind::NumberInvalid)),
1605        }
1606    }
1607
1608    fn integer(&self, s: &'a str, radix: u32) -> Result<i64, Error> {
1609        let allow_sign = radix == 10;
1610        let allow_leading_zeros = radix != 10;
1611        let (prefix, suffix) = self.parse_integer(s, allow_sign, allow_leading_zeros, radix)?;
1612        let start = self.tokens.substr_offset(s);
1613        if suffix != "" {
1614            return Err(self.error(start, ErrorKind::NumberInvalid));
1615        }
1616        i64::from_str_radix(&prefix.replace("_", "").trim_start_matches('+'), radix)
1617            .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
1618    }
1619
1620    fn parse_integer(
1621        &self,
1622        s: &'a str,
1623        allow_sign: bool,
1624        allow_leading_zeros: bool,
1625        radix: u32,
1626    ) -> Result<(&'a str, &'a str), Error> {
1627        let start = self.tokens.substr_offset(s);
1628
1629        let mut first = true;
1630        let mut first_zero = false;
1631        let mut underscore = false;
1632        let mut end = s.len();
1633        for (i, c) in s.char_indices() {
1634            let at = i + start;
1635            if i == 0 && (c == '+' || c == '-') && allow_sign {
1636                continue;
1637            }
1638
1639            if c == '0' && first {
1640                first_zero = true;
1641            } else if c.to_digit(radix).is_some() {
1642                if !first && first_zero && !allow_leading_zeros {
1643                    return Err(self.error(at, ErrorKind::NumberInvalid));
1644                }
1645                underscore = false;
1646            } else if c == '_' && first {
1647                return Err(self.error(at, ErrorKind::NumberInvalid));
1648            } else if c == '_' && !underscore {
1649                underscore = true;
1650            } else {
1651                end = i;
1652                break;
1653            }
1654            first = false;
1655        }
1656        if first || underscore {
1657            return Err(self.error(start, ErrorKind::NumberInvalid));
1658        }
1659        Ok((&s[..end], &s[end..]))
1660    }
1661
1662    fn float(&mut self, s: &'a str, after_decimal: Option<&'a str>) -> Result<f64, Error> {
1663        let (integral, mut suffix) = self.parse_integer(s, true, false, 10)?;
1664        let start = self.tokens.substr_offset(integral);
1665
1666        let mut fraction = None;
1667        if let Some(after) = after_decimal {
1668            if suffix != "" {
1669                return Err(self.error(start, ErrorKind::NumberInvalid));
1670            }
1671            let (a, b) = self.parse_integer(after, false, true, 10)?;
1672            fraction = Some(a);
1673            suffix = b;
1674        }
1675
1676        let mut exponent = None;
1677        if suffix.starts_with('e') || suffix.starts_with('E') {
1678            let (a, b) = if suffix.len() == 1 {
1679                self.eat(Token::Plus)?;
1680                match self.next()? {
1681                    Some((_, Token::Keylike(s))) => self.parse_integer(s, false, true, 10)?,
1682                    _ => return Err(self.error(start, ErrorKind::NumberInvalid)),
1683                }
1684            } else {
1685                self.parse_integer(&suffix[1..], true, true, 10)?
1686            };
1687            if b != "" {
1688                return Err(self.error(start, ErrorKind::NumberInvalid));
1689            }
1690            exponent = Some(a);
1691        } else if !suffix.is_empty() {
1692            return Err(self.error(start, ErrorKind::NumberInvalid));
1693        }
1694
1695        let mut number = integral
1696            .trim_start_matches('+')
1697            .chars()
1698            .filter(|c| *c != '_')
1699            .collect::<String>();
1700        if let Some(fraction) = fraction {
1701            number.push_str(".");
1702            number.extend(fraction.chars().filter(|c| *c != '_'));
1703        }
1704        if let Some(exponent) = exponent {
1705            number.push_str("E");
1706            number.extend(exponent.chars().filter(|c| *c != '_'));
1707        }
1708        number
1709            .parse()
1710            .map_err(|_e| self.error(start, ErrorKind::NumberInvalid))
1711            .and_then(|n: f64| {
1712                if n.is_finite() {
1713                    Ok(n)
1714                } else {
1715                    Err(self.error(start, ErrorKind::NumberInvalid))
1716                }
1717            })
1718    }
1719
1720    fn datetime(
1721        &mut self,
1722        mut span: Span,
1723        date: &'a str,
1724        colon_eaten: bool,
1725    ) -> Result<(Span, &'a str), Error> {
1726        let start = self.tokens.substr_offset(date);
1727
1728        // Check for space separated date and time.
1729        let mut lookahead = self.tokens.clone();
1730        if let Ok(Some((_, Token::Whitespace(" ")))) = lookahead.next() {
1731            // Check if hour follows.
1732            if let Ok(Some((_, Token::Keylike(_)))) = lookahead.next() {
1733                self.next()?; // skip space
1734                self.next()?; // skip keylike hour
1735            }
1736        }
1737
1738        if colon_eaten || self.eat(Token::Colon)? {
1739            // minutes
1740            match self.next()? {
1741                Some((_, Token::Keylike(_))) => {}
1742                _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1743            }
1744            // Seconds
1745            self.expect(Token::Colon)?;
1746            match self.next()? {
1747                Some((Span { end, .. }, Token::Keylike(_))) => {
1748                    span.end = end;
1749                }
1750                _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1751            }
1752            // Fractional seconds
1753            if self.eat(Token::Period)? {
1754                match self.next()? {
1755                    Some((Span { end, .. }, Token::Keylike(_))) => {
1756                        span.end = end;
1757                    }
1758                    _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1759                }
1760            }
1761
1762            // offset
1763            if self.eat(Token::Plus)? {
1764                match self.next()? {
1765                    Some((Span { end, .. }, Token::Keylike(_))) => {
1766                        span.end = end;
1767                    }
1768                    _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1769                }
1770            }
1771            if self.eat(Token::Colon)? {
1772                match self.next()? {
1773                    Some((Span { end, .. }, Token::Keylike(_))) => {
1774                        span.end = end;
1775                    }
1776                    _ => return Err(self.error(start, ErrorKind::DateInvalid)),
1777                }
1778            }
1779        }
1780
1781        let end = self.tokens.current();
1782        Ok((span, &self.tokens.input()[start..end]))
1783    }
1784
1785    // TODO(#140): shouldn't buffer up this entire table in memory, it'd be
1786    // great to defer parsing everything until later.
1787    fn inline_table(&mut self) -> Result<(Span, Vec<TablePair<'a>>), Error> {
1788        let mut ret = Vec::new();
1789        self.eat_whitespace()?;
1790        if let Some(span) = self.eat_spanned(Token::RightBrace)? {
1791            return Ok((span, ret));
1792        }
1793        loop {
1794            let key = self.dotted_key()?;
1795            self.eat_whitespace()?;
1796            self.expect(Token::Equals)?;
1797            self.eat_whitespace()?;
1798            let value = self.value()?;
1799            self.add_dotted_key(key, value, &mut ret)?;
1800
1801            self.eat_whitespace()?;
1802            if let Some(span) = self.eat_spanned(Token::RightBrace)? {
1803                return Ok((span, ret));
1804            }
1805            self.expect(Token::Comma)?;
1806            self.eat_whitespace()?;
1807        }
1808    }
1809
1810    // TODO(#140): shouldn't buffer up this entire array in memory, it'd be
1811    // great to defer parsing everything until later.
1812    fn array(&mut self) -> Result<(Span, Vec<Value<'a>>), Error> {
1813        let mut ret = Vec::new();
1814
1815        let intermediate = |me: &mut Deserializer<'_>| {
1816            loop {
1817                me.eat_whitespace()?;
1818                if !me.eat(Token::Newline)? && !me.eat_comment()? {
1819                    break;
1820                }
1821            }
1822            Ok(())
1823        };
1824
1825        loop {
1826            intermediate(self)?;
1827            if let Some(span) = self.eat_spanned(Token::RightBracket)? {
1828                return Ok((span, ret));
1829            }
1830            let at = self.tokens.current();
1831            let value = self.value()?;
1832            if let Some(last) = ret.last() {
1833                if !value.same_type(last) {
1834                    return Err(self.error(at, ErrorKind::MixedArrayType));
1835                }
1836            }
1837            ret.push(value);
1838            intermediate(self)?;
1839            if !self.eat(Token::Comma)? {
1840                break;
1841            }
1842        }
1843        intermediate(self)?;
1844        let span = self.expect_spanned(Token::RightBracket)?;
1845        Ok((span, ret))
1846    }
1847
1848    fn table_key(&mut self) -> Result<(Span, Cow<'a, str>), Error> {
1849        self.tokens.table_key().map_err(|e| self.token_error(e))
1850    }
1851
1852    fn dotted_key(&mut self) -> Result<Vec<(Span, Cow<'a, str>)>, Error> {
1853        let mut result = Vec::new();
1854        result.push(self.table_key()?);
1855        self.eat_whitespace()?;
1856        while self.eat(Token::Period)? {
1857            self.eat_whitespace()?;
1858            result.push(self.table_key()?);
1859            self.eat_whitespace()?;
1860        }
1861        Ok(result)
1862    }
1863
1864    /// Stores a value in the appropriate hierachical structure positioned based on the dotted key.
1865    ///
1866    /// Given the following definition: `multi.part.key = "value"`, `multi` and `part` are
1867    /// intermediate parts which are mapped to the relevant fields in the deserialized type's data
1868    /// hierarchy.
1869    ///
1870    /// # Parameters
1871    ///
1872    /// * `key_parts`: Each segment of the dotted key, e.g. `part.one` maps to
1873    ///                `vec![Cow::Borrowed("part"), Cow::Borrowed("one")].`
1874    /// * `value`: The parsed value.
1875    /// * `values`: The `Vec` to store the value in.
1876    fn add_dotted_key(
1877        &self,
1878        mut key_parts: Vec<(Span, Cow<'a, str>)>,
1879        value: Value<'a>,
1880        values: &mut Vec<TablePair<'a>>,
1881    ) -> Result<(), Error> {
1882        let key = key_parts.remove(0);
1883        if key_parts.is_empty() {
1884            values.push((key, value));
1885            return Ok(());
1886        }
1887        match values.iter_mut().find(|&&mut (ref k, _)| *k.1 == key.1) {
1888            Some(&mut (
1889                _,
1890                Value {
1891                    e: E::DottedTable(ref mut v),
1892                    ..
1893                },
1894            )) => {
1895                return self.add_dotted_key(key_parts, value, v);
1896            }
1897            Some(&mut (_, Value { start, .. })) => {
1898                return Err(self.error(start, ErrorKind::DottedKeyInvalidType));
1899            }
1900            None => {}
1901        }
1902        // The start/end value is somewhat misleading here.
1903        let table_values = Value {
1904            e: E::DottedTable(Vec::new()),
1905            start: value.start,
1906            end: value.end,
1907        };
1908        values.push((key, table_values));
1909        let last_i = values.len() - 1;
1910        if let (
1911            _,
1912            Value {
1913                e: E::DottedTable(ref mut v),
1914                ..
1915            },
1916        ) = values[last_i]
1917        {
1918            self.add_dotted_key(key_parts, value, v)?;
1919        }
1920        Ok(())
1921    }
1922
1923    fn eat_whitespace(&mut self) -> Result<(), Error> {
1924        self.tokens
1925            .eat_whitespace()
1926            .map_err(|e| self.token_error(e))
1927    }
1928
1929    fn eat_comment(&mut self) -> Result<bool, Error> {
1930        self.tokens.eat_comment().map_err(|e| self.token_error(e))
1931    }
1932
1933    fn eat_newline_or_eof(&mut self) -> Result<(), Error> {
1934        self.tokens
1935            .eat_newline_or_eof()
1936            .map_err(|e| self.token_error(e))
1937    }
1938
1939    fn eat(&mut self, expected: Token<'a>) -> Result<bool, Error> {
1940        self.tokens.eat(expected).map_err(|e| self.token_error(e))
1941    }
1942
1943    fn eat_spanned(&mut self, expected: Token<'a>) -> Result<Option<Span>, Error> {
1944        self.tokens
1945            .eat_spanned(expected)
1946            .map_err(|e| self.token_error(e))
1947    }
1948
1949    fn expect(&mut self, expected: Token<'a>) -> Result<(), Error> {
1950        self.tokens
1951            .expect(expected)
1952            .map_err(|e| self.token_error(e))
1953    }
1954
1955    fn expect_spanned(&mut self, expected: Token<'a>) -> Result<Span, Error> {
1956        self.tokens
1957            .expect_spanned(expected)
1958            .map_err(|e| self.token_error(e))
1959    }
1960
1961    fn next(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
1962        self.tokens.next().map_err(|e| self.token_error(e))
1963    }
1964
1965    fn peek(&mut self) -> Result<Option<(Span, Token<'a>)>, Error> {
1966        self.tokens.peek().map_err(|e| self.token_error(e))
1967    }
1968
1969    fn eof(&self) -> Error {
1970        self.error(self.input.len(), ErrorKind::UnexpectedEof)
1971    }
1972
1973    fn token_error(&self, error: TokenError) -> Error {
1974        match error {
1975            TokenError::InvalidCharInString(at, ch) => {
1976                self.error(at, ErrorKind::InvalidCharInString(ch))
1977            }
1978            TokenError::InvalidEscape(at, ch) => self.error(at, ErrorKind::InvalidEscape(ch)),
1979            TokenError::InvalidEscapeValue(at, v) => {
1980                self.error(at, ErrorKind::InvalidEscapeValue(v))
1981            }
1982            TokenError::InvalidHexEscape(at, ch) => self.error(at, ErrorKind::InvalidHexEscape(ch)),
1983            TokenError::NewlineInString(at) => self.error(at, ErrorKind::NewlineInString),
1984            TokenError::Unexpected(at, ch) => self.error(at, ErrorKind::Unexpected(ch)),
1985            TokenError::UnterminatedString(at) => self.error(at, ErrorKind::UnterminatedString),
1986            TokenError::NewlineInTableKey(at) => self.error(at, ErrorKind::NewlineInTableKey),
1987            TokenError::Wanted {
1988                at,
1989                expected,
1990                found,
1991            } => self.error(at, ErrorKind::Wanted { expected, found }),
1992            TokenError::EmptyTableKey(at) => self.error(at, ErrorKind::EmptyTableKey),
1993            TokenError::MultilineStringKey(at) => self.error(at, ErrorKind::MultilineStringKey),
1994        }
1995    }
1996
1997    fn error(&self, at: usize, kind: ErrorKind) -> Error {
1998        let mut err = Error::from_kind(Some(at), kind);
1999        err.fix_linecol(|at| self.to_linecol(at));
2000        err
2001    }
2002
2003    /// Converts a byte offset from an error message to a (line, column) pair
2004    ///
2005    /// All indexes are 0-based.
2006    fn to_linecol(&self, offset: usize) -> (usize, usize) {
2007        let mut cur = 0;
2008        // Use split_terminator instead of lines so that if there is a `\r`,
2009        // it is included in the offset calculation. The `+1` values below
2010        // account for the `\n`.
2011        for (i, line) in self.input.split_terminator('\n').enumerate() {
2012            if cur + line.len() + 1 > offset {
2013                return (i, offset - cur);
2014            }
2015            cur += line.len() + 1;
2016        }
2017        (self.input.lines().count(), 0)
2018    }
2019}
2020
2021impl Error {
2022    /// Produces a (line, column) pair of the position of the error if available
2023    ///
2024    /// All indexes are 0-based.
2025    pub fn line_col(&self) -> Option<(usize, usize)> {
2026        self.inner.line.map(|line| (line, self.inner.col))
2027    }
2028
2029    fn from_kind(at: Option<usize>, kind: ErrorKind) -> Error {
2030        Error {
2031            inner: Box::new(ErrorInner {
2032                kind,
2033                line: None,
2034                col: 0,
2035                at,
2036                message: String::new(),
2037                key: Vec::new(),
2038            }),
2039        }
2040    }
2041
2042    fn custom(at: Option<usize>, s: String) -> Error {
2043        Error {
2044            inner: Box::new(ErrorInner {
2045                kind: ErrorKind::Custom,
2046                line: None,
2047                col: 0,
2048                at,
2049                message: s,
2050                key: Vec::new(),
2051            }),
2052        }
2053    }
2054
2055    pub(crate) fn add_key_context(&mut self, key: &str) {
2056        self.inner.key.insert(0, key.to_string());
2057    }
2058
2059    fn fix_offset<F>(&mut self, f: F)
2060    where
2061        F: FnOnce() -> Option<usize>,
2062    {
2063        // An existing offset is always better positioned than anything we
2064        // might want to add later.
2065        if self.inner.at.is_none() {
2066            self.inner.at = f();
2067        }
2068    }
2069
2070    fn fix_linecol<F>(&mut self, f: F)
2071    where
2072        F: FnOnce(usize) -> (usize, usize),
2073    {
2074        if let Some(at) = self.inner.at {
2075            let (line, col) = f(at);
2076            self.inner.line = Some(line);
2077            self.inner.col = col;
2078        }
2079    }
2080}
2081
2082impl std::convert::From<Error> for std::io::Error {
2083    fn from(e: Error) -> Self {
2084        std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string())
2085    }
2086}
2087
2088impl fmt::Display for Error {
2089    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2090        match self.inner.kind {
2091            ErrorKind::UnexpectedEof => "unexpected eof encountered".fmt(f)?,
2092            ErrorKind::InvalidCharInString(c) => write!(
2093                f,
2094                "invalid character in string: `{}`",
2095                c.escape_default().collect::<String>()
2096            )?,
2097            ErrorKind::InvalidEscape(c) => write!(
2098                f,
2099                "invalid escape character in string: `{}`",
2100                c.escape_default().collect::<String>()
2101            )?,
2102            ErrorKind::InvalidHexEscape(c) => write!(
2103                f,
2104                "invalid hex escape character in string: `{}`",
2105                c.escape_default().collect::<String>()
2106            )?,
2107            ErrorKind::InvalidEscapeValue(c) => write!(f, "invalid escape value: `{}`", c)?,
2108            ErrorKind::NewlineInString => "newline in string found".fmt(f)?,
2109            ErrorKind::Unexpected(ch) => write!(
2110                f,
2111                "unexpected character found: `{}`",
2112                ch.escape_default().collect::<String>()
2113            )?,
2114            ErrorKind::UnterminatedString => "unterminated string".fmt(f)?,
2115            ErrorKind::NewlineInTableKey => "found newline in table key".fmt(f)?,
2116            ErrorKind::Wanted { expected, found } => {
2117                write!(f, "expected {}, found {}", expected, found)?
2118            }
2119            ErrorKind::NumberInvalid => "invalid number".fmt(f)?,
2120            ErrorKind::DateInvalid => "invalid date".fmt(f)?,
2121            ErrorKind::MixedArrayType => "mixed types in an array".fmt(f)?,
2122            ErrorKind::DuplicateTable(ref s) => {
2123                write!(f, "redefinition of table `{}`", s)?;
2124            }
2125            ErrorKind::RedefineAsArray => "table redefined as array".fmt(f)?,
2126            ErrorKind::EmptyTableKey => "empty table key found".fmt(f)?,
2127            ErrorKind::MultilineStringKey => "multiline strings are not allowed for key".fmt(f)?,
2128            ErrorKind::Custom => self.inner.message.fmt(f)?,
2129            ErrorKind::ExpectedTuple(l) => write!(f, "expected table with length {}", l)?,
2130            ErrorKind::ExpectedTupleIndex {
2131                expected,
2132                ref found,
2133            } => write!(f, "expected table key `{}`, but was `{}`", expected, found)?,
2134            ErrorKind::ExpectedEmptyTable => "expected empty table".fmt(f)?,
2135            ErrorKind::DottedKeyInvalidType => {
2136                "dotted key attempted to extend non-table type".fmt(f)?
2137            }
2138            ErrorKind::UnexpectedKeys {
2139                ref keys,
2140                available,
2141            } => write!(
2142                f,
2143                "unexpected keys in table: `{:?}`, available keys: `{:?}`",
2144                keys, available
2145            )?,
2146            ErrorKind::__Nonexhaustive => panic!(),
2147        }
2148
2149        if !self.inner.key.is_empty() {
2150            write!(f, " for key `")?;
2151            for (i, k) in self.inner.key.iter().enumerate() {
2152                if i > 0 {
2153                    write!(f, ".")?;
2154                }
2155                write!(f, "{}", k)?;
2156            }
2157            write!(f, "`")?;
2158        }
2159
2160        if let Some(line) = self.inner.line {
2161            write!(f, " at line {} column {}", line + 1, self.inner.col + 1)?;
2162        }
2163
2164        Ok(())
2165    }
2166}
2167
2168impl error::Error for Error {
2169    fn description(&self) -> &str {
2170        match self.inner.kind {
2171            ErrorKind::UnexpectedEof => "unexpected eof encountered",
2172            ErrorKind::InvalidCharInString(_) => "invalid char in string",
2173            ErrorKind::InvalidEscape(_) => "invalid escape in string",
2174            ErrorKind::InvalidHexEscape(_) => "invalid hex escape in string",
2175            ErrorKind::InvalidEscapeValue(_) => "invalid escape value in string",
2176            ErrorKind::NewlineInString => "newline in string found",
2177            ErrorKind::Unexpected(_) => "unexpected or invalid character",
2178            ErrorKind::UnterminatedString => "unterminated string",
2179            ErrorKind::NewlineInTableKey => "found newline in table key",
2180            ErrorKind::Wanted { .. } => "expected a token but found another",
2181            ErrorKind::NumberInvalid => "invalid number",
2182            ErrorKind::DateInvalid => "invalid date",
2183            ErrorKind::MixedArrayType => "mixed types in an array",
2184            ErrorKind::DuplicateTable(_) => "duplicate table",
2185            ErrorKind::RedefineAsArray => "table redefined as array",
2186            ErrorKind::EmptyTableKey => "empty table key found",
2187            ErrorKind::MultilineStringKey => "invalid multiline string for key",
2188            ErrorKind::Custom => "a custom error",
2189            ErrorKind::ExpectedTuple(_) => "expected table length",
2190            ErrorKind::ExpectedTupleIndex { .. } => "expected table key",
2191            ErrorKind::ExpectedEmptyTable => "expected empty table",
2192            ErrorKind::DottedKeyInvalidType => "dotted key invalid type",
2193            ErrorKind::UnexpectedKeys { .. } => "unexpected keys in table",
2194            ErrorKind::__Nonexhaustive => panic!(),
2195        }
2196    }
2197}
2198
2199impl de::Error for Error {
2200    fn custom<T: fmt::Display>(msg: T) -> Error {
2201        Error::custom(None, msg.to_string())
2202    }
2203}
2204
2205enum Line<'a> {
2206    Table {
2207        at: usize,
2208        header: Header<'a>,
2209        array: bool,
2210    },
2211    KeyValue(Vec<(Span, Cow<'a, str>)>, Value<'a>),
2212}
2213
2214struct Header<'a> {
2215    first: bool,
2216    array: bool,
2217    require_newline_after_table: bool,
2218    tokens: Tokenizer<'a>,
2219}
2220
2221impl<'a> Header<'a> {
2222    fn new(tokens: Tokenizer<'a>, array: bool, require_newline_after_table: bool) -> Header<'a> {
2223        Header {
2224            first: true,
2225            array,
2226            tokens,
2227            require_newline_after_table,
2228        }
2229    }
2230
2231    fn next(&mut self) -> Result<Option<(Span, Cow<'a, str>)>, TokenError> {
2232        self.tokens.eat_whitespace()?;
2233
2234        if self.first || self.tokens.eat(Token::Period)? {
2235            self.first = false;
2236            self.tokens.eat_whitespace()?;
2237            self.tokens.table_key().map(|t| t).map(Some)
2238        } else {
2239            self.tokens.expect(Token::RightBracket)?;
2240            if self.array {
2241                self.tokens.expect(Token::RightBracket)?;
2242            }
2243
2244            self.tokens.eat_whitespace()?;
2245            if self.require_newline_after_table && !self.tokens.eat_comment()? {
2246                self.tokens.eat_newline_or_eof()?;
2247            }
2248            Ok(None)
2249        }
2250    }
2251}
2252
2253#[derive(Debug)]
2254struct Value<'a> {
2255    e: E<'a>,
2256    start: usize,
2257    end: usize,
2258}
2259
2260#[derive(Debug)]
2261enum E<'a> {
2262    Integer(i64),
2263    Float(f64),
2264    Boolean(bool),
2265    String(Cow<'a, str>),
2266    Datetime(&'a str),
2267    Array(Vec<Value<'a>>),
2268    InlineTable(Vec<TablePair<'a>>),
2269    DottedTable(Vec<TablePair<'a>>),
2270}
2271
2272impl<'a> E<'a> {
2273    fn type_name(&self) -> &'static str {
2274        match *self {
2275            E::String(..) => "string",
2276            E::Integer(..) => "integer",
2277            E::Float(..) => "float",
2278            E::Boolean(..) => "boolean",
2279            E::Datetime(..) => "datetime",
2280            E::Array(..) => "array",
2281            E::InlineTable(..) => "inline table",
2282            E::DottedTable(..) => "dotted table",
2283        }
2284    }
2285}
2286
2287impl<'a> Value<'a> {
2288    fn same_type(&self, other: &Value<'a>) -> bool {
2289        discriminant(&self.e) == discriminant(&other.e)
2290    }
2291}