fix(cli): Don't recognize known file extensions as typos

Fixes #1253.

Author: not-my-profile

crates/typos-cli/src/default_types.rs

@@ -315,6 +315,7 @@ pub(crate) const DEFAULT_TYPES: &[(&str, &[&str])] = &[
     ("ts", &["*.ts", "*.tsx", "*.cts", "*.mts"]),
     ("twig", &["*.twig"]),
     ("txt", &["*.txt"]),
+    ("typ", &["*.typ"]),
     ("typoscript", &["*.typoscript"]),
     ("usd", &["*.usd", "*.usda", "*.usdc"]),
     ("v", &["*.v", "*.vsh"]),

crates/typos-cli/src/file.rs

@@ -27,6 +27,7 @@ impl FileChecker for Typos {
     ) -> Result<(), std::io::Error> {
         if policy.check_filenames {
             if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                let file_name = policy.strip_file_extension(file_name);
                 for typo in check_str(file_name, policy) {
                     let msg = report::Typo {
                         context: Some(report::PathContext { path }.into()),
@@ -111,6 +112,7 @@ impl FileChecker for FixTypos {
         // Ensure the above write can happen before renaming the file.
         if policy.check_filenames {
             if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                let file_name = policy.strip_file_extension(file_name);
                 let mut fixes = Vec::new();
                 for typo in check_str(file_name, policy) {
                     if is_fixable(&typo) {
@@ -264,6 +266,7 @@ impl FileChecker for HighlightIdentifiers {
         let mut ignores: Option<Ignores> = None;
         if policy.check_filenames {
             if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                let file_name = policy.strip_file_extension(file_name);
                 let mut styled = String::new();
                 let mut prev_end = 0;
                 for (word, highlight) in policy
@@ -366,6 +369,7 @@ impl FileChecker for Identifiers {
         let mut ignores: Option<Ignores> = None;
         if policy.check_filenames {
             if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                let file_name = policy.strip_file_extension(file_name);
                 for word in policy.tokenizer.parse_str(file_name) {
                     if ignores
                         .get_or_insert_with(|| Ignores::new(file_name.as_bytes(), policy.ignore))
@@ -546,6 +550,7 @@ impl FileChecker for Words {
         let mut ignores: Option<Ignores> = None;
         if policy.check_filenames {
             if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                let file_name = policy.strip_file_extension(file_name);
                 for word in policy
                     .tokenizer
                     .parse_str(file_name)

crates/typos-cli/src/policy.rs

@@ -94,8 +94,36 @@ impl<'s> ConfigEngine<'s> {
         debug_assert!(path.is_absolute(), "{} is not absolute", path.display());
         let dir = self.get_dir(path).expect("`walk()` should be called first");
         let (file_type, file_config) = dir.get_file_config(path);
+
+        let mut extension_regex = None;
+
+        if file_config.check_filenames {
+            if let Some(file_type) = file_type {
+                // File extensions can be in our typo dictionary.
+                // E.g. .typ is the file extension for Typst but we correct typ to (typo, type).
+                // Here we build a regex later used to ensure that we don't recognize file extensions
+                // we know (via the glob list of type definitions) in filenames as typos.
+                let mut extension_regex_str = String::new();
+                for pattern in &dir.type_matcher.definitions()[file_type] {
+                    if let Some(pattern) = pattern.strip_prefix("*.") {
+                        if !extension_regex_str.is_empty() {
+                            extension_regex_str.push('|');
+                        }
+                        let glob = globset::Glob::new(pattern).unwrap();
+                        if glob.regex().ends_with('$') {
+                            // Policy::strip_file_extension assumes the regex is $-anchored to avoid allocations.
+                            extension_regex_str
+                                .push_str(glob.regex().strip_prefix("(?-u)^").unwrap());
+                        }
+                    }
+                }
+                extension_regex = Some(regex::Regex::new(&extension_regex_str).unwrap());
+            }
+        }
+
         Policy {
             check_filenames: file_config.check_filenames,
+            extension_regex,
             check_files: file_config.check_files,
             file_type,
             binary: file_config.binary,
@@ -351,6 +379,7 @@ struct FileConfig {
 #[derive(derive_setters::Setters)]
 pub struct Policy<'t, 'd, 'i> {
     pub check_filenames: bool,
+    extension_regex: Option<regex::Regex>,
     pub check_files: bool,
     pub file_type: Option<&'d str>,
     pub binary: bool,
@@ -363,6 +392,15 @@ impl Policy<'_, '_, '_> {
     pub fn new() -> Self {
         Default::default()
     }
+
+    pub fn strip_file_extension<'a>(&self, filename: &'a str) -> &'a str {
+        if let Some(extension_regex) = &self.extension_regex {
+            if let Some(m) = extension_regex.find(filename) {
+                return &filename[..filename.len() - m.len()];
+            }
+        }
+        filename
+    }
 }
 
 static DEFAULT_TOKENIZER: typos::tokens::Tokenizer = typos::tokens::Tokenizer::new();
@@ -373,6 +411,7 @@ impl Default for Policy<'_, '_, '_> {
     fn default() -> Self {
         Self {
             check_filenames: true,
+            extension_regex: None,
             check_files: true,
             file_type: None,
             binary: false,

crates/typos-cli/tests/cmd/extension-equals-typo.in/_typos.toml

@@ -0,0 +1,6 @@
+[default.extend-words]
+boom = "booom"
+foo = "fooo"
+
+[type.some-type]
+extend-glob = ["*.boom"]

crates/typos-cli/tests/cmd/extension-equals-typo.in/foo.boom

@@ -0,0 +1 @@
+bada bing bada boom

crates/typos-cli/tests/cmd/extension-equals-typo.toml

@@ -0,0 +1,17 @@
+bin.name = "typos"
+args = ""
+stdin = ""
+# The file extension equals a known typo but it's not a typo because it matches a type glob pattern.
+# (The known file extension is stripped before checking the filename for typos.)
+stdout = """
+error: `foo` should be `fooo`
+  --> ./foo.boom:1
+error: `boom` should be `booom`
+  --> ./foo.boom:1:16
+  |
+1 | bada bing bada boom
+  |                ^^^^
+  |
+"""
+stderr = ""
+status.code = 2