debugger/extensions: Revert changes to extension store related to language config (#30225)

Revert #29945 

Release Notes:

- N/A

---------

Co-authored-by: Conrad <conrad@zed.dev>

crates/language/src/language_registry.rs

@@ -145,24 +145,25 @@ pub enum BinaryStatus {
 #[derive(Clone)]
 pub struct AvailableLanguage {
     id: LanguageId,
-    config: LanguageConfig,
+    name: LanguageName,
+    grammar: Option<Arc<str>>,
+    matcher: LanguageMatcher,
+    hidden: bool,
     load: Arc<dyn Fn() -> Result<LoadedLanguage> + 'static + Send + Sync>,
     loaded: bool,
 }
 
 impl AvailableLanguage {
     pub fn name(&self) -> LanguageName {
-        self.config.name.clone()
+        self.name.clone()
     }
 
     pub fn matcher(&self) -> &LanguageMatcher {
-        &self.config.matcher
+        &self.matcher
     }
+
     pub fn hidden(&self) -> bool {
-        self.config.hidden
-    }
-    pub fn config(&self) -> &LanguageConfig {
-        &self.config
+        self.hidden
     }
 }
 
@@ -326,7 +327,10 @@ impl LanguageRegistry {
     #[cfg(any(feature = "test-support", test))]
     pub fn register_test_language(&self, config: LanguageConfig) {
         self.register_language(
-            config.clone(),
+            config.name.clone(),
+            config.grammar.clone(),
+            config.matcher.clone(),
+            config.hidden,
             Arc::new(move || {
                 Ok(LoadedLanguage {
                     config: config.clone(),
@@ -485,14 +489,18 @@ impl LanguageRegistry {
     /// Adds a language to the registry, which can be loaded if needed.
     pub fn register_language(
         &self,
-        config: LanguageConfig,
+        name: LanguageName,
+        grammar_name: Option<Arc<str>>,
+        matcher: LanguageMatcher,
+        hidden: bool,
         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.config.name == config.name {
-                existing_language.config = config;
+            if existing_language.name == name {
+                existing_language.grammar = grammar_name;
+                existing_language.matcher = matcher;
                 existing_language.load = load;
                 return;
             }
@@ -500,8 +508,11 @@ impl LanguageRegistry {
 
         state.available_languages.push(AvailableLanguage {
             id: LanguageId::new(),
-            config,
+            name,
+            grammar: grammar_name,
+            matcher,
             load,
+            hidden,
             loaded: false,
         });
         state.version += 1;
@@ -547,7 +558,7 @@ impl LanguageRegistry {
         let mut result = state
             .available_languages
             .iter()
-            .filter_map(|l| l.loaded.not().then_some(l.config.name.to_string()))
+            .filter_map(|l| l.loaded.not().then_some(l.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());
@@ -566,7 +577,10 @@ impl LanguageRegistry {
         let mut state = self.state.write();
         state.available_languages.push(AvailableLanguage {
             id: language.id,
-            config: language.config.clone(),
+            name: language.name(),
+            grammar: language.config.grammar.clone(),
+            matcher: language.config.matcher.clone(),
+            hidden: language.config.hidden,
             load: Arc::new(|| Err(anyhow!("already loaded"))),
             loaded: true,
         });
@@ -635,7 +649,7 @@ impl LanguageRegistry {
         state
             .available_languages
             .iter()
-            .find(|l| l.config.name.0.as_ref() == name)
+            .find(|l| l.name.0.as_ref() == name)
             .cloned()
     }
 
@@ -752,11 +766,8 @@ impl LanguageRegistry {
                 let current_match_type = best_language_match
                     .as_ref()
                     .map_or(LanguageMatchPrecedence::default(), |(_, score)| *score);
-                let language_score = callback(
-                    &language.config.name,
-                    &language.config.matcher,
-                    current_match_type,
-                );
+                let language_score =
+                    callback(&language.name, &language.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"
@@ -804,7 +815,7 @@ impl LanguageRegistry {
                 let this = self.clone();
 
                 let id = language.id;
-                let name = language.config.name.clone();
+                let name = language.name.clone();
                 let language_load = language.load.clone();
 
                 self.executor
@@ -1120,7 +1131,7 @@ impl LanguageRegistryState {
         self.languages
             .retain(|language| !languages_to_remove.contains(&language.name()));
         self.available_languages
-            .retain(|language| !languages_to_remove.contains(&language.config.name));
+            .retain(|language| !languages_to_remove.contains(&language.name));
         self.grammars
             .retain(|name, _| !grammars_to_remove.contains(name));
         self.version += 1;