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.rsindex 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()