From 66986a04715cf2cc71032cff27eb1785af1a6fe4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Delafargue?= <clement@delafargue.name>
Date: Fri, 17 Mar 2023 11:02:42 +0100
Subject: [PATCH 1/2] [WIP] TS-based spell-checking with hunspell

Co-authored-by: Connor Lay (Clay) <connorlay@pm.me>
---
 Cargo.lock                               |  9 +++
 Cargo.toml                               |  1 +
 helix-core/src/lib.rs                    |  1 +
 helix-core/src/spellcheck.rs             | 22 +++++++
 helix-core/src/syntax.rs                 | 11 ++++
 helix-spell/Cargo.toml                   | 11 ++++
 helix-spell/src/client.rs                | 70 +++++++++++++++++++++
 helix-spell/src/lib.rs                   |  1 +
 helix-term/Cargo.toml                    |  1 +
 helix-term/src/commands.rs               | 45 ++++++++++++++
 helix-term/src/commands/typed.rs         | 42 +++++++++++++
 helix-term/src/keymap/default.rs         |  2 +
 helix-term/src/ui/editor.rs              |  6 +-
 helix-term/src/ui/statusline.rs          | 27 ++++----
 helix-view/Cargo.toml                    |  1 +
 helix-view/src/document.rs               | 78 ++++++++++++++++++++++++
 helix-view/src/editor.rs                 |  9 +++
 helix-view/src/gutter.rs                 |  2 +-
 runtime/queries/elixir/spellchecks.scm   | 13 ++++
 runtime/queries/markdown/spellchecks.scm |  1 +
 runtime/queries/rust/spellchecks.scm     |  4 ++
 21 files changed, 341 insertions(+), 16 deletions(-)
 create mode 100644 helix-core/src/spellcheck.rs
 create mode 100644 helix-spell/Cargo.toml
 create mode 100644 helix-spell/src/client.rs
 create mode 100644 helix-spell/src/lib.rs
 create mode 100644 runtime/queries/elixir/spellchecks.scm
 create mode 100644 runtime/queries/markdown/spellchecks.scm
 create mode 100644 runtime/queries/rust/spellchecks.scm

diff --git a/Cargo.lock b/Cargo.lock
index af0858efe4d7..5fb1c7e41e1e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1154,6 +1154,13 @@ dependencies = [
 name = "helix-parsec"
 version = "0.6.0"
 
+[[package]]
+name = "helix-spell"
+version = "0.6.0"
+dependencies = [
+ "log",
+]
+
 [[package]]
 name = "helix-term"
 version = "0.6.0"
@@ -1172,6 +1179,7 @@ dependencies = [
  "helix-dap",
  "helix-loader",
  "helix-lsp",
+ "helix-spell",
  "helix-tui",
  "helix-vcs",
  "helix-view",
@@ -1238,6 +1246,7 @@ dependencies = [
  "helix-dap",
  "helix-loader",
  "helix-lsp",
+ "helix-spell",
  "helix-tui",
  "helix-vcs",
  "libc",
diff --git a/Cargo.toml b/Cargo.toml
index aaa21659ada3..67e8c78de0b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ members = [
   "helix-loader",
   "helix-vcs",
   "helix-parsec",
+  "helix-spell",
   "xtask",
 ]
 
diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs
index e3f862a6054c..834cd089bfe1 100644
--- a/helix-core/src/lib.rs
+++ b/helix-core/src/lib.rs
@@ -22,6 +22,7 @@ pub mod register;
 pub mod search;
 pub mod selection;
 pub mod shellwords;
+pub mod spellcheck;
 pub mod surround;
 pub mod syntax;
 pub mod test;
diff --git a/helix-core/src/spellcheck.rs b/helix-core/src/spellcheck.rs
new file mode 100644
index 000000000000..6b74ddb09fb8
--- /dev/null
+++ b/helix-core/src/spellcheck.rs
@@ -0,0 +1,22 @@
+use crate::selection::Range;
+use crate::syntax::LanguageConfiguration;
+use crate::RopeSlice;
+use tree_sitter::{Node, QueryCursor};
+
+pub fn spellcheck_treesitter(
+    doc_tree: Node,
+    doc_slice: RopeSlice,
+    lang_config: &LanguageConfiguration,
+) -> Option<Vec<Range>> {
+    let mut cursor = QueryCursor::new();
+    let ranges: Vec<Range> = lang_config
+        .spellcheck_query()?
+        .capture_nodes("spell", doc_tree, doc_slice, &mut cursor)?
+        .map(|node| {
+            let start_char = doc_slice.byte_to_char(node.start_byte());
+            let end_char = doc_slice.byte_to_char(node.end_byte());
+            Range::new(start_char, end_char)
+        })
+        .collect();
+    Some(ranges)
+}
diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs
index 941e3ba7bd3b..8f332883e399 100644
--- a/helix-core/src/syntax.rs
+++ b/helix-core/src/syntax.rs
@@ -116,6 +116,8 @@ pub struct LanguageConfiguration {
     pub(crate) indent_query: OnceCell<Option<Query>>,
     #[serde(skip)]
     pub(crate) textobject_query: OnceCell<Option<TextObjectQuery>>,
+    #[serde(skip)]
+    pub(crate) spellcheck_query: OnceCell<Option<TextObjectQuery>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub debugger: Option<DebugAdapterConfig>,
 
@@ -525,6 +527,15 @@ impl LanguageConfiguration {
             .as_ref()
     }
 
+    pub fn spellcheck_query(&self) -> Option<&TextObjectQuery> {
+        self.spellcheck_query
+            .get_or_init(|| {
+                self.load_query("spellchecks.scm")
+                    .map(|query| TextObjectQuery { query })
+            })
+            .as_ref()
+    }
+
     pub fn scope(&self) -> &str {
         &self.scope
     }
diff --git a/helix-spell/Cargo.toml b/helix-spell/Cargo.toml
new file mode 100644
index 000000000000..072413c3a9a6
--- /dev/null
+++ b/helix-spell/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "helix-spell"
+version = "0.6.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# i can't have it compile on my machine yet
+#hunspell-rs = "0.4.0"
+log = "0.4"
diff --git a/helix-spell/src/client.rs b/helix-spell/src/client.rs
new file mode 100644
index 000000000000..2f92e6a59c5f
--- /dev/null
+++ b/helix-spell/src/client.rs
@@ -0,0 +1,70 @@
+//use hunspell_rs::Hunspell;
+use std::collections::HashMap;
+
+// dummy placeholder to test behaviour while i figure out how to make hunspell-rs compile
+struct Hunspell;
+
+mod hunspell_rs {
+    pub enum CheckResult {
+        MissingInDictionary,
+        CheckOk,
+    }
+}
+
+impl Hunspell {
+    pub fn new(_: &str, _: &str) -> Self {
+        Hunspell
+    }
+
+    pub fn check(&self, word: &str) -> hunspell_rs::CheckResult {
+        if word == "bad" {
+            hunspell_rs::CheckResult::MissingInDictionary
+        } else {
+            hunspell_rs::CheckResult::CheckOk
+        }
+    }
+
+    fn suggest(&self, _: &str) -> Vec<String> {
+        vec!["toto".to_owned()]
+    }
+}
+
+pub struct Client {
+    hunspell: Hunspell,
+    suggest_cache: HashMap<String, Vec<String>>,
+}
+
+impl Default for Client {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Client {
+    pub fn new() -> Self {
+        let hunspell = Hunspell::new(
+            "/usr/share/hunspell/en_US.aff",
+            "/usr/share/hunspell/en_US.dic",
+        );
+        let suggest_cache = HashMap::new();
+        Self {
+            hunspell,
+            suggest_cache,
+        }
+    }
+
+    pub fn check(&mut self, word: &str) -> Result<(), Vec<String>> {
+        if let hunspell_rs::CheckResult::MissingInDictionary = self.hunspell.check(word) {
+            let suggestions = if let Some((_, words)) = self.suggest_cache.get_key_value(word) {
+                words
+            } else {
+                let words = self.hunspell.suggest(word);
+                self.suggest_cache.insert(word.to_string(), words);
+                self.suggest_cache.get(word).unwrap()
+            };
+            Err(suggestions.to_vec())
+        } else {
+            Ok(())
+        }
+    }
+}
diff --git a/helix-spell/src/lib.rs b/helix-spell/src/lib.rs
new file mode 100644
index 000000000000..b9babe5bc1d6
--- /dev/null
+++ b/helix-spell/src/lib.rs
@@ -0,0 +1 @@
+pub mod client;
diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml
index 5222ddaa15f6..a4640f66dad2 100644
--- a/helix-term/Cargo.toml
+++ b/helix-term/Cargo.toml
@@ -29,6 +29,7 @@ helix-lsp = { version = "0.6", path = "../helix-lsp" }
 helix-dap = { version = "0.6", path = "../helix-dap" }
 helix-vcs = { version = "0.6", path = "../helix-vcs" }
 helix-loader = { version = "0.6", path = "../helix-loader" }
+helix-spell = { version = "0.6", path = "../helix-spell" }
 
 anyhow = "1"
 once_cell = "1.17"
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 1c1edece1a31..645001bc727c 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -339,6 +339,8 @@ impl MappableCommand {
         goto_prev_change, "Goto previous change",
         goto_first_change, "Goto first change",
         goto_last_change, "Goto last change",
+        goto_next_misspell, "Goto next misspell",
+        goto_prev_misspell, "Goto previous misspell",
         goto_line_start, "Goto line start",
         goto_line_end, "Goto line end",
         goto_next_buffer, "Goto next buffer",
@@ -3115,6 +3117,49 @@ fn hunk_range(hunk: Hunk, text: RopeSlice) -> Range {
     Range::new(anchor, head)
 }
 
+fn goto_next_misspell(cx: &mut Context) {
+    let (view, doc) = current!(cx.editor);
+
+    let cursor_pos = doc
+        .selection(view.id)
+        .primary()
+        .cursor(doc.text().slice(..));
+
+    let diag = doc
+        .spell_diagnostics()
+        .iter()
+        .find(|diag| diag.range.start > cursor_pos)
+        .or_else(|| doc.diagnostics().first());
+
+    let selection = match diag {
+        Some(diag) => Selection::single(diag.range.start, diag.range.end),
+        None => return,
+    };
+    doc.set_selection(view.id, selection);
+}
+
+fn goto_prev_misspell(cx: &mut Context) {
+    let (view, doc) = current!(cx.editor);
+
+    let cursor_pos = doc
+        .selection(view.id)
+        .primary()
+        .cursor(doc.text().slice(..));
+
+    let diag = doc
+        .spell_diagnostics()
+        .iter()
+        .rev()
+        .find(|diag| diag.range.start < cursor_pos)
+        .or_else(|| doc.spell_diagnostics().last());
+
+    let selection = match diag {
+        Some(diag) => Selection::single(diag.range.start, diag.range.end),
+        None => return,
+    };
+    doc.set_selection(view.id, selection);
+}
+
 pub mod insert {
     use super::*;
     pub type Hook = fn(&Rope, &Selection, char) -> Option<Transaction>;
diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs
index 6fbdc0d7afa3..0b9fca519801 100644
--- a/helix-term/src/commands/typed.rs
+++ b/helix-term/src/commands/typed.rs
@@ -330,10 +330,15 @@ fn write_impl(
     force: bool,
 ) -> anyhow::Result<()> {
     let editor_auto_fmt = cx.editor.config().auto_format;
+    let editor_auto_spellcheck = cx.editor.config().auto_spellcheck;
     let jobs = &mut cx.jobs;
     let (view, doc) = current!(cx.editor);
     let path = path.map(AsRef::as_ref);
 
+    if editor_auto_spellcheck {
+        jobs.callback(make_spell_check_callback(doc.id()));
+    };
+
     let fmt = if editor_auto_fmt {
         doc.auto_format().map(|fmt| {
             let callback = make_format_callback(
@@ -413,6 +418,31 @@ fn format(
 
     Ok(())
 }
+
+fn spell_check(
+    cx: &mut compositor::Context,
+    _args: &[Cow<str>],
+    event: PromptEvent,
+) -> anyhow::Result<()> {
+    if event != PromptEvent::Validate {
+        return Ok(());
+    }
+    let doc = doc!(cx.editor);
+    cx.jobs.callback(make_spell_check_callback(doc.id()));
+    Ok(())
+}
+
+async fn make_spell_check_callback(doc_id: DocumentId) -> anyhow::Result<job::Callback> {
+    let call: job::Callback = job::Callback::EditorCompositor(Box::new(
+        move |editor: &mut Editor, _: &mut Compositor| {
+            if let Some(doc) = editor.document_mut(doc_id) {
+                doc.spell_check();
+            };
+        },
+    ));
+    Ok(call)
+}
+
 fn set_indent_style(
     cx: &mut compositor::Context,
     args: &[Cow<str>],
@@ -628,6 +658,7 @@ pub fn write_all_impl(
 ) -> anyhow::Result<()> {
     let mut errors: Vec<&'static str> = Vec::new();
     let auto_format = cx.editor.config().auto_format;
+    let auto_spellcheck = cx.editor.config().auto_spellcheck;
     let jobs = &mut cx.jobs;
     let current_view = view!(cx.editor);
 
@@ -662,6 +693,10 @@ pub fn write_all_impl(
                 current_view.id
             };
 
+            if auto_spellcheck {
+                jobs.callback(make_spell_check_callback(doc.id()));
+            };
+
             let fmt = if auto_format {
                 doc.auto_format().map(|fmt| {
                     let callback = make_format_callback(
@@ -2257,6 +2292,13 @@ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[
             fun: format,
             signature: CommandSignature::none(),
         },
+        TypableCommand {
+            name: "spell-check",
+            aliases: &["sc"],
+            doc: "Check spelling using tree-sitter and hunspell.",
+            fun: spell_check,
+            signature: CommandSignature::none(),
+        },
         TypableCommand {
             name: "indent-style",
             aliases: &[],
diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs
index 9bd002809d61..559da63a7f65 100644
--- a/helix-term/src/keymap/default.rs
+++ b/helix-term/src/keymap/default.rs
@@ -106,6 +106,7 @@ pub fn default() -> HashMap<Mode, Keymap> {
             "D" => goto_first_diag,
             "g" => goto_prev_change,
             "G" => goto_first_change,
+            "z" => goto_prev_misspell,
             "f" => goto_prev_function,
             "t" => goto_prev_class,
             "a" => goto_prev_parameter,
@@ -119,6 +120,7 @@ pub fn default() -> HashMap<Mode, Keymap> {
             "D" => goto_last_diag,
             "g" => goto_next_change,
             "G" => goto_last_change,
+            "z" => goto_next_misspell,
             "f" => goto_next_function,
             "t" => goto_next_class,
             "a" => goto_next_parameter,
diff --git a/helix-term/src/ui/editor.rs b/helix-term/src/ui/editor.rs
index 7c22df747642..8cd3fd38f679 100644
--- a/helix-term/src/ui/editor.rs
+++ b/helix-term/src/ui/editor.rs
@@ -372,7 +372,8 @@ impl EditorView {
         let mut warning_vec = Vec::new();
         let mut error_vec = Vec::new();
 
-        for diagnostic in doc.diagnostics() {
+        let all_diagnostics = doc.all_diagnostics();
+        for diagnostic in all_diagnostics {
             // Separate diagnostics into different Vecs by severity.
             let (vec, scope) = match diagnostic.severity {
                 Some(Severity::Info) => (&mut info_vec, info),
@@ -662,7 +663,8 @@ impl EditorView {
             .primary()
             .cursor(doc.text().slice(..));
 
-        let diagnostics = doc.diagnostics().iter().filter(|diagnostic| {
+        let all_diagnostics = doc.all_diagnostics();
+        let diagnostics = all_diagnostics.iter().filter(|diagnostic| {
             diagnostic.range.start <= cursor && diagnostic.range.end >= cursor
         });
 
diff --git a/helix-term/src/ui/statusline.rs b/helix-term/src/ui/statusline.rs
index 887863519319..76782122bcb3 100644
--- a/helix-term/src/ui/statusline.rs
+++ b/helix-term/src/ui/statusline.rs
@@ -223,19 +223,20 @@ fn render_diagnostics<F>(context: &mut RenderContext, write: F)
 where
     F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
 {
-    let (warnings, errors) = context
-        .doc
-        .diagnostics()
-        .iter()
-        .fold((0, 0), |mut counts, diag| {
-            use helix_core::diagnostic::Severity;
-            match diag.severity {
-                Some(Severity::Warning) => counts.0 += 1,
-                Some(Severity::Error) | None => counts.1 += 1,
-                _ => {}
-            }
-            counts
-        });
+    let (warnings, errors) =
+        context
+            .doc
+            .all_diagnostics()
+            .iter()
+            .fold((0, 0), |mut counts, diag| {
+                use helix_core::diagnostic::Severity;
+                match diag.severity {
+                    Some(Severity::Warning) => counts.0 += 1,
+                    Some(Severity::Error) | None => counts.1 += 1,
+                    _ => {}
+                }
+                counts
+            });
 
     if warnings > 0 {
         write(
diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml
index e3f98a8d3c29..9a5c2ef6f1d3 100644
--- a/helix-view/Cargo.toml
+++ b/helix-view/Cargo.toml
@@ -22,6 +22,7 @@ helix-lsp = { version = "0.6", path = "../helix-lsp" }
 helix-dap = { version = "0.6", path = "../helix-dap" }
 crossterm = { version = "0.26", optional = true }
 helix-vcs = { version = "0.6", path = "../helix-vcs" }
+helix-spell = { version = "0.6", path = "../helix-spell" }
 
 # Conversion traits
 once_cell = "1.17"
diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs
index eca6002653f5..5fc21ea17ae6 100644
--- a/helix-view/src/document.rs
+++ b/helix-view/src/document.rs
@@ -5,6 +5,7 @@ use futures_util::future::BoxFuture;
 use futures_util::FutureExt;
 use helix_core::auto_pairs::AutoPairs;
 use helix_core::doc_formatter::TextFormat;
+use helix_core::regex::Regex;
 use helix_core::syntax::Highlight;
 use helix_core::text_annotations::{InlineAnnotation, TextAnnotations};
 use helix_core::Range;
@@ -165,10 +166,13 @@ pub struct Document {
     pub(crate) modified_since_accessed: bool,
 
     diagnostics: Vec<Diagnostic>,
+    spell_diagnostics: Vec<Diagnostic>,
     language_server: Option<Arc<helix_lsp::Client>>,
 
     diff_handle: Option<DiffHandle>,
     version_control_head: Option<Arc<ArcSwap<Box<str>>>>,
+
+    spell_checker: Option<Arc<Mutex<helix_spell::client::Client>>>,
 }
 
 /// Inlay hints for a single `(Document, View)` combo.
@@ -486,6 +490,7 @@ impl Document {
             changes,
             old_state,
             diagnostics: Vec::new(),
+            spell_diagnostics: Vec::new(),
             version: 0,
             history: Cell::new(History::default()),
             savepoints: Vec::new(),
@@ -496,6 +501,7 @@ impl Document {
             diff_handle: None,
             config,
             version_control_head: None,
+            spell_checker: None,
         }
     }
     pub fn default(config: Arc<dyn DynAccess<Config>>) -> Self {
@@ -534,6 +540,52 @@ impl Document {
         Ok(doc)
     }
 
+    pub fn spell_check(&mut self) {
+        let mut diagnostics = Vec::new();
+        let spell_checker = self.spell_checker.clone().unwrap();
+        if let Some(node) = self.syntax() {
+            let doc_slice = self.text().slice(..);
+            if let Some(ranges) = helix_core::spellcheck::spellcheck_treesitter(
+                node.tree().root_node(),
+                doc_slice,
+                self.language_config().unwrap(),
+            ) {
+                let mut client = spell_checker.lock();
+                let regex = Regex::new(r"[[:alpha:]']+").unwrap();
+                for range in ranges {
+                    let (start_line, _) = range.line_range(doc_slice);
+                    let mut position = range.from();
+                    for (i, line_slice) in range.slice(doc_slice).lines().enumerate() {
+                        let line = String::from(line_slice);
+                        for capture in regex.captures_iter(line.as_str()) {
+                            let capture_match = capture.get(0).unwrap();
+                            let word = capture_match.as_str();
+                            let start = capture_match.start();
+                            let end = capture_match.end();
+                            if let Err(suggestions) = client.check(word) {
+                                diagnostics.push(Diagnostic {
+                                    severity: Some(helix_core::diagnostic::Severity::Warning),
+                                    code: None,
+                                    tags: Vec::new(),
+                                    source: None,
+                                    message: suggestions.join("\n"),
+                                    line: start_line + i,
+                                    range: helix_core::diagnostic::Range {
+                                        start: position + start,
+                                        end: position + end,
+                                    },
+                                    data: None,
+                                });
+                            }
+                        }
+                        position += line_slice.len_chars();
+                    }
+                }
+            };
+        };
+        self.set_spell_diagnostics(diagnostics);
+    }
+
     /// The same as [`format`], but only returns formatting changes if auto-formatting
     /// is configured.
     pub fn auto_format(&self) -> Option<BoxFuture<'static, Result<Transaction, FormatterError>>> {
@@ -875,6 +927,14 @@ impl Document {
         self.language_server = language_server;
     }
 
+    /// Set the spell checker.
+    pub fn set_spell_checker(
+        &mut self,
+        spell_checker: Option<Arc<Mutex<helix_spell::client::Client>>>,
+    ) {
+        self.spell_checker = spell_checker;
+    }
+
     /// Select text within the [`Document`].
     pub fn set_selection(&mut self, view_id: ViewId, selection: Selection) {
         // TODO: use a transaction?
@@ -1380,6 +1440,13 @@ impl Document {
         )
     }
 
+    pub fn all_diagnostics(&self) -> Vec<&Diagnostic> {
+        self.diagnostics
+            .iter()
+            .chain(self.spell_diagnostics.iter())
+            .collect()
+    }
+
     #[inline]
     pub fn diagnostics(&self) -> &[Diagnostic] {
         &self.diagnostics
@@ -1391,6 +1458,17 @@ impl Document {
             .sort_unstable_by_key(|diagnostic| diagnostic.range);
     }
 
+    #[inline]
+    pub fn spell_diagnostics(&self) -> &[Diagnostic] {
+        &self.spell_diagnostics
+    }
+
+    pub fn set_spell_diagnostics(&mut self, diagnostics: Vec<Diagnostic>) {
+        self.spell_diagnostics = diagnostics;
+        self.spell_diagnostics
+            .sort_unstable_by_key(|diagnostic| diagnostic.range);
+    }
+
     /// Get the document's auto pairs. If the document has a recognized
     /// language config with auto pairs configured, returns that;
     /// otherwise, falls back to the global auto pairs config. If the global
diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs
index 7207baf38a2e..4b11656584ae 100644
--- a/helix-view/src/editor.rs
+++ b/helix-view/src/editor.rs
@@ -15,8 +15,10 @@ use helix_vcs::DiffProviderRegistry;
 use futures_util::stream::select_all::SelectAll;
 use futures_util::{future, StreamExt};
 use helix_lsp::Call;
+use helix_spell::client as spell;
 use tokio_stream::wrappers::UnboundedReceiverStream;
 
+use ::parking_lot::Mutex;
 use std::{
     borrow::Cow,
     cell::Cell,
@@ -239,6 +241,8 @@ pub struct Config {
     pub auto_completion: bool,
     /// Automatic formatting on save. Defaults to true.
     pub auto_format: bool,
+    /// Automatic spell checking on save. Defaults to true.
+    pub auto_spellcheck: bool,
     /// Automatic save on focus lost. Defaults to false.
     pub auto_save: bool,
     /// Set a global text_width
@@ -731,6 +735,7 @@ impl Default for Config {
             auto_pairs: AutoPairConfig::default(),
             auto_completion: true,
             auto_format: true,
+            auto_spellcheck: true,
             auto_save: false,
             idle_timeout: Duration::from_millis(400),
             completion_trigger_len: 2,
@@ -812,6 +817,7 @@ pub struct Editor {
     pub language_servers: helix_lsp::Registry,
     pub diagnostics: BTreeMap<lsp::Url, Vec<lsp::Diagnostic>>,
     pub diff_providers: DiffProviderRegistry,
+    pub spell_checker: Arc<Mutex<spell::Client>>,
 
     pub debugger: Option<dap::Client>,
     pub debugger_events: SelectAll<UnboundedReceiverStream<dap::Payload>>,
@@ -972,6 +978,7 @@ impl Editor {
             needs_redraw: false,
             cursor_cache: Cell::new(None),
             completion_request_handle: None,
+            spell_checker: Arc::new(Mutex::new(spell::Client::new())),
         }
     }
 
@@ -1321,6 +1328,8 @@ impl Editor {
             }
             doc.set_version_control_head(self.diff_providers.get_current_head_name(&path));
 
+            doc.set_spell_checker(Some(self.spell_checker.clone()));
+
             let id = self.new_document(doc);
             let _ = self.launch_language_server(id);
 
diff --git a/helix-view/src/gutter.rs b/helix-view/src/gutter.rs
index 36e8e16a436e..0853e934848d 100644
--- a/helix-view/src/gutter.rs
+++ b/helix-view/src/gutter.rs
@@ -55,7 +55,7 @@ pub fn diagnostic<'doc>(
     let error = theme.get("error");
     let info = theme.get("info");
     let hint = theme.get("hint");
-    let diagnostics = doc.diagnostics();
+    let diagnostics = doc.all_diagnostics();
 
     Box::new(
         move |line: usize, _selected: bool, first_visual_line: bool, out: &mut String| {
diff --git a/runtime/queries/elixir/spellchecks.scm b/runtime/queries/elixir/spellchecks.scm
new file mode 100644
index 000000000000..c3fbcfd33e4a
--- /dev/null
+++ b/runtime/queries/elixir/spellchecks.scm
@@ -0,0 +1,13 @@
+(unary_operator
+  operator: "@"
+  operand: (call
+    target: (identifier) @spell.__attribute__
+    (arguments
+      [
+        (string) @spell
+        (charlist) @spell
+        (sigil (quoted_content) @spell)
+      ]))
+  (#match? @spell.__attribute__ "^(moduledoc|typedoc|doc)$"))
+
+(comment) @spell
diff --git a/runtime/queries/markdown/spellchecks.scm b/runtime/queries/markdown/spellchecks.scm
new file mode 100644
index 000000000000..027005db8ff7
--- /dev/null
+++ b/runtime/queries/markdown/spellchecks.scm
@@ -0,0 +1 @@
+(paragraph) @spell
diff --git a/runtime/queries/rust/spellchecks.scm b/runtime/queries/rust/spellchecks.scm
new file mode 100644
index 000000000000..98499baf43c0
--- /dev/null
+++ b/runtime/queries/rust/spellchecks.scm
@@ -0,0 +1,4 @@
+[
+  (line_comment)
+  (block_comment)
+] @spell

From d083dfeb3021e12433280d9fbdc3bb9bd81b110f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Delafargue?= <clement@delafargue.name>
Date: Fri, 17 Mar 2023 11:23:35 +0100
Subject: [PATCH 2/2] feat(spellcheck): update documentation

---
 book/src/generated/typable-cmd.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/book/src/generated/typable-cmd.md b/book/src/generated/typable-cmd.md
index 8b367aad8bc4..286eb683f0bc 100644
--- a/book/src/generated/typable-cmd.md
+++ b/book/src/generated/typable-cmd.md
@@ -15,6 +15,7 @@
 | `:write!`, `:w!` | Force write changes to disk creating necessary subdirectories. Accepts an optional path (:write some/path.txt) |
 | `:new`, `:n` | Create a new scratch buffer. |
 | `:format`, `:fmt` | Format the file using the LSP formatter. |
+| `:spell-check`, `:sc` | Check spelling using tree-sitter and hunspell. |
 | `:indent-style` | Set the indentation style for editing. ('t' for tabs or 1-8 for number of spaces.) |
 | `:line-ending` | Set the document's default line ending. Options: crlf, lf. |
 | `:earlier`, `:ear` | Jump back to an earlier point in edit history. Accepts a number of steps or a time span. |