Skip to content

Offline, privacy-first grammar checker. Fast, open-source, Rust-powered

refactor(#230): simplify matching macros

Grant Lemonsfe4979e4ff5d
diff --git a/harper-core/src/parsers/typst.rs b/harper-core/src/parsers/typst.rs
index 445c77aa8..a7cf593c2 100644
--- a/harper-core/src/parsers/typst.rs
+++ b/harper-core/src/parsers/typst.rs
@@ -9,19 +9,18 @@ use crate::{
ConjunctionData, Lrc, NounData, Punctuation, Span, Token, TokenKind, VecExt, WordMetadata,
};
-/// A parser that wraps the [`PlainEnglish`] parser that allows one to parse
-/// Typst files.
+/// A parser that wraps the [`PlainEnglish`] parser allowing one to parse Typst files.
pub struct Typst;
/// Encapsulation of the translation between byte-based spans and char-based spans
#[derive(Debug, Clone, Copy)]
-struct Offset<'a> {
+struct OffsetCursor<'a> {
doc: &'a typst_syntax::Source,
pub char: usize,
pub byte: usize,
}
-impl<'a> Offset<'a> {
+impl<'a> OffsetCursor<'a> {
pub fn new(doc: &'a typst_syntax::Source) -> Self {
Self {
doc,
@@ -30,40 +29,39 @@ impl<'a> Offset<'a> {
}
}
+ /// Returns a new [`OffsetCursor`] at the given byte based on the current cursor.
pub fn push_to(self, new_byte: usize) -> Self {
assert!(new_byte >= self.byte);
- Self {
- char: self.doc.get(self.byte..new_byte).unwrap().chars().count(),
- byte: new_byte,
- ..self
+
+ if new_byte == self.byte {
+ return self;
}
- }
- pub fn push_by(self, relative_bytes: usize) -> Self {
- let new_byte = self.byte + relative_bytes;
Self {
- char: self.doc.get(self.byte..new_byte).unwrap().chars().count(),
+ char: self.char + self.doc.get(self.byte..new_byte).unwrap().chars().count(),
byte: new_byte,
..self
}
}
+ /// Returns a new [`OffsetCursor`] at the beginning of the given [`typst_syntax::Span`] based
+ /// on the current cursor.
pub fn push_to_span(self, span: typst_syntax::Span) -> Self {
let new_byte = self.doc.range(span).unwrap().start;
- assert!(new_byte >= self.byte);
self.push_to(new_byte)
}
}
-macro_rules! constant_token {
- ($doc:ident, $a:expr, $kind:expr, $offset:expr) => {{
- let start_char_loc = $offset.push_to($doc.range($a.span()).unwrap().start).char;
- let end_char_loc = $offset.push_to($doc.range($a.span()).unwrap().end).char;
+macro_rules! def_token {
+ ($doc:ident, $a:expr, $kind:expr, $offset:ident) => {{
+ let range = $doc.range($a.span()).unwrap();
+ let start = $offset.push_to(range.start);
+ let end_char_loc = start.push_to(range.end).char;
Some(vec![Token {
span: Span {
- start: start_char_loc,
+ start: start.char,
end: end_char_loc,
},
kind: $kind,
@@ -71,7 +69,7 @@ macro_rules! constant_token {
}};
}
-macro_rules! merge_expr {
+macro_rules! merge {
($($inner:expr),*) => {
Some(
[$($inner),*]
@@ -86,7 +84,7 @@ macro_rules! merge_expr {
fn parse_english(
str: impl Into<String>,
parser: &mut PlainEnglish,
- offset: Offset,
+ offset: OffsetCursor,
) -> Option<Vec<Token>> {
Some(
parser
@@ -104,47 +102,30 @@ fn parse_dict(
dict: &mut dyn Iterator<Item = typst_syntax::ast::DictItem>,
doc: &typst_syntax::Source,
parser: &mut PlainEnglish,
- offset: Offset,
+ offset: OffsetCursor,
) -> Option<Vec<Token>> {
Some(
dict.filter_map(|di| match di {
- typst_syntax::ast::DictItem::Named(named) => merge_expr!(
- constant_token!(
+ typst_syntax::ast::DictItem::Named(named) => merge!(
+ def_token!(
doc,
named.name(),
TokenKind::Word(WordMetadata::default()),
offset
),
- parse_expr(
- named.expr(),
- doc,
- parser,
- offset.push_to_span(named.expr().span())
- )
+ parse_expr(named.expr(), doc, parser, offset)
),
- typst_syntax::ast::DictItem::Keyed(keyed) => merge_expr!(
- parse_expr(
- keyed.key(),
- doc,
- parser,
- offset.push_to_span(keyed.key().span())
- ),
- parse_expr(
- keyed.expr(),
- doc,
- parser,
- offset.push_to_span(keyed.expr().span())
- )
+ typst_syntax::ast::DictItem::Keyed(keyed) => merge!(
+ parse_expr(keyed.key(), doc, parser, offset),
+ parse_expr(keyed.expr(), doc, parser, offset)
),
typst_syntax::ast::DictItem::Spread(spread) => spread.sink_ident().map_or_else(
|| {
- spread.sink_expr().and_then(|expr| {
- parse_expr(expr, doc, parser, offset.push_to_span(expr.span()))
- })
- },
- |ident| {
- constant_token!(doc, ident, TokenKind::Word(WordMetadata::default()), offset)
+ spread
+ .sink_expr()
+ .and_then(|expr| parse_expr(expr, doc, parser, offset))
},
+ |ident| def_token!(doc, ident, TokenKind::Word(WordMetadata::default()), offset),
),
})
.flatten()
@@ -156,59 +137,42 @@ fn parse_pattern(
pat: typst_syntax::ast::Pattern,
doc: &typst_syntax::Source,
parser: &mut PlainEnglish,
- offset: Offset,
+ offset: OffsetCursor,
) -> Option<Vec<Token>> {
match pat {
- typst_syntax::ast::Pattern::Normal(expr) => {
- parse_expr(expr, doc, parser, offset.push_to_span(expr.span()))
- }
+ typst_syntax::ast::Pattern::Normal(expr) => parse_expr(expr, doc, parser, offset),
typst_syntax::ast::Pattern::Placeholder(underscore) => {
- constant_token!(doc, underscore, TokenKind::Unlintable, offset)
+ def_token!(doc, underscore, TokenKind::Unlintable, offset)
}
- typst_syntax::ast::Pattern::Parenthesized(parenthesized) => merge_expr!(
- parse_expr(
- parenthesized.expr(),
- doc,
- parser,
- offset.push_to_span(parenthesized.expr().span())
- ),
- parse_pattern(
- parenthesized.pattern(),
- doc,
- parser,
- offset.push_to_span(parenthesized.pattern().span())
- )
+ typst_syntax::ast::Pattern::Parenthesized(parenthesized) => merge!(
+ parse_expr(parenthesized.expr(), doc, parser, offset),
+ parse_pattern(parenthesized.pattern(), doc, parser, offset)
),
typst_syntax::ast::Pattern::Destructuring(destructuring) => Some(
destructuring
.items()
.filter_map(|item| match item {
typst_syntax::ast::DestructuringItem::Pattern(pattern) => {
- parse_pattern(pattern, doc, parser, offset.push_to_span(pattern.span()))
+ parse_pattern(pattern, doc, parser, offset)
}
- typst_syntax::ast::DestructuringItem::Named(named) => merge_expr!(
- constant_token!(
+ typst_syntax::ast::DestructuringItem::Named(named) => merge!(
+ def_token!(
doc,
named.name(),
TokenKind::Word(WordMetadata::default()),
offset
),
- parse_pattern(
- named.pattern(),
- doc,
- parser,
- offset.push_to_span(named.pattern().span())
- )
+ parse_pattern(named.pattern(), doc, parser, offset)
),
typst_syntax::ast::DestructuringItem::Spread(spread) => {
spread.sink_ident().map_or_else(
|| {
- spread.sink_expr().and_then(|expr| {
- parse_expr(expr, doc, parser, offset.push_to_span(expr.span()))
- })
+ spread
+ .sink_expr()
+ .and_then(|expr| parse_expr(expr, doc, parser, offset))
},
|ident| {
- constant_token!(
+ def_token!(
doc,
ident,
TokenKind::Word(WordMetadata::default()),
@@ -228,100 +192,76 @@ fn parse_expr(
ex: typst_syntax::ast::Expr,
doc: &typst_syntax::Source,
parser: &mut PlainEnglish,
- offset: Offset,
+ old_offset: OffsetCursor,
) -> Option<Vec<Token>> {
- macro_rules! constant_token {
- ($a:expr, $kind:expr) => {{
- let start_char_loc = offset.push_to(doc.range($a.span()).unwrap().start).char;
- let end_char_loc = offset.push_to(doc.range($a.span()).unwrap().end).char;
-
- Some(vec![Token {
- span: Span {
- start: start_char_loc,
- end: end_char_loc,
- },
- kind: $kind,
- }])
- }};
+ let offset = old_offset.push_to_span(ex.span());
+
+ macro_rules! token {
+ ($a:expr, $kind:expr) => {
+ def_token!(doc, $a, $kind, offset)
+ };
}
- let mut nested_env = |exprs: &mut dyn Iterator<Item = typst_syntax::ast::Expr>,
- offset: Offset| {
- Some(
- exprs
- .filter_map(|e| parse_expr(e, doc, parser, offset))
- .flatten()
- .collect_vec(),
- )
+ macro_rules! recurse {
+ ($inner:expr) => {
+ parse_expr($inner, doc, parser, offset)
+ };
+ ($($inner:expr),*) => {
+ merge!(
+ $(recurse!($inner)),*
+ )
+ };
+ }
+
+ let mut iter_recurse = |exprs: &mut dyn Iterator<Item = typst_syntax::ast::Expr>| {
+ Some(exprs.filter_map(|e| recurse!(e)).flatten().collect_vec())
};
match ex {
Expr::Text(text) => parse_english(text.get(), parser, offset.push_to_span(text.span())),
- Expr::Space(a) => constant_token!(a, TokenKind::Space(1)),
- Expr::Linebreak(a) => constant_token!(a, TokenKind::Newline(1)),
- Expr::Parbreak(a) => constant_token!(a, TokenKind::ParagraphBreak),
- Expr::Escape(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Shorthand(a) => constant_token!(a, TokenKind::Unlintable),
+ Expr::Space(a) => token!(a, TokenKind::Space(1)),
+ Expr::Linebreak(a) => token!(a, TokenKind::Newline(1)),
+ Expr::Parbreak(a) => token!(a, TokenKind::ParagraphBreak),
+ Expr::Escape(a) => token!(a, TokenKind::Unlintable),
+ Expr::Shorthand(a) => token!(a, TokenKind::Unlintable),
Expr::SmartQuote(quote) => {
if quote.double() {
- constant_token!(
+ token!(
quote,
TokenKind::Punctuation(Punctuation::Quote(crate::Quote { twin_loc: None }))
)
} else {
- constant_token!(quote, TokenKind::Punctuation(Punctuation::Apostrophe))
+ token!(quote, TokenKind::Punctuation(Punctuation::Apostrophe))
}
}
- Expr::Strong(strong) => nested_env(
- &mut strong.body().exprs(),
- offset.push_to_span(strong.span()),
- ),
- Expr::Emph(emph) => nested_env(&mut emph.body().exprs(), offset.push_to_span(emph.span())),
- Expr::Raw(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Link(a) => constant_token!(a, TokenKind::Url),
- Expr::Label(a) => constant_token!(a, TokenKind::Unlintable),
+ Expr::Strong(strong) => iter_recurse(&mut strong.body().exprs()),
+ Expr::Emph(emph) => iter_recurse(&mut emph.body().exprs()),
+ Expr::Raw(a) => token!(a, TokenKind::Unlintable),
+ Expr::Link(a) => token!(a, TokenKind::Url),
+ Expr::Label(a) => token!(a, TokenKind::Unlintable),
Expr::Ref(a) => {
- constant_token!(a, TokenKind::Word(WordMetadata::default()))
+ token!(a, TokenKind::Word(WordMetadata::default()))
}
- Expr::Heading(heading) => nested_env(
- &mut heading.body().exprs(),
- offset.push_to_span(heading.span()),
- ),
- Expr::List(list_item) => nested_env(
- &mut list_item.body().exprs(),
- offset.push_to_span(list_item.span()),
- ),
- Expr::Enum(enum_item) => nested_env(
- &mut enum_item.body().exprs(),
- offset.push_to_span(enum_item.span()),
- ),
- Expr::Term(term_item) => nested_env(
+ Expr::Heading(heading) => iter_recurse(&mut heading.body().exprs()),
+ Expr::List(list_item) => iter_recurse(&mut list_item.body().exprs()),
+ Expr::Enum(enum_item) => iter_recurse(&mut enum_item.body().exprs()),
+ Expr::Term(term_item) => iter_recurse(
&mut term_item
.term()
.exprs()
.chain(term_item.description().exprs()),
- offset.push_to_span(term_item.span()),
),
- Expr::Equation(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Math(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathIdent(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathShorthand(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathAlignPoint(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathDelimited(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathAttach(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathPrimes(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathFrac(_) => panic!("Unexpected math outside equation environment."),
- Expr::MathRoot(_) => panic!("Unexpected math outside equation environment."),
- Expr::Ident(a) => constant_token!(a, TokenKind::Word(WordMetadata::default())),
- Expr::None(a) => constant_token!(a, TokenKind::Word(WordMetadata::default())),
- Expr::Auto(a) => constant_token!(a, TokenKind::Word(WordMetadata::default())),
- Expr::Bool(a) => constant_token!(a, TokenKind::Word(WordMetadata::default())),
+ Expr::Equation(a) => token!(a, TokenKind::Unlintable),
+ Expr::Ident(a) => token!(a, TokenKind::Word(WordMetadata::default())),
+ Expr::None(a) => token!(a, TokenKind::Word(WordMetadata::default())),
+ Expr::Auto(a) => token!(a, TokenKind::Word(WordMetadata::default())),
+ Expr::Bool(a) => token!(a, TokenKind::Word(WordMetadata::default())),
Expr::Int(int) => {
- constant_token!(int, TokenKind::Number((int.get() as f64).into(), None))
+ token!(int, TokenKind::Number((int.get() as f64).into(), None))
}
Expr::Float(float) => {
- constant_token!(float, TokenKind::Number(float.get().into(), None))
+ token!(float, TokenKind::Number(float.get().into(), None))
}
- Expr::Numeric(a) => constant_token!(a, TokenKind::Unlintable),
+ Expr::Numeric(a) => token!(a, TokenKind::Unlintable),
Expr::Str(text) => {
let offset = doc.range(text.span()).unwrap().start + 1;
let text = text.to_untyped().text();
@@ -336,23 +276,15 @@ fn parse_expr(
.collect_vec(),
)
}
- Expr::Code(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Content(content_block) => nested_env(
- &mut content_block.body().exprs(),
- offset.push_to_span(content_block.span()),
- ),
- Expr::Parenthesized(parenthesized) => parse_expr(
- parenthesized.expr(),
- doc,
- parser,
- offset.push_to_span(parenthesized.span()),
- ),
+ Expr::Code(a) => token!(a, TokenKind::Unlintable),
+ Expr::Content(content_block) => iter_recurse(&mut content_block.body().exprs()),
+ Expr::Parenthesized(parenthesized) => recurse!(parenthesized.expr()),
Expr::Array(array) => Some(
array
.items()
.filter_map(|i| {
if let typst_syntax::ast::ArrayItem::Pos(e) = i {
- parse_expr(e, doc, parser, offset.push_to_span(array.span()))
+ recurse!(e)
} else {
None
}
@@ -360,143 +292,41 @@ fn parse_expr(
.flatten()
.collect_vec(),
),
- Expr::Dict(a) => parse_dict(&mut a.items(), doc, parser, offset.push_to_span(a.span())),
- Expr::Unary(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Binary(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::FieldAccess(field_access) => merge_expr!(
- parse_expr(
- field_access.target(),
- doc,
- parser,
- offset.push_to_span(field_access.span())
- ),
- constant_token!(
+ Expr::Dict(a) => parse_dict(&mut a.items(), doc, parser, offset),
+ Expr::Unary(a) => token!(a, TokenKind::Unlintable),
+ Expr::Binary(a) => token!(a, TokenKind::Unlintable),
+ Expr::FieldAccess(field_access) => merge!(
+ recurse!(field_access.target()),
+ token!(
field_access.field(),
TokenKind::Word(WordMetadata::default())
)
),
- Expr::FuncCall(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Closure(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Let(let_binding) => merge_expr!(
+ Expr::FuncCall(func_call) => recurse!(func_call.callee()),
+ Expr::Closure(a) => token!(a, TokenKind::Unlintable),
+ Expr::Let(let_binding) => merge!(
match let_binding.kind() {
typst_syntax::ast::LetBindingKind::Normal(pattern) =>
- parse_pattern(pattern, doc, parser, offset.push_to_span(pattern.span())),
+ parse_pattern(pattern, doc, parser, offset),
typst_syntax::ast::LetBindingKind::Closure(ident) =>
- constant_token!(ident, TokenKind::Word(WordMetadata::default())),
+ token!(ident, TokenKind::Word(WordMetadata::default())),
},
- let_binding.init().and_then(|e| parse_expr(
- e,
- doc,
- parser,
- offset.push_to_span(e.span())
- ))
- ),
- Expr::DestructAssign(destruct_assignment) => parse_expr(
- destruct_assignment.value(),
- doc,
- parser,
- offset.push_to_span(destruct_assignment.span()),
- ),
- Expr::Set(set_rule) => merge_expr!(
- parse_expr(
- set_rule.target(),
- doc,
- parser,
- offset.push_to_span(set_rule.target().span())
- ),
- parse_expr(
- set_rule.condition()?,
- doc,
- parser,
- offset.push_to_span(set_rule.condition()?.span())
- )
- ),
- Expr::Show(show_rule) => merge_expr!(
- parse_expr(
- show_rule.transform(),
- doc,
- parser,
- offset.push_to_span(show_rule.transform().span())
- ),
- parse_expr(
- show_rule.selector()?,
- doc,
- parser,
- offset.push_to_span(show_rule.selector()?.span())
- )
- ),
- Expr::Contextual(contextual) => parse_expr(
- contextual.body(),
- doc,
- parser,
- offset.push_to_span(contextual.span()),
+ let_binding.init().and_then(|e| recurse!(e))
),
- Expr::Conditional(conditional) => merge_expr!(
- parse_expr(
- conditional.condition(),
- doc,
- parser,
- offset.push_to_span(conditional.condition().span())
- ),
- parse_expr(
- conditional.if_body(),
- doc,
- parser,
- offset.push_to_span(conditional.if_body().span())
- ),
- parse_expr(
- conditional.else_body()?,
- doc,
- parser,
- offset.push_to_span(conditional.else_body()?.span())
- )
- ),
- Expr::While(while_loop) => merge_expr!(
- parse_expr(
- while_loop.condition(),
- doc,
- parser,
- offset.push_to_span(while_loop.condition().span())
- ),
- parse_expr(
- while_loop.body(),
- doc,
- parser,
- offset.push_to_span(while_loop.body().span())
- )
- ),
- Expr::For(for_loop) => merge_expr!(
- parse_expr(
- for_loop.iterable(),
- doc,
- parser,
- offset.push_to_span(for_loop.iterable().span())
- ),
- parse_expr(
- for_loop.body(),
- doc,
- parser,
- offset.push_to_span(for_loop.body().span())
- )
- ),
- Expr::Import(module_import) => {
- merge_expr!(
- parse_expr(
- module_import.source(),
- doc,
- parser,
- offset.push_to_span(module_import.source().span())
- ),
- constant_token!(
- module_import.new_name()?,
- TokenKind::Word(WordMetadata::default())
- )
- )
+ Expr::DestructAssign(destruct_assignment) => {
+ recurse!(destruct_assignment.value())
}
- Expr::Include(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Break(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Continue(a) => constant_token!(a, TokenKind::Unlintable),
- Expr::Return(a) => constant_token!(a, TokenKind::Unlintable),
+ Expr::Set(set_rule) => recurse!(set_rule.target(), set_rule.condition()?),
+ Expr::Show(show_rule) => recurse!(show_rule.transform(), show_rule.selector()?),
+ Expr::Contextual(contextual) => recurse!(contextual.body()),
+ Expr::Conditional(conditional) => recurse!(
+ conditional.condition(),
+ conditional.if_body(),
+ conditional.else_body()?
+ ),
+ Expr::While(while_loop) => recurse!(while_loop.condition(), while_loop.body()),
+ Expr::For(for_loop) => recurse!(for_loop.iterable(), for_loop.body()),
+ a => token!(a, TokenKind::Unlintable),
}
}
@@ -525,7 +355,7 @@ impl Parser for Typst {
ex,
&typst_document,
&mut english_parser,
- Offset::new(&typst_document),
+ OffsetCursor::new(&typst_document),
)
})
.flatten()