debugger: Rework language association with the debuggers (#29945)

- Languages now define their preferred debuggers in `config.toml`.
- `LanguageRegistry` now exposes language config even for languages that
are not yet loaded. This necessitated extension registry changes (we now
deserialize config.toml of all language entries when loading new
extension index), but it should be backwards compatible with the old
format. /cc @maxdeviant

Release Notes:

- N/A

---------

Co-authored-by: Anthony Eid <hello@anthonyeid.me>
Co-authored-by: Remco Smits <djsmits12@gmail.com>
Co-authored-by: Anthony <anthony@zed.dev>

crates/language/src/language_registry.rs

@@ -145,24 +145,24 @@ pub enum BinaryStatus {
 #[derive(Clone)]
 pub struct AvailableLanguage {
     id: LanguageId,
-    name: LanguageName,
-    grammar: Option<Arc<str>>,
-    matcher: LanguageMatcher,
-    hidden: bool,
+    config: LanguageConfig,
     load: Arc<dyn Fn() -> Result<LoadedLanguage> + 'static + Send + Sync>,
     loaded: bool,
 }
 
 impl AvailableLanguage {
     pub fn name(&self) -> LanguageName {
-        self.name.clone()
+        self.config.name.clone()
     }
 
     pub fn matcher(&self) -> &LanguageMatcher {
-        &self.matcher
+        &self.config.matcher
     }
     pub fn hidden(&self) -> bool {
-        self.hidden
+        self.config.hidden
+    }
+    pub fn config(&self) -> &LanguageConfig {
+        &self.config
     }
 }
 
@@ -326,10 +326,7 @@ impl LanguageRegistry {
     #[cfg(any(feature = "test-support", test))]
     pub fn register_test_language(&self, config: LanguageConfig) {
         self.register_language(
-            config.name.clone(),
-            config.grammar.clone(),
-            config.matcher.clone(),
-            config.hidden,
+            config.clone(),
             Arc::new(move || {
                 Ok(LoadedLanguage {
                     config: config.clone(),
@@ -488,18 +485,14 @@ impl LanguageRegistry {
     /// Adds a language to the registry, which can be loaded if needed.
     pub fn register_language(
         &self,
-        name: LanguageName,
-        grammar_name: Option<Arc<str>>,
-        matcher: LanguageMatcher,
-        hidden: bool,
+        config: LanguageConfig,
         load: Arc<dyn Fn() -> Result<LoadedLanguage> + 'static + Send + Sync>,
     ) {
         let state = &mut *self.state.write();
 
         for existing_language in &mut state.available_languages {
-            if existing_language.name == name {
-                existing_language.grammar = grammar_name;
-                existing_language.matcher = matcher;
+            if existing_language.config.name == config.name {
+                existing_language.config = config;
                 existing_language.load = load;
                 return;
             }
@@ -507,11 +500,8 @@ impl LanguageRegistry {
 
         state.available_languages.push(AvailableLanguage {
             id: LanguageId::new(),
-            name,
-            grammar: grammar_name,
-            matcher,
+            config,
             load,
-            hidden,
             loaded: false,
         });
         state.version += 1;
@@ -557,7 +547,7 @@ impl LanguageRegistry {
         let mut result = state
             .available_languages
             .iter()
-            .filter_map(|l| l.loaded.not().then_some(l.name.to_string()))
+            .filter_map(|l| l.loaded.not().then_some(l.config.name.to_string()))
             .chain(state.languages.iter().map(|l| l.config.name.to_string()))
             .collect::<Vec<_>>();
         result.sort_unstable_by_key(|language_name| language_name.to_lowercase());
@@ -576,10 +566,7 @@ impl LanguageRegistry {
         let mut state = self.state.write();
         state.available_languages.push(AvailableLanguage {
             id: language.id,
-            name: language.name(),
-            grammar: language.config.grammar.clone(),
-            matcher: language.config.matcher.clone(),
-            hidden: language.config.hidden,
+            config: language.config.clone(),
             load: Arc::new(|| Err(anyhow!("already loaded"))),
             loaded: true,
         });
@@ -648,7 +635,7 @@ impl LanguageRegistry {
         state
             .available_languages
             .iter()
-            .find(|l| l.name.0.as_ref() == name)
+            .find(|l| l.config.name.0.as_ref() == name)
             .cloned()
     }
 
@@ -765,8 +752,11 @@ impl LanguageRegistry {
                 let current_match_type = best_language_match
                     .as_ref()
                     .map_or(LanguageMatchPrecedence::default(), |(_, score)| *score);
-                let language_score =
-                    callback(&language.name, &language.matcher, current_match_type);
+                let language_score = callback(
+                    &language.config.name,
+                    &language.config.matcher,
+                    current_match_type,
+                );
                 debug_assert!(
                     language_score.is_none_or(|new_score| new_score > current_match_type),
                     "Matching callback should only return a better match than the current one"
@@ -814,7 +804,7 @@ impl LanguageRegistry {
                 let this = self.clone();
 
                 let id = language.id;
-                let name = language.name.clone();
+                let name = language.config.name.clone();
                 let language_load = language.load.clone();
 
                 self.executor
@@ -1130,7 +1120,7 @@ impl LanguageRegistryState {
         self.languages
             .retain(|language| !languages_to_remove.contains(&language.name()));
         self.available_languages
-            .retain(|language| !languages_to_remove.contains(&language.name));
+            .retain(|language| !languages_to_remove.contains(&language.config.name));
         self.grammars
             .retain(|name, _| !grammars_to_remove.contains(name));
         self.version += 1;