From e226dc9d5d91d824b2afa4bf7fb929b69789a483 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Mon, 20 Jan 2025 12:18:06 -0700
Subject: [PATCH 1/9] fix(typst): mark reference as unlintable

---
 harper-typst/src/lib.rs              | 6 ++++--
 harper-typst/src/typst_translator.rs | 3 ---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs
index 9668fc52..e123ec8d 100644
--- a/harper-typst/src/lib.rs
+++ b/harper-typst/src/lib.rs
@@ -216,10 +216,10 @@ mod tests {
     }
 
     #[test]
-    fn label_unlintable() {
+    fn label_ref_unlintable() {
         let source = "= Header
                       <label>
-                      Paragraph";
+                      Paragraph @label";
 
         let document = Document::new_curated(source, &Typst);
         let token_kinds = document.tokens().map(|t| t.kind).collect_vec();
@@ -233,6 +233,8 @@ mod tests {
                 TokenKind::Unlintable,
                 TokenKind::Newline(1),
                 TokenKind::Word(_),
+                TokenKind::Space(_),
+                TokenKind::Unlintable,
             ]
         ))
     }
diff --git a/harper-typst/src/typst_translator.rs b/harper-typst/src/typst_translator.rs
index 34400b2a..6d335803 100644
--- a/harper-typst/src/typst_translator.rs
+++ b/harper-typst/src/typst_translator.rs
@@ -225,9 +225,6 @@ impl<'a> TypstTranslator<'a> {
             Expr::Strong(strong) => iter_recurse(&mut strong.body().exprs()),
             Expr::Emph(emph) => iter_recurse(&mut emph.body().exprs()),
             Expr::Link(a) => token!(a, TokenKind::Url),
-            Expr::Ref(a) => {
-                token!(a, TokenKind::Word(WordMetadata::default()))
-            }
             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()),

From 21a47e6f614f9c9b3f31fa9d812d214fb01c8079 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Mon, 20 Jan 2025 14:34:19 -0700
Subject: [PATCH 2/9] fix(typst): newline->parbreak around headings and list
 items

---
 harper-typst/src/lib.rs | 116 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 109 insertions(+), 7 deletions(-)

diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs
index e123ec8d..3b9ca5d1 100644
--- a/harper-typst/src/lib.rs
+++ b/harper-typst/src/lib.rs
@@ -7,8 +7,8 @@ use typst_translator::TypstTranslator;
 use harper_core::{parsers::Parser, Token};
 use itertools::Itertools;
 use typst_syntax::{
-    ast::{AstNode, Markup},
-    Source,
+    ast::{AstNode, Expr, Markup},
+    Source, SyntaxNode,
 };
 
 /// A parser that wraps Harper's `PlainEnglish` parser allowing one to ingest Typst files.
@@ -23,10 +23,52 @@ impl Parser for Typst {
         let typst_tree = Markup::from_untyped(typst_document.root())
             .expect("Unable to create typst document from parsed tree!");
 
+        // Owned collection of nodes forcibly casted to paragraph breaks
+        let untyped_nodes = typst_tree
+            .exprs()
+            .map(|e| {
+                let mut node = SyntaxNode::placeholder(typst_syntax::SyntaxKind::Parbreak);
+                node.synthesize(e.span());
+                node
+            })
+            .collect_vec();
+
+        // Converts newlines after certain elements to paragraph breaks
+        // This is accomplished here instead of in the translating module because at this point there is
+        // still semantic information associated with the elements.
+        //
+        // Newlines are separate expressions in the parse tree (as the Space variant)
+        let should_parbreak = |e1, e2, e3| {
+            matches!(e2, Expr::Space(_))
+                && (matches!(e1, Expr::Heading(_) | Expr::List(_))
+                    || matches!(e3, Expr::Heading(_) | Expr::List(_)))
+        };
+
+        let mut exprs: Vec<Expr> = Vec::new();
+        let mut last_element: Option<Expr> = None;
+        for ((i, expr), (_, next_expr)) in typst_tree.exprs().enumerate().tuple_windows() {
+            let mut current_expr = expr;
+            if let Some(last_element) = last_element {
+                if should_parbreak(last_element, expr, next_expr) {
+                    let pbreak = typst_syntax::ast::Parbreak::from_untyped(&untyped_nodes[i])
+                        .expect("Unable to convert expression to Parbreak");
+                    current_expr = Expr::Parbreak(pbreak);
+                }
+            }
+            exprs.push(current_expr);
+            last_element = Some(expr)
+        }
+        // Push last element because it will be excluded by tuple_windows() above
+        if let Some(last) = typst_tree.exprs().last() {
+            exprs.push(last);
+        }
+
+        dbg!(&exprs);
+
         // Recurse through AST to create tokens
         let parse_helper = TypstTranslator::new(&typst_document);
-        typst_tree
-            .exprs()
+        exprs
+            .into_iter()
             .filter_map(|ex| parse_helper.parse_expr(ex, OffsetCursor::new(&typst_document)))
             .flatten()
             .collect_vec()
@@ -189,7 +231,7 @@ mod tests {
             &token_kinds.as_slice(),
             &[
                 TokenKind::Word(_),
-                TokenKind::Newline(1),
+                TokenKind::ParagraphBreak,
                 TokenKind::Word(_)
             ]
         ))
@@ -229,9 +271,9 @@ mod tests {
             &token_kinds.as_slice(),
             &[
                 TokenKind::Word(_),
-                TokenKind::Newline(1),
+                TokenKind::ParagraphBreak,
                 TokenKind::Unlintable,
-                TokenKind::Newline(1),
+                TokenKind::Newline(_),
                 TokenKind::Word(_),
                 TokenKind::Space(_),
                 TokenKind::Unlintable,
@@ -299,4 +341,64 @@ mod tests {
             ]
         ));
     }
+
+    #[test]
+    fn newline_in_paragraph() {
+        let source = "Paragraph with
+newlines
+not paragraph breaks";
+
+        let document = Document::new_curated(source, &Typst);
+        let token_kinds = document.tokens().map(|t| t.kind).collect_vec();
+        dbg!(&token_kinds);
+
+        assert!(matches!(
+            &token_kinds.as_slice(),
+            &[
+                TokenKind::Word(_), // Paragraph
+                TokenKind::Space(_),
+                TokenKind::Word(_), // with
+                TokenKind::Newline(1),
+                TokenKind::Word(_), // newlines
+                TokenKind::Newline(1),
+                TokenKind::Word(_), // not
+                TokenKind::Space(_),
+                TokenKind::Word(_), // paragraph
+                TokenKind::Space(_),
+                TokenKind::Word(_), // breaks
+            ]
+        ))
+    }
+
+    #[test]
+    fn parbreaks_in_list() {
+        let source = "This is a list:
+- p1
+- p2
+- p3";
+
+        let document = Document::new_curated(source, &Typst);
+        let token_kinds = document.tokens().map(|t| t.kind).collect_vec();
+        dbg!(&token_kinds);
+
+        assert!(matches!(
+            &token_kinds.as_slice(),
+            &[
+                TokenKind::Word(_), // This
+                TokenKind::Space(_),
+                TokenKind::Word(_), // is
+                TokenKind::Space(_),
+                TokenKind::Word(_), // a
+                TokenKind::Space(_),
+                TokenKind::Word(_), // list
+                TokenKind::Punctuation(Punctuation::Colon),
+                TokenKind::ParagraphBreak,
+                TokenKind::Word(_),
+                TokenKind::ParagraphBreak,
+                TokenKind::Word(_),
+                TokenKind::ParagraphBreak,
+                TokenKind::Word(_)
+            ]
+        ))
+    }
 }

From b1946d8ba05b6dac25af55cd5178b1676432d3ed Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Mon, 20 Jan 2025 14:37:00 -0700
Subject: [PATCH 3/9] tests(typst): add test for issue #399

---
 harper-typst/tests/run_tests.rs               |  1 +
 harper-typst/tests/test_sources/issue_399.typ | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 harper-typst/tests/test_sources/issue_399.typ

diff --git a/harper-typst/tests/run_tests.rs b/harper-typst/tests/run_tests.rs
index b6cba665..814787ba 100644
--- a/harper-typst/tests/run_tests.rs
+++ b/harper-typst/tests/run_tests.rs
@@ -40,3 +40,4 @@ macro_rules! create_test {
 create_test!(complex_document.typ, 0);
 create_test!(simplified_document.typ, 0);
 create_test!(complex_document_with_spelling_mistakes.typ, 4);
+create_test!(issue_399.typ, 0);
diff --git a/harper-typst/tests/test_sources/issue_399.typ b/harper-typst/tests/test_sources/issue_399.typ
new file mode 100644
index 00000000..090b53ff
--- /dev/null
+++ b/harper-typst/tests/test_sources/issue_399.typ
@@ -0,0 +1,18 @@
+#problem[
+	4. Find all the $x$ values where the following function is discontinuous.
+]
+
+#solution[
+	$x=-2,0,3$
+]
+
+#aside[
+	at $x=-2$ jump discontinuity. 
+        // this "at" doesn't get flagged
+
+	at $x=0$ infinite discontinuity.
+	// this "at" does `This sentence doesn't start with a capital letter`
+
+	at $x=3$ removable discontinuity. (can be removed via re-defining the domain to exclude that)
+        // this "at" does `This sentence doesn't start with a capital letter`
+]

From 3112a3e0fe60bded87338a0511b245d4eac09429 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Mon, 20 Jan 2025 14:39:15 -0700
Subject: [PATCH 4/9] fix: elide lifetimes in feature flagged trait

---
 harper-core/src/linting/pattern_linter.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/harper-core/src/linting/pattern_linter.rs b/harper-core/src/linting/pattern_linter.rs
index 4fed2072..c4e0052d 100644
--- a/harper-core/src/linting/pattern_linter.rs
+++ b/harper-core/src/linting/pattern_linter.rs
@@ -7,7 +7,7 @@ pub trait PatternLinter {
     /// A simple getter for the pattern to be searched for.
     fn pattern(&self) -> &dyn Pattern;
     fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Lint;
-    fn description<'a>(&'a self) -> &'a str;
+    fn description(&self) -> &str;
 }
 
 #[cfg(feature = "concurrent")]

From 6909ad7cbf2618249827fa8bf4bd38979e5ebfb4 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Tue, 21 Jan 2025 12:47:03 -0700
Subject: [PATCH 5/9] fix(typst): move parbreak replacer into function and call
 in nested elements

---
 harper-typst/src/lib.rs              | 47 ++++++++++++++++++++++++++++
 harper-typst/src/typst_translator.rs | 11 ++++++-
 2 files changed, 57 insertions(+), 1 deletion(-)

diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs
index 3b9ca5d1..a67eb9ea 100644
--- a/harper-typst/src/lib.rs
+++ b/harper-typst/src/lib.rs
@@ -67,6 +67,9 @@ impl Parser for Typst {
 
         // Recurse through AST to create tokens
         let parse_helper = TypstTranslator::new(&typst_document);
+        let mut buf = Vec::new();
+        let exprs = typst_tree.exprs().collect_vec();
+        let exprs = convert_parbreaks(&mut buf, &exprs);
         exprs
             .into_iter()
             .filter_map(|ex| parse_helper.parse_expr(ex, OffsetCursor::new(&typst_document)))
@@ -75,6 +78,50 @@ impl Parser for Typst {
     }
 }
 
+fn convert_parbreaks<'a>(buf: &'a mut Vec<SyntaxNode>, exprs: &'a [Expr]) -> Vec<Expr<'a>> {
+    // Owned collection of nodes forcibly casted to paragraph breaks
+    *buf = exprs
+        .iter()
+        .map(|e| {
+            let mut node = SyntaxNode::placeholder(typst_syntax::SyntaxKind::Parbreak);
+            node.synthesize(e.span());
+            node
+        })
+        .collect_vec();
+
+    // Converts newlines after certain elements to paragraph breaks
+    // This is accomplished here instead of in the translating module because at this point there is
+    // still semantic information associated with the elements.
+    //
+    // Newlines are separate expressions in the parse tree (as the Space variant)
+    let should_parbreak = |e1, e2, e3| {
+        matches!(e2, Expr::Space(_))
+            && (matches!(e1, Expr::Heading(_) | Expr::List(_))
+                || matches!(e3, Expr::Heading(_) | Expr::List(_)))
+    };
+
+    let mut res: Vec<Expr> = Vec::new();
+    let mut last_element: Option<Expr> = None;
+    for ((i, expr), (_, next_expr)) in exprs.iter().enumerate().tuple_windows() {
+        let mut current_expr = expr.clone();
+        if let Some(last_element) = last_element {
+            if should_parbreak(last_element, *expr, *next_expr) {
+                let pbreak = typst_syntax::ast::Parbreak::from_untyped(&buf[i])
+                    .expect("Unable to convert expression to Parbreak");
+                current_expr = Expr::Parbreak(pbreak);
+            }
+        }
+        res.push(current_expr);
+        last_element = Some(expr.clone())
+    }
+    // Push last element because it will be excluded by tuple_windows() above
+    if let Some(last) = exprs.iter().last() {
+        res.push(last.clone());
+    }
+
+    res
+}
+
 #[cfg(test)]
 mod tests {
     use itertools::Itertools;
diff --git a/harper-typst/src/typst_translator.rs b/harper-typst/src/typst_translator.rs
index 6d335803..6ba16760 100644
--- a/harper-typst/src/typst_translator.rs
+++ b/harper-typst/src/typst_translator.rs
@@ -149,7 +149,16 @@ impl<'a> TypstTranslator<'a> {
 
         // Recurse on each element of an iterator
         let iter_recurse = |exprs: &mut dyn Iterator<Item = Expr>| {
-            Some(exprs.filter_map(|e| recurse!(e)).flatten().collect_vec())
+            let mut buf = Vec::new();
+            let exprs = exprs.collect_vec();
+            let exprs = super::convert_parbreaks(&mut buf, &exprs);
+            Some(
+                exprs
+                    .into_iter()
+                    .filter_map(|e| recurse!(e))
+                    .flatten()
+                    .collect_vec(),
+            )
         };
 
         // Parse the parameters of a function or closure

From 543a047f2e0eae302eb291f8b82aadd2360733fb Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Tue, 21 Jan 2025 12:47:57 -0700
Subject: [PATCH 6/9] tests(typst): change expected number of errors for
 issue_399 to 3

---
 harper-typst/tests/run_tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/harper-typst/tests/run_tests.rs b/harper-typst/tests/run_tests.rs
index 814787ba..971ce940 100644
--- a/harper-typst/tests/run_tests.rs
+++ b/harper-typst/tests/run_tests.rs
@@ -40,4 +40,4 @@ macro_rules! create_test {
 create_test!(complex_document.typ, 0);
 create_test!(simplified_document.typ, 0);
 create_test!(complex_document_with_spelling_mistakes.typ, 4);
-create_test!(issue_399.typ, 0);
+create_test!(issue_399.typ, 3);

From 0a6aa45664147e53631e99cd431ac86458b483d8 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Tue, 21 Jan 2025 12:49:23 -0700
Subject: [PATCH 7/9] fix(typst): remove duplicated code

---
 harper-typst/src/lib.rs | 42 -----------------------------------------
 1 file changed, 42 deletions(-)

diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs
index a67eb9ea..bbd51aa9 100644
--- a/harper-typst/src/lib.rs
+++ b/harper-typst/src/lib.rs
@@ -23,48 +23,6 @@ impl Parser for Typst {
         let typst_tree = Markup::from_untyped(typst_document.root())
             .expect("Unable to create typst document from parsed tree!");
 
-        // Owned collection of nodes forcibly casted to paragraph breaks
-        let untyped_nodes = typst_tree
-            .exprs()
-            .map(|e| {
-                let mut node = SyntaxNode::placeholder(typst_syntax::SyntaxKind::Parbreak);
-                node.synthesize(e.span());
-                node
-            })
-            .collect_vec();
-
-        // Converts newlines after certain elements to paragraph breaks
-        // This is accomplished here instead of in the translating module because at this point there is
-        // still semantic information associated with the elements.
-        //
-        // Newlines are separate expressions in the parse tree (as the Space variant)
-        let should_parbreak = |e1, e2, e3| {
-            matches!(e2, Expr::Space(_))
-                && (matches!(e1, Expr::Heading(_) | Expr::List(_))
-                    || matches!(e3, Expr::Heading(_) | Expr::List(_)))
-        };
-
-        let mut exprs: Vec<Expr> = Vec::new();
-        let mut last_element: Option<Expr> = None;
-        for ((i, expr), (_, next_expr)) in typst_tree.exprs().enumerate().tuple_windows() {
-            let mut current_expr = expr;
-            if let Some(last_element) = last_element {
-                if should_parbreak(last_element, expr, next_expr) {
-                    let pbreak = typst_syntax::ast::Parbreak::from_untyped(&untyped_nodes[i])
-                        .expect("Unable to convert expression to Parbreak");
-                    current_expr = Expr::Parbreak(pbreak);
-                }
-            }
-            exprs.push(current_expr);
-            last_element = Some(expr)
-        }
-        // Push last element because it will be excluded by tuple_windows() above
-        if let Some(last) = typst_tree.exprs().last() {
-            exprs.push(last);
-        }
-
-        dbg!(&exprs);
-
         // Recurse through AST to create tokens
         let parse_helper = TypstTranslator::new(&typst_document);
         let mut buf = Vec::new();

From 03a0f8403bf94e2f417cbf5e9801eaa6b5f56da8 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Tue, 21 Jan 2025 12:50:18 -0700
Subject: [PATCH 8/9] refactor(typst): move comment to be doc comment of new
 function

---
 harper-typst/src/lib.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/harper-typst/src/lib.rs b/harper-typst/src/lib.rs
index bbd51aa9..2cd2124b 100644
--- a/harper-typst/src/lib.rs
+++ b/harper-typst/src/lib.rs
@@ -36,6 +36,11 @@ impl Parser for Typst {
     }
 }
 
+/// Converts newlines after certain elements to paragraph breaks
+/// This is accomplished here instead of in the translating module because at this point there is
+/// still semantic information associated with the elements.
+///
+/// Newlines are separate expressions in the parse tree (as the Space variant)
 fn convert_parbreaks<'a>(buf: &'a mut Vec<SyntaxNode>, exprs: &'a [Expr]) -> Vec<Expr<'a>> {
     // Owned collection of nodes forcibly casted to paragraph breaks
     *buf = exprs
@@ -47,11 +52,6 @@ fn convert_parbreaks<'a>(buf: &'a mut Vec<SyntaxNode>, exprs: &'a [Expr]) -> Vec
         })
         .collect_vec();
 
-    // Converts newlines after certain elements to paragraph breaks
-    // This is accomplished here instead of in the translating module because at this point there is
-    // still semantic information associated with the elements.
-    //
-    // Newlines are separate expressions in the parse tree (as the Space variant)
     let should_parbreak = |e1, e2, e3| {
         matches!(e2, Expr::Space(_))
             && (matches!(e1, Expr::Heading(_) | Expr::List(_))

From 3cb2980392091baddf8b313dd83c6e2d5fba5454 Mon Sep 17 00:00:00 2001
From: Grant Lemons <grantlemons@aol.com>
Date: Fri, 31 Jan 2025 12:21:30 -0700
Subject: [PATCH 9/9] remove comments from issue_399, comments can be tested
 elsewhere

---
 harper-typst/tests/test_sources/issue_399.typ | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/harper-typst/tests/test_sources/issue_399.typ b/harper-typst/tests/test_sources/issue_399.typ
index 090b53ff..9e5bd0fb 100644
--- a/harper-typst/tests/test_sources/issue_399.typ
+++ b/harper-typst/tests/test_sources/issue_399.typ
@@ -8,11 +8,8 @@
 
 #aside[
 	at $x=-2$ jump discontinuity. 
-        // this "at" doesn't get flagged
 
 	at $x=0$ infinite discontinuity.
-	// this "at" does `This sentence doesn't start with a capital letter`
 
 	at $x=3$ removable discontinuity. (can be removed via re-defining the domain to exclude that)
-        // this "at" does `This sentence doesn't start with a capital letter`
 ]