Improve Python query for type hints

Author: blopker

.claude/settings.local.json

@@ -4,7 +4,12 @@
       "Bash(cargo test:*)",
       "Bash(cargo clippy:*)",
       "Bash(git fetch:*)",
-      "Bash(git show:*)"
+      "Bash(git show:*)",
+      "Bash(gh pr view:*)",
+      "Bash(gh pr diff:*)",
+      "WebSearch",
+      "mcp__kagi__kagi_summarizer",
+      "Bash(cargo run:*)"
     ]
   }
 }

Cargo.lock

@@ -117,15 +117,15 @@ pub(crate) fn should_flag_word(settings: &ConfigSettings, word: &str) -> bool {
 pub(crate) fn build_ignore_regexes(patterns: &[String]) -> Vec<Regex> {
     patterns
         .iter()
-        .filter_map(|pattern| {
-            match RegexBuilder::new(pattern).multi_line(true).build() {
+        .filter_map(
+            |pattern| match RegexBuilder::new(pattern).multi_line(true).build() {
                 Ok(regex) => Some(regex),
                 Err(e) => {
                     error!("Ignoring invalid regex pattern '{pattern}': {e}");
                     None
                 }
-            }
-        })
+            },
+        )
         .collect()
 }
 
@@ -234,10 +234,7 @@ mod tests {
 
     #[test]
     fn test_build_ignore_regexes_valid_patterns() {
-        let patterns = vec![
-            r"\b[A-Z]{2,}\b".to_string(),
-            r"TODO:.*".to_string(),
-        ];
+        let patterns = vec![r"\b[A-Z]{2,}\b".to_string(), r"TODO:.*".to_string()];
 
         let compiled = build_ignore_regexes(&patterns);
         assert_eq!(compiled.len(), 2);

crates/codebook-config/src/helpers.rs

@@ -348,11 +348,7 @@ impl LanguageServer for Backend {
                 Ok(None)
             }
             CodebookCommand::IgnoreFile => {
-                let Some(file_uri) = params
-                    .arguments
-                    .first()
-                    .and_then(|arg| arg.as_str())
-                else {
+                let Some(file_uri) = params.arguments.first().and_then(|arg| arg.as_str()) else {
                     error!("IgnoreFile command missing or invalid file URI argument");
                     return Ok(None);
                 };

crates/codebook-lsp/src/lsp.rs

@@ -23,7 +23,6 @@ struct SkipRange {
     end_byte: usize,
 }
 
-
 /// Check if a word at [start, end) is entirely within any skip range
 fn is_within_skip_range(start: usize, end: usize, skip_ranges: &[SkipRange]) -> bool {
     skip_ranges

crates/codebook/src/parser.rs

@@ -1,16 +1,37 @@
 (comment) @comment
+
 (string_content) @string
+
 (function_definition
     name: (identifier) @identifier)
-(function_definition
-    parameters: (parameters) @identifier)
+
 (class_definition
     name: (identifier) @identifier)
+
 (assignment
     left: (identifier) @identifier)
+
 (import_statement
     name: (aliased_import
         alias: (identifier) @identifier))
+
 (import_from_statement
     name: (aliased_import
         alias: (identifier) @identifier))
+
+(parameters
+  (identifier) @identifier)
+
+; Matches typed parameters (e.g., "name: str")
+; The identifier for the name is a *direct child* of typed_parameter,
+; while the type identifier is nested inside a (type) node.
+(typed_parameter
+  (identifier) @identifier)
+
+; Matches parameters with default values (e.g., "limit=10")
+(default_parameter
+  (identifier) @identifier)
+
+; Matches typed parameters with default values (e.g., "limit: int = 10")
+(typed_default_parameter
+  (identifier) @identifier)

crates/codebook/src/queries/python.scm

@@ -20,8 +20,8 @@ lazy_static! {
         Regex::new(r"[A-Za-z0-9+/]{20,}={0,2}").expect("Valid Base64 regex"),
         // Git commit hashes (7+ hex characters)
         Regex::new(r"\b[0-9a-fA-F]{7,40}\b").expect("Valid git hash regex"),
-        // Markdown/HTML links
-        Regex::new(r"\[([^\]]+)\]\(([^)]+)\)").expect("Valid markdown link regex"),
+        // Markdown/HTML links (URL part must not contain spaces)
+        Regex::new(r"\[([^\]]+)\]\([^\s)]+\)").expect("Valid markdown link regex"),
     ];
 }
 

crates/codebook/src/regexes.rs

@@ -5,6 +5,52 @@ use codebook::{
 
 mod utils;
 
+/// Strategy:
+/// Use distinct misspellings to test location sensitive checking.
+/// This simpler to write than asserting exact locations.
+/// Granted - it doesn't test that the spell_check return correct locations,
+/// but should be sufficient that some tests tests this.
+/// This can be used to test language-specific grammar rules with less effort.
+///
+/// `not_expected` does not have to be exhaustive.
+fn assert_simple_misspellings(
+    processor: &codebook::Codebook,
+    sample_text: &str,
+    expected_misspellings: Vec<&str>,
+    not_expected: Vec<&str>,
+    language: LanguageType,
+) {
+    // Check that the misspelled words used are distinct,
+    // otherwise the test could fail to properly test location sensitive properties
+    for word in expected_misspellings.iter() {
+        let count = sample_text.matches(word).count();
+        assert_eq!(
+            count, 1,
+            "Word '{}' should occur exactly once in sample_text, but found {} occurrences",
+            word, count
+        );
+    }
+
+    let binding = processor
+        .spell_check(sample_text, Some(language), None)
+        .to_vec();
+    let mut misspelled = binding
+        .iter()
+        .map(|r| r.word.as_str())
+        .collect::<Vec<&str>>();
+    misspelled.sort();
+    println!("Misspelled words: {misspelled:?}");
+
+    let mut expected_misspellings_sorted = expected_misspellings.clone();
+    expected_misspellings_sorted.sort();
+    assert_eq!(misspelled, expected_misspellings_sorted);
+
+    for word in not_expected {
+        println!("Not expecting: {word:?}");
+        assert!(!misspelled.iter().any(|w| *w == word));
+    }
+}
+
 #[test]
 fn test_python_simple() {
     utils::init_logging();
@@ -298,3 +344,79 @@ fn test_python_import_statements() {
     println!("Misspelled words: {misspelled:?}");
     assert_eq!(misspelled, expected);
 }
+
+#[test]
+fn test_python_functions() {
+    utils::init_logging();
+    let processor = utils::get_processor();
+
+    // Test simple function - function name and parameter names should be checked
+    let simple_function = r#"
+def simple_wrngfunction_name(wrngparam, correct, wrngdefaultparam=1, correct_default=2):
+    pass
+    "#;
+    assert_simple_misspellings(
+        &processor,
+        simple_function,
+        vec!["wrngfunction", "wrngparam", "wrngdefaultparam"],
+        vec!["simple", "correct", "def", "name", "default"],
+        LanguageType::Python,
+    );
+
+    // Test typed function - function names and parameters should be checked, but not types or modules
+    let simple_typed_function = r#"
+def simple_wrngfunction(wrngparam: str, correct: Wrngtype, other: wrngmod.Wrngmodtype, correct_default: Nons | int = 2) -> Wrngret:
+    pass
+    "#;
+    assert_simple_misspellings(
+        &processor,
+        simple_typed_function,
+        vec!["wrngfunction", "wrngparam"],
+        vec![
+            "simple",
+            "correct",
+            "str",
+            "Wrngtype",
+            "wrngmod",
+            "Wrngmodtype",
+            "Wrngret",
+            "def",
+            "Nons",
+            "default",
+        ],
+        LanguageType::Python,
+    );
+
+    // Test generic function 1 - function names and parameters should be checked, but not types
+    let generic_function_1 = r#"
+def simple_wrngfunction(wrngparam: str, correct: Wrngtype[Wrngtemplate]):
+    pass
+    "#;
+    assert_simple_misspellings(
+        &processor,
+        generic_function_1,
+        vec!["wrngfunction", "wrngparam"],
+        vec!["simple", "correct", "str", "Wrngtype", "Wrngtemplate"],
+        LanguageType::Python,
+    );
+
+    // Test generic function 2 - function names and parameters should be checked, but not type templates
+    let generic_function_2 = r#"
+def simple_wrngfunction[Wrgtemplate](wrngparam: str, correct: Wrngtype[Wrngtemplate]):
+    pass
+    "#;
+    assert_simple_misspellings(
+        &processor,
+        generic_function_2,
+        vec!["wrngfunction", "wrngparam"],
+        vec![
+            "simple",
+            "correct",
+            "str",
+            "Wrgtemplate",
+            "Wrngtype",
+            "Wrngtemplate",
+        ],
+        LanguageType::Python,
+    );
+}

crates/codebook/tests/test_python.rs

@@ -46,7 +46,19 @@ fn test_swift_simple() {
         }
     "#;
     let expected = vec![
-        "Moar", "Thig", "comented", "enumrable", "frm", "helo", "inented", "lne", "lteral", "nunber", "opttions", "sepaate", "wors"
+        "Moar",
+        "Thig",
+        "comented",
+        "enumrable",
+        "frm",
+        "helo",
+        "inented",
+        "lne",
+        "lteral",
+        "nunber",
+        "opttions",
+        "sepaate",
+        "wors",
     ];
     let binding = processor
         .spell_check(sample_text, Some(LanguageType::Swift), None)