update parser to handle new slashdash syntax

src/document.rs

@@ -485,7 +485,7 @@ final;";
         );
 
         let foo = doc.get("foo").expect("expected a foo node");
-        assert_eq!(foo.format().map(|f| &f.trailing[..]), Some("\n"));
+        assert_eq!(foo.format().map(|f| &f.terminator[..]), Some("\n"));
         assert_eq!(&foo[2], &"three".into());
         assert_eq!(&foo["bar"], &"baz".into());
         assert_eq!(
@@ -527,6 +527,7 @@ final;";
         // if you're making KdlEntries this way, you need to inject
         // your own whitespace (or format the node)
         node.push(" \"blah\"=0xDEADbeef".parse::<KdlEntry>()?);
+        dbg!(&node);
         doc.nodes_mut().push(node);
 
         assert_eq!(
@@ -714,7 +715,8 @@ this {
 }
 // that's
 nice
-inline { time; to; live "our" "dreams"; "y;all"; }
+inline { time; to; live "our" "dreams"; "y;all" }
+
 "####;
 
         let doc: KdlDocument = input.parse()?;
@@ -724,8 +726,9 @@ inline { time; to; live "our" "dreams"; "y;all"; }
 
         // Now check some more interesting concrete spans
 
-        // The whole document should presumably be "the input" again?
-        check_span(input, doc.span(), &input);
+        // The whole document should be everything from the first node until the
+        // last before_terminator whitespace.
+        check_span(&input[1..(input.len() - 2)], doc.span(), &input);
 
         // This one-liner node should be the whole line without leading whitespace
         let is_node = doc
@@ -772,13 +775,11 @@ inline { time; to; live "our" "dreams"; "y;all"; }
         );
 
         // The child document is a little weird, it's the contents *inside* the braces
-        // with extra newlines on both ends.
+        // without the surrounding whitespace/comments. Just the actual contents.
         check_span(
-            r####"{
-        "it" /*shh*/ "has"="💯" ##"the"##
+            r####""it" /*shh*/ "has"="💯" ##"the"##
         Best🎊est
-        "syntax ever"
-    }"####,
+        "syntax ever""####,
             and_node.children().unwrap().span(),
             &input,
         );
@@ -807,14 +808,14 @@ inline { time; to; live "our" "dreams"; "y;all"; }
         // Make sure inline nodes work ok
         let inline_node = doc.get("inline").unwrap();
         check_span(
-            r#"inline { time; to; live "our" "dreams"; "y;all"; }"#,
+            r#"inline { time; to; live "our" "dreams"; "y;all" }"#,
             inline_node.span(),
             &input,
         );
 
         let inline_children = inline_node.children().unwrap();
         check_span(
-            r#"{ time; to; live "our" "dreams"; "y;all"; }"#,
+            r#"time; to; live "our" "dreams"; "y;all" "#,
             inline_children.span(),
             &input,
         );

src/node.rs

@@ -515,28 +515,30 @@ impl KdlNode {
     pub(crate) fn autoformat_impl(&mut self, indent: usize, no_comments: bool) {
         if let Some(KdlNodeFormat {
             leading,
+            before_terminator,
+            terminator,
             trailing,
             before_children,
             ..
         }) = self.format_mut()
         {
             crate::fmt::autoformat_leading(leading, indent, no_comments);
+            crate::fmt::autoformat_trailing(before_terminator, no_comments);
             crate::fmt::autoformat_trailing(trailing, no_comments);
             *trailing = trailing.trim().into();
-            if trailing.starts_with(';') {
-                trailing.remove(0);
+            if !terminator.starts_with('\n') {
+                *terminator = "\n".into();
             }
             if let Some(c) = trailing.chars().next() {
                 if !c.is_whitespace() {
                     trailing.insert(0, ' ');
                 }
             }
-            trailing.push('\n');
 
             *before_children = " ".into();
         } else {
             self.set_format(KdlNodeFormat {
-                trailing: "\n".into(),
+                terminator: "\n".into(),
                 ..Default::default()
             })
         }
@@ -598,8 +600,14 @@ impl KdlNode {
             }
             write!(f, "}}")?;
         }
-        if let Some(KdlNodeFormat { trailing, .. }) = self.format() {
-            write!(f, "{}", trailing)?;
+        if let Some(KdlNodeFormat {
+            before_terminator,
+            terminator,
+            trailing,
+            ..
+        }) = self.format()
+        {
+            write!(f, "{before_terminator}{terminator}{trailing}")?;
         }
         Ok(())
     }
@@ -618,8 +626,11 @@ pub struct KdlNodeFormat {
     pub after_ty: String,
     /// Whitespace and comments preceding the node's children block.
     pub before_children: String,
-    /// Whitespace and comments following the node itself, including the
-    /// optional semicolon.
+    /// Whitespace and comments right before the node's terminator.
+    pub before_terminator: String,
+    /// The terminator for the node.
+    pub terminator: String,
+    /// Whitespace and comments following the node itself, after the terminator.
     pub trailing: String,
 }
 
@@ -652,7 +663,9 @@ mod test {
             node.format(),
             Some(&KdlNodeFormat {
                 leading: "\n\t  ".into(),
-                trailing: ";\n".into(),
+                before_terminator: "".into(),
+                terminator: ";".into(),
+                trailing: "\n".into(),
                 before_ty_name: "".into(),
                 after_ty_name: "".into(),
                 after_ty: "".into(),