Scheduled maintenance 🔨

- New naming scheme
  - TextNode instead of NodeText
  - CallExpr instead of ExprCall
  - ...
- Less glob imports
- Removes Value::Args variant
- Removes prelude
- Renames Layouted to Fragment
- Moves font into env
- Moves shaping into layout
- Moves frame into separate module

3 files changed, 54 insertions, 54 deletions

diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index f23f1978..ceb8a206 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -136,11 +136,11 @@ fn heading(p: &mut Parser) -> Node {
         contents.extend(node(p, &mut false));
     }
 
-    Node::Heading(NodeHeading { level, contents })
+    Node::Heading(HeadingNode { level, contents })
 }
 
 /// Handle a raw block.
-fn raw(p: &mut Parser, token: TokenRaw) -> Node {
+fn raw(p: &mut Parser, token: RawToken) -> Node {
     let raw = resolve::resolve_raw(token.text, token.backticks, p.start());
     if !token.terminated {
         p.diag(error!(p.peek_span().end, "expected backtick(s)"));
@@ -149,7 +149,7 @@ fn raw(p: &mut Parser, token: TokenRaw) -> Node {
 }
 
 /// Handle a unicode escape sequence.
-fn unicode_escape(p: &mut Parser, token: TokenUnicodeEscape) -> String {
+fn unicode_escape(p: &mut Parser, token: UnicodeEscapeToken) -> String {
     let span = p.peek_span();
     let text = if let Some(c) = resolve::resolve_hex(token.sequence) {
         c.to_string()
@@ -184,7 +184,7 @@ fn expr_with(p: &mut Parser, atomic: bool, min_prec: usize) -> Option<Expr> {
         Some(op) => {
             let prec = op.precedence();
             let expr = Box::new(expr_with(p, atomic, prec)?);
-            Expr::Unary(ExprUnary { span: p.span(start), op, expr })
+            Expr::Unary(UnaryExpr { span: p.span(start), op, expr })
         }
         None => primary(p, atomic)?,
     };
@@ -225,7 +225,7 @@ fn expr_with(p: &mut Parser, atomic: bool, min_prec: usize) -> Option<Expr> {
         };
 
         let span = lhs.span().join(rhs.span());
-        lhs = Expr::Binary(ExprBinary { span, lhs: Box::new(lhs), op, rhs });
+        lhs = Expr::Binary(BinaryExpr { span, lhs: Box::new(lhs), op, rhs });
     }
 
     Some(lhs)
@@ -248,7 +248,7 @@ fn primary(p: &mut Parser, atomic: bool) -> Option<Expr> {
             // Arrow means this is a closure's lone parameter.
             Some(if !atomic && p.eat_if(Token::Arrow) {
                 let body = expr(p)?;
-                Expr::Closure(ExprClosure {
+                Expr::Closure(ClosureExpr {
                     span: id.span.join(body.span()),
                     name: None,
                     params: Rc::new(vec![id]),
@@ -306,7 +306,7 @@ fn literal(p: &mut Parser) -> Option<Expr> {
 /// - Dictionary literal
 /// - Parenthesized expression
 /// - Parameter list of closure expression
-pub fn parenthesized(p: &mut Parser) -> Option<Expr> {
+fn parenthesized(p: &mut Parser) -> Option<Expr> {
     p.start_group(Group::Paren, TokenMode::Code);
     let colon = p.eat_if(Token::Colon);
     let (items, has_comma) = collection(p);
@@ -321,7 +321,7 @@ pub fn parenthesized(p: &mut Parser) -> Option<Expr> {
     if p.eat_if(Token::Arrow) {
         let params = params(p, items);
         let body = expr(p)?;
-        return Some(Expr::Closure(ExprClosure {
+        return Some(Expr::Closure(ClosureExpr {
             span: span.join(body.span()),
             name: None,
             params: Rc::new(params),
@@ -332,21 +332,21 @@ pub fn parenthesized(p: &mut Parser) -> Option<Expr> {
     // Find out which kind of collection this is.
     Some(match items.as_slice() {
         [] => array(p, items, span),
-        [ExprArg::Pos(_)] if !has_comma => match items.into_iter().next() {
-            Some(ExprArg::Pos(expr)) => {
-                Expr::Group(ExprGroup { span, expr: Box::new(expr) })
+        [CallArg::Pos(_)] if !has_comma => match items.into_iter().next() {
+            Some(CallArg::Pos(expr)) => {
+                Expr::Group(GroupExpr { span, expr: Box::new(expr) })
             }
             _ => unreachable!(),
         },
-        [ExprArg::Pos(_), ..] => array(p, items, span),
-        [ExprArg::Named(_), ..] => dict(p, items, span),
+        [CallArg::Pos(_), ..] => array(p, items, span),
+        [CallArg::Named(_), ..] => dict(p, items, span),
     })
 }
 
 /// Parse a collection.
 ///
 /// Returns whether the literal contained any commas.
-fn collection(p: &mut Parser) -> (Vec<ExprArg>, bool) {
+fn collection(p: &mut Parser) -> (Vec<CallArg>, bool) {
     let mut items = vec![];
     let mut has_comma = false;
     let mut missing_coma = None;
@@ -376,52 +376,52 @@ fn collection(p: &mut Parser) -> (Vec<ExprArg>, bool) {
 }
 
 /// Parse an expression or a named pair.
-fn item(p: &mut Parser) -> Option<ExprArg> {
+fn item(p: &mut Parser) -> Option<CallArg> {
     let first = expr(p)?;
     if p.eat_if(Token::Colon) {
         if let Expr::Ident(name) = first {
-            Some(ExprArg::Named(Named { name, expr: expr(p)? }))
+            Some(CallArg::Named(Named { name, expr: expr(p)? }))
         } else {
             p.diag(error!(first.span(), "expected identifier"));
             expr(p);
             None
         }
     } else {
-        Some(ExprArg::Pos(first))
+        Some(CallArg::Pos(first))
     }
 }
 
 /// Convert a collection into an array, producing errors for named items.
-fn array(p: &mut Parser, items: Vec<ExprArg>, span: Span) -> Expr {
+fn array(p: &mut Parser, items: Vec<CallArg>, span: Span) -> Expr {
     let items = items.into_iter().filter_map(|item| match item {
-        ExprArg::Pos(expr) => Some(expr),
-        ExprArg::Named(_) => {
+        CallArg::Pos(expr) => Some(expr),
+        CallArg::Named(_) => {
             p.diag(error!(item.span(), "expected expression, found named pair"));
             None
         }
     });
 
-    Expr::Array(ExprArray { span, items: items.collect() })
+    Expr::Array(ArrayExpr { span, items: items.collect() })
 }
 
 /// Convert a collection into a dictionary, producing errors for expressions.
-fn dict(p: &mut Parser, items: Vec<ExprArg>, span: Span) -> Expr {
+fn dict(p: &mut Parser, items: Vec<CallArg>, span: Span) -> Expr {
     let items = items.into_iter().filter_map(|item| match item {
-        ExprArg::Named(named) => Some(named),
-        ExprArg::Pos(_) => {
+        CallArg::Named(named) => Some(named),
+        CallArg::Pos(_) => {
             p.diag(error!(item.span(), "expected named pair, found expression"));
             None
         }
     });
 
-    Expr::Dict(ExprDict { span, items: items.collect() })
+    Expr::Dict(DictExpr { span, items: items.collect() })
 }
 
 /// Convert a collection into a parameter list, producing errors for anything
 /// other than identifiers.
-fn params(p: &mut Parser, items: Vec<ExprArg>) -> Vec<Ident> {
+fn params(p: &mut Parser, items: Vec<CallArg>) -> Vec<Ident> {
     let items = items.into_iter().filter_map(|item| match item {
-        ExprArg::Pos(Expr::Ident(id)) => Some(id),
+        CallArg::Pos(Expr::Ident(id)) => Some(id),
         _ => {
             p.diag(error!(item.span(), "expected identifier"));
             None
@@ -435,7 +435,7 @@ fn template(p: &mut Parser) -> Expr {
     p.start_group(Group::Bracket, TokenMode::Markup);
     let tree = Rc::new(tree(p));
     let span = p.end_group();
-    Expr::Template(ExprTemplate { span, tree })
+    Expr::Template(TemplateExpr { span, tree })
 }
 
 /// Parse a block expression: `{...}`.
@@ -454,7 +454,7 @@ fn block(p: &mut Parser, scoping: bool) -> Expr {
         p.skip_white();
     }
     let span = p.end_group();
-    Expr::Block(ExprBlock { span, exprs, scoping })
+    Expr::Block(BlockExpr { span, exprs, scoping })
 }
 
 /// Parse a function call.
@@ -466,7 +466,7 @@ fn call(p: &mut Parser, callee: Expr) -> Expr {
             p.end_group();
             args
         }
-        _ => ExprArgs {
+        _ => CallArgs {
             span: Span::at(callee.span().end),
             items: vec![],
         },
@@ -474,10 +474,10 @@ fn call(p: &mut Parser, callee: Expr) -> Expr {
 
     if p.peek_direct() == Some(Token::LeftBracket) {
         let body = template(p);
-        args.items.push(ExprArg::Pos(body));
+        args.items.push(CallArg::Pos(body));
     }
 
-    Expr::Call(ExprCall {
+    Expr::Call(CallExpr {
         span: p.span(callee.span().start),
         callee: Box::new(callee),
         args,
@@ -485,10 +485,10 @@ fn call(p: &mut Parser, callee: Expr) -> Expr {
 }
 
 /// Parse the arguments to a function call.
-fn args(p: &mut Parser) -> ExprArgs {
+fn args(p: &mut Parser) -> CallArgs {
     let start = p.start();
     let items = collection(p).0;
-    ExprArgs { span: p.span(start), items }
+    CallArgs { span: p.span(start), items }
 }
 
 /// Parse a let expression.
@@ -518,7 +518,7 @@ fn expr_let(p: &mut Parser) -> Option<Expr> {
         // Rewrite into a closure expression if it's a function definition.
         if let Some(params) = parameters {
             let body = init?;
-            init = Some(Expr::Closure(ExprClosure {
+            init = Some(Expr::Closure(ClosureExpr {
                 span: binding.span.join(body.span()),
                 name: Some(binding.clone()),
                 params: Rc::new(params),
@@ -526,7 +526,7 @@ fn expr_let(p: &mut Parser) -> Option<Expr> {
             }));
         }
 
-        expr_let = Some(Expr::Let(ExprLet {
+        expr_let = Some(Expr::Let(LetExpr {
             span: p.span(start),
             binding,
             init: init.map(Box::new),
@@ -555,7 +555,7 @@ fn expr_if(p: &mut Parser) -> Option<Expr> {
                 else_body = body(p);
             }
 
-            expr_if = Some(Expr::If(ExprIf {
+            expr_if = Some(Expr::If(IfExpr {
                 span: p.span(start),
                 condition: Box::new(condition),
                 if_body: Box::new(if_body),
@@ -575,7 +575,7 @@ fn expr_while(p: &mut Parser) -> Option<Expr> {
     let mut expr_while = None;
     if let Some(condition) = expr(p) {
         if let Some(body) = body(p) {
-            expr_while = Some(Expr::While(ExprWhile {
+            expr_while = Some(Expr::While(WhileExpr {
                 span: p.span(start),
                 condition: Box::new(condition),
                 body: Box::new(body),
@@ -596,7 +596,7 @@ fn expr_for(p: &mut Parser) -> Option<Expr> {
         if p.expect(Token::In) {
             if let Some(iter) = expr(p) {
                 if let Some(body) = body(p) {
-                    expr_for = Some(Expr::For(ExprFor {
+                    expr_for = Some(Expr::For(ForExpr {
                         span: p.span(start),
                         pattern,
                         iter: Box::new(iter),
diff --git a/src/parse/resolve.rs b/src/parse/resolve.rs
index 88e11784..1f33198a 100644
--- a/src/parse/resolve.rs
+++ b/src/parse/resolve.rs
@@ -1,5 +1,5 @@
 use super::{is_newline, Scanner};
-use crate::syntax::{Ident, NodeRaw, Pos};
+use crate::syntax::{Ident, Pos, RawNode};
 
 /// Resolve all escape sequences in a string.
 pub fn resolve_string(string: &str) -> String {
@@ -47,17 +47,17 @@ pub fn resolve_hex(sequence: &str) -> Option<char> {
 }
 
 /// Resolve the language tag and trims the raw text.
-pub fn resolve_raw(text: &str, backticks: usize, start: Pos) -> NodeRaw {
+pub fn resolve_raw(text: &str, backticks: usize, start: Pos) -> RawNode {
     if backticks > 1 {
         let (tag, inner) = split_at_lang_tag(text);
         let (lines, had_newline) = trim_and_split_raw(inner);
-        NodeRaw {
+        RawNode {
             lang: Ident::new(tag, start .. start + tag.len()),
             lines,
             block: had_newline,
         }
     } else {
-        NodeRaw {
+        RawNode {
             lang: None,
             lines: split_lines(text),
             block: false,
@@ -105,7 +105,7 @@ fn trim_and_split_raw(mut raw: &str) -> (Vec<String>, bool) {
 
 /// Split a string into a vector of lines
 /// (respecting Unicode, Unix, Mac and Windows line breaks).
-pub fn split_lines(text: &str) -> Vec<String> {
+fn split_lines(text: &str) -> Vec<String> {
     let mut s = Scanner::new(text);
     let mut line = String::new();
     let mut lines = Vec::new();
@@ -174,7 +174,7 @@ mod tests {
             lines: &[&str],
             block: bool,
         ) {
-            Span::without_cmp(|| assert_eq!(resolve_raw(raw, backticks, Pos(0)), NodeRaw {
+            Span::without_cmp(|| assert_eq!(resolve_raw(raw, backticks, Pos(0)), RawNode {
                 lang: lang.and_then(|id| Ident::new(id, 0)),
                 lines: lines.iter().map(ToString::to_string).collect(),
                 block,
diff --git a/src/parse/tokens.rs b/src/parse/tokens.rs
index a1457c22..a57db93b 100644
--- a/src/parse/tokens.rs
+++ b/src/parse/tokens.rs
@@ -232,7 +232,7 @@ impl<'s> Tokens<'s> {
 
         // Special case for empty inline block.
         if backticks == 2 {
-            return Token::Raw(TokenRaw { text: "", backticks: 1, terminated: true });
+            return Token::Raw(RawToken { text: "", backticks: 1, terminated: true });
         }
 
         let start = self.s.index();
@@ -249,7 +249,7 @@ impl<'s> Tokens<'s> {
         let terminated = found == backticks;
         let end = self.s.index() - if terminated { found } else { 0 };
 
-        Token::Raw(TokenRaw {
+        Token::Raw(RawToken {
             text: self.s.get(start .. end),
             backticks,
             terminated,
@@ -286,7 +286,7 @@ impl<'s> Tokens<'s> {
                 (true, true) => 2,
             };
 
-        Token::Math(TokenMath {
+        Token::Math(MathToken {
             formula: self.s.get(start .. end),
             display,
             terminated,
@@ -309,7 +309,7 @@ impl<'s> Tokens<'s> {
                 'u' if self.s.peek_nth(1) == Some('{') => {
                     self.s.eat_assert('u');
                     self.s.eat_assert('{');
-                    Token::UnicodeEscape(TokenUnicodeEscape {
+                    Token::UnicodeEscape(UnicodeEscapeToken {
                         // Allow more than `ascii_hexdigit` for better error recovery.
                         sequence: self.s.eat_while(|c| c.is_ascii_alphanumeric()),
                         terminated: self.s.eat_if('}'),
@@ -391,7 +391,7 @@ impl<'s> Tokens<'s> {
 
     fn string(&mut self) -> Token<'s> {
         let mut escaped = false;
-        Token::Str(TokenStr {
+        Token::Str(StrToken {
             string: self.s.eat_until(|c| {
                 if c == '"' && !escaped {
                     true
@@ -470,19 +470,19 @@ mod tests {
     use TokenMode::{Code, Markup};
 
     const fn Raw(text: &str, backticks: usize, terminated: bool) -> Token {
-        Token::Raw(TokenRaw { text, backticks, terminated })
+        Token::Raw(RawToken { text, backticks, terminated })
     }
 
     const fn Math(formula: &str, display: bool, terminated: bool) -> Token {
-        Token::Math(TokenMath { formula, display, terminated })
+        Token::Math(MathToken { formula, display, terminated })
     }
 
     const fn UnicodeEscape(sequence: &str, terminated: bool) -> Token {
-        Token::UnicodeEscape(TokenUnicodeEscape { sequence, terminated })
+        Token::UnicodeEscape(UnicodeEscapeToken { sequence, terminated })
     }
 
     const fn Str(string: &str, terminated: bool) -> Token {
-        Token::Str(TokenStr { string, terminated })
+        Token::Str(StrToken { string, terminated })
     }
 
     const fn Color(r: u8, g: u8, b: u8, a: u8) -> Token<'static> {