refactor: extract regex check into a function and lower its precedence compared to the current grammar directory

cli/loader/src/lib.rs

@@ -2,7 +2,7 @@
 
 use std::collections::HashMap;
 use std::ffi::{OsStr, OsString};
-use std::io::BufReader;
+use std::io::{BufRead, BufReader};
 use std::ops::Range;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -227,6 +227,30 @@ impl Loader {
         Ok(None)
     }
 
+    pub fn language_configuration_for_first_line_regex(
+        &self,
+        path: &Path,
+    ) -> Result<Option<(Language, &LanguageConfiguration)>> {
+        self.language_configuration_ids_by_first_line_regex
+            .iter()
+            .try_fold(None, |_, (regex, ids)| {
+                if let Some(regex) = Self::regex(Some(regex)) {
+                    let file = fs::File::open(path)?;
+                    let reader = BufReader::new(file);
+                    let first_line = reader.lines().next().transpose()?;
+                    if let Some(first_line) = first_line {
+                        if regex.is_match(&first_line) && !ids.is_empty() {
+                            let configuration = &self.language_configurations[ids[0]];
+                            let language = self.language_for_id(configuration.language_id)?;
+                            return Ok(Some((language, configuration)));
+                        }
+                    }
+                }
+
+                Ok(None)
+            })
+    }
+
     pub fn language_configuration_for_file_name(
         &self,
         path: &Path,
@@ -243,26 +267,6 @@ impl Loader {
                     .and_then(|extension| {
                         self.language_configuration_ids_by_file_type.get(extension)
                     })
-            })
-            .or_else(|| {
-                let Ok(file) = fs::File::open(path) else {
-                    return None;
-                };
-                let reader = BufReader::new(file);
-                let Some(Ok(first_line)) = std::io::BufRead::lines(reader).next() else {
-                    return None;
-                };
-
-                self.language_configuration_ids_by_first_line_regex
-                    .iter()
-                    .find(|(regex, _)| {
-                        if let Some(regex) = Self::regex(Some(regex)) {
-                            regex.is_match(&first_line)
-                        } else {
-                            false
-                        }
-                    })
-                    .map(|(_, ids)| ids)
             });
 
         if let Some(configuration_ids) = configuration_ids {
@@ -1006,6 +1010,8 @@ impl Loader {
             .cloned()
         {
             Ok(lang)
+        } else if let Some(lang) = self.language_configuration_for_first_line_regex(path)? {
+            Ok(lang.0)
         } else {
             Err(anyhow!("No language found"))
         }
@@ -1066,8 +1072,7 @@ impl<'a> LanguageConfiguration<'a> {
             ),
             None => (None, None, None),
         };
-        return self
-            .highlight_config
+        self.highlight_config
             .get_or_try_init(|| {
                 let (highlights_query, highlight_ranges) = self.read_queries(
                     if highlights_filenames.is_some() {
@@ -1145,7 +1150,7 @@ impl<'a> LanguageConfiguration<'a> {
                     Ok(Some(result))
                 }
             })
-            .map(Option::as_ref);
+            .map(Option::as_ref)
     }
 
     pub fn tags_config(&self, language: Language) -> Result<Option<&TagsConfiguration>> {

cli/src/generate/render.rs

@@ -346,12 +346,12 @@ impl Generator {
         for symbol in &self.parse_table.symbols {
             if *symbol != Symbol::end() {
                 self.symbol_order.insert(*symbol, i);
-                add_line!(self, "{} = {},", self.symbol_ids[&symbol], i);
+                add_line!(self, "{} = {},", self.symbol_ids[symbol], i);
                 i += 1;
             }
         }
         for alias in &self.unique_aliases {
-            add_line!(self, "{} = {},", self.alias_ids[&alias], i);
+            add_line!(self, "{} = {},", self.alias_ids[alias], i);
             i += 1;
         }
         dedent!(self);
@@ -370,13 +370,13 @@ impl Generator {
                         alias.value.as_str()
                     }),
             );
-            add_line!(self, "[{}] = \"{}\",", self.symbol_ids[&symbol], name);
+            add_line!(self, "[{}] = \"{}\",", self.symbol_ids[symbol], name);
         }
         for alias in &self.unique_aliases {
             add_line!(
                 self,
                 "[{}] = \"{}\",",
-                self.alias_ids[&alias],
+                self.alias_ids[alias],
                 self.sanitize_string(&alias.value)
             );
         }
@@ -401,8 +401,8 @@ impl Generator {
             add_line!(
                 self,
                 "[{}] = {},",
-                self.alias_ids[&alias],
-                self.alias_ids[&alias],
+                self.alias_ids[alias],
+                self.alias_ids[alias],
             );
         }
 
@@ -446,7 +446,7 @@ impl Generator {
         );
         indent!(self);
         for symbol in &self.parse_table.symbols {
-            add_line!(self, "[{}] = {{", self.symbol_ids[&symbol]);
+            add_line!(self, "[{}] = {{", self.symbol_ids[symbol]);
             indent!(self);
             if let Some(Alias { is_named, .. }) = self.default_aliases.get(symbol) {
                 add_line!(self, ".visible = true,");
@@ -478,7 +478,7 @@ impl Generator {
             add_line!(self, "}},");
         }
         for alias in &self.unique_aliases {
-            add_line!(self, "[{}] = {{", self.alias_ids[&alias]);
+            add_line!(self, "[{}] = {{", self.alias_ids[alias]);
             indent!(self);
             add_line!(self, ".visible = true,");
             add_line!(self, ".named = {},", alias.is_named);
@@ -510,7 +510,7 @@ impl Generator {
             indent!(self);
             for (j, alias) in production_info.alias_sequence.iter().enumerate() {
                 if let Some(alias) = alias {
-                    add_line!(self, "[{}] = {},", j, self.alias_ids[&alias]);
+                    add_line!(self, "[{}] = {},", j, self.alias_ids[alias]);
                 }
             }
             dedent!(self);
@@ -554,7 +554,7 @@ impl Generator {
         indent!(self);
         for (symbol, alias_ids) in alias_ids_by_symbol {
             let symbol_id = &self.symbol_ids[symbol];
-            let public_symbol_id = &self.symbol_ids[&self.symbol_map[&symbol]];
+            let public_symbol_id = &self.symbol_ids[&self.symbol_map[symbol]];
             add_line!(self, "{symbol_id}, {},", 1 + alias_ids.len());
             indent!(self);
             add_line!(self, "{public_symbol_id},");

cli/src/tests/detect_language.rs

@@ -117,6 +117,16 @@ fn tree_sitter_dir(package_json: &str, name: &str) -> tempfile::TempDir {
 fn get_lang_scope(loader: &mut Loader, file_name: &Path) -> Option<String> {
     loader
         .language_configuration_for_file_name(file_name)
-        .unwrap()
-        .and_then(|r| r.1.scope.clone())
+        .ok()
+        .and_then(|config| {
+            if let Some((_, config)) = config {
+                config.scope.clone()
+            } else if let Ok(Some((_, config))) =
+                loader.language_configuration_for_first_line_regex(file_name)
+            {
+                config.scope.clone()
+            } else {
+                None
+            }
+        })
 }

cli/src/tests/helpers/fixtures.rs

@@ -79,7 +79,7 @@ pub fn get_tags_config(language_name: &str) -> TagsConfiguration {
 }
 
 pub fn get_test_language(name: &str, parser_code: &str, path: Option<&Path>) -> Language {
-    let src_dir = SCRATCH_DIR.join("src").join(name);
+    let src_dir = scratch_dir().join("src").join(name);
     fs::create_dir_all(&src_dir).unwrap();
 
     let parser_path = src_dir.join("parser.c");

cli/src/tests/helpers/query_helpers.rs

@@ -263,11 +263,11 @@ impl Pattern {
     }
 }
 
-impl ToString for Pattern {
-    fn to_string(&self) -> String {
+impl std::fmt::Display for Pattern {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut result = String::new();
         self.write_to_string(&mut result, 0);
-        result
+        write!(f, "{result}")
     }
 }
 

cli/src/util.rs

@@ -22,6 +22,7 @@ svg { width: 100%; }
 
 ";
 
+#[must_use]
 pub fn lang_not_found_for_path(path: &Path, loader_config: &LoaderConfig) -> String {
     let path = path.display();
     format!(