summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cli/lsp/config.rs330
-rw-r--r--cli/lsp/diagnostics.rs10
-rw-r--r--cli/lsp/language_server.rs144
-rw-r--r--cli/lsp/repl.rs2
-rw-r--r--test_util/src/lsp.rs15
5 files changed, 260 insertions, 241 deletions
diff --git a/cli/lsp/config.rs b/cli/lsp/config.rs
index 2d77abaee..6d47d9502 100644
--- a/cli/lsp/config.rs
+++ b/cli/lsp/config.rs
@@ -239,8 +239,7 @@ pub struct SpecifierSettings {
pub enable: Option<bool>,
/// A list of paths, using the workspace folder as a base that should be Deno
/// enabled.
- #[serde(default)]
- pub enable_paths: Vec<String>,
+ pub enable_paths: Option<Vec<String>>,
/// Code lens specific settings for the resource.
#[serde(default)]
pub code_lens: CodeLensSpecifierSettings,
@@ -291,8 +290,7 @@ pub struct WorkspaceSettings {
pub enable: Option<bool>,
/// A list of paths, using the root_uri as a base that should be Deno enabled.
- #[serde(default)]
- pub enable_paths: Vec<String>,
+ pub enable_paths: Option<Vec<String>>,
/// An option that points to a path string of the path to utilise as the
/// cache/DENO_DIR for the language server.
@@ -359,7 +357,7 @@ impl Default for WorkspaceSettings {
fn default() -> Self {
WorkspaceSettings {
enable: None,
- enable_paths: vec![],
+ enable_paths: None,
cache: None,
certificate_stores: None,
config: None,
@@ -402,21 +400,21 @@ impl WorkspaceSettings {
#[derive(Debug, Clone, Default)]
pub struct ConfigSnapshot {
pub client_capabilities: ClientCapabilities,
- pub enabled_paths: HashMap<Url, Vec<Url>>,
pub excluded_paths: Option<Vec<Url>>,
pub has_config_file: bool,
pub settings: Settings,
+ pub workspace_folders: Vec<(ModuleSpecifier, lsp::WorkspaceFolder)>,
}
impl ConfigSnapshot {
/// Determine if the provided specifier is enabled or not.
pub fn specifier_enabled(&self, specifier: &ModuleSpecifier) -> bool {
specifier_enabled(
- &self.enabled_paths,
- self.excluded_paths.as_ref(),
+ specifier,
&self.settings,
+ self.excluded_paths.as_ref(),
+ &self.workspace_folders,
self.has_config_file,
- specifier,
)
}
}
@@ -448,10 +446,8 @@ struct LspConfigFileInfo {
#[derive(Debug)]
pub struct Config {
pub client_capabilities: ClientCapabilities,
- enabled_paths: HashMap<Url, Vec<Url>>,
- pub root_uri: Option<ModuleSpecifier>,
settings: Settings,
- pub workspace_folders: Option<Vec<(ModuleSpecifier, lsp::WorkspaceFolder)>>,
+ pub workspace_folders: Vec<(ModuleSpecifier, lsp::WorkspaceFolder)>,
/// An optional configuration file which has been specified in the client
/// options along with some data that is computed after the config file is set.
maybe_config_file_info: Option<LspConfigFileInfo>,
@@ -461,15 +457,32 @@ impl Config {
pub fn new() -> Self {
Self {
client_capabilities: ClientCapabilities::default(),
- enabled_paths: Default::default(),
/// Root provided by the initialization parameters.
- root_uri: None,
settings: Default::default(),
- workspace_folders: None,
+ workspace_folders: vec![],
maybe_config_file_info: None,
}
}
+ #[cfg(test)]
+ pub fn new_with_root(root_uri: Url) -> Self {
+ let mut config = Self::new();
+ let name = root_uri.path_segments().and_then(|s| s.last());
+ let name = name.unwrap_or_default().to_string();
+ config.workspace_folders = vec![(
+ root_uri.clone(),
+ lsp::WorkspaceFolder {
+ uri: root_uri,
+ name,
+ },
+ )];
+ config
+ }
+
+ pub fn root_uri(&self) -> Option<&Url> {
+ self.workspace_folders.get(0).map(|p| &p.0)
+ }
+
pub fn maybe_node_modules_dir_path(&self) -> Option<&PathBuf> {
self
.maybe_config_file_info
@@ -574,21 +587,24 @@ impl Config {
&mut self,
value: Value,
) -> Result<(), AnyError> {
- let workspace_settings = serde_json::from_value(value)?;
- self.settings.workspace = workspace_settings;
+ self.settings.workspace = serde_json::from_value(value)?;
+ // See https://github.com/denoland/vscode_deno/issues/908.
+ if self.settings.workspace.enable_paths == Some(vec![]) {
+ self.settings.workspace.enable_paths = None;
+ }
Ok(())
}
pub fn snapshot(&self) -> Arc<ConfigSnapshot> {
Arc::new(ConfigSnapshot {
client_capabilities: self.client_capabilities.clone(),
- enabled_paths: self.enabled_paths.clone(),
excluded_paths: self
.maybe_config_file_info
.as_ref()
.map(|i| i.excluded_paths.clone()),
has_config_file: self.has_config_file(),
settings: self.settings.clone(),
+ workspace_folders: self.workspace_folders.clone(),
})
}
@@ -596,24 +612,16 @@ impl Config {
self.settings.specifiers.contains_key(specifier)
}
- pub fn enabled(&self) -> bool {
- self
- .settings
- .workspace
- .enable
- .unwrap_or_else(|| self.has_config_file())
- }
-
pub fn specifier_enabled(&self, specifier: &ModuleSpecifier) -> bool {
specifier_enabled(
- &self.enabled_paths,
+ specifier,
+ &self.settings,
self
.maybe_config_file_info
.as_ref()
.map(|i| &i.excluded_paths),
- &self.settings,
+ &self.workspace_folders,
self.has_config_file(),
- specifier,
)
}
@@ -623,24 +631,31 @@ impl Config {
/// WARNING: This may incorrectly have some directory urls as being
/// represented as file urls.
pub fn enabled_urls(&self) -> Vec<Url> {
- let mut urls: Vec<Url> = Vec::new();
-
- if !self.enabled() && self.enabled_paths.is_empty() {
- // do not return any urls when disabled
- return urls;
- }
-
- for (workspace, enabled_paths) in &self.enabled_paths {
- if !enabled_paths.is_empty() {
- urls.extend(enabled_paths.iter().cloned());
- } else {
- urls.push(workspace.clone());
- }
- }
-
- if urls.is_empty() {
- if let Some(root_dir) = &self.root_uri {
- urls.push(root_dir.clone())
+ let mut urls = vec![];
+ for (workspace_uri, _) in &self.workspace_folders {
+ let specifier_settings = self.settings.specifiers.get(workspace_uri);
+ let enable = specifier_settings
+ .and_then(|s| s.enable)
+ .or(self.settings.workspace.enable)
+ .unwrap_or(self.has_config_file());
+ let enable_paths = specifier_settings
+ .and_then(|s| s.enable_paths.as_ref())
+ .or(self.settings.workspace.enable_paths.as_ref());
+ if let Some(enable_paths) = enable_paths {
+ let Ok(scope_path) = specifier_to_file_path(workspace_uri) else {
+ lsp_log!("Unable to convert uri \"{}\" to path.", workspace_uri);
+ return vec![];
+ };
+ for path in enable_paths {
+ let path = scope_path.join(path);
+ let Ok(path_uri) = Url::from_file_path(&path) else {
+ lsp_log!("Unable to convert path \"{}\" to uri.", path.display());
+ continue;
+ };
+ urls.push(path_uri);
+ }
+ } else if enable {
+ urls.push(workspace_uri.clone());
}
}
@@ -712,64 +727,6 @@ impl Config {
}
}
- /// Given the configured workspaces or root URI and the their settings,
- /// update and resolve any paths that should be enabled
- pub fn update_enabled_paths(&mut self) -> bool {
- if let Some(workspace_folders) = self.workspace_folders.clone() {
- let mut touched = false;
- for (workspace, _) in workspace_folders {
- let enabled_paths = match self.settings.specifiers.get(&workspace) {
- Some(settings) => settings.enable_paths.clone(),
- None => self.settings.workspace.enable_paths.clone(),
- };
- if self.update_enabled_paths_entry(workspace, enabled_paths) {
- touched = true;
- }
- }
- touched
- } else if let Some(root_uri) = self.root_uri.clone() {
- self.update_enabled_paths_entry(
- root_uri,
- self.settings.workspace.enable_paths.clone(),
- )
- } else {
- false
- }
- }
-
- /// Update a specific entry in the enabled paths for a given workspace.
- fn update_enabled_paths_entry(
- &mut self,
- workspace: ModuleSpecifier,
- enabled_paths: Vec<String>,
- ) -> bool {
- let mut touched = false;
- if !enabled_paths.is_empty() {
- if let Ok(workspace_path) = specifier_to_file_path(&workspace) {
- let mut paths = Vec::new();
- for path in &enabled_paths {
- let fs_path = workspace_path.join(path);
- match ModuleSpecifier::from_file_path(fs_path) {
- Ok(path_uri) => {
- paths.push(path_uri);
- }
- Err(_) => {
- lsp_log!("Unable to resolve a file path for `deno.enablePath` from \"{}\" for workspace \"{}\".", path, workspace);
- }
- }
- }
- if !paths.is_empty() {
- touched = true;
- self.enabled_paths.insert(workspace.clone(), paths);
- }
- }
- } else {
- touched = true;
- self.enabled_paths.remove(&workspace);
- }
- touched
- }
-
pub fn get_specifiers(&self) -> Vec<ModuleSpecifier> {
self.settings.specifiers.keys().cloned().collect()
}
@@ -777,8 +734,13 @@ impl Config {
pub fn set_specifier_settings(
&mut self,
specifier: ModuleSpecifier,
- settings: SpecifierSettings,
+ mut settings: SpecifierSettings,
) -> bool {
+ // See https://github.com/denoland/vscode_deno/issues/908.
+ if settings.enable_paths == Some(vec![]) {
+ settings.enable_paths = None;
+ }
+
if let Some(existing) = self.settings.specifiers.get(&specifier) {
if *existing == settings {
return false;
@@ -791,33 +753,63 @@ impl Config {
}
fn specifier_enabled(
- enabled_paths: &HashMap<Url, Vec<Url>>,
- excluded_paths: Option<&Vec<Url>>,
+ specifier: &Url,
settings: &Settings,
+ excluded_urls: Option<&Vec<Url>>,
+ workspace_folders: &Vec<(Url, lsp::WorkspaceFolder)>,
workspace_has_config_file: bool,
- specifier: &Url,
) -> bool {
- let specifier_str = specifier.as_str();
- for (workspace, enabled_paths) in enabled_paths.iter() {
- if specifier_str.starts_with(workspace.as_str()) {
- return enabled_paths
- .iter()
- .any(|path| specifier_str.starts_with(path.as_str()));
+ if let Some(excluded_urls) = excluded_urls {
+ for excluded_path in excluded_urls {
+ if specifier.as_str().starts_with(excluded_path.as_str()) {
+ return false;
+ }
+ }
+ }
+
+ let root_enable = settings
+ .workspace
+ .enable
+ .unwrap_or(workspace_has_config_file);
+
+ if let Some(settings) = settings.specifiers.get(specifier) {
+ // TODO(nayeemrmn): We don't know from where to resolve `enable_paths` in
+ // this case. If it's detected, instead defer to workspace scopes.
+ if settings.enable_paths.is_none() {
+ return settings.enable.unwrap_or(root_enable);
}
}
- if let Some(excluded_paths) = excluded_paths {
- for excluded_path in excluded_paths {
- if specifier_str.starts_with(excluded_path.as_str()) {
+ for (workspace_uri, _) in workspace_folders {
+ if specifier.as_str().starts_with(workspace_uri.as_str()) {
+ let specifier_settings = settings.specifiers.get(workspace_uri);
+ let enable_paths = specifier_settings
+ .and_then(|s| s.enable_paths.as_ref())
+ .or(settings.workspace.enable_paths.as_ref());
+ if let Some(enable_paths) = enable_paths {
+ let Ok(scope_path) = specifier_to_file_path(workspace_uri) else {
+ lsp_log!("Unable to convert uri \"{}\" to path.", workspace_uri);
+ return false;
+ };
+ for path in enable_paths {
+ let path = scope_path.join(path);
+ let Ok(path_uri) = Url::from_file_path(&path) else {
+ lsp_log!("Unable to convert path \"{}\" to uri.", path.display());
+ continue;
+ };
+ if specifier.as_str().starts_with(path_uri.as_str()) {
+ return true;
+ }
+ }
return false;
+ } else {
+ return specifier_settings
+ .and_then(|s| s.enable)
+ .unwrap_or(root_enable);
}
}
}
- settings
- .specifiers
- .get(specifier)
- .and_then(|settings| settings.enable)
- .or(settings.workspace.enable)
- .unwrap_or(workspace_has_config_file)
+
+ root_enable
}
fn resolve_lockfile_from_config(config_file: &ConfigFile) -> Option<Lockfile> {
@@ -878,7 +870,8 @@ mod tests {
#[test]
fn test_config_specifier_enabled() {
- let mut config = Config::new();
+ let root_uri = resolve_url("file:///").unwrap();
+ let mut config = Config::new_with_root(root_uri);
let specifier = resolve_url("file:///a.ts").unwrap();
assert!(!config.specifier_enabled(&specifier));
config
@@ -891,7 +884,8 @@ mod tests {
#[test]
fn test_config_snapshot_specifier_enabled() {
- let mut config = Config::new();
+ let root_uri = resolve_url("file:///").unwrap();
+ let mut config = Config::new_with_root(root_uri);
let specifier = resolve_url("file:///a.ts").unwrap();
assert!(!config.specifier_enabled(&specifier));
config
@@ -905,17 +899,15 @@ mod tests {
#[test]
fn test_config_specifier_enabled_path() {
- let mut config = Config::new();
+ let root_uri = resolve_url("file:///project/").unwrap();
+ let mut config = Config::new_with_root(root_uri);
let specifier_a = resolve_url("file:///project/worker/a.ts").unwrap();
let specifier_b = resolve_url("file:///project/other/b.ts").unwrap();
assert!(!config.specifier_enabled(&specifier_a));
assert!(!config.specifier_enabled(&specifier_b));
- let mut enabled_paths = HashMap::new();
- enabled_paths.insert(
- Url::parse("file:///project/").unwrap(),
- vec![Url::parse("file:///project/worker/").unwrap()],
- );
- config.enabled_paths = enabled_paths;
+ let workspace_settings =
+ serde_json::from_str(r#"{ "enablePaths": ["worker"] }"#).unwrap();
+ config.set_workspace_settings(workspace_settings).unwrap();
assert!(config.specifier_enabled(&specifier_a));
assert!(!config.specifier_enabled(&specifier_b));
let config_snapshot = config.snapshot();
@@ -933,7 +925,7 @@ mod tests {
config.workspace_settings().clone(),
WorkspaceSettings {
enable: None,
- enable_paths: Vec::new(),
+ enable_paths: None,
cache: None,
certificate_stores: None,
config: None,
@@ -1038,11 +1030,10 @@ mod tests {
#[test]
fn config_enabled_urls() {
- let mut config = Config::new();
- let root_dir = Url::parse("file:///example/").unwrap();
- config.root_uri = Some(root_dir.clone());
+ let root_dir = resolve_url("file:///example/").unwrap();
+ let mut config = Config::new_with_root(root_dir.clone());
config.settings.workspace.enable = Some(false);
- config.settings.workspace.enable_paths = Vec::new();
+ config.settings.workspace.enable_paths = None;
assert_eq!(config.enabled_urls(), vec![]);
config.settings.workspace.enable = Some(true);
@@ -1052,24 +1043,60 @@ mod tests {
let root_dir1 = Url::parse("file:///root1/").unwrap();
let root_dir2 = Url::parse("file:///root2/").unwrap();
let root_dir3 = Url::parse("file:///root3/").unwrap();
- config.enabled_paths = HashMap::from([
+ config.workspace_folders = vec![
(
root_dir1.clone(),
- vec![
- root_dir1.join("sub_dir/").unwrap(),
- root_dir1.join("sub_dir/other/").unwrap(),
- root_dir1.join("test.ts").unwrap(),
- ],
+ lsp::WorkspaceFolder {
+ uri: root_dir1.clone(),
+ name: "1".to_string(),
+ },
),
- (root_dir2.clone(), vec![root_dir2.join("other.ts").unwrap()]),
- (root_dir3.clone(), vec![]),
- ]);
+ (
+ root_dir2.clone(),
+ lsp::WorkspaceFolder {
+ uri: root_dir2.clone(),
+ name: "2".to_string(),
+ },
+ ),
+ (
+ root_dir3.clone(),
+ lsp::WorkspaceFolder {
+ uri: root_dir3.clone(),
+ name: "3".to_string(),
+ },
+ ),
+ ];
+ config.set_specifier_settings(
+ root_dir1.clone(),
+ SpecifierSettings {
+ enable_paths: Some(vec![
+ "sub_dir".to_string(),
+ "sub_dir/other".to_string(),
+ "test.ts".to_string(),
+ ]),
+ ..Default::default()
+ },
+ );
+ config.set_specifier_settings(
+ root_dir2.clone(),
+ SpecifierSettings {
+ enable_paths: Some(vec!["other.ts".to_string()]),
+ ..Default::default()
+ },
+ );
+ config.set_specifier_settings(
+ root_dir3.clone(),
+ SpecifierSettings {
+ enable: Some(true),
+ ..Default::default()
+ },
+ );
assert_eq!(
config.enabled_urls(),
vec![
- root_dir1.join("sub_dir/").unwrap(),
- root_dir1.join("sub_dir/other/").unwrap(),
+ root_dir1.join("sub_dir").unwrap(),
+ root_dir1.join("sub_dir/other").unwrap(),
root_dir1.join("test.ts").unwrap(),
root_dir2.join("other.ts").unwrap(),
root_dir3
@@ -1079,9 +1106,8 @@ mod tests {
#[test]
fn config_enable_via_config_file_detection() {
- let mut config = Config::new();
- let root_uri = Url::parse("file:///root/").unwrap();
- config.root_uri = Some(root_uri.clone());
+ let root_uri = resolve_url("file:///root/").unwrap();
+ let mut config = Config::new_with_root(root_uri.clone());
config.settings.workspace.enable = None;
assert_eq!(config.enabled_urls(), vec![]);
diff --git a/cli/lsp/diagnostics.rs b/cli/lsp/diagnostics.rs
index fd4142fd9..7d8368b27 100644
--- a/cli/lsp/diagnostics.rs
+++ b/cli/lsp/diagnostics.rs
@@ -1388,6 +1388,7 @@ mod tests {
}
fn mock_config() -> ConfigSnapshot {
+ let root_uri = resolve_url("file:///").unwrap();
ConfigSnapshot {
settings: Settings {
workspace: WorkspaceSettings {
@@ -1397,6 +1398,13 @@ mod tests {
},
..Default::default()
},
+ workspace_folders: vec![(
+ root_uri.clone(),
+ lsp::WorkspaceFolder {
+ uri: root_uri,
+ name: "".to_string(),
+ },
+ )],
..Default::default()
}
}
@@ -1468,7 +1476,7 @@ let c: number = "a";
specifier.clone(),
SpecifierSettings {
enable: Some(false),
- enable_paths: Vec::new(),
+ enable_paths: None,
code_lens: Default::default(),
},
);
diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs
index a893308ae..3b19d9288 100644
--- a/cli/lsp/language_server.rs
+++ b/cli/lsp/language_server.rs
@@ -403,48 +403,33 @@ impl LanguageServer {
}
pub async fn refresh_specifiers_from_client(&self) -> bool {
- let (client, specifiers) =
+ let (client, specifiers) = {
+ let ls = self.0.read().await;
+ let specifiers = if ls.config.client_capabilities.workspace_configuration
{
- let ls = self.0.read().await;
- let specifiers =
- if ls.config.client_capabilities.workspace_configuration {
- let root_capacity = match &ls.config.workspace_folders {
- Some(folder) => folder.len(),
- None => 1,
- };
- let config_specifiers = ls.config.get_specifiers();
- let mut specifiers =
- HashMap::with_capacity(root_capacity + config_specifiers.len());
- match &ls.config.workspace_folders {
- Some(entry) => {
- for (specifier, folder) in entry {
- specifiers.insert(
- specifier.clone(),
- LspClientUrl::new(folder.uri.clone()),
- );
- }
- }
- None => {
- if let Some(root_uri) = &ls.config.root_uri {
- specifiers.insert(
- root_uri.clone(),
- ls.url_map.normalize_specifier(root_uri).unwrap(),
- );
- }
- }
- }
- specifiers.extend(ls.config.get_specifiers().iter().map(|s| {
- (s.clone(), ls.url_map.normalize_specifier(s).unwrap())
- }));
-
- Some(specifiers.into_iter().collect::<Vec<_>>())
- } else {
- None
- };
+ let root_capacity = std::cmp::max(ls.config.workspace_folders.len(), 1);
+ let config_specifiers = ls.config.get_specifiers();
+ let mut specifiers =
+ HashMap::with_capacity(root_capacity + config_specifiers.len());
+ for (specifier, folder) in &ls.config.workspace_folders {
+ specifiers
+ .insert(specifier.clone(), LspClientUrl::new(folder.uri.clone()));
+ }
+ specifiers.extend(
+ ls.config
+ .get_specifiers()
+ .iter()
+ .map(|s| (s.clone(), ls.url_map.normalize_specifier(s).unwrap())),
+ );
- (ls.client.clone(), specifiers)
+ Some(specifiers.into_iter().collect::<Vec<_>>())
+ } else {
+ None
};
+ (ls.client.clone(), specifiers)
+ };
+
let mut touched = false;
if let Some(specifiers) = specifiers {
let configs_result = client
@@ -477,10 +462,6 @@ impl LanguageServer {
}
}
}
-
- if ls.config.update_enabled_paths() {
- touched = true;
- }
}
touched
}
@@ -701,7 +682,7 @@ impl Inner {
lsp_log!("Setting Deno configuration from: \"{}\"", config_str);
let config_url = if let Ok(url) = Url::from_file_path(config_str) {
Ok(url)
- } else if let Some(root_uri) = &self.config.root_uri {
+ } else if let Some(root_uri) = self.config.root_uri() {
root_uri.join(config_str).map_err(|_| {
anyhow!("Bad file path for configuration file: \"{}\"", config_str)
})
@@ -723,7 +704,7 @@ impl Inner {
// It is possible that root_uri is not set, for example when having a single
// file open and not a workspace. In those situations we can't
// automatically discover the configuration
- if let Some(root_uri) = &self.config.root_uri {
+ if let Some(root_uri) = self.config.root_uri() {
let root_path = specifier_to_file_path(root_uri)?;
let mut checked = std::collections::HashSet::new();
let maybe_config = ConfigFile::discover_from(&root_path, &mut checked)?;
@@ -747,7 +728,7 @@ impl Inner {
// It is possible that root_uri is not set, for example when having a single
// file open and not a workspace. In those situations we can't
// automatically discover the configuration
- if let Some(root_uri) = &self.config.root_uri {
+ if let Some(root_uri) = self.config.root_uri() {
let root_path = specifier_to_file_path(root_uri)?;
let maybe_package_json = package_json::discover_from(
&root_path,
@@ -846,7 +827,7 @@ impl Inner {
lsp_log!("Setting global cache path from: \"{}\"", cache_str);
let cache_url = if let Ok(url) = Url::from_file_path(cache_str) {
Ok(url)
- } else if let Some(root_uri) = &self.config.root_uri {
+ } else if let Some(root_uri) = self.config.root_uri() {
let root_path = specifier_to_file_path(root_uri)?;
let cache_path = root_path.join(cache_str);
Url::from_file_path(cache_path).map_err(|_| {
@@ -892,8 +873,7 @@ impl Inner {
let workspace_settings = self.config.workspace_settings();
let maybe_root_path = self
.config
- .root_uri
- .as_ref()
+ .root_uri()
.and_then(|uri| specifier_to_file_path(uri).ok());
let root_cert_store = get_root_cert_store(
maybe_root_path,
@@ -1074,7 +1054,7 @@ impl Inner {
anyhow!("Bad data url for import map: {}", import_map_str)
})?;
Some(import_map_url)
- } else if let Some(root_uri) = &self.config.root_uri {
+ } else if let Some(root_uri) = self.config.root_uri() {
let root_path = specifier_to_file_path(root_uri)?;
let import_map_path = root_path.join(&import_map_str);
let import_map_url =
@@ -1282,20 +1262,14 @@ impl Inner {
}
{
- // sometimes this root uri may not have a trailing slash, so force it to
- self.config.root_uri = params
- .root_uri
- .map(|s| self.url_map.normalize_url(&s, LspUrlKind::Folder));
-
if let Some(value) = params.initialization_options {
self.config.set_workspace_settings(value).map_err(|err| {
error!("Cannot set workspace settings: {}", err);
LspError::internal_error()
})?;
- self.config.update_enabled_paths();
}
- self.config.workspace_folders = params.workspace_folders.map(|folders| {
- folders
+ if let Some(folders) = params.workspace_folders {
+ self.config.workspace_folders = folders
.into_iter()
.map(|folder| {
(
@@ -1303,8 +1277,31 @@ impl Inner {
folder,
)
})
- .collect()
- });
+ .collect();
+ }
+ // rootUri is deprecated by the LSP spec. If it's specified, merge it into
+ // workspace_folders.
+ if let Some(root_uri) = params.root_uri {
+ if !self
+ .config
+ .workspace_folders
+ .iter()
+ .any(|(_, f)| f.uri == root_uri)
+ {
+ let name = root_uri.path_segments().and_then(|s| s.last());
+ let name = name.unwrap_or_default().to_string();
+ self.config.workspace_folders.insert(
+ 0,
+ (
+ self.url_map.normalize_url(&root_uri, LspUrlKind::Folder),
+ WorkspaceFolder {
+ uri: root_uri,
+ name,
+ },
+ ),
+ );
+ }
+ }
self.config.update_capabilities(&params.capabilities);
}
@@ -1489,7 +1486,6 @@ impl Inner {
if let Err(err) = self.config.set_workspace_settings(value) {
error!("failed to update settings: {}", err);
}
- self.config.update_enabled_paths();
}
self.update_debug_flag();
@@ -1656,18 +1652,16 @@ impl Inner {
)
})
.collect::<Vec<(ModuleSpecifier, WorkspaceFolder)>>();
- if let Some(current_folders) = &self.config.workspace_folders {
- for (specifier, folder) in current_folders {
- if !params.event.removed.is_empty()
- && params.event.removed.iter().any(|f| f.uri == folder.uri)
- {
- continue;
- }
- workspace_folders.push((specifier.clone(), folder.clone()));
+ for (specifier, folder) in &self.config.workspace_folders {
+ if !params.event.removed.is_empty()
+ && params.event.removed.iter().any(|f| f.uri == folder.uri)
+ {
+ continue;
}
+ workspace_folders.push((specifier.clone(), folder.clone()));
}
- self.config.workspace_folders = Some(workspace_folders);
+ self.config.workspace_folders = workspace_folders;
}
async fn document_symbol(
@@ -2627,8 +2621,7 @@ impl Inner {
let maybe_root_path_owned = self
.config
- .root_uri
- .as_ref()
+ .root_uri()
.and_then(|uri| specifier_to_file_path(uri).ok());
let mut resolved_items = Vec::<CallHierarchyIncomingCall>::new();
for item in incoming_calls.iter() {
@@ -2671,8 +2664,7 @@ impl Inner {
let maybe_root_path_owned = self
.config
- .root_uri
- .as_ref()
+ .root_uri()
.and_then(|uri| specifier_to_file_path(uri).ok());
let mut resolved_items = Vec::<CallHierarchyOutgoingCall>::new();
for item in outgoing_calls.iter() {
@@ -2720,8 +2712,7 @@ impl Inner {
let response = if let Some(one_or_many) = maybe_one_or_many {
let maybe_root_path_owned = self
.config
- .root_uri
- .as_ref()
+ .root_uri()
.and_then(|uri| specifier_to_file_path(uri).ok());
let mut resolved_items = Vec::<CallHierarchyItem>::new();
match one_or_many {
@@ -3131,7 +3122,7 @@ impl tower_lsp::LanguageServer for LanguageServer {
let test_server = testing::TestServer::new(
ls.client.clone(),
ls.performance.clone(),
- ls.config.root_uri.clone(),
+ ls.config.root_uri().cloned(),
);
ls.maybe_testing_server = Some(test_server);
}
@@ -3208,7 +3199,6 @@ impl tower_lsp::LanguageServer for LanguageServer {
Ok(specifier_settings) => {
ls.config
.set_specifier_settings(specifier.clone(), specifier_settings);
- ls.config.update_enabled_paths();
}
Err(err) => {
error!("{}", err);
diff --git a/cli/lsp/repl.rs b/cli/lsp/repl.rs
index 598674fdc..6c820701c 100644
--- a/cli/lsp/repl.rs
+++ b/cli/lsp/repl.rs
@@ -285,7 +285,7 @@ fn get_cwd_uri() -> Result<ModuleSpecifier, AnyError> {
pub fn get_repl_workspace_settings() -> WorkspaceSettings {
WorkspaceSettings {
enable: Some(true),
- enable_paths: Vec::new(),
+ enable_paths: None,
config: None,
certificate_stores: None,
cache: None,
diff --git a/test_util/src/lsp.rs b/test_util/src/lsp.rs
index 5369d6361..d276e3ed3 100644
--- a/test_util/src/lsp.rs
+++ b/test_util/src/lsp.rs
@@ -591,6 +591,7 @@ impl LspClientBuilder {
writer,
deno_dir,
stderr_lines_rx,
+ config: json!("{}"),
supports_workspace_configuration: false,
})
}
@@ -605,6 +606,7 @@ pub struct LspClient {
deno_dir: TempDir,
context: TestContext,
stderr_lines_rx: Option<mpsc::Receiver<String>>,
+ config: serde_json::Value,
supports_workspace_configuration: bool,
}
@@ -699,21 +701,14 @@ impl LspClient {
};
self.write_request("initialize", params);
self.write_notification("initialized", json!({}));
+ self.config = config;
if self.supports_workspace_configuration {
- self.handle_configuration_request(config);
+ self.handle_configuration_request(self.config.clone());
}
}
pub fn did_open(&mut self, params: Value) -> CollectedDiagnostics {
- self.did_open_with_config(
- params,
- json!([{
- "enable": true,
- "codeLens": {
- "test": true
- }
- }]),
- )
+ self.did_open_with_config(params, self.config.clone())
}
pub fn did_open_with_config(
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 00:22:51 +0000