Move and rename many things 🚛

7 files changed, 47 insertions, 55 deletions

diff --git a/src/parse/collection.rs b/src/parse/collection.rs
index db267dbe..889cfb0f 100644
--- a/src/parse/collection.rs
+++ b/src/parse/collection.rs
@@ -2,7 +2,7 @@ use super::*;
 use crate::diag::Deco;
 
 /// Parse the arguments to a function call.
-pub fn arguments(p: &mut Parser) -> Arguments {
+pub fn arguments(p: &mut Parser) -> ExprArgs {
     collection(p, vec![])
 }
 
@@ -74,7 +74,7 @@ trait Collection {
     fn push_comma(&mut self) {}
 }
 
-impl Collection for Arguments {
+impl Collection for ExprArgs {
     fn push_arg(&mut self, _: &mut Parser, arg: Spanned<Argument>) {
         self.push(arg.v);
     }
@@ -85,17 +85,17 @@ impl Collection for Arguments {
 enum State {
     Unknown,
     Expr(Spanned<Expr>),
-    Array(Array),
-    Dict(Dict),
+    Array(ExprArray),
+    Dict(ExprDict),
 }
 
 impl State {
     fn into_expr(self) -> Expr {
         match self {
-            Self::Unknown => Expr::Lit(Lit::Array(vec![])),
+            Self::Unknown => Expr::Array(vec![]),
             Self::Expr(expr) => expr.v,
-            Self::Array(array) => Expr::Lit(Lit::Array(array)),
-            Self::Dict(dict) => Expr::Lit(Lit::Dict(dict)),
+            Self::Array(array) => Expr::Array(array),
+            Self::Dict(dict) => Expr::Dict(dict),
         }
     }
 }
diff --git a/src/parse/lines.rs b/src/parse/lines.rs
index be120d8a..d1a6c781 100644
--- a/src/parse/lines.rs
+++ b/src/parse/lines.rs
@@ -1,5 +1,3 @@
-//! Conversion of byte positions to line/column locations.
-
 use super::Scanner;
 use crate::syntax::{Location, Offset, Pos};
 
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 912a34d0..e6cac17f 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -22,13 +22,13 @@ use crate::syntax::*;
 use collection::{arguments, parenthesized};
 
 /// Parse a string of source code.
-pub fn parse(src: &str) -> Pass<SynTree> {
+pub fn parse(src: &str) -> Pass<Tree> {
     let mut p = Parser::new(src);
     Pass::new(tree(&mut p), p.finish())
 }
 
 /// Parse a syntax tree.
-fn tree(p: &mut Parser) -> SynTree {
+fn tree(p: &mut Parser) -> Tree {
     // We keep track of whether we are at the start of a block or paragraph
     // to know whether headings are allowed.
     let mut at_start = true;
@@ -36,8 +36,8 @@ fn tree(p: &mut Parser) -> SynTree {
     while !p.eof() {
         if let Some(node) = p.span_if(|p| node(p, at_start)) {
             match node.v {
-                SynNode::Parbreak => at_start = true,
-                SynNode::Space => {}
+                Node::Parbreak => at_start = true,
+                Node::Space => {}
                 _ => at_start = false,
             }
             tree.push(node);
@@ -47,42 +47,42 @@ fn tree(p: &mut Parser) -> SynTree {
 }
 
 /// Parse a syntax node.
-fn node(p: &mut Parser, at_start: bool) -> Option<SynNode> {
+fn node(p: &mut Parser, at_start: bool) -> Option<Node> {
     let node = match p.peek()? {
         Token::Space(newlines) => {
             if newlines < 2 {
-                SynNode::Space
+                Node::Space
             } else {
-                SynNode::Parbreak
+                Node::Parbreak
             }
         }
-        Token::Text(text) => SynNode::Text(text.into()),
+        Token::Text(text) => Node::Text(text.into()),
 
         Token::LineComment(_) | Token::BlockComment(_) => {
             p.eat();
             return None;
         }
 
-        Token::Star => SynNode::Strong,
-        Token::Underscore => SynNode::Emph,
-        Token::Tilde => SynNode::Text("\u{00A0}".into()),
-        Token::Backslash => SynNode::Linebreak,
+        Token::Star => Node::Strong,
+        Token::Underscore => Node::Emph,
+        Token::Tilde => Node::Text("\u{00A0}".into()),
+        Token::Backslash => Node::Linebreak,
         Token::Hashtag => {
             if at_start {
-                return Some(SynNode::Heading(heading(p)));
+                return Some(Node::Heading(heading(p)));
             } else {
-                SynNode::Text(p.get(p.peek_span()).into())
+                Node::Text(p.get(p.peek_span()).into())
             }
         }
-        Token::Raw(t) => SynNode::Raw(raw(p, t)),
-        Token::UnicodeEscape(t) => SynNode::Text(unicode_escape(p, t)),
+        Token::Raw(t) => Node::Raw(raw(p, t)),
+        Token::UnicodeEscape(t) => Node::Text(unicode_escape(p, t)),
 
         Token::LeftBracket => {
-            return Some(SynNode::Expr(Expr::Call(bracket_call(p))));
+            return Some(Node::Expr(Expr::Call(bracket_call(p))));
         }
 
         Token::LeftBrace => {
-            return Some(SynNode::Expr(block_expr(p)?));
+            return Some(Node::Expr(block_expr(p)?));
         }
 
         _ => {
@@ -189,15 +189,15 @@ fn bracket_call(p: &mut Parser) -> ExprCall {
     p.end_group();
 
     if p.peek() == Some(Token::LeftBracket) {
-        let body = p.span(|p| Expr::Lit(Lit::Content(bracket_body(p))));
+        let body = p.span(|p| Expr::Content(bracket_body(p)));
         inner.span.expand(body.span);
         inner.v.args.v.push(Argument::Pos(body));
     }
 
     while let Some(mut top) = outer.pop() {
         let span = inner.span;
-        let node = inner.map(|c| SynNode::Expr(Expr::Call(c)));
-        let expr = Expr::Lit(Lit::Content(vec![node])).with_span(span);
+        let node = inner.map(|c| Node::Expr(Expr::Call(c)));
+        let expr = Expr::Content(vec![node]).with_span(span);
         top.v.args.v.push(Argument::Pos(expr));
         inner = top;
     }
@@ -227,7 +227,7 @@ fn bracket_subheader(p: &mut Parser) -> ExprCall {
 }
 
 /// Parse the body of a bracketed function call.
-fn bracket_body(p: &mut Parser) -> SynTree {
+fn bracket_body(p: &mut Parser) -> Tree {
     p.push_mode(TokenMode::Body);
     p.start_group(Group::Bracket);
     let tree = tree(p);
@@ -299,13 +299,13 @@ fn value(p: &mut Parser) -> Option<Expr> {
     let expr = match p.peek() {
         // Bracketed function call.
         Some(Token::LeftBracket) => {
-            let node = p.span(|p| SynNode::Expr(Expr::Call(bracket_call(p))));
-            return Some(Expr::Lit(Lit::Content(vec![node])));
+            let node = p.span(|p| Node::Expr(Expr::Call(bracket_call(p))));
+            return Some(Expr::Content(vec![node]));
         }
 
         // Content expression.
         Some(Token::LeftBrace) => {
-            return Some(Expr::Lit(Lit::Content(content(p))));
+            return Some(Expr::Content(content(p)));
         }
 
         // Dictionary or just a parenthesized expression.
@@ -345,7 +345,7 @@ fn value(p: &mut Parser) -> Option<Expr> {
 }
 
 // Parse a content value: `{...}`.
-fn content(p: &mut Parser) -> SynTree {
+fn content(p: &mut Parser) -> Tree {
     p.push_mode(TokenMode::Body);
     p.start_group(Group::Brace);
     let tree = tree(p);
diff --git a/src/parse/resolve.rs b/src/parse/resolve.rs
index 051bc7d5..d6c6d8a4 100644
--- a/src/parse/resolve.rs
+++ b/src/parse/resolve.rs
@@ -1,5 +1,3 @@
-//! Resolve strings and raw blocks.
-
 use super::{is_newline, Scanner};
 use crate::syntax::{Ident, NodeRaw};
 
diff --git a/src/parse/scanner.rs b/src/parse/scanner.rs
index 69ad2138..cc23a612 100644
--- a/src/parse/scanner.rs
+++ b/src/parse/scanner.rs
@@ -1,9 +1,7 @@
-//! Low-level char-based scanner.
-
 use std::fmt::{self, Debug, Formatter};
 use std::slice::SliceIndex;
 
-/// A low-level featureful char-based scanner.
+/// A featureful char-based scanner.
 #[derive(Clone)]
 pub struct Scanner<'s> {
     src: &'s str,
diff --git a/src/parse/tests.rs b/src/parse/tests.rs
index 0c8998b5..d01d09a5 100644
--- a/src/parse/tests.rs
+++ b/src/parse/tests.rs
@@ -9,7 +9,7 @@ use crate::geom::Unit;
 use crate::syntax::*;
 
 use BinOp::*;
-use SynNode::{Emph, Linebreak, Parbreak, Space, Strong};
+use Node::{Emph, Linebreak, Parbreak, Space, Strong};
 use UnOp::*;
 
 macro_rules! t {
@@ -82,16 +82,16 @@ macro_rules! into {
     };
 }
 
-fn Text(text: &str) -> SynNode {
-    SynNode::Text(text.into())
+fn Text(text: &str) -> Node {
+    Node::Text(text.into())
 }
 
-fn Heading(level: impl Into<Spanned<u8>>, contents: SynTree) -> SynNode {
-    SynNode::Heading(NodeHeading { level: level.into(), contents })
+fn Heading(level: impl Into<Spanned<u8>>, contents: Tree) -> Node {
+    Node::Heading(NodeHeading { level: level.into(), contents })
 }
 
-fn Raw(lang: Option<&str>, lines: &[&str], inline: bool) -> SynNode {
-    SynNode::Raw(NodeRaw {
+fn Raw(lang: Option<&str>, lines: &[&str], inline: bool) -> Node {
+    Node::Raw(NodeRaw {
         lang: lang.map(|id| Ident(id.into())),
         lines: lines.iter().map(ToString::to_string).collect(),
         inline,
@@ -130,8 +130,8 @@ fn Str(string: &str) -> Expr {
     Expr::Lit(Lit::Str(string.to_string()))
 }
 
-fn Block(expr: Expr) -> SynNode {
-    SynNode::Expr(expr)
+fn Block(expr: Expr) -> Node {
+    Node::Expr(expr)
 }
 
 fn Binary(
@@ -157,7 +157,7 @@ macro_rules! Array {
     (@$($expr:expr),* $(,)?) => {
         vec![$(into!($expr)),*]
     };
-    ($($tts:tt)*) => (Expr::Lit(Lit::Array(Array![@$($tts)*])));
+    ($($tts:tt)*) => (Expr::Array(Array![@$($tts)*]));
 }
 
 macro_rules! Dict {
@@ -167,7 +167,7 @@ macro_rules! Dict {
             expr: into!($expr)
         }),*]
     };
-    ($($tts:tt)*) => (Expr::Lit(Lit::Dict(Dict![@$($tts)*])));
+    ($($tts:tt)*) => (Expr::Dict(Dict![@$($tts)*]));
 }
 
 macro_rules! Args {
@@ -187,7 +187,7 @@ macro_rules! Args {
 
 macro_rules! Content {
     (@$($node:expr),* $(,)?) => (vec![$(into!($node)),*]);
-    ($($tts:tt)*) => (Expr::Lit(Lit::Content(Content![@$($tts)*])));
+    ($($tts:tt)*) => (Expr::Content(Content![@$($tts)*]));
 }
 
 macro_rules! Call {
@@ -201,7 +201,7 @@ macro_rules! Call {
         }
     };
     (@$($tts:tt)*) => (Expr::Call(Call!(@@$($tts)*)));
-    ($($tts:tt)*) => (SynNode::Expr(Call!(@$($tts)*)));
+    ($($tts:tt)*) => (Node::Expr(Call!(@$($tts)*)));
 }
 
 #[test]
diff --git a/src/parse/tokens.rs b/src/parse/tokens.rs
index a9692a58..ff7f11bd 100644
--- a/src/parse/tokens.rs
+++ b/src/parse/tokens.rs
@@ -1,5 +1,3 @@
-//! Tokenization.
-
 use std::fmt::{self, Debug, Formatter};
 
 use super::{is_newline, Scanner};