use std::sync::{Arc, LazyLock}; use anyhow::{Context as _, Result};use collections::HashMap;use gpui::{App, AsyncApp, BorrowAppContext as _, Entity, Task, WeakEntity};use language::{ LanguageRegistry, LanguageServerName, LspAdapterDelegate, language_settings::AllLanguageSettings,};use parking_lot::RwLock;use project::{LspStore, lsp_store::LocalLspAdapterDelegate};use settings::{LSP_SETTINGS_SCHEMA_URL_PREFIX, Settings as _, SettingsLocation};use util::schemars::{AllowTrailingCommas, DefaultDenyUnknownFields}; const SCHEMA_URI_PREFIX: &str = "zed://schemas/"; const TSCONFIG_SCHEMA: &str = include_str!("schemas/tsconfig.json");const PACKAGE_JSON_SCHEMA: &str = include_str!("schemas/package.json"); static TASKS_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&task::TaskTemplates::generate_json_schema()) .expect("TaskTemplates schema should serialize")}); static SNIPPETS_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&snippet_provider::format::VsSnippetsFile::generate_json_schema()) .expect("VsSnippetsFile schema should serialize")}); static JSONC_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&generate_jsonc_schema()).expect("JSONC schema should serialize")}); #[cfg(debug_assertions)]static INSPECTOR_STYLE_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&generate_inspector_style_schema()) .expect("Inspector style schema should serialize")}); static KEYMAP_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&settings::KeymapFile::generate_json_schema_from_inventory()) .expect("Keymap schema should serialize")}); static ACTION_SCHEMA_CACHE: LazyLock<RwLock<HashMap<String, String>>> = LazyLock::new(|| RwLock::new(HashMap::default())); // Runtime cache for dynamic schemas that depend on runtime state:// - "settings": depends on installed fonts, themes, languages, LSP adapters (extensions can add these)// - "settings/lsp/*": depends on LSP adapter initialization options// - "debug_tasks": depends on DAP adapters (extensions can add these)// Cache is invalidated via notify_schema_changed() when extensions or DAP registry change.static DYNAMIC_SCHEMA_CACHE: LazyLock<RwLock<HashMap<String, String>>> = LazyLock::new(|| RwLock::new(HashMap::default())); pub fn init(cx: &mut App) { cx.set_global(SchemaStore::default()); project::lsp_store::json_language_server_ext::register_schema_handler( handle_schema_request, cx, ); cx.observe_new(|_, _, cx| { let lsp_store = cx.weak_entity(); cx.global_mut::<SchemaStore>().lsp_stores.push(lsp_store); }) .detach(); if let Some(extension_events) = extension::ExtensionEvents::try_global(cx) { cx.subscribe(&extension_events, move |_, evt, cx| match evt { extension::Event::ExtensionsInstalledChanged => { cx.update_global::<SchemaStore, _>(|schema_store, cx| { schema_store.notify_schema_changed(ChangedSchemas::Settings, cx); }); } extension::Event::ExtensionUninstalled(_) | extension::Event::ExtensionInstalled(_) | extension::Event::ConfigureExtensionRequested(_) => {} }) .detach(); } cx.observe_global::<dap::DapRegistry>(move |cx| { cx.update_global::<SchemaStore, _>(|schema_store, cx| { schema_store.notify_schema_changed(ChangedSchemas::DebugTasks, cx); }); }) .detach();} #[derive(Default)]pub struct SchemaStore { lsp_stores: Vec<WeakEntity<LspStore>>,} impl gpui::Global for SchemaStore {} enum ChangedSchemas { Settings, DebugTasks,} impl SchemaStore { fn notify_schema_changed(&mut self, changed_schemas: ChangedSchemas, cx: &mut App) { let uris_to_invalidate = match changed_schemas { ChangedSchemas::Settings => { let settings_uri_prefix = &format!("{SCHEMA_URI_PREFIX}settings"); let project_settings_uri = &format!("{SCHEMA_URI_PREFIX}project_settings"); DYNAMIC_SCHEMA_CACHE .write() .extract_if(|uri, _| { uri == project_settings_uri || uri.starts_with(settings_uri_prefix) }) .map(|(url, _)| url) .collect() } ChangedSchemas::DebugTasks => DYNAMIC_SCHEMA_CACHE .write() .remove_entry(&format!("{SCHEMA_URI_PREFIX}debug_tasks")) .map_or_else(Vec::new, |(uri, _)| vec![uri]), }; if uris_to_invalidate.is_empty() { return; } self.lsp_stores.retain(|lsp_store| { let Some(lsp_store) = lsp_store.upgrade() else { return false; }; project::lsp_store::json_language_server_ext::notify_schemas_changed( lsp_store, &uris_to_invalidate, cx, ); true }) }} pub fn handle_schema_request( lsp_store: Entity<LspStore>, uri: String, cx: &mut AsyncApp,) -> Task<Result<String>> { let path = match uri.strip_prefix(SCHEMA_URI_PREFIX) { Some(path) => path, None => return Task::ready(Err(anyhow::anyhow!("Invalid schema URI: {}", uri))), }; if let Some(json) = resolve_static_schema(path) { return Task::ready(Ok(json)); } if let Some(cached) = DYNAMIC_SCHEMA_CACHE.read().get(&uri).cloned() { return Task::ready(Ok(cached)); } let path = path.to_string(); let uri_clone = uri.clone(); cx.spawn(async move |cx| { let schema = resolve_dynamic_schema(lsp_store, &path, cx).await?; let json = serde_json::to_string(&schema).context("Failed to serialize schema")?; DYNAMIC_SCHEMA_CACHE.write().insert(uri_clone, json.clone()); Ok(json) })} fn resolve_static_schema(path: &str) -> Option<String> { let (schema_name, rest) = path.split_once('/').unzip(); let schema_name = schema_name.unwrap_or(path); match schema_name { "tsconfig" => Some(TSCONFIG_SCHEMA.to_string()), "package_json" => Some(PACKAGE_JSON_SCHEMA.to_string()), "tasks" => Some(TASKS_SCHEMA.clone()), "snippets" => Some(SNIPPETS_SCHEMA.clone()), "jsonc" => Some(JSONC_SCHEMA.clone()), "keymap" => Some(KEYMAP_SCHEMA.clone()), "zed_inspector_style" => { #[cfg(debug_assertions)] { Some(INSPECTOR_STYLE_SCHEMA.clone()) } #[cfg(not(debug_assertions))] { Some( serde_json::to_string(&schemars::json_schema!(true).to_value()) .expect("true schema should serialize"), ) } } "action" => { let normalized_action_name = match rest { Some(name) => name, None => return None, }; let action_name = denormalize_action_name(normalized_action_name); if let Some(cached) = ACTION_SCHEMA_CACHE.read().get(&action_name).cloned() { return Some(cached); } let mut generator = settings::KeymapFile::action_schema_generator(); let schema = settings::KeymapFile::get_action_schema_by_name(&action_name, &mut generator); let json = serde_json::to_string( &root_schema_from_action_schema(schema, &mut generator).to_value(), ) .expect("Action schema should serialize"); ACTION_SCHEMA_CACHE .write() .insert(action_name, json.clone()); Some(json) } _ => None, }} async fn resolve_dynamic_schema( lsp_store: Entity<LspStore>, path: &str, cx: &mut AsyncApp,) -> Result<serde_json::Value> { let languages = lsp_store.read_with(cx, |lsp_store, _| lsp_store.languages.clone()); let (schema_name, rest) = path.split_once('/').unzip(); let schema_name = schema_name.unwrap_or(path); let schema = match schema_name { "settings" if rest.is_some_and(|r| r.starts_with("lsp/")) => { let lsp_path = rest .and_then(|r| { r.strip_prefix( LSP_SETTINGS_SCHEMA_URL_PREFIX .strip_prefix(SCHEMA_URI_PREFIX) .and_then(|s| s.strip_prefix("settings/")) .unwrap_or("lsp/"), ) }) .context("Invalid LSP schema path")?; // Parse the schema type from the path: // - "rust-analyzer/initialization_options" → initialization_options_schema // - "rust-analyzer/settings" → settings_schema enum LspSchemaKind { InitializationOptions, Settings, } let (lsp_name, schema_kind) = if let Some(adapter_name) = lsp_path.strip_suffix("/initialization_options") { (adapter_name, LspSchemaKind::InitializationOptions) } else if let Some(adapter_name) = lsp_path.strip_suffix("/settings") { (adapter_name, LspSchemaKind::Settings) } else { anyhow::bail!( "Invalid LSP schema path: \ Expected '{{adapter}}/initialization_options' or '{{adapter}}/settings', got '{}'", lsp_path ); }; let adapter = languages .all_lsp_adapters() .into_iter() .find(|adapter| adapter.name().as_ref() as &str == lsp_name) .or_else(|| { languages.load_available_lsp_adapter(&LanguageServerName::from(lsp_name)) }) .with_context(|| format!("LSP adapter not found: {}", lsp_name))?; let delegate: Arc<dyn LspAdapterDelegate> = cx .update(|inner_cx| { lsp_store.update(inner_cx, |lsp_store, cx| { let Some(local) = lsp_store.as_local() else { return None; }; let Some(worktree) = local.worktree_store.read(cx).worktrees().next() else { return None; }; Some(LocalLspAdapterDelegate::from_local_lsp( local, &worktree, cx, )) }) }) .context(concat!( "Failed to create adapter delegate - ", "either LSP store is not in local mode or no worktree is available" ))?; let schema = match schema_kind { LspSchemaKind::InitializationOptions => { adapter.initialization_options_schema(&delegate, cx).await } LspSchemaKind::Settings => adapter.settings_schema(&delegate, cx).await, }; schema.unwrap_or_else(|| { serde_json::json!({ "type": "object", "additionalProperties": true }) }) } "settings" => { let mut lsp_adapter_names: Vec<String> = languages .all_lsp_adapters() .into_iter() .map(|adapter| adapter.name()) .chain(languages.available_lsp_adapter_names()) .map(|name| name.to_string()) .collect(); let mut i = 0; while i < lsp_adapter_names.len() { let mut j = i + 1; while j < lsp_adapter_names.len() { if lsp_adapter_names[i] == lsp_adapter_names[j] { lsp_adapter_names.swap_remove(j); } else { j += 1; } } i += 1; } cx.update(|cx| { let font_names = &cx.text_system().all_font_names(); let language_names = &languages .language_names() .into_iter() .map(|name| name.to_string()) .collect::<Vec<_>>(); let mut icon_theme_names = vec![]; let mut theme_names = vec![]; if let Some(registry) = theme::ThemeRegistry::try_global(cx) { icon_theme_names.extend( registry .list_icon_themes() .into_iter() .map(|icon_theme| icon_theme.name), ); theme_names.extend(registry.list_names()); } let icon_theme_names = icon_theme_names.as_slice(); let theme_names = theme_names.as_slice(); let action_names = cx.all_action_names(); let action_documentation = cx.action_documentation(); let deprecations = cx.deprecated_actions_to_preferred_actions(); let deprecation_messages = cx.action_deprecation_messages(); let mut schema = settings::SettingsStore::json_schema(&settings::SettingsJsonSchemaParams { language_names, font_names, theme_names, icon_theme_names, lsp_adapter_names: &lsp_adapter_names, action_names, action_documentation, deprecations, deprecation_messages, }); inject_feature_flags_schema(&mut schema); schema }) } "project_settings" => { let lsp_adapter_names = languages .all_lsp_adapters() .into_iter() .map(|adapter| adapter.name().to_string()) .collect::<Vec<_>>(); let language_names = &languages .language_names() .into_iter() .map(|name| name.to_string()) .collect::<Vec<_>>(); let mut schema = settings::SettingsStore::project_json_schema(&settings::SettingsJsonSchemaParams { language_names, lsp_adapter_names: &lsp_adapter_names, // These are not allowed in project-specific settings but // they're still fields required by the // `SettingsJsonSchemaParams` struct. font_names: &[], theme_names: &[], icon_theme_names: &[], action_names: &[], action_documentation: &HashMap::default(), deprecations: &HashMap::default(), deprecation_messages: &HashMap::default(), }); inject_feature_flags_schema(&mut schema); schema } "debug_tasks" => { let adapter_schemas = cx.read_global::<dap::DapRegistry, _>(|dap_registry, _| { dap_registry.adapters_schema() }); task::DebugTaskFile::generate_json_schema(&adapter_schemas) } "keymap" => cx.update(settings::KeymapFile::generate_json_schema_for_registered_actions), "action" => { let normalized_action_name = rest.context("No Action name provided")?; let action_name = denormalize_action_name(normalized_action_name); let mut generator = settings::KeymapFile::action_schema_generator(); let schema = cx .update(|cx| cx.action_schema_by_name(&action_name, &mut generator)) .flatten(); root_schema_from_action_schema(schema, &mut generator).to_value() } "tasks" => task::TaskTemplates::generate_json_schema(), _ => { anyhow::bail!("Unrecognized schema: {schema_name}"); } }; Ok(schema)} const JSONC_LANGUAGE_NAME: &str = "JSONC"; pub fn all_schema_file_associations( languages: &Arc<LanguageRegistry>, path: Option<SettingsLocation<'_>>, cx: &mut App,) -> serde_json::Value { let extension_globs = languages .available_language_for_name(JSONC_LANGUAGE_NAME) .map(|language| language.matcher().path_suffixes.clone()) .into_iter() .flatten() // Path suffixes can be entire file names or just their extensions. .flat_map(|path_suffix| [format!("*.{path_suffix}"), path_suffix]); let override_globs = AllLanguageSettings::get(path, cx) .file_types .get(JSONC_LANGUAGE_NAME) .into_iter() .flat_map(|(_, glob_strings)| glob_strings) .cloned(); let jsonc_globs = extension_globs.chain(override_globs).collect::<Vec<_>>(); let mut file_associations = serde_json::json!([ { "fileMatch": [ schema_file_match(paths::settings_file()), ], "url": format!("{SCHEMA_URI_PREFIX}settings"), }, { "fileMatch": [ paths::local_settings_file_relative_path()], "url": format!("{SCHEMA_URI_PREFIX}project_settings"), }, { "fileMatch": [schema_file_match(paths::keymap_file())], "url": format!("{SCHEMA_URI_PREFIX}keymap"), }, { "fileMatch": [ schema_file_match(paths::tasks_file()), paths::local_tasks_file_relative_path() ], "url": format!("{SCHEMA_URI_PREFIX}tasks"), }, { "fileMatch": [ schema_file_match(paths::debug_scenarios_file()), paths::local_debug_file_relative_path() ], "url": format!("{SCHEMA_URI_PREFIX}debug_tasks"), }, { "fileMatch": [ schema_file_match( paths::snippets_dir() .join("*.json") .as_path() ) ], "url": format!("{SCHEMA_URI_PREFIX}snippets"), }, { "fileMatch": ["tsconfig.json"], "url": format!("{SCHEMA_URI_PREFIX}tsconfig") }, { "fileMatch": ["package.json"], "url": format!("{SCHEMA_URI_PREFIX}package_json") },Lines 1–500 of 629. Load more
use std::sync::{Arc, LazyLock}; use anyhow::{Context as _, Result}; use collections::HashMap; use gpui::{App, AsyncApp, BorrowAppContext as _, Entity, Task, WeakEntity}; use language::{ LanguageRegistry, LanguageServerName, LspAdapterDelegate, language_settings::AllLanguageSettings, }; use parking_lot::RwLock; use project::{LspStore, lsp_store::LocalLspAdapterDelegate}; use settings::{LSP_SETTINGS_SCHEMA_URL_PREFIX, Settings as _, SettingsLocation}; use util::schemars::{AllowTrailingCommas, DefaultDenyUnknownFields}; const SCHEMA_URI_PREFIX: &str = "zed://schemas/"; const TSCONFIG_SCHEMA: &str = include_str!("schemas/tsconfig.json"); const PACKAGE_JSON_SCHEMA: &str = include_str!("schemas/package.json"); static TASKS_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&task::TaskTemplates::generate_json_schema()) .expect("TaskTemplates schema should serialize") }); static SNIPPETS_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&snippet_provider::format::VsSnippetsFile::generate_json_schema()) .expect("VsSnippetsFile schema should serialize") }); static JSONC_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&generate_jsonc_schema()).expect("JSONC schema should serialize") }); #[cfg(debug_assertions)] static INSPECTOR_STYLE_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&generate_inspector_style_schema()) .expect("Inspector style schema should serialize") }); static KEYMAP_SCHEMA: LazyLock<String> = LazyLock::new(|| { serde_json::to_string(&settings::KeymapFile::generate_json_schema_from_inventory()) .expect("Keymap schema should serialize") }); static ACTION_SCHEMA_CACHE: LazyLock<RwLock<HashMap<String, String>>> = LazyLock::new(|| RwLock::new(HashMap::default())); // Runtime cache for dynamic schemas that depend on runtime state: // - "settings": depends on installed fonts, themes, languages, LSP adapters (extensions can add these) // - "settings/lsp/*": depends on LSP adapter initialization options // - "debug_tasks": depends on DAP adapters (extensions can add these) // Cache is invalidated via notify_schema_changed() when extensions or DAP registry change. static DYNAMIC_SCHEMA_CACHE: LazyLock<RwLock<HashMap<String, String>>> = LazyLock::new(|| RwLock::new(HashMap::default())); pub fn init(cx: &mut App) { cx.set_global(SchemaStore::default()); project::lsp_store::json_language_server_ext::register_schema_handler( handle_schema_request, cx, ); cx.observe_new(|_, _, cx| { let lsp_store = cx.weak_entity(); cx.global_mut::<SchemaStore>().lsp_stores.push(lsp_store); }) .detach(); if let Some(extension_events) = extension::ExtensionEvents::try_global(cx) { cx.subscribe(&extension_events, move |_, evt, cx| match evt { extension::Event::ExtensionsInstalledChanged => { cx.update_global::<SchemaStore, _>(|schema_store, cx| { schema_store.notify_schema_changed(ChangedSchemas::Settings, cx); }); } extension::Event::ExtensionUninstalled(_) | extension::Event::ExtensionInstalled(_) | extension::Event::ConfigureExtensionRequested(_) => {} }) .detach(); } cx.observe_global::<dap::DapRegistry>(move |cx| { cx.update_global::<SchemaStore, _>(|schema_store, cx| { schema_store.notify_schema_changed(ChangedSchemas::DebugTasks, cx); }); }) .detach(); } #[derive(Default)] pub struct SchemaStore { lsp_stores: Vec<WeakEntity<LspStore>>, } impl gpui::Global for SchemaStore {} enum ChangedSchemas { Settings, DebugTasks, } impl SchemaStore { fn notify_schema_changed(&mut self, changed_schemas: ChangedSchemas, cx: &mut App) { let uris_to_invalidate = match changed_schemas { ChangedSchemas::Settings => { let settings_uri_prefix = &format!("{SCHEMA_URI_PREFIX}settings"); let project_settings_uri = &format!("{SCHEMA_URI_PREFIX}project_settings"); DYNAMIC_SCHEMA_CACHE .write() .extract_if(|uri, _| { uri == project_settings_uri || uri.starts_with(settings_uri_prefix) }) .map(|(url, _)| url) .collect() } ChangedSchemas::DebugTasks => DYNAMIC_SCHEMA_CACHE .write() .remove_entry(&format!("{SCHEMA_URI_PREFIX}debug_tasks")) .map_or_else(Vec::new, |(uri, _)| vec![uri]), }; if uris_to_invalidate.is_empty() { return; } self.lsp_stores.retain(|lsp_store| { let Some(lsp_store) = lsp_store.upgrade() else { return false; }; project::lsp_store::json_language_server_ext::notify_schemas_changed( lsp_store, &uris_to_invalidate, cx, ); true }) } } pub fn handle_schema_request( lsp_store: Entity<LspStore>, uri: String, cx: &mut AsyncApp, ) -> Task<Result<String>> { let path = match uri.strip_prefix(SCHEMA_URI_PREFIX) { Some(path) => path, None => return Task::ready(Err(anyhow::anyhow!("Invalid schema URI: {}", uri))), }; if let Some(json) = resolve_static_schema(path) { return Task::ready(Ok(json)); } if let Some(cached) = DYNAMIC_SCHEMA_CACHE.read().get(&uri).cloned() { return Task::ready(Ok(cached)); } let path = path.to_string(); let uri_clone = uri.clone(); cx.spawn(async move |cx| { let schema = resolve_dynamic_schema(lsp_store, &path, cx).await?; let json = serde_json::to_string(&schema).context("Failed to serialize schema")?; DYNAMIC_SCHEMA_CACHE.write().insert(uri_clone, json.clone()); Ok(json) }) } fn resolve_static_schema(path: &str) -> Option<String> { let (schema_name, rest) = path.split_once('/').unzip(); let schema_name = schema_name.unwrap_or(path); match schema_name { "tsconfig" => Some(TSCONFIG_SCHEMA.to_string()), "package_json" => Some(PACKAGE_JSON_SCHEMA.to_string()), "tasks" => Some(TASKS_SCHEMA.clone()), "snippets" => Some(SNIPPETS_SCHEMA.clone()), "jsonc" => Some(JSONC_SCHEMA.clone()), "keymap" => Some(KEYMAP_SCHEMA.clone()), "zed_inspector_style" => { #[cfg(debug_assertions)] { Some(INSPECTOR_STYLE_SCHEMA.clone()) } #[cfg(not(debug_assertions))] { Some( serde_json::to_string(&schemars::json_schema!(true).to_value()) .expect("true schema should serialize"), ) } } "action" => { let normalized_action_name = match rest { Some(name) => name, None => return None, }; let action_name = denormalize_action_name(normalized_action_name); if let Some(cached) = ACTION_SCHEMA_CACHE.read().get(&action_name).cloned() { return Some(cached); } let mut generator = settings::KeymapFile::action_schema_generator(); let schema = settings::KeymapFile::get_action_schema_by_name(&action_name, &mut generator); let json = serde_json::to_string( &root_schema_from_action_schema(schema, &mut generator).to_value(), ) .expect("Action schema should serialize"); ACTION_SCHEMA_CACHE .write() .insert(action_name, json.clone()); Some(json) } _ => None, } } async fn resolve_dynamic_schema( lsp_store: Entity<LspStore>, path: &str, cx: &mut AsyncApp, ) -> Result<serde_json::Value> { let languages = lsp_store.read_with(cx, |lsp_store, _| lsp_store.languages.clone()); let (schema_name, rest) = path.split_once('/').unzip(); let schema_name = schema_name.unwrap_or(path); let schema = match schema_name { "settings" if rest.is_some_and(|r| r.starts_with("lsp/")) => { let lsp_path = rest .and_then(|r| { r.strip_prefix( LSP_SETTINGS_SCHEMA_URL_PREFIX .strip_prefix(SCHEMA_URI_PREFIX) .and_then(|s| s.strip_prefix("settings/")) .unwrap_or("lsp/"), ) }) .context("Invalid LSP schema path")?; // Parse the schema type from the path: // - "rust-analyzer/initialization_options" → initialization_options_schema // - "rust-analyzer/settings" → settings_schema enum LspSchemaKind { InitializationOptions, Settings, } let (lsp_name, schema_kind) = if let Some(adapter_name) = lsp_path.strip_suffix("/initialization_options") { (adapter_name, LspSchemaKind::InitializationOptions) } else if let Some(adapter_name) = lsp_path.strip_suffix("/settings") { (adapter_name, LspSchemaKind::Settings) } else { anyhow::bail!( "Invalid LSP schema path: \ Expected '{{adapter}}/initialization_options' or '{{adapter}}/settings', got '{}'", lsp_path ); }; let adapter = languages .all_lsp_adapters() .into_iter() .find(|adapter| adapter.name().as_ref() as &str == lsp_name) .or_else(|| { languages.load_available_lsp_adapter(&LanguageServerName::from(lsp_name)) }) .with_context(|| format!("LSP adapter not found: {}", lsp_name))?; let delegate: Arc<dyn LspAdapterDelegate> = cx .update(|inner_cx| { lsp_store.update(inner_cx, |lsp_store, cx| { let Some(local) = lsp_store.as_local() else { return None; }; let Some(worktree) = local.worktree_store.read(cx).worktrees().next() else { return None; }; Some(LocalLspAdapterDelegate::from_local_lsp( local, &worktree, cx, )) }) }) .context(concat!( "Failed to create adapter delegate - ", "either LSP store is not in local mode or no worktree is available" ))?; let schema = match schema_kind { LspSchemaKind::InitializationOptions => { adapter.initialization_options_schema(&delegate, cx).await } LspSchemaKind::Settings => adapter.settings_schema(&delegate, cx).await, }; schema.unwrap_or_else(|| { serde_json::json!({ "type": "object", "additionalProperties": true }) }) } "settings" => { let mut lsp_adapter_names: Vec<String> = languages .all_lsp_adapters() .into_iter() .map(|adapter| adapter.name()) .chain(languages.available_lsp_adapter_names()) .map(|name| name.to_string()) .collect(); let mut i = 0; while i < lsp_adapter_names.len() { let mut j = i + 1; while j < lsp_adapter_names.len() { if lsp_adapter_names[i] == lsp_adapter_names[j] { lsp_adapter_names.swap_remove(j); } else { j += 1; } } i += 1; } cx.update(|cx| { let font_names = &cx.text_system().all_font_names(); let language_names = &languages .language_names() .into_iter() .map(|name| name.to_string()) .collect::<Vec<_>>(); let mut icon_theme_names = vec![]; let mut theme_names = vec![]; if let Some(registry) = theme::ThemeRegistry::try_global(cx) { icon_theme_names.extend( registry .list_icon_themes() .into_iter() .map(|icon_theme| icon_theme.name), ); theme_names.extend(registry.list_names()); } let icon_theme_names = icon_theme_names.as_slice(); let theme_names = theme_names.as_slice(); let action_names = cx.all_action_names(); let action_documentation = cx.action_documentation(); let deprecations = cx.deprecated_actions_to_preferred_actions(); let deprecation_messages = cx.action_deprecation_messages(); let mut schema = settings::SettingsStore::json_schema(&settings::SettingsJsonSchemaParams { language_names, font_names, theme_names, icon_theme_names, lsp_adapter_names: &lsp_adapter_names, action_names, action_documentation, deprecations, deprecation_messages, }); inject_feature_flags_schema(&mut schema); schema }) } "project_settings" => { let lsp_adapter_names = languages .all_lsp_adapters() .into_iter() .map(|adapter| adapter.name().to_string()) .collect::<Vec<_>>(); let language_names = &languages .language_names() .into_iter() .map(|name| name.to_string()) .collect::<Vec<_>>(); let mut schema = settings::SettingsStore::project_json_schema(&settings::SettingsJsonSchemaParams { language_names, lsp_adapter_names: &lsp_adapter_names, // These are not allowed in project-specific settings but // they're still fields required by the // `SettingsJsonSchemaParams` struct. font_names: &[], theme_names: &[], icon_theme_names: &[], action_names: &[], action_documentation: &HashMap::default(), deprecations: &HashMap::default(), deprecation_messages: &HashMap::default(), }); inject_feature_flags_schema(&mut schema); schema } "debug_tasks" => { let adapter_schemas = cx.read_global::<dap::DapRegistry, _>(|dap_registry, _| { dap_registry.adapters_schema() }); task::DebugTaskFile::generate_json_schema(&adapter_schemas) } "keymap" => cx.update(settings::KeymapFile::generate_json_schema_for_registered_actions), "action" => { let normalized_action_name = rest.context("No Action name provided")?; let action_name = denormalize_action_name(normalized_action_name); let mut generator = settings::KeymapFile::action_schema_generator(); let schema = cx .update(|cx| cx.action_schema_by_name(&action_name, &mut generator)) .flatten(); root_schema_from_action_schema(schema, &mut generator).to_value() } "tasks" => task::TaskTemplates::generate_json_schema(), _ => { anyhow::bail!("Unrecognized schema: {schema_name}"); } }; Ok(schema) } const JSONC_LANGUAGE_NAME: &str = "JSONC"; pub fn all_schema_file_associations( languages: &Arc<LanguageRegistry>, path: Option<SettingsLocation<'_>>, cx: &mut App, ) -> serde_json::Value { let extension_globs = languages .available_language_for_name(JSONC_LANGUAGE_NAME) .map(|language| language.matcher().path_suffixes.clone()) .into_iter() .flatten() // Path suffixes can be entire file names or just their extensions. .flat_map(|path_suffix| [format!("*.{path_suffix}"), path_suffix]); let override_globs = AllLanguageSettings::get(path, cx) .file_types .get(JSONC_LANGUAGE_NAME) .into_iter() .flat_map(|(_, glob_strings)| glob_strings) .cloned(); let jsonc_globs = extension_globs.chain(override_globs).collect::<Vec<_>>(); let mut file_associations = serde_json::json!([ { "fileMatch": [ schema_file_match(paths::settings_file()), ], "url": format!("{SCHEMA_URI_PREFIX}settings"), }, { "fileMatch": [ paths::local_settings_file_relative_path()], "url": format!("{SCHEMA_URI_PREFIX}project_settings"), }, { "fileMatch": [schema_file_match(paths::keymap_file())], "url": format!("{SCHEMA_URI_PREFIX}keymap"), }, { "fileMatch": [ schema_file_match(paths::tasks_file()), paths::local_tasks_file_relative_path() ], "url": format!("{SCHEMA_URI_PREFIX}tasks"), }, { "fileMatch": [ schema_file_match(paths::debug_scenarios_file()), paths::local_debug_file_relative_path() ], "url": format!("{SCHEMA_URI_PREFIX}debug_tasks"), }, { "fileMatch": [ schema_file_match( paths::snippets_dir() .join("*.json") .as_path() ) ], "url": format!("{SCHEMA_URI_PREFIX}snippets"), }, { "fileMatch": ["tsconfig.json"], "url": format!("{SCHEMA_URI_PREFIX}tsconfig") }, { "fileMatch": ["package.json"], "url": format!("{SCHEMA_URI_PREFIX}package_json") },