crates/json-pawarser/src/syntax_kind.rs

@@ -62,15 +62,13 @@ pub enum SyntaxKind {
     PARSE_ERR,
 
     // Meta SyntaxKinds
-    ROOT,
     EOF,
 }
 
 impl pawarser::parser::SyntaxElement for SyntaxKind {
-    const SYNTAX_EOF: Self = Self::EOF;
+    const EOF: Self = Self::EOF;
 
-    const SYNTAX_ERROR: Self = Self::PARSE_ERR;
-    const SYNTAX_ROOT: Self = Self::ROOT;
+    const ERROR: Self = Self::PARSE_ERR;
 }
 
 impl From<SyntaxKind> for rowan::SyntaxKind {

crates/pawarser/src/parser.rs

@@ -26,10 +26,9 @@ where
         + Eq,
 {
     /// EOF value. This will be used by the rest of the parser library to represent an EOF.
-    const SYNTAX_EOF: Self;
+    const EOF: Self;
     /// Error value. This will be used as a placeholder for associated respective errors.
-    const SYNTAX_ERROR: Self;
-    const SYNTAX_ROOT: Self;
+    const ERROR: Self;
 }
 
 pub struct Parser<'src, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError> {
@@ -120,9 +119,6 @@ impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
         let mut errors: Vec<SyntaxErr> = Vec::new();
         raw_toks.reverse();
 
-        // always have an implicit root node to avoid [`GreenNodeBuilder::finish()`] panicking due to multiple root elements.
-        builder.start_node(SyntaxKind::SYNTAX_ROOT.into());
-
         for i in 0..events.len() {
             match mem::replace(&mut events[i], Event::tombstone()) {
                 Event::Start {
@@ -174,7 +170,7 @@ impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
                             NodeKind::Syntax(kind) => builder.start_node(kind.into()),
                             NodeKind::Error(err) => {
                                 errors.push(err);
-                                builder.start_node(SyntaxKind::SYNTAX_ERROR.into())
+                                builder.start_node(SyntaxKind::ERROR.into())
                             }
                             _ => {}
                         }
@@ -188,9 +184,6 @@ impl<'src, 'toks, SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>
             }
         }
 
-        // finish SYNTAX_ROOT
-        builder.finish_node();
-
         ParserOutput {
             green_node: builder.finish(),
             errors,

crates/pawarser/src/parser/input.rs

@@ -34,7 +34,7 @@ impl<'src, SyntaxKind: SyntaxElement> Input<'src, SyntaxKind> {
 
     pub fn kind(&self, idx: usize) -> SyntaxKind {
         let Some(meaningful_idx) = self.meaningful_toks.get(idx) else {
-            return SyntaxKind::SYNTAX_EOF;
+            return SyntaxKind::EOF;
         };
 
         self.raw.get(*meaningful_idx).unwrap().0

crates/pawarser/src/parser/output.rs

@@ -31,40 +31,34 @@ fn debug_print_output<SyntaxKind: SyntaxElement, SyntaxErr: SyntaxError>(
     lvl: i32,
     errs: &mut Vec<&SyntaxErr>,
 ) -> std::fmt::Result {
-    if f.alternate() {
-        for _ in 0..lvl {
-            f.write_str("    ")?;
-        }
+    for _ in 0..lvl {
+        f.write_str("    ")?;
     }
-    let maybe_newline = if f.alternate() { "\n" } else { " " };
 
     match node {
         NodeOrToken::Node(n) => {
             let kind: SyntaxKind = node.kind().into();
-            if kind != SyntaxKind::SYNTAX_ERROR {
-                write!(f, "{:?} {{{maybe_newline}", kind)?;
+            if kind != SyntaxKind::ERROR {
+                writeln!(f, "{:?} {{", kind)?;
             } else {
                 let err = errs
                     .pop()
                     .expect("all error syntax nodes should correspond to an error");
 
-                write!(f, "{:?}: {err:?} {{{maybe_newline}", kind)?;
+                writeln!(f, "{:?}: {err:?} {{", kind)?;
             }
             for c in n.children() {
                 debug_print_output::<SyntaxKind, SyntaxErr>(c, f, lvl + 1, errs)?;
             }
-
-            if f.alternate() {
-                for _ in 0..lvl {
-                    f.write_str("    ")?;
-                }
+            for _ in 0..lvl {
+                f.write_str("    ")?;
             }
-            write!(f, "}}{maybe_newline}")
+            f.write_str("}\n")
         }
         NodeOrToken::Token(t) => {
-            write!(
+            writeln!(
                 f,
-                "{:?} {:?};{maybe_newline}",
+                "{:?} {:?};",
                 Into::<SyntaxKind>::into(t.kind()),
                 t.text()
             )