support TOML 1.1

Author: wolfv

integ-tests/tests/parser.rs

@@ -140,10 +140,9 @@ invalid!(eof, "key =");
 mod bad_inline_tables {
     use super::invalid;
 
-    invalid!(trailing_comma, "a = {a=1,}");
+    // TOML 1.1: trailing_comma and newline are now valid, so removed from invalid tests
     invalid!(only_comma, "a = {,}");
     invalid!(duplicate_key, "a = {a=1,a=1}");
-    invalid!(newline, "a = {\n}");
     invalid!(eof, "a = {");
 }
 
@@ -307,3 +306,58 @@ mod require_newlines {
     invalid!(basic2, "0=0r0=0r=false");
     invalid!(basic3, "0=0r0=0r=falsefal=false");
 }
+
+// TOML 1.1 features
+mod toml_1_1 {
+    use super::valid;
+
+    // Inline tables can now have newlines
+    valid!(
+        inline_table_newlines,
+        r#"
+tbl = {
+    key = "value",
+    nested = {
+        inner = 42,
+    },
+}
+"#
+    );
+
+    // Trailing commas in inline tables
+    valid!(inline_table_trailing_comma, "a = {a=1,}");
+
+    // Empty inline table with newlines
+    valid!(inline_table_empty_newlines, "a = {\n}");
+
+    // \e escape sequence (escape character U+001B)
+    valid!(escape_e, r#"csi = "\e[""#);
+
+    // \xHH escape sequence for codepoints < 255
+    valid!(
+        escape_x,
+        r#"
+null = "\x00"
+letter = "\x61"
+"#
+    );
+
+    // Combined escape sequences
+    valid!(
+        escape_combined,
+        r#"test = "\x00\x1b\e\x61\u0041\U00000042""#
+    );
+
+    // Complex inline table with comments
+    valid!(
+        inline_table_with_comments,
+        r#"
+tbl = {
+    # This is a comment
+    key = "value",
+    # Another comment
+    num = 123,
+}
+"#
+    );
+}

toml-span/src/de.rs

@@ -776,24 +776,40 @@ impl<'a> Deserializer<'a> {
     // great to defer parsing everything until later.
     fn inline_table(&mut self) -> Result<(Span, TableValues<'a>), Error> {
         let mut ret = TableValues::default();
-        self.eat_whitespace();
+
+        // TOML 1.1: inline tables can span multiple lines and have trailing commas
+        let intermediate = |me: &mut Deserializer<'_>| -> Result<(), Error> {
+            loop {
+                me.eat_whitespace();
+                if !me.eat(Token::Newline)? && !me.eat_comment()? {
+                    break;
+                }
+            }
+            Ok(())
+        };
+
+        intermediate(self)?;
         if let Some(span) = self.eat_spanned(Token::RightBrace)? {
             return Ok((span, ret));
         }
         loop {
             let key = self.dotted_key()?;
-            self.eat_whitespace();
+            intermediate(self)?;
             self.expect(Token::Equals)?;
-            self.eat_whitespace();
+            intermediate(self)?;
             let value = self.value()?;
             self.add_dotted_key(key, value, &mut ret)?;
 
-            self.eat_whitespace();
+            intermediate(self)?;
             if let Some(span) = self.eat_spanned(Token::RightBrace)? {
                 return Ok((span, ret));
             }
             self.expect(Token::Comma)?;
-            self.eat_whitespace();
+            intermediate(self)?;
+            // TOML 1.1: trailing comma is allowed
+            if let Some(span) = self.eat_spanned(Token::RightBrace)? {
+                return Ok((span, ret));
+            }
         }
     }
 

toml-span/src/tokens.rs

@@ -384,6 +384,7 @@ impl<'a> Tokenizer<'a> {
                     Some((_, 'n')) => val.push('\n'),
                     Some((_, 'r')) => val.push('\r'),
                     Some((_, 't')) => val.push('\t'),
+                    Some((_, 'e')) => val.push('\u{1b}'), // TOML 1.1: escape character
                     Some((i, c @ ('u' | 'U'))) => {
                         let c = if c == 'u' {
                             me.hex::<4>(start, i)
@@ -392,6 +393,10 @@ impl<'a> Tokenizer<'a> {
                         };
                         val.push(c?);
                     }
+                    Some((i, 'x')) => {
+                        // TOML 1.1: \xHH for codepoints < 255
+                        val.push(me.hex::<2>(start, i)?);
+                    }
                     Some((i, c @ (' ' | '\t' | '\n'))) if multi => {
                         if c != '\n' {
                             while let Some((_, ch)) = me.chars.clone().next() {