Rename two syntax types

1 files changed, 219 insertions, 218 deletions

diff --git a/src/syntax/parsing.rs b/src/syntax/parsing.rs
index acf76b7e..9529d1d1 100644
--- a/src/syntax/parsing.rs
+++ b/src/syntax/parsing.rs
@@ -2,7 +2,7 @@ use std::collections::HashSet;
 
 use super::ast::{Assoc, BinOp, UnOp};
 use super::{
-    ErrorPos, Group, Marker, NodeKind, ParseError, ParseResult, Parser, SyntaxNode,
+    ErrorPos, Group, Marker, ParseError, ParseResult, Parser, SyntaxKind, SyntaxNode,
     TokenMode,
 };
 use crate::util::EcoString;
@@ -17,7 +17,7 @@ pub fn parse(text: &str) -> SyntaxNode {
 /// Parse code directly, only used for syntax highlighting.
 pub fn parse_code(text: &str) -> SyntaxNode {
     let mut p = Parser::new(text, TokenMode::Code);
-    p.perform(NodeKind::CodeBlock, code);
+    p.perform(SyntaxKind::CodeBlock, code);
     p.finish().into_iter().next().unwrap()
 }
 
@@ -30,7 +30,7 @@ pub(crate) fn reparse_code_block(
     end_pos: usize,
 ) -> Option<(Vec<SyntaxNode>, bool, usize)> {
     let mut p = Parser::with_prefix(prefix, text, TokenMode::Code);
-    if !p.at(NodeKind::LeftBrace) {
+    if !p.at(SyntaxKind::LeftBrace) {
         return None;
     }
 
@@ -54,7 +54,7 @@ pub(crate) fn reparse_content_block(
     end_pos: usize,
 ) -> Option<(Vec<SyntaxNode>, bool, usize)> {
     let mut p = Parser::with_prefix(prefix, text, TokenMode::Code);
-    if !p.at(NodeKind::LeftBracket) {
+    if !p.at(SyntaxKind::LeftBracket) {
         return None;
     }
 
@@ -90,7 +90,7 @@ pub(crate) fn reparse_markup_elements(
     let mut stopped = false;
 
     'outer: while !p.eof() {
-        if let Some(NodeKind::Space { newlines: (1..) }) = p.peek() {
+        if let Some(SyntaxKind::Space { newlines: (1..) }) = p.peek() {
             if p.column(p.current_end()) < min_indent {
                 return None;
             }
@@ -147,7 +147,7 @@ pub(crate) fn reparse_markup_elements(
 /// If `at_start` is true, things like headings that may only appear at the
 /// beginning of a line or content block are initially allowed.
 fn markup(p: &mut Parser, mut at_start: bool) {
-    p.perform(NodeKind::Markup { min_indent: 0 }, |p| {
+    p.perform(SyntaxKind::Markup { min_indent: 0 }, |p| {
         while !p.eof() {
             markup_node(p, &mut at_start);
         }
@@ -157,8 +157,8 @@ fn markup(p: &mut Parser, mut at_start: bool) {
 /// Parse markup that stays right of the given `column`.
 fn markup_indented(p: &mut Parser, min_indent: usize) {
     p.eat_while(|t| match t {
-        NodeKind::Space { newlines } => *newlines == 0,
-        NodeKind::LineComment | NodeKind::BlockComment => true,
+        SyntaxKind::Space { newlines } => *newlines == 0,
+        SyntaxKind::LineComment | SyntaxKind::BlockComment => true,
         _ => false,
     });
 
@@ -167,7 +167,7 @@ fn markup_indented(p: &mut Parser, min_indent: usize) {
 
     while !p.eof() {
         match p.peek() {
-            Some(NodeKind::Space { newlines: (1..) })
+            Some(SyntaxKind::Space { newlines: (1..) })
                 if p.column(p.current_end()) < min_indent =>
             {
                 break;
@@ -178,24 +178,24 @@ fn markup_indented(p: &mut Parser, min_indent: usize) {
         markup_node(p, &mut at_start);
     }
 
-    marker.end(p, NodeKind::Markup { min_indent });
+    marker.end(p, SyntaxKind::Markup { min_indent });
 }
 
 /// Parse a line of markup that can prematurely end if `f` returns true.
 fn markup_line<F>(p: &mut Parser, mut f: F)
 where
-    F: FnMut(&NodeKind) -> bool,
+    F: FnMut(&SyntaxKind) -> bool,
 {
     p.eat_while(|t| match t {
-        NodeKind::Space { newlines } => *newlines == 0,
-        NodeKind::LineComment | NodeKind::BlockComment => true,
+        SyntaxKind::Space { newlines } => *newlines == 0,
+        SyntaxKind::LineComment | SyntaxKind::BlockComment => true,
         _ => false,
     });
 
-    p.perform(NodeKind::Markup { min_indent: usize::MAX }, |p| {
+    p.perform(SyntaxKind::Markup { min_indent: usize::MAX }, |p| {
         let mut at_start = false;
         while let Some(kind) = p.peek() {
-            if let NodeKind::Space { newlines: (1..) } = kind {
+            if let SyntaxKind::Space { newlines: (1..) } = kind {
                 break;
             }
 
@@ -212,68 +212,68 @@ fn markup_node(p: &mut Parser, at_start: &mut bool) {
     let Some(token) = p.peek() else { return };
     match token {
         // Whitespace.
-        NodeKind::Space { newlines } => {
+        SyntaxKind::Space { newlines } => {
             *at_start |= *newlines > 0;
             p.eat();
             return;
         }
 
         // Comments.
-        NodeKind::LineComment | NodeKind::BlockComment => {
+        SyntaxKind::LineComment | SyntaxKind::BlockComment => {
             p.eat();
             return;
         }
 
         // Text and markup.
-        NodeKind::Text(_)
-        | NodeKind::Linebreak
-        | NodeKind::SmartQuote { .. }
-        | NodeKind::Escape(_)
-        | NodeKind::Shorthand(_)
-        | NodeKind::Link(_)
-        | NodeKind::Raw(_)
-        | NodeKind::Label(_)
-        | NodeKind::Ref(_) => p.eat(),
+        SyntaxKind::Text(_)
+        | SyntaxKind::Linebreak
+        | SyntaxKind::SmartQuote { .. }
+        | SyntaxKind::Escape(_)
+        | SyntaxKind::Shorthand(_)
+        | SyntaxKind::Link(_)
+        | SyntaxKind::Raw(_)
+        | SyntaxKind::Label(_)
+        | SyntaxKind::Ref(_) => p.eat(),
 
         // Math.
-        NodeKind::Dollar => math(p),
+        SyntaxKind::Dollar => math(p),
 
         // Strong, emph, heading.
-        NodeKind::Star => strong(p),
-        NodeKind::Underscore => emph(p),
-        NodeKind::Eq => heading(p, *at_start),
+        SyntaxKind::Star => strong(p),
+        SyntaxKind::Underscore => emph(p),
+        SyntaxKind::Eq => heading(p, *at_start),
 
         // Lists.
-        NodeKind::Minus => list_item(p, *at_start),
-        NodeKind::Plus | NodeKind::EnumNumbering(_) => enum_item(p, *at_start),
-        NodeKind::Slash => {
+        SyntaxKind::Minus => list_item(p, *at_start),
+        SyntaxKind::Plus | SyntaxKind::EnumNumbering(_) => enum_item(p, *at_start),
+        SyntaxKind::Slash => {
             desc_item(p, *at_start).ok();
         }
-        NodeKind::Colon => {
+        SyntaxKind::Colon => {
             let marker = p.marker();
             p.eat();
-            marker.convert(p, NodeKind::Text(':'.into()));
+            marker.convert(p, SyntaxKind::Text(':'.into()));
         }
 
         // Hashtag + keyword / identifier.
-        NodeKind::Ident(_)
-        | NodeKind::Let
-        | NodeKind::Set
-        | NodeKind::Show
-        | NodeKind::If
-        | NodeKind::While
-        | NodeKind::For
-        | NodeKind::Import
-        | NodeKind::Include
-        | NodeKind::Break
-        | NodeKind::Continue
-        | NodeKind::Return => markup_expr(p),
+        SyntaxKind::Ident(_)
+        | SyntaxKind::Let
+        | SyntaxKind::Set
+        | SyntaxKind::Show
+        | SyntaxKind::If
+        | SyntaxKind::While
+        | SyntaxKind::For
+        | SyntaxKind::Import
+        | SyntaxKind::Include
+        | SyntaxKind::Break
+        | SyntaxKind::Continue
+        | SyntaxKind::Return => markup_expr(p),
 
         // Code and content block.
-        NodeKind::LeftBrace => code_block(p),
-        NodeKind::LeftBracket => content_block(p),
+        SyntaxKind::LeftBrace => code_block(p),
+        SyntaxKind::LeftBracket => content_block(p),
 
-        NodeKind::Error(_, _) => p.eat(),
+        SyntaxKind::Error(_, _) => p.eat(),
         _ => p.unexpected(),
     };
 
@@ -281,7 +281,7 @@ fn markup_node(p: &mut Parser, at_start: &mut bool) {
 }
 
 fn strong(p: &mut Parser) {
-    p.perform(NodeKind::Strong, |p| {
+    p.perform(SyntaxKind::Strong, |p| {
         p.start_group(Group::Strong);
         markup(p, false);
         p.end_group();
@@ -289,7 +289,7 @@ fn strong(p: &mut Parser) {
 }
 
 fn emph(p: &mut Parser) {
-    p.perform(NodeKind::Emph, |p| {
+    p.perform(SyntaxKind::Emph, |p| {
         p.start_group(Group::Emph);
         markup(p, false);
         p.end_group();
@@ -299,30 +299,30 @@ fn emph(p: &mut Parser) {
 fn heading(p: &mut Parser, at_start: bool) {
     let marker = p.marker();
     let current_start = p.current_start();
-    p.assert(NodeKind::Eq);
-    while p.eat_if(NodeKind::Eq) {}
+    p.assert(SyntaxKind::Eq);
+    while p.eat_if(SyntaxKind::Eq) {}
 
     if at_start && p.peek().map_or(true, |kind| kind.is_space()) {
-        p.eat_while(|kind| *kind == NodeKind::Space { newlines: 0 });
-        markup_line(p, |kind| matches!(kind, NodeKind::Label(_)));
-        marker.end(p, NodeKind::Heading);
+        p.eat_while(|kind| *kind == SyntaxKind::Space { newlines: 0 });
+        markup_line(p, |kind| matches!(kind, SyntaxKind::Label(_)));
+        marker.end(p, SyntaxKind::Heading);
     } else {
         let text = p.get(current_start..p.prev_end()).into();
-        marker.convert(p, NodeKind::Text(text));
+        marker.convert(p, SyntaxKind::Text(text));
     }
 }
 
 fn list_item(p: &mut Parser, at_start: bool) {
     let marker = p.marker();
     let text: EcoString = p.peek_src().into();
-    p.assert(NodeKind::Minus);
+    p.assert(SyntaxKind::Minus);
 
     let min_indent = p.column(p.prev_end());
-    if at_start && p.eat_if(NodeKind::Space { newlines: 0 }) && !p.eof() {
+    if at_start && p.eat_if(SyntaxKind::Space { newlines: 0 }) && !p.eof() {
         markup_indented(p, min_indent);
-        marker.end(p, NodeKind::ListItem);
+        marker.end(p, SyntaxKind::ListItem);
     } else {
-        marker.convert(p, NodeKind::Text(text));
+        marker.convert(p, SyntaxKind::Text(text));
     }
 }
 
@@ -332,11 +332,11 @@ fn enum_item(p: &mut Parser, at_start: bool) {
     p.eat();
 
     let min_indent = p.column(p.prev_end());
-    if at_start && p.eat_if(NodeKind::Space { newlines: 0 }) && !p.eof() {
+    if at_start && p.eat_if(SyntaxKind::Space { newlines: 0 }) && !p.eof() {
         markup_indented(p, min_indent);
-        marker.end(p, NodeKind::EnumItem);
+        marker.end(p, SyntaxKind::EnumItem);
     } else {
-        marker.convert(p, NodeKind::Text(text));
+        marker.convert(p, SyntaxKind::Text(text));
     }
 }
 
@@ -346,13 +346,13 @@ fn desc_item(p: &mut Parser, at_start: bool) -> ParseResult {
     p.eat();
 
     let min_indent = p.column(p.prev_end());
-    if at_start && p.eat_if(NodeKind::Space { newlines: 0 }) && !p.eof() {
-        markup_line(p, |node| matches!(node, NodeKind::Colon));
-        p.expect(NodeKind::Colon)?;
+    if at_start && p.eat_if(SyntaxKind::Space { newlines: 0 }) && !p.eof() {
+        markup_line(p, |node| matches!(node, SyntaxKind::Colon));
+        p.expect(SyntaxKind::Colon)?;
         markup_indented(p, min_indent);
-        marker.end(p, NodeKind::DescItem);
+        marker.end(p, SyntaxKind::DescItem);
     } else {
-        marker.convert(p, NodeKind::Text(text));
+        marker.convert(p, SyntaxKind::Text(text));
     }
 
     Ok(())
@@ -363,11 +363,11 @@ fn markup_expr(p: &mut Parser) {
     let stmt = matches!(
         p.peek(),
         Some(
-            NodeKind::Let
-                | NodeKind::Set
-                | NodeKind::Show
-                | NodeKind::Import
-                | NodeKind::Include
+            SyntaxKind::Let
+                | SyntaxKind::Set
+                | SyntaxKind::Show
+                | SyntaxKind::Import
+                | SyntaxKind::Include
         )
     );
 
@@ -380,7 +380,7 @@ fn markup_expr(p: &mut Parser) {
 }
 
 fn math(p: &mut Parser) {
-    p.perform(NodeKind::Math, |p| {
+    p.perform(SyntaxKind::Math, |p| {
         p.start_group(Group::Math);
         while !p.eof() {
             math_node(p);
@@ -393,20 +393,20 @@ fn math_node(p: &mut Parser) {
     math_node_prec(p, 0, None)
 }
 
-fn math_node_prec(p: &mut Parser, min_prec: usize, stop: Option<NodeKind>) {
+fn math_node_prec(p: &mut Parser, min_prec: usize, stop: Option<SyntaxKind>) {
     let marker = p.marker();
     math_primary(p);
 
     loop {
         let (kind, mut prec, assoc, stop) = match p.peek() {
             v if v == stop.as_ref() => break,
-            Some(NodeKind::Underscore) => {
-                (NodeKind::Script, 2, Assoc::Right, Some(NodeKind::Hat))
+            Some(SyntaxKind::Underscore) => {
+                (SyntaxKind::Script, 2, Assoc::Right, Some(SyntaxKind::Hat))
             }
-            Some(NodeKind::Hat) => {
-                (NodeKind::Script, 2, Assoc::Right, Some(NodeKind::Underscore))
+            Some(SyntaxKind::Hat) => {
+                (SyntaxKind::Script, 2, Assoc::Right, Some(SyntaxKind::Underscore))
             }
-            Some(NodeKind::Slash) => (NodeKind::Frac, 1, Assoc::Left, None),
+            Some(SyntaxKind::Slash) => (SyntaxKind::Frac, 1, Assoc::Left, None),
             _ => break,
         };
 
@@ -424,7 +424,7 @@ fn math_node_prec(p: &mut Parser, min_prec: usize, stop: Option<NodeKind>) {
 
         // Allow up to two different scripts. We do not risk encountering the
         // previous script kind again here due to right-associativity.
-        if p.eat_if(NodeKind::Underscore) || p.eat_if(NodeKind::Hat) {
+        if p.eat_if(SyntaxKind::Underscore) || p.eat_if(SyntaxKind::Hat) {
             math_node_prec(p, prec, None);
         }
 
@@ -437,42 +437,42 @@ fn math_primary(p: &mut Parser) {
     let Some(token) = p.peek() else { return };
     match token {
         // Spaces, atoms and expressions.
-        NodeKind::Space { .. }
-        | NodeKind::Linebreak
-        | NodeKind::Escape(_)
-        | NodeKind::Atom(_)
-        | NodeKind::Ident(_) => p.eat(),
+        SyntaxKind::Space { .. }
+        | SyntaxKind::Linebreak
+        | SyntaxKind::Escape(_)
+        | SyntaxKind::Atom(_)
+        | SyntaxKind::Ident(_) => p.eat(),
 
         // Groups.
-        NodeKind::LeftParen => math_group(p, Group::Paren, '(', ')'),
-        NodeKind::LeftBracket => math_group(p, Group::Bracket, '[', ']'),
-        NodeKind::LeftBrace => math_group(p, Group::Brace, '{', '}'),
+        SyntaxKind::LeftParen => math_group(p, Group::Paren, '(', ')'),
+        SyntaxKind::LeftBracket => math_group(p, Group::Bracket, '[', ']'),
+        SyntaxKind::LeftBrace => math_group(p, Group::Brace, '{', '}'),
 
         // Alignment indactor.
-        NodeKind::Amp => math_align(p),
+        SyntaxKind::Amp => math_align(p),
 
         _ => p.unexpected(),
     }
 }
 
 fn math_group(p: &mut Parser, group: Group, l: char, r: char) {
-    p.perform(NodeKind::Math, |p| {
+    p.perform(SyntaxKind::Math, |p| {
         let marker = p.marker();
         p.start_group(group);
-        marker.convert(p, NodeKind::Atom(l.into()));
+        marker.convert(p, SyntaxKind::Atom(l.into()));
         while !p.eof() {
             math_node(p);
         }
         let marker = p.marker();
         p.end_group();
-        marker.convert(p, NodeKind::Atom(r.into()));
+        marker.convert(p, SyntaxKind::Atom(r.into()));
     })
 }
 
 fn math_align(p: &mut Parser) {
-    p.perform(NodeKind::Align, |p| {
-        p.assert(NodeKind::Amp);
-        while p.eat_if(NodeKind::Amp) {}
+    p.perform(SyntaxKind::Align, |p| {
+        p.assert(SyntaxKind::Amp);
+        while p.eat_if(SyntaxKind::Amp) {}
     })
 }
 
@@ -496,15 +496,15 @@ fn expr_prec(p: &mut Parser, atomic: bool, min_prec: usize) -> ParseResult {
             p.eat();
             let prec = op.precedence();
             expr_prec(p, atomic, prec)?;
-            marker.end(p, NodeKind::Unary);
+            marker.end(p, SyntaxKind::Unary);
         }
         _ => primary(p, atomic)?,
     };
 
     loop {
         // Parenthesis or bracket means this is a function call.
-        if let Some(NodeKind::LeftParen | NodeKind::LeftBracket) = p.peek_direct() {
-            marker.perform(p, NodeKind::FuncCall, args)?;
+        if let Some(SyntaxKind::LeftParen | SyntaxKind::LeftBracket) = p.peek_direct() {
+            marker.perform(p, SyntaxKind::FuncCall, args)?;
             continue;
         }
 
@@ -513,18 +513,19 @@ fn expr_prec(p: &mut Parser, atomic: bool, min_prec: usize) -> ParseResult {
         }
 
         // Method call or field access.
-        if p.eat_if(NodeKind::Dot) {
+        if p.eat_if(SyntaxKind::Dot) {
             ident(p)?;
-            if let Some(NodeKind::LeftParen | NodeKind::LeftBracket) = p.peek_direct() {
-                marker.perform(p, NodeKind::MethodCall, args)?;
+            if let Some(SyntaxKind::LeftParen | SyntaxKind::LeftBracket) = p.peek_direct()
+            {
+                marker.perform(p, SyntaxKind::MethodCall, args)?;
             } else {
-                marker.end(p, NodeKind::FieldAccess);
+                marker.end(p, SyntaxKind::FieldAccess);
             }
             continue;
         }
 
-        let op = if p.eat_if(NodeKind::Not) {
-            if p.at(NodeKind::In) {
+        let op = if p.eat_if(SyntaxKind::Not) {
+            if p.at(SyntaxKind::In) {
                 BinOp::NotIn
             } else {
                 p.expected("keyword `in`");
@@ -549,7 +550,7 @@ fn expr_prec(p: &mut Parser, atomic: bool, min_prec: usize) -> ParseResult {
             Assoc::Right => {}
         }
 
-        marker.perform(p, NodeKind::Binary, |p| expr_prec(p, atomic, prec))?;
+        marker.perform(p, SyntaxKind::Binary, |p| expr_prec(p, atomic, prec))?;
     }
 
     Ok(())
@@ -562,39 +563,39 @@ fn primary(p: &mut Parser, atomic: bool) -> ParseResult {
 
     match p.peek() {
         // Things that start with an identifier.
-        Some(NodeKind::Ident(_)) => {
+        Some(SyntaxKind::Ident(_)) => {
             let marker = p.marker();
             p.eat();
 
             // Arrow means this is a closure's lone parameter.
-            if !atomic && p.at(NodeKind::Arrow) {
-                marker.end(p, NodeKind::Params);
-                p.assert(NodeKind::Arrow);
-                marker.perform(p, NodeKind::Closure, expr)
+            if !atomic && p.at(SyntaxKind::Arrow) {
+                marker.end(p, SyntaxKind::Params);
+                p.assert(SyntaxKind::Arrow);
+                marker.perform(p, SyntaxKind::Closure, expr)
             } else {
                 Ok(())
             }
         }
 
         // Structures.
-        Some(NodeKind::LeftParen) => parenthesized(p, atomic),
-        Some(NodeKind::LeftBrace) => Ok(code_block(p)),
-        Some(NodeKind::LeftBracket) => Ok(content_block(p)),
+        Some(SyntaxKind::LeftParen) => parenthesized(p, atomic),
+        Some(SyntaxKind::LeftBrace) => Ok(code_block(p)),
+        Some(SyntaxKind::LeftBracket) => Ok(content_block(p)),
 
         // Keywords.
-        Some(NodeKind::Let) => let_binding(p),
-        Some(NodeKind::Set) => set_rule(p),
-        Some(NodeKind::Show) => show_rule(p),
-        Some(NodeKind::If) => conditional(p),
-        Some(NodeKind::While) => while_loop(p),
-        Some(NodeKind::For) => for_loop(p),
-        Some(NodeKind::Import) => module_import(p),
-        Some(NodeKind::Include) => module_include(p),
-        Some(NodeKind::Break) => break_stmt(p),
-        Some(NodeKind::Continue) => continue_stmt(p),
-        Some(NodeKind::Return) => return_stmt(p),
-
-        Some(NodeKind::Error(_, _)) => {
+        Some(SyntaxKind::Let) => let_binding(p),
+        Some(SyntaxKind::Set) => set_rule(p),
+        Some(SyntaxKind::Show) => show_rule(p),
+        Some(SyntaxKind::If) => conditional(p),
+        Some(SyntaxKind::While) => while_loop(p),
+        Some(SyntaxKind::For) => for_loop(p),
+        Some(SyntaxKind::Import) => module_import(p),
+        Some(SyntaxKind::Include) => module_include(p),
+        Some(SyntaxKind::Break) => break_stmt(p),
+        Some(SyntaxKind::Continue) => continue_stmt(p),
+        Some(SyntaxKind::Return) => return_stmt(p),
+
+        Some(SyntaxKind::Error(_, _)) => {
             p.eat();
             Err(ParseError)
         }
@@ -610,13 +611,13 @@ fn primary(p: &mut Parser, atomic: bool) -> ParseResult {
 fn literal(p: &mut Parser) -> bool {
     match p.peek() {
         Some(
-            NodeKind::None
-            | NodeKind::Auto
-            | NodeKind::Int(_)
-            | NodeKind::Float(_)
-            | NodeKind::Bool(_)
-            | NodeKind::Numeric(_, _)
-            | NodeKind::Str(_),
+            SyntaxKind::None
+            | SyntaxKind::Auto
+            | SyntaxKind::Int(_)
+            | SyntaxKind::Float(_)
+            | SyntaxKind::Bool(_)
+            | SyntaxKind::Numeric(_, _)
+            | SyntaxKind::Str(_),
         ) => {
             p.eat();
             true
@@ -627,7 +628,7 @@ fn literal(p: &mut Parser) -> bool {
 
 fn ident(p: &mut Parser) -> ParseResult {
     match p.peek() {
-        Some(NodeKind::Ident(_)) => {
+        Some(SyntaxKind::Ident(_)) => {
             p.eat();
             Ok(())
         }
@@ -647,7 +648,7 @@ fn parenthesized(p: &mut Parser, atomic: bool) -> ParseResult {
     let marker = p.marker();
 
     p.start_group(Group::Paren);
-    let colon = p.eat_if(NodeKind::Colon);
+    let colon = p.eat_if(SyntaxKind::Colon);
     let kind = collection(p, true).0;
     p.end_group();
 
@@ -658,15 +659,15 @@ fn parenthesized(p: &mut Parser, atomic: bool) -> ParseResult {
     }
 
     // Arrow means this is a closure's parameter list.
-    if !atomic && p.at(NodeKind::Arrow) {
+    if !atomic && p.at(SyntaxKind::Arrow) {
         params(p, marker);
-        p.assert(NodeKind::Arrow);
-        return marker.perform(p, NodeKind::Closure, expr);
+        p.assert(SyntaxKind::Arrow);
+        return marker.perform(p, SyntaxKind::Closure, expr);
     }
 
     // Transform into the identified collection.
     match kind {
-        CollectionKind::Group => marker.end(p, NodeKind::Parenthesized),
+        CollectionKind::Group => marker.end(p, SyntaxKind::Parenthesized),
         CollectionKind::Positional => array(p, marker),
         CollectionKind::Named => dict(p, marker),
     }
@@ -698,14 +699,14 @@ fn collection(p: &mut Parser, keyed: bool) -> (CollectionKind, usize) {
 
     while !p.eof() {
         let Ok(item_kind) = item(p, keyed) else {
-            p.eat_if(NodeKind::Comma);
+            p.eat_if(SyntaxKind::Comma);
             collection_kind = Some(CollectionKind::Group);
             continue;
         };
 
         match item_kind {
-            NodeKind::Spread => can_group = false,
-            NodeKind::Named if collection_kind.is_none() => {
+            SyntaxKind::Spread => can_group = false,
+            SyntaxKind::Named if collection_kind.is_none() => {
                 collection_kind = Some(CollectionKind::Named);
                 can_group = false;
             }
@@ -725,7 +726,7 @@ fn collection(p: &mut Parser, keyed: bool) -> (CollectionKind, usize) {
             break;
         }
 
-        if p.eat_if(NodeKind::Comma) {
+        if p.eat_if(SyntaxKind::Comma) {
             can_group = false;
         } else {
             missing_coma = Some(p.trivia_start());
@@ -741,24 +742,24 @@ fn collection(p: &mut Parser, keyed: bool) -> (CollectionKind, usize) {
     (kind, items)
 }
 
-fn item(p: &mut Parser, keyed: bool) -> ParseResult<NodeKind> {
+fn item(p: &mut Parser, keyed: bool) -> ParseResult<SyntaxKind> {
     let marker = p.marker();
-    if p.eat_if(NodeKind::Dots) {
-        marker.perform(p, NodeKind::Spread, expr)?;
-        return Ok(NodeKind::Spread);
+    if p.eat_if(SyntaxKind::Dots) {
+        marker.perform(p, SyntaxKind::Spread, expr)?;
+        return Ok(SyntaxKind::Spread);
     }
 
     expr(p)?;
 
-    if p.at(NodeKind::Colon) {
+    if p.at(SyntaxKind::Colon) {
         match marker.after(p).map(|c| c.kind()) {
-            Some(NodeKind::Ident(_)) => {
+            Some(SyntaxKind::Ident(_)) => {
                 p.eat();
-                marker.perform(p, NodeKind::Named, expr)?;
+                marker.perform(p, SyntaxKind::Named, expr)?;
             }
-            Some(NodeKind::Str(_)) if keyed => {
+            Some(SyntaxKind::Str(_)) if keyed => {
                 p.eat();
-                marker.perform(p, NodeKind::Keyed, expr)?;
+                marker.perform(p, SyntaxKind::Keyed, expr)?;
             }
             kind => {
                 let mut msg = EcoString::from("expected identifier");
@@ -769,34 +770,34 @@ fn item(p: &mut Parser, keyed: bool) -> ParseResult<NodeKind> {
                     msg.push_str(", found ");
                     msg.push_str(kind.name());
                 }
-                let error = NodeKind::Error(ErrorPos::Full, msg);
+                let error = SyntaxKind::Error(ErrorPos::Full, msg);
                 marker.end(p, error);
                 p.eat();
-                marker.perform(p, NodeKind::Named, expr).ok();
+                marker.perform(p, SyntaxKind::Named, expr).ok();
                 return Err(ParseError);
             }
         }
 
-        Ok(NodeKind::Named)
+        Ok(SyntaxKind::Named)
     } else {
-        Ok(NodeKind::None)
+        Ok(SyntaxKind::None)
     }
 }
 
 fn array(p: &mut Parser, marker: Marker) {
     marker.filter_children(p, |x| match x.kind() {
-        NodeKind::Named | NodeKind::Keyed => Err("expected expression"),
+        SyntaxKind::Named | SyntaxKind::Keyed => Err("expected expression"),
         _ => Ok(()),
     });
-    marker.end(p, NodeKind::Array);
+    marker.end(p, SyntaxKind::Array);
 }
 
 fn dict(p: &mut Parser, marker: Marker) {
     let mut used = HashSet::new();
     marker.filter_children(p, |x| match x.kind() {
         kind if kind.is_paren() => Ok(()),
-        NodeKind::Named | NodeKind::Keyed => {
-            if let Some(NodeKind::Ident(key) | NodeKind::Str(key)) =
+        SyntaxKind::Named | SyntaxKind::Keyed => {
+            if let Some(SyntaxKind::Ident(key) | SyntaxKind::Str(key)) =
                 x.children().next().map(|child| child.kind())
             {
                 if !used.insert(key.clone()) {
@@ -805,32 +806,32 @@ fn dict(p: &mut Parser, marker: Marker) {
             }
             Ok(())
         }
-        NodeKind::Spread | NodeKind::Comma | NodeKind::Colon => Ok(()),
+        SyntaxKind::Spread | SyntaxKind::Comma | SyntaxKind::Colon => Ok(()),
         _ => Err("expected named or keyed pair"),
     });
-    marker.end(p, NodeKind::Dict);
+    marker.end(p, SyntaxKind::Dict);
 }
 
 fn params(p: &mut Parser, marker: Marker) {
     marker.filter_children(p, |x| match x.kind() {
         kind if kind.is_paren() => Ok(()),
-        NodeKind::Named | NodeKind::Ident(_) | NodeKind::Comma => Ok(()),
-        NodeKind::Spread
+        SyntaxKind::Named | SyntaxKind::Ident(_) | SyntaxKind::Comma => Ok(()),
+        SyntaxKind::Spread
             if matches!(
                 x.children().last().map(|child| child.kind()),
-                Some(&NodeKind::Ident(_))
+                Some(&SyntaxKind::Ident(_))
             ) =>
         {
             Ok(())
         }
         _ => Err("expected identifier, named pair or argument sink"),
     });
-    marker.end(p, NodeKind::Params);
+    marker.end(p, SyntaxKind::Params);
 }
 
 /// Parse a code block: `{...}`.
 fn code_block(p: &mut Parser) {
-    p.perform(NodeKind::CodeBlock, |p| {
+    p.perform(SyntaxKind::CodeBlock, |p| {
         p.start_group(Group::Brace);
         code(p);
         p.end_group();
@@ -846,12 +847,12 @@ fn code(p: &mut Parser) {
         p.end_group();
 
         // Forcefully skip over newlines since the group's contents can't.
-        p.eat_while(NodeKind::is_space);
+        p.eat_while(SyntaxKind::is_space);
     }
 }
 
 fn content_block(p: &mut Parser) {
-    p.perform(NodeKind::ContentBlock, |p| {
+    p.perform(SyntaxKind::ContentBlock, |p| {
         p.start_group(Group::Bracket);
         markup(p, true);
         p.end_group();
@@ -860,16 +861,16 @@ fn content_block(p: &mut Parser) {
 
 fn args(p: &mut Parser) -> ParseResult {
     match p.peek_direct() {
-        Some(NodeKind::LeftParen) => {}
-        Some(NodeKind::LeftBracket) => {}
+        Some(SyntaxKind::LeftParen) => {}
+        Some(SyntaxKind::LeftBracket) => {}
         _ => {
             p.expected_found("argument list");
             return Err(ParseError);
         }
     }
 
-    p.perform(NodeKind::Args, |p| {
-        if p.at(NodeKind::LeftParen) {
+    p.perform(SyntaxKind::Args, |p| {
+        if p.at(SyntaxKind::LeftParen) {
             let marker = p.marker();
             p.start_group(Group::Paren);
             collection(p, false);
@@ -877,8 +878,8 @@ fn args(p: &mut Parser) -> ParseResult {
 
             let mut used = HashSet::new();
             marker.filter_children(p, |x| match x.kind() {
-                NodeKind::Named => {
-                    if let Some(NodeKind::Ident(ident)) =
+                SyntaxKind::Named => {
+                    if let Some(SyntaxKind::Ident(ident)) =
                         x.children().next().map(|child| child.kind())
                     {
                         if !used.insert(ident.clone()) {
@@ -891,7 +892,7 @@ fn args(p: &mut Parser) -> ParseResult {
             });
         }
 
-        while p.peek_direct() == Some(&NodeKind::LeftBracket) {
+        while p.peek_direct() == Some(&SyntaxKind::LeftBracket) {
             content_block(p);
         }
     });
@@ -900,14 +901,14 @@ fn args(p: &mut Parser) -> ParseResult {
 }
 
 fn let_binding(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::LetBinding, |p| {
-        p.assert(NodeKind::Let);
+    p.perform(SyntaxKind::LetBinding, |p| {
+        p.assert(SyntaxKind::Let);
 
         let marker = p.marker();
         ident(p)?;
 
         // If a parenthesis follows, this is a function definition.
-        let has_params = p.peek_direct() == Some(&NodeKind::LeftParen);
+        let has_params = p.peek_direct() == Some(&SyntaxKind::LeftParen);
         if has_params {
             let marker = p.marker();
             p.start_group(Group::Paren);
@@ -916,7 +917,7 @@ fn let_binding(p: &mut Parser) -> ParseResult {
             params(p, marker);
         }
 
-        if p.eat_if(NodeKind::Eq) {
+        if p.eat_if(SyntaxKind::Eq) {
             expr(p)?;
         } else if has_params {
             // Function definitions must have a body.
@@ -925,7 +926,7 @@ fn let_binding(p: &mut Parser) -> ParseResult {
 
         // Rewrite into a closure expression if it's a function definition.
         if has_params {
-            marker.end(p, NodeKind::Closure);
+            marker.end(p, SyntaxKind::Closure);
         }
 
         Ok(())
@@ -933,11 +934,11 @@ fn let_binding(p: &mut Parser) -> ParseResult {
 }
 
 fn set_rule(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::SetRule, |p| {
-        p.assert(NodeKind::Set);
+    p.perform(SyntaxKind::SetRule, |p| {
+        p.assert(SyntaxKind::Set);
         ident(p)?;
         args(p)?;
-        if p.eat_if(NodeKind::If) {
+        if p.eat_if(SyntaxKind::If) {
             expr(p)?;
         }
         Ok(())
@@ -945,10 +946,10 @@ fn set_rule(p: &mut Parser) -> ParseResult {
 }
 
 fn show_rule(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::ShowRule, |p| {
-        p.assert(NodeKind::Show);
+    p.perform(SyntaxKind::ShowRule, |p| {
+        p.assert(SyntaxKind::Show);
         expr(p)?;
-        if p.eat_if(NodeKind::Colon) {
+        if p.eat_if(SyntaxKind::Colon) {
             expr(p)?;
         }
         Ok(())
@@ -956,14 +957,14 @@ fn show_rule(p: &mut Parser) -> ParseResult {
 }
 
 fn conditional(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::Conditional, |p| {
-        p.assert(NodeKind::If);
+    p.perform(SyntaxKind::Conditional, |p| {
+        p.assert(SyntaxKind::If);
 
         expr(p)?;
         body(p)?;
 
-        if p.eat_if(NodeKind::Else) {
-            if p.at(NodeKind::If) {
+        if p.eat_if(SyntaxKind::Else) {
+            if p.at(SyntaxKind::If) {
                 conditional(p)?;
             } else {
                 body(p)?;
@@ -975,27 +976,27 @@ fn conditional(p: &mut Parser) -> ParseResult {
 }
 
 fn while_loop(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::WhileLoop, |p| {
-        p.assert(NodeKind::While);
+    p.perform(SyntaxKind::WhileLoop, |p| {
+        p.assert(SyntaxKind::While);
         expr(p)?;
         body(p)
     })
 }
 
 fn for_loop(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::ForLoop, |p| {
-        p.assert(NodeKind::For);
+    p.perform(SyntaxKind::ForLoop, |p| {
+        p.assert(SyntaxKind::For);
         for_pattern(p)?;
-        p.expect(NodeKind::In)?;
+        p.expect(SyntaxKind::In)?;
         expr(p)?;
         body(p)
     })
 }
 
 fn for_pattern(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::ForPattern, |p| {
+    p.perform(SyntaxKind::ForPattern, |p| {
         ident(p)?;
-        if p.eat_if(NodeKind::Comma) {
+        if p.eat_if(SyntaxKind::Comma) {
             ident(p)?;
         }
         Ok(())
@@ -1003,12 +1004,12 @@ fn for_pattern(p: &mut Parser) -> ParseResult {
 }
 
 fn module_import(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::ModuleImport, |p| {
-        p.assert(NodeKind::Import);
+    p.perform(SyntaxKind::ModuleImport, |p| {
+        p.assert(SyntaxKind::Import);
 
-        if !p.eat_if(NodeKind::Star) {
+        if !p.eat_if(SyntaxKind::Star) {
             // This is the list of identifiers scenario.
-            p.perform(NodeKind::ImportItems, |p| {
+            p.perform(SyntaxKind::ImportItems, |p| {
                 p.start_group(Group::Imports);
                 let marker = p.marker();
                 let items = collection(p, false).1;
@@ -1018,42 +1019,42 @@ fn module_import(p: &mut Parser) -> ParseResult {
                 p.end_group();
 
                 marker.filter_children(p, |n| match n.kind() {
-                    NodeKind::Ident(_) | NodeKind::Comma => Ok(()),
+                    SyntaxKind::Ident(_) | SyntaxKind::Comma => Ok(()),
                     _ => Err("expected identifier"),
                 });
             });
         };
 
-        p.expect(NodeKind::From)?;
+        p.expect(SyntaxKind::From)?;
         expr(p)
     })
 }
 
 fn module_include(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::ModuleInclude, |p| {
-        p.assert(NodeKind::Include);
+    p.perform(SyntaxKind::ModuleInclude, |p| {
+        p.assert(SyntaxKind::Include);
         expr(p)
     })
 }
 
 fn break_stmt(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::LoopBreak, |p| {
-        p.assert(NodeKind::Break);
+    p.perform(SyntaxKind::LoopBreak, |p| {
+        p.assert(SyntaxKind::Break);
         Ok(())
     })
 }
 
 fn continue_stmt(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::LoopContinue, |p| {
-        p.assert(NodeKind::Continue);
+    p.perform(SyntaxKind::LoopContinue, |p| {
+        p.assert(SyntaxKind::Continue);
         Ok(())
     })
 }
 
 fn return_stmt(p: &mut Parser) -> ParseResult {
-    p.perform(NodeKind::FuncReturn, |p| {
-        p.assert(NodeKind::Return);
-        if !p.at(NodeKind::Comma) && !p.eof() {
+    p.perform(SyntaxKind::FuncReturn, |p| {
+        p.assert(SyntaxKind::Return);
+        if !p.at(SyntaxKind::Comma) && !p.eof() {
             expr(p)?;
         }
         Ok(())
@@ -1062,8 +1063,8 @@ fn return_stmt(p: &mut Parser) -> ParseResult {
 
 fn body(p: &mut Parser) -> ParseResult {
     match p.peek() {
-        Some(NodeKind::LeftBracket) => Ok(content_block(p)),
-        Some(NodeKind::LeftBrace) => Ok(code_block(p)),
+        Some(SyntaxKind::LeftBracket) => Ok(content_block(p)),
+        Some(SyntaxKind::LeftBrace) => Ok(code_block(p)),
         _ => {
             p.expected("body");
             Err(ParseError)