From 264a7dedd42e27cd9e604037640cf0594b2ec46b Mon Sep 17 00:00:00 2001 From: Laurenz Date: Fri, 19 Mar 2021 17:57:31 +0100 Subject: =?UTF-8?q?Scheduled=20maintenance=20=F0=9F=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 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 --- src/parse/mod.rs | 78 ++++++++++++++++++++++++++-------------------------- src/parse/resolve.rs | 12 ++++---- src/parse/tokens.rs | 18 ++++++------ 3 files changed, 54 insertions(+), 54 deletions(-) (limited to 'src/parse') 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 { 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 { }; 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 { // 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 { /// - Dictionary literal /// - Parenthesized expression /// - Parameter list of closure expression -pub fn parenthesized(p: &mut Parser) -> Option { +fn parenthesized(p: &mut Parser) -> Option { 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 { 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 { // 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, bool) { +fn collection(p: &mut Parser) -> (Vec, 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, bool) { } /// Parse an expression or a named pair. -fn item(p: &mut Parser) -> Option { +fn item(p: &mut Parser) -> Option { 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, span: Span) -> Expr { +fn array(p: &mut Parser, items: Vec, 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, span: Span) -> Expr { +fn dict(p: &mut Parser, items: Vec, 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) -> Vec { +fn params(p: &mut Parser, items: Vec) -> Vec { 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 { // 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_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 { 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 { 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 { 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 { } /// 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, bool) { /// Split a string into a vector of lines /// (respecting Unicode, Unix, Mac and Windows line breaks). -pub fn split_lines(text: &str) -> Vec { +fn split_lines(text: &str) -> Vec { 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> { -- cgit v1.2.3