Skip to content

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

feat: number agreement in this/these type(s) of thing(s) (#2400)

Andrew Dunbaradf42ee8b676
diff --git a/harper-core/src/linting/lint_group.rs b/harper-core/src/linting/lint_group.rs
index b698b7143..c85b9b512 100644
--- a/harper-core/src/linting/lint_group.rs
+++ b/harper-core/src/linting/lint_group.rs
@@ -187,6 +187,7 @@ use super::then_than::ThenThan;
use super::theres::Theres;
use super::theses_these::ThesesThese;
use super::thing_think::ThingThink;
+use super::this_type_of_thing::ThisTypeOfThing;
use super::though_thought::ThoughThought;
use super::throw_away::ThrowAway;
use super::throw_rubbish::ThrowRubbish;
@@ -660,6 +661,7 @@ impl LintGroup {
insert_expr_rule!(Theres, true);
insert_expr_rule!(ThesesThese, true);
insert_expr_rule!(ThingThink, true);
+ insert_expr_rule!(ThisTypeOfThing, true);
insert_expr_rule!(ThoughThought, true);
insert_expr_rule!(ThrowAway, true);
insert_struct_rule!(ThrowRubbish, true);
diff --git a/harper-core/src/linting/mod.rs b/harper-core/src/linting/mod.rs
index 828b4631e..e633bde02 100644
--- a/harper-core/src/linting/mod.rs
+++ b/harper-core/src/linting/mod.rs
@@ -199,6 +199,7 @@ mod then_than;
mod theres;
mod theses_these;
mod thing_think;
+mod this_type_of_thing;
mod though_thought;
mod throw_away;
mod throw_rubbish;
diff --git a/harper-core/src/linting/this_type_of_thing.rs b/harper-core/src/linting/this_type_of_thing.rs
new file mode 100644
index 000000000..651c7b0b8
--- /dev/null
+++ b/harper-core/src/linting/this_type_of_thing.rs
@@ -0,0 +1,257 @@
+use crate::{
+ CharStringExt, Lint, Token,
+ expr::{Expr, SequenceExpr},
+ linting::{ExprLinter, LintKind, Suggestion, expr_linter::Chunk},
+ patterns::WordSet,
+};
+
+pub struct ThisTypeOfThing {
+ expr: Box<dyn Expr>,
+}
+
+impl Default for ThisTypeOfThing {
+ fn default() -> Self {
+ Self {
+ expr: Box::new(
+ SequenceExpr::word_set(&["this", "these", "that", "those"])
+ .t_ws()
+ .then(
+ SequenceExpr::word_set(&[
+ "kind", "kinds", "sort", "sorts", "type", "types",
+ ])
+ .t_ws(),
+ )
+ .then(SequenceExpr::aco("of").t_ws())
+ .then_any_of(vec![
+ // "thing" is common in this construction and won't be part of a compound noun.
+ Box::new(WordSet::new(&["thing", "things"])),
+ // Other singular nouns may be part of hard-to-determine compound nouns, but plural nouns won't.
+ Box::new(
+ SequenceExpr::default()
+ .then_kind_where(|k| k.is_plural_noun() && !k.is_singular_noun()),
+ ),
+ ]),
+ ),
+ }
+ }
+}
+
+impl ExprLinter for ThisTypeOfThing {
+ type Unit = Chunk;
+
+ fn expr(&self) -> &dyn Expr {
+ self.expr.as_ref()
+ }
+
+ fn description(&self) -> &str {
+ "Checks that the parts of `this/these type(s) of thing(s)` agree in grammatical number"
+ }
+
+ fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+ #[derive(PartialEq)]
+ enum Num {
+ Sg,
+ Pl,
+ }
+
+ let (det_tok, type_tok, thing_tok) = (toks.first()?, toks.get(2)?, toks.last()?);
+ let (type_kind, thing_kind) = (&type_tok.kind, &thing_tok.kind);
+ let (det_span, type_span) = (det_tok.span, type_tok.span);
+ let (det_chars, type_chars) = (det_span.get_content(src), type_span.get_content(src));
+ let (det_num, type_num, thing_num) = (
+ if det_chars.eq_any_ignore_ascii_case_str(&["this", "that"]) {
+ Num::Sg
+ } else {
+ Num::Pl
+ },
+ if type_kind.is_plural_noun() {
+ Num::Pl
+ } else {
+ Num::Sg
+ },
+ if thing_kind.is_plural_noun() {
+ Num::Pl
+ } else {
+ Num::Sg
+ },
+ );
+ if det_num == type_num && type_num == thing_num {
+ return None;
+ };
+
+ enum Deixis {
+ Proximal,
+ Distal,
+ }
+ let deixis = if det_chars.eq_any_ignore_ascii_case_str(&["this", "these"]) {
+ Deixis::Proximal
+ } else {
+ Deixis::Distal
+ };
+
+ enum Specie {
+ Kind,
+ Sort,
+ Type,
+ }
+ let specie = match type_chars.first()? {
+ 'k' | 'K' => Specie::Kind,
+ 's' | 'S' => Specie::Sort,
+ 't' | 'T' => Specie::Type,
+ _ => return None,
+ };
+
+ // Due to the logic above, when we get here we either have 1 singular and 2 plurals or 2 plurals and 1 singular.
+ // Meaning one of the three varying words does not agree in number with the other two.
+ let bad_tok = match (&det_num, &type_num, &thing_num) {
+ (Num::Sg, Num::Sg, Num::Pl) => thing_tok,
+ (Num::Sg, Num::Pl, Num::Sg) => type_tok,
+ (Num::Sg, Num::Pl, Num::Pl) => det_tok,
+ (Num::Pl, Num::Sg, Num::Sg) => det_tok,
+ (Num::Pl, Num::Sg, Num::Pl) => type_tok,
+ (Num::Pl, Num::Pl, Num::Sg) => thing_tok,
+ _ => return None,
+ };
+
+ Some(Lint {
+ span: bad_tok.span,
+ lint_kind: LintKind::Agreement,
+ suggestions: vec![Suggestion::replace_with_match_case(
+ if bad_tok == det_tok {
+ match (det_num, deixis) {
+ (Num::Sg, Deixis::Proximal) => "these",
+ (Num::Sg, Deixis::Distal) => "those",
+ (Num::Pl, Deixis::Proximal) => "this",
+ (Num::Pl, Deixis::Distal) => "that",
+ }
+ } else if bad_tok == type_tok {
+ match (type_num, specie) {
+ (Num::Sg, Specie::Kind) => "kinds",
+ (Num::Pl, Specie::Kind) => "kind",
+ (Num::Sg, Specie::Sort) => "sorts",
+ (Num::Pl, Specie::Sort) => "sort",
+ (Num::Sg, Specie::Type) => "types",
+ (Num::Pl, Specie::Type) => "type",
+ }
+ } else if bad_tok == thing_tok {
+ match thing_num {
+ Num::Sg => "things",
+ Num::Pl => "thing",
+ }
+ } else {
+ return None;
+ }
+ .chars()
+ .collect(),
+ bad_tok.span.get_content(src),
+ )],
+ message: "The grammatical number of the determiner and the two nouns must agree."
+ .to_string(),
+ ..Default::default()
+ })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::linting::{tests::assert_suggestion_result, this_type_of_thing::ThisTypeOfThing};
+
+ #[test]
+ fn fix_that_kind_of_things() {
+ assert_suggestion_result(
+ "it's specific to TypeScript and not Go nor Python can do that kind of things",
+ ThisTypeOfThing::default(),
+ "it's specific to TypeScript and not Go nor Python can do that kind of thing",
+ );
+ }
+
+ #[test]
+ fn fix_that_sort_of_things() {
+ assert_suggestion_result(
+ "there isn't a trivial stb-like ready-to-use C++ library to do that sort of things",
+ ThisTypeOfThing::default(),
+ "there isn't a trivial stb-like ready-to-use C++ library to do that sort of thing",
+ );
+ }
+
+ #[test]
+ fn fix_these_kind_of_things() {
+ assert_suggestion_result(
+ "For these kind of things, I think it would be great to have a user-defined field which can be used to search for files.",
+ ThisTypeOfThing::default(),
+ "For these kinds of things, I think it would be great to have a user-defined field which can be used to search for files.",
+ );
+ }
+
+ #[test]
+ fn fix_these_sort_of_thing() {
+ assert_suggestion_result(
+ "People from npm actually get death threats for these sort of thing",
+ ThisTypeOfThing::default(),
+ "People from npm actually get death threats for this sort of thing",
+ );
+ }
+
+ #[test]
+ fn fix_these_sort_of_things() {
+ assert_suggestion_result(
+ "I suppose doing these sort of things should be legal",
+ ThisTypeOfThing::default(),
+ "I suppose doing these sorts of things should be legal",
+ );
+ }
+
+ #[test]
+ fn fix_these_sorts_of_thing() {
+ assert_suggestion_result(
+ "What I would like to understand is what the syntactic structure is for these sorts of things.",
+ ThisTypeOfThing::default(),
+ "What I would like to understand is what the syntactic structure is for these sorts of things.",
+ );
+ }
+
+ #[test]
+ fn fix_these_type_of_things() {
+ assert_suggestion_result(
+ "You can use the Symfony validator to validate these type of things easily.",
+ ThisTypeOfThing::default(),
+ "You can use the Symfony validator to validate these types of things easily.",
+ );
+ }
+
+ #[test]
+ fn fix_this_kind_of_things() {
+ assert_suggestion_result(
+ "this kind of things could exists in languages like Haskell which supports higher kinded types",
+ ThisTypeOfThing::default(),
+ "this kind of thing could exists in languages like Haskell which supports higher kinded types",
+ );
+ }
+
+ #[test]
+ fn fix_this_sort_of_things() {
+ assert_suggestion_result(
+ "I have heard this sort of things happening in the movie industry but it's appalling that it happens in the business world too",
+ ThisTypeOfThing::default(),
+ "I have heard this sort of thing happening in the movie industry but it's appalling that it happens in the business world too",
+ );
+ }
+
+ #[test]
+ fn fix_this_type_of_things() {
+ assert_suggestion_result(
+ "how to handle this type of things",
+ ThisTypeOfThing::default(),
+ "how to handle this type of thing",
+ );
+ }
+
+ #[test]
+ fn fix_those_kind_of_things() {
+ assert_suggestion_result(
+ "uh, so I was playing both of those kind of things",
+ ThisTypeOfThing::default(),
+ "uh, so I was playing both of those kinds of things",
+ );
+ }
+}