Ben KunkleandMichael
4aac5642c1
Closes #ISSUE Improves the efficiency of our interactions with the Zed language server. Previously, on startup and after every workspace configuration changed notification, we would send >1MB of JSON Schemas to the JSON LSP. The only reason this had to happen was due to the case where an extension was installed that would result in a change to the JSON schema for settings (i.e. added language, theme, etc). This PR changes the behavior to use the URI LSP extensions of `vscode-json-language-server` in order to send the server URI's that it can then use to fetch the schemas as needed (i.e. the settings schema is only generated and sent when `settings.json` is opened. This brings the JSON we send to on startup and after every workspace configuration changed notification down to a couple of KB. Additionally, using another LSP extension request we can notify the server when a schema has changed using the URI as a key, so we no longer have to send a workspace configuration changed notification, and the schema contents will only be re-requested and regenerated if the schema is in use. Release Notes: - Improved the efficiency of communication with the builtin JSON LSP. JSON Schemas are no longer sent to the JSON language server in their full form. If you wish to view a builtin JSON schema in the language server info tab of the language server logs (`dev: open language server logs`), you must now use the `editor: open url` action with your cursor over the URL that is sent to the server. - Made it so that Zed urls (`zed://...`) are resolved locally when opened within the editor instead of being resolved through the OS. Users who could not previously open `zed://*` URLs in the editor can now do so by pasting the link into a buffer and using the `editor: open url` action (please open an issue if this is the case for you!). --------- Co-authored-by: Michael <michael@zed.dev>
94 lines
2.8 KiB
Rust
94 lines
2.8 KiB
Rust
use anyhow::Result;
|
|
use async_trait::async_trait;
|
|
use collections::FxHashMap;
|
|
use gpui::{App, Global, SharedString};
|
|
use language::LanguageName;
|
|
use parking_lot::RwLock;
|
|
use task::{
|
|
AdapterSchema, AdapterSchemas, DebugRequest, DebugScenario, SpawnInTerminal, TaskTemplate,
|
|
};
|
|
|
|
use crate::adapters::{DebugAdapter, DebugAdapterName};
|
|
use std::{collections::BTreeMap, sync::Arc};
|
|
|
|
/// Given a user build configuration, locator creates a fill-in debug target ([DebugScenario]) on behalf of the user.
|
|
#[async_trait]
|
|
pub trait DapLocator: Send + Sync {
|
|
fn name(&self) -> SharedString;
|
|
/// Determines whether this locator can generate debug target for given task.
|
|
async fn create_scenario(
|
|
&self,
|
|
build_config: &TaskTemplate,
|
|
resolved_label: &str,
|
|
adapter: &DebugAdapterName,
|
|
) -> Option<DebugScenario>;
|
|
|
|
async fn run(&self, build_config: SpawnInTerminal) -> Result<DebugRequest>;
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct DapRegistryState {
|
|
adapters: BTreeMap<DebugAdapterName, Arc<dyn DebugAdapter>>,
|
|
locators: FxHashMap<SharedString, Arc<dyn DapLocator>>,
|
|
}
|
|
|
|
#[derive(Clone, Default)]
|
|
/// Stores available debug adapters.
|
|
pub struct DapRegistry(Arc<RwLock<DapRegistryState>>);
|
|
impl Global for DapRegistry {}
|
|
|
|
impl DapRegistry {
|
|
pub fn global(cx: &mut App) -> &mut Self {
|
|
cx.default_global::<Self>()
|
|
}
|
|
|
|
pub fn add_adapter(&self, adapter: Arc<dyn DebugAdapter>) {
|
|
let name = adapter.name();
|
|
let _previous_value = self.0.write().adapters.insert(name, adapter);
|
|
}
|
|
|
|
pub fn add_locator(&self, locator: Arc<dyn DapLocator>) {
|
|
self.0.write().locators.insert(locator.name(), locator);
|
|
}
|
|
|
|
pub fn remove_adapter(&self, name: &str) {
|
|
self.0.write().adapters.remove(name);
|
|
}
|
|
|
|
pub fn remove_locator(&self, locator: &str) {
|
|
self.0.write().locators.remove(locator);
|
|
}
|
|
|
|
pub fn adapter_language(&self, adapter_name: &str) -> Option<LanguageName> {
|
|
self.adapter(adapter_name)
|
|
.and_then(|adapter| adapter.adapter_language_name())
|
|
}
|
|
|
|
pub fn adapters_schema(&self) -> task::AdapterSchemas {
|
|
let mut schemas = vec![];
|
|
|
|
let adapters = &self.0.read().adapters;
|
|
|
|
for (name, adapter) in adapters.into_iter() {
|
|
schemas.push(AdapterSchema {
|
|
adapter: name.clone().into(),
|
|
schema: adapter.dap_schema(),
|
|
});
|
|
}
|
|
|
|
AdapterSchemas(schemas)
|
|
}
|
|
|
|
pub fn locators(&self) -> FxHashMap<SharedString, Arc<dyn DapLocator>> {
|
|
self.0.read().locators.clone()
|
|
}
|
|
|
|
pub fn adapter(&self, name: &str) -> Option<Arc<dyn DebugAdapter>> {
|
|
self.0.read().adapters.get(name).cloned()
|
|
}
|
|
|
|
pub fn enumerate_adapters<B: FromIterator<DebugAdapterName>>(&self) -> B {
|
|
self.0.read().adapters.keys().cloned().collect()
|
|
}
|
|
}
|