Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(cargo): dependency version inspections and updates (#684)

l0ng-aib5dbd3c02012
diff --git a/Cargo.lock b/Cargo.lock
index 5c25ebe5f..ee5c7b819 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4684,6 +4684,7 @@ dependencies = [
"ide-text",
"ide-vfs",
"parking_lot",
+ "semver",
"serde",
"serde_json",
"specta",
diff --git a/crates/ide-host/src/lib.rs b/crates/ide-host/src/lib.rs
index 7acd168da..66e21c9b7 100644
--- a/crates/ide-host/src/lib.rs
+++ b/crates/ide-host/src/lib.rs
@@ -60,6 +60,7 @@ pub struct Host {
pub languages: Arc<LanguageRegistry>,
syntax: Arc<OnceLock<Arc<Syntax>>>,
pub global_settings: SettingsStore,
+ pub dependency_versions: Arc<ide_workspace::dependencies::VersionCache>,
pub terminals: TerminalManager,
pub processes: ProcessManager,
/// Debug sessions (adapters run on this machine, next to the project).
@@ -104,6 +105,9 @@ impl Host {
ssh,
environment: environment::Environment::new(project_environment, local_data_dir.clone()),
global_settings,
+ dependency_versions: Arc::new(ide_workspace::dependencies::VersionCache::new(
+ data_dir.join("cache/dependency-versions"),
+ )),
// Sessions, runs and terminals report to the window that started them (`window_sink`).
terminals: TerminalManager::new(),
processes: ProcessManager::new(),
diff --git a/crates/ide-host/src/ops/dependencies.rs b/crates/ide-host/src/ops/dependencies.rs
new file mode 100644
index 000000000..96dfad9b3
--- /dev/null
+++ b/crates/ide-host/src/ops/dependencies.rs
@@ -0,0 +1,123 @@
+//! Repository version lookups for manifest inspections and completion.
+use crate::{Host, rpc::Dispatcher};
+use ide_core::{CancellationToken, DocId, IdeError, IdeResult, RequestId};
+use ide_workspace::dependencies::{DependencyVersionSource, DependencyVersions, cargo};
+
+struct CratesIo;
+impl DependencyVersionSource for CratesIo {
+ fn id(&self) -> &'static str {
+ "crates-io"
+ }
+
+ fn fetch(&self, package: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>> {
+ let path = cargo::index_path(package).ok_or_else(|| IdeError::internal("invalid crate name"))?;
+ let search_path = std::env::var_os("PATH").unwrap_or_default();
+ let text = ide_tools::Http::new(&search_path)?.https_only().get_text_limited(
+ &format!("https://index.crates.io/{path}"),
+ Some(16 * 1024 * 1024),
+ cancel,
+ )?;
+ cargo::parse_index(&text).ok_or_else(|| IdeError::internal("invalid sparse index"))
+ }
+}
+
+/// `offset` limits a completion request to its version string; inspections omit it.
+pub async fn dependency_versions(
+ host: &Host,
+ window: &str,
+ doc: DocId,
+ offset: Option<u32>,
+ request: RequestId,
+) -> IdeResult<Vec<DependencyVersions>> {
+ let project = host.project(window)?;
+ let cache = host.dependency_versions.clone();
+ let cancel = host.begin_request(request);
+ let result = host
+ .blocking(move || {
+ let snap = project.documents.snapshot(doc)?;
+ if snap.large || snap.read_only || snap.path.file_name().is_none_or(|n| n != "Cargo.toml") {
+ return Ok(Vec::new());
+ }
+ let mut out = Vec::new();
+ for dependency in cargo::dependencies(&snap.text) {
+ if offset.is_some_and(|pos| pos < dependency.from || pos > dependency.to) {
+ continue;
+ }
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ let versions = cache.versions(&CratesIo, &dependency.package, &cancel)?;
+ let update = cargo::update(&dependency.requirement, &versions);
+ out.push(DependencyVersions { dependency, versions, update });
+ }
+ Ok(out)
+ })
+ .await;
+ host.end_request(request);
+ result
+}
+
+pub(crate) fn register(d: &mut Dispatcher) {
+ d.add("dependency_versions", |c| async move {
+ dependency_versions(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?, c.arg("request")?).await
+ });
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::HostConfig;
+ use std::sync::Arc;
+
+ struct Source;
+ impl DependencyVersionSource for Source {
+ fn id(&self) -> &'static str {
+ "crates-io"
+ }
+ fn fetch(&self, _: &str, _: &CancellationToken) -> IdeResult<Vec<String>> {
+ Ok(vec!["1.10.0".into(), "0.2.1".into()])
+ }
+ }
+
+ #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+ async fn host_uses_synced_document_cache_and_cursor_filter_without_network() {
+ let temp = tempfile::tempdir().unwrap();
+ let base = dunce::canonicalize(temp.path()).unwrap();
+ let root = base.join("project");
+ std::fs::create_dir(&root).unwrap();
+ let text = "# 中文 😀\n[dependencies]\ntokio = { version = \"0.2\", features = [\"full\"] }\nserde = \"1.0.100\"\nlocal = { path = \"../x\", version = \"0.2\" }\n";
+ let path = root.join("Cargo.toml");
+ std::fs::write(&path, text).unwrap();
+ let host = Host::new(HostConfig {
+ config_dir: base.join("config"),
+ data_dir: base.join("data"),
+ languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
+ syntax: Arc::default(),
+ sink_for: Box::new(|_| Arc::new(|_| {})),
+ owner: |w| w,
+ runtime: tokio::runtime::Handle::current(),
+ project_environment: false,
+ });
+ let project = host.open_project("main", &root).unwrap();
+ let info = project.documents.open(&path).unwrap();
+ for package in ["tokio", "serde"] {
+ host.dependency_versions.versions(&Source, package, &CancellationToken::new()).unwrap();
+ }
+ let all = dependency_versions(&host, "main", info.id, None, RequestId(410)).await.unwrap();
+ assert_eq!(all.len(), 2);
+ assert_eq!(all[0].update.as_ref().unwrap().replacement, "1.10");
+ assert!(all[1].update.is_none());
+ let offset = all[1].dependency.from;
+ let at_cursor = dependency_versions(&host, "main", info.id, Some(offset), RequestId(411)).await.unwrap();
+ assert_eq!(at_cursor.len(), 1);
+ assert_eq!(at_cursor[0].dependency.package, "serde");
+ assert!(dependency_versions(&host, "main", info.id, Some(0), RequestId(412)).await.unwrap().is_empty());
+ host.cancel_request(RequestId(413));
+ assert!(dependency_versions(&host, "main", info.id, None, RequestId(413)).await.is_err());
+ let other = root.join("other.toml");
+ std::fs::write(&other, text).unwrap();
+ let info = project.documents.open(&other).unwrap();
+ assert!(dependency_versions(&host, "main", info.id, None, RequestId(414)).await.unwrap().is_empty());
+ host.close_project("main");
+ }
+}
diff --git a/crates/ide-host/src/ops/mod.rs b/crates/ide-host/src/ops/mod.rs
index 228d02fcd..93a0b28fe 100644
--- a/crates/ide-host/src/ops/mod.rs
+++ b/crates/ide-host/src/ops/mod.rs
@@ -8,6 +8,7 @@ pub mod build;
pub mod bytes;
pub mod coverage;
pub mod debug;
+pub mod dependencies;
pub mod deploy;
pub mod doc;
pub mod env;
@@ -69,6 +70,7 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
analysis::register(d);
syntax::register(d);
spell::register(d);
+ dependencies::register(d);
history::register(d);
coverage::register(d);
build::register(d);
diff --git a/crates/ide-workspace/Cargo.toml b/crates/ide-workspace/Cargo.toml
index cfb75f560..9036108e6 100644
--- a/crates/ide-workspace/Cargo.toml
+++ b/crates/ide-workspace/Cargo.toml
@@ -15,6 +15,7 @@ serde_json.workspace = true
specta.workspace = true
toml.workspace = true
toml_edit.workspace = true
+semver = "1.0.28"
parking_lot.workspace = true
blake3.workspace = true
tracing.workspace = true
diff --git a/crates/ide-workspace/src/dependencies/cache.rs b/crates/ide-workspace/src/dependencies/cache.rs
new file mode 100644
index 000000000..7be33fe7e
--- /dev/null
+++ b/crates/ide-workspace/src/dependencies/cache.rs
@@ -0,0 +1,102 @@
+use super::DependencyVersionSource;
+use ide_core::{CancellationToken, IdeError, IdeResult};
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+const TTL: Duration = Duration::from_secs(3600);
+const FAILURE_TTL: Duration = Duration::from_secs(30);
+const MAX_DISK_BYTES: u64 = 2 * 1024 * 1024;
+type Slot = Arc<Mutex<Option<Cached>>>;
+
+#[derive(Clone, Serialize, Deserialize)]
+struct Cached {
+ fetched: u64,
+ versions: Vec<String>,
+ #[serde(skip)]
+ failed: bool,
+}
+
+/// Same-package lookups share one lock and fetch. Different packages don't block
+/// each other; waiting callers can cancel independently of the active fetch.
+pub struct VersionCache {
+ directory: PathBuf,
+ entries: Mutex<HashMap<String, Slot>>,
+ ttl: Duration,
+}
+
+impl VersionCache {
+ pub fn new(directory: PathBuf) -> Self {
+ Self { directory, entries: Mutex::default(), ttl: TTL }
+ }
+
+ pub fn versions(
+ &self,
+ source: &dyn DependencyVersionSource,
+ package: &str,
+ cancel: &CancellationToken,
+ ) -> IdeResult<Vec<String>> {
+ let safe = |s: &str| !s.is_empty() && s.bytes().all(|b| b.is_ascii_alphanumeric() || b"-_".contains(&b));
+ if !safe(source.id()) || !safe(package) || package.len() > 64 {
+ return Ok(Vec::new());
+ }
+ let key = format!("{}-{}", source.id(), package.to_ascii_lowercase());
+ let slot = self.entries.lock().entry(key.clone()).or_default().clone();
+ let mut cached = loop {
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ if let Some(guard) = slot.try_lock_for(Duration::from_millis(50)) {
+ break guard;
+ }
+ };
+ let checked_at = now();
+ let fresh = |c: &Cached| {
+ c.fetched <= checked_at && checked_at - c.fetched < if c.failed { FAILURE_TTL } else { self.ttl }.as_secs()
+ };
+ if let Some(entry) = cached.as_ref().filter(|c| fresh(c)) {
+ return Ok(entry.versions.clone());
+ }
+ let path = self.directory.join(format!("{key}.json"));
+ let disk = std::fs::metadata(&path)
+ .ok()
+ .filter(|m| m.len() <= MAX_DISK_BYTES)
+ .and_then(|_| std::fs::read(&path).ok())
+ .and_then(|bytes| serde_json::from_slice::<Cached>(&bytes).ok())
+ .filter(fresh);
+ if let Some(entry) = disk {
+ let versions = entry.versions.clone();
+ *cached = Some(entry);
+ return Ok(versions);
+ }
+ let result = source.fetch(package, cancel);
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ let failed = result.is_err();
+ let versions = result.unwrap_or_default();
+ let entry = Cached { fetched: now(), versions: versions.clone(), failed };
+ if !failed
+ && let Ok(bytes) = serde_json::to_vec(&entry)
+ && std::fs::create_dir_all(&self.directory).is_ok()
+ {
+ let temporary = path.with_extension("tmp");
+ if std::fs::write(&temporary, bytes).is_ok() {
+ let _ = std::fs::rename(&temporary, &path);
+ let _ = std::fs::remove_file(&temporary);
+ }
+ }
+ *cached = Some(entry);
+ Ok(versions)
+ }
+}
+
+fn now() -> u64 {
+ SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs()
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ide-workspace/src/dependencies/cache/tests.rs b/crates/ide-workspace/src/dependencies/cache/tests.rs
new file mode 100644
index 000000000..c84265102
--- /dev/null
+++ b/crates/ide-workspace/src/dependencies/cache/tests.rs
@@ -0,0 +1,97 @@
+use super::*;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+struct Source {
+ calls: AtomicUsize,
+ fail: bool,
+}
+impl DependencyVersionSource for Source {
+ fn id(&self) -> &'static str {
+ "test"
+ }
+ fn fetch(&self, _: &str, _: &CancellationToken) -> IdeResult<Vec<String>> {
+ self.calls.fetch_add(1, Ordering::SeqCst);
+ std::thread::sleep(Duration::from_millis(20));
+ if self.fail { Err(IdeError::unavailable("offline")) } else { Ok(vec!["2.0.0".into()]) }
+ }
+}
+fn source(fail: bool) -> Source {
+ Source { calls: AtomicUsize::new(0), fail }
+}
+
+#[test]
+fn memory_disk_ttl_corruption_and_failed_cache_writes() {
+ let dir = tempfile::tempdir().unwrap();
+ let s = source(false);
+ let cancel = CancellationToken::new();
+ let cache = VersionCache::new(dir.path().into());
+ for _ in 0..2 {
+ assert_eq!(cache.versions(&s, "foo", &cancel).unwrap(), ["2.0.0"]);
+ }
+ assert_eq!(s.calls.load(Ordering::SeqCst), 1);
+ VersionCache::new(dir.path().into()).versions(&s, "foo", &cancel).unwrap();
+ assert_eq!(s.calls.load(Ordering::SeqCst), 1, "disk hit after service restart");
+ let mut expired = VersionCache::new(dir.path().into());
+ expired.ttl = Duration::ZERO;
+ expired.versions(&s, "foo", &cancel).unwrap();
+ assert_eq!(s.calls.load(Ordering::SeqCst), 2);
+ std::fs::write(dir.path().join("test-foo.json"), b"corrupt").unwrap();
+ VersionCache::new(dir.path().into()).versions(&s, "foo", &cancel).unwrap();
+ assert_eq!(s.calls.load(Ordering::SeqCst), 3);
+ let file = dir.path().join("not-a-directory");
+ std::fs::write(&file, "x").unwrap();
+ assert_eq!(VersionCache::new(file).versions(&s, "foo", &cancel).unwrap(), ["2.0.0"]);
+}
+
+#[test]
+fn concurrent_fetches_coalesce_and_failures_are_silent_and_short_cached() {
+ let dir = tempfile::tempdir().unwrap();
+ let cache = VersionCache::new(dir.path().into());
+ let s = source(false);
+ std::thread::scope(|scope| {
+ for _ in 0..8 {
+ scope.spawn(|| assert_eq!(cache.versions(&s, "foo", &CancellationToken::new()).unwrap(), ["2.0.0"]));
+ }
+ });
+ assert_eq!(s.calls.load(Ordering::SeqCst), 1);
+ let s = source(true);
+ for _ in 0..2 {
+ assert!(cache.versions(&s, "offline", &CancellationToken::new()).unwrap().is_empty());
+ }
+ assert_eq!(s.calls.load(Ordering::SeqCst), 1);
+ assert!(!dir.path().join("test-offline.json").exists(), "failures aren't persisted");
+ let slot = cache.entries.lock().get("test-offline").unwrap().clone();
+ slot.lock().as_mut().unwrap().fetched -= 31;
+ cache.versions(&s, "offline", &CancellationToken::new()).unwrap();
+ assert_eq!(s.calls.load(Ordering::SeqCst), 2);
+}
+
+#[test]
+fn cancellation_and_invalid_cache_keys_do_not_fetch() {
+ let dir = tempfile::tempdir().unwrap();
+ let cache = VersionCache::new(dir.path().into());
+ let s = source(false);
+ let token = CancellationToken::new();
+ token.cancel();
+ assert!(cache.versions(&s, "foo", &token).is_err());
+ assert!(cache.versions(&s, "../foo", &CancellationToken::new()).unwrap().is_empty());
+ assert_eq!(s.calls.load(Ordering::SeqCst), 0);
+}
+
+#[test]
+fn cancelled_waiter_does_not_cancel_the_shared_fetch() {
+ let dir = tempfile::tempdir().unwrap();
+ let cache = VersionCache::new(dir.path().into());
+ let s = source(false);
+ let slot = Arc::new(Mutex::new(None));
+ cache.entries.lock().insert("test-foo".into(), slot.clone());
+ let guard = slot.lock();
+ let token = CancellationToken::new();
+ std::thread::scope(|scope| {
+ let waiter = scope.spawn(|| cache.versions(&s, "foo", &token));
+ token.cancel();
+ assert!(waiter.join().unwrap().is_err());
+ });
+ drop(guard);
+ assert_eq!(cache.versions(&s, "foo", &CancellationToken::new()).unwrap(), ["2.0.0"]);
+}
diff --git a/crates/ide-workspace/src/dependencies/cargo.rs b/crates/ide-workspace/src/dependencies/cargo.rs
new file mode 100644
index 000000000..a63e701e8
--- /dev/null
+++ b/crates/ide-workspace/src/dependencies/cargo.rs
@@ -0,0 +1,150 @@
+use super::{DependencyUpdate, ManifestDependency};
+use semver::{Op, Version, VersionReq};
+use serde::Deserialize;
+use toml_edit::{Document, Item, TableLike};
+
+/// Cargo's sparse-index path, including the special cases for short names.
+pub fn index_path(name: &str) -> Option<String> {
+ if name.is_empty()
+ || name.len() > 64
+ || !name.bytes().all(|c| c.is_ascii_alphanumeric() || matches!(c, b'-' | b'_'))
+ || !name.as_bytes()[0].is_ascii_alphabetic()
+ {
+ return None;
+ }
+ let name = name.to_ascii_lowercase();
+ Some(match name.len() {
+ 1 => format!("1/{name}"),
+ 2 => format!("2/{name}"),
+ 3 => format!("3/{}/{name}", &name[..1]),
+ _ => format!("{}/{}/{name}", &name[..2], &name[2..4]),
+ })
+}
+
+pub fn parse_index(text: &str) -> Option<Vec<String>> {
+ #[derive(Deserialize)]
+ struct Entry {
+ vers: String,
+ #[serde(default)]
+ yanked: bool,
+ }
+ let mut versions = Vec::new();
+ for line in text.lines().filter(|l| !l.trim().is_empty()) {
+ let entry: Entry = serde_json::from_str(line).ok()?;
+ if !entry.yanked {
+ versions.push(Version::parse(&entry.vers).ok()?);
+ }
+ }
+ versions.sort_unstable_by(|a, b| b.cmp(a));
+ versions.dedup();
+ Some(versions.into_iter().map(|v| v.to_string()).collect())
+}
+
+/// A complete TOML parser supplies spans, so strings/comments that resemble tables
+/// never become dependencies. Broken documents are silent until they parse again.
+pub fn dependencies(text: &str) -> Vec<ManifestDependency> {
+ let Ok(doc) = text.parse::<Document<String>>() else { return Vec::new() };
+ let mut out = Vec::new();
+ sections(doc.as_table(), text, &mut out);
+ if let Some(workspace) = doc.get("workspace").and_then(Item::as_table_like)
+ && let Some(deps) = workspace.get("dependencies").and_then(Item::as_table_like)
+ {
+ collect(deps, text, &mut out);
+ }
+ if let Some(targets) = doc.get("target").and_then(Item::as_table_like) {
+ for (_, target) in targets.iter() {
+ if let Some(target) = target.as_table_like() {
+ sections(target, text, &mut out);
+ }
+ }
+ }
+ out.sort_unstable_by_key(|d| d.from);
+ out
+}
+
+fn sections(table: &dyn TableLike, text: &str, out: &mut Vec<ManifestDependency>) {
+ for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
+ if let Some(deps) = table.get(section).and_then(Item::as_table_like) {
+ collect(deps, text, out);
+ }
+ }
+}
+
+fn collect(table: &dyn TableLike, text: &str, out: &mut Vec<ManifestDependency>) {
+ for (name, item) in table.iter() {
+ let (package, value) = if let Some(dep) = item.as_table_like() {
+ if ["path", "git", "registry", "registry-index"].iter().any(|k| dep.contains_key(k))
+ || dep.get("workspace").and_then(Item::as_bool) == Some(true)
+ {
+ continue;
+ }
+ let Some(version) = dep.get("version") else { continue };
+ (dep.get("package").and_then(Item::as_str).unwrap_or(name), version)
+ } else {
+ (name, item)
+ };
+ if index_path(package).is_none() {
+ continue;
+ }
+ let Some(requirement) = value.as_str() else { continue };
+ let Some(span) = value.span() else { continue };
+ let Some(raw) = text.get(span.clone()) else { continue };
+ // Spans cover the encoded TOML string. Replace its entire contents,
+ // including escapes, while retaining the original quote delimiters.
+ let delimiter = if raw.starts_with("\"\"\"") || raw.starts_with("'''") { 3 } else { 1 };
+ out.push(ManifestDependency {
+ package: package.to_owned(),
+ requirement: requirement.to_owned(),
+ from: text[..span.start + delimiter].encode_utf16().count() as u32,
+ to: text[..span.end - delimiter].encode_utf16().count() as u32,
+ });
+ }
+}
+
+pub fn update(requirement: &str, versions: &[String]) -> Option<DependencyUpdate> {
+ let req = VersionReq::parse(requirement).ok()?;
+ let prerelease = req.comparators.iter().any(|c| !c.pre.is_empty());
+ let latest =
+ versions.iter().filter_map(|v| Version::parse(v).ok()).filter(|v| prerelease || v.pre.is_empty()).max()?;
+ if req.matches(&latest) {
+ return None;
+ }
+ // An unavailable future version isn't an invitation to downgrade.
+ if req.comparators.iter().any(|c| {
+ (c.op == Op::Greater
+ && c.patch.is_none()
+ && (latest.major < c.major
+ || (latest.major == c.major && c.minor.is_none_or(|minor| latest.minor <= minor))))
+ || !matches!(c.op, Op::Less | Op::LessEq)
+ && latest
+ <= Version {
+ major: c.major,
+ minor: c.minor.unwrap_or(0),
+ patch: c.patch.unwrap_or(0),
+ pre: c.pre.clone(),
+ build: Default::default(),
+ }
+ }) {
+ return None;
+ }
+ let trimmed = requirement.trim();
+ let digits = trimmed.trim_start_matches(['^', '~', '=']).trim_start();
+ let simple = digits.split('.').all(|s| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit()));
+ let mut replacement = latest.to_string();
+ if simple && latest.pre.is_empty() {
+ let precision = digits.split('.').count();
+ let version = match precision {
+ 1 => latest.major.to_string(),
+ 2 => format!("{}.{}", latest.major, latest.minor),
+ _ => latest.to_string(),
+ };
+ let candidate = format!("{}{version}", &trimmed[..trimmed.len() - digits.len()]);
+ if VersionReq::parse(&candidate).is_ok_and(|r| r.matches(&latest)) {
+ replacement = candidate;
+ }
+ }
+ Some(DependencyUpdate { latest: latest.to_string(), replacement })
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ide-workspace/src/dependencies/cargo/tests.rs b/crates/ide-workspace/src/dependencies/cargo/tests.rs
new file mode 100644
index 000000000..7be9927dc
--- /dev/null
+++ b/crates/ide-workspace/src/dependencies/cargo/tests.rs
@@ -0,0 +1,143 @@
+use super::*;
+
+#[test]
+fn sparse_paths_and_input_validation() {
+ for (name, path) in
+ [("A", "1/a"), ("ab", "2/ab"), ("AbC", "3/a/abc"), ("serde", "se/rd/serde"), ("my_crate", "my/_c/my_crate")]
+ {
+ assert_eq!(index_path(name).as_deref(), Some(path));
+ }
+ for name in ["", "../serde", "a/b", "sé", "-foo", "a?b", "1abc"] {
+ assert!(index_path(name).is_none(), "{name}");
+ }
+}
+
+#[test]
+fn sparse_index_filters_yanked_sorts_semver_and_keeps_prereleases_for_completion() {
+ let text = r#"{"vers":"1.9.0","yanked":false}
+{"vers":"2.0.0-beta.1","yanked":false}
+{"vers":"9.0.0","yanked":true}
+{"vers":"1.10.0","yanked":false}
+{"vers":"1.10.0"}"#;
+ assert_eq!(parse_index(text).unwrap(), ["2.0.0-beta.1", "1.10.0", "1.9.0"]);
+ assert!(parse_index("{broken").is_none());
+ assert!(parse_index(r#"{"vers":"bogus"}"#).is_none());
+}
+
+#[test]
+fn cargo_requirements_updates_and_precision() {
+ for (req, latest, expected) in [
+ ("1", "1.9.0", None),
+ ("1.0.100", "1.0.228", None),
+ ("^1.2", "1.9.0", None),
+ ("0.7", "0.7.9", None),
+ ("0.0.1", "0.0.2", Some("0.0.2")),
+ ("1", "2.3.4", Some("2")),
+ ("1.2", "2.3.4", Some("2.3")),
+ ("1.2.3", "2.3.0", Some("2.3.0")),
+ ("1.2.3", "1.3.0", None),
+ ("0.2", "1.3.0", Some("1.3")),
+ ("=1.2.3", "1.3.0", Some("=1.3.0")),
+ ("~1.2", "1.3.0", Some("~1.3")),
+ ("^0.2", "0.3.1", Some("^0.3")),
+ ("1.*", "1.9.0", None),
+ ("*", "2.3.4", None),
+ (">=1, <2", "2.3.4", Some("2.3.4")),
+ (">=1, <2", "2.0.0", Some("2.0.0")),
+ ("<1", "1.0.0", Some("1.0.0")),
+ (">=1, <3", "2.3.4", None),
+ (">=9", "2.3.4", None),
+ (">1", "1.9.0", None),
+ (">1.2", "1.2.9", None),
+ (">1.2.3", "1.2.3", None),
+ ("=9.1.2", "2.3.4", None),
+ ("bad", "2.3.4", None),
+ ("1.0", "2.0.0-beta.1", None),
+ ("1.0.0-beta.1", "1.0.0-beta.2", None),
+ ("=1.0.0-beta.1", "1.0.0-beta.2", Some("1.0.0-beta.2")),
+ ("1.0.0-beta.1", "2.0.0-beta.1", Some("2.0.0-beta.1")),
+ ] {
+ let actual = update(req, &[latest.to_owned()]);
+ assert_eq!(actual.as_ref().map(|u| u.replacement.as_str()), expected, "{req} -> {latest}");
+ if let Some(u) = actual {
+ assert!(VersionReq::parse(&u.replacement).unwrap().matches(&Version::parse(latest).unwrap()));
+ }
+ }
+ let versions = vec!["3.0.0-beta.1".into(), "2.0.0".into(), "1.0.0".into()];
+ assert_eq!(update("1", &versions).unwrap().latest, "2.0.0");
+}
+
+#[test]
+fn locates_all_cargo_sections_and_only_replaces_version_contents() {
+ let text = r#"# 中文 😀
+[package]
+name = "fixture"
+version = "1.0.0"
+[dependencies]
+serde = "1.0.100" # stays
+rand = '0.7'
+tokio = { version = "0.2", features = ["full"] }
+renamed = { package = "real-crate", version = "1.2" }
+local = { path = "../local", version = "1" }
+git = { git = "https://example.com/repo", version = "1" }
+inherited = { workspace = true }
+other = { registry = "private", version = "1" }
+[dev-dependencies]
+check = "1"
+[build-dependencies.build]
+version = "1.2.3"
+[target.'cfg(unix)'.dependencies]
+native = "0.1"
+[target.'cfg(windows)'.dev-dependencies]
+win = { version = "1" }
+[target.'cfg(unix)'.build-dependencies]
+build-native = "2"
+[workspace.dependencies]
+shared = { version = "1", features = ["std"] }
+[package.metadata.dependencies]
+not-a-dependency = "1"
+"#;
+ let deps = dependencies(text);
+ assert_eq!(
+ deps.iter().map(|d| d.package.as_str()).collect::<Vec<_>>(),
+ ["serde", "rand", "tokio", "real-crate", "check", "build", "native", "win", "build-native", "shared"]
+ );
+ let utf16: Vec<_> = text.encode_utf16().collect();
+ for dep in &deps {
+ assert_eq!(String::from_utf16(&utf16[dep.from as usize..dep.to as usize]).unwrap(), dep.requirement);
+ }
+ let tokio = &deps[2];
+ let mut edited = utf16.clone();
+ edited.splice(tokio.from as usize..tokio.to as usize, "1.3".encode_utf16());
+ assert_eq!(String::from_utf16(&edited).unwrap(), text.replace("version = \"0.2\"", "version = \"1.3\""));
+ let rand = &deps[1];
+ let mut edited = utf16;
+ edited.splice(rand.from as usize..rand.to as usize, "0.9".encode_utf16());
+ assert_eq!(String::from_utf16(&edited).unwrap(), text.replace("'0.7'", "'0.9'"));
+}
+
+#[test]
+fn invalid_toml_and_decoy_tables_are_silent() {
+ assert!(dependencies("[dependencies]\na = \"").is_empty());
+ assert!(dependencies("[package]\ndescription = '''\n[dependencies]\na = \"1\"\n'''\n").is_empty());
+ assert!(dependencies("[dependencies]\na = { version = 1 }\nb = { workspace = true, version = \"1\" }\nc = { version = \"1\", registry-index = \"x\" }").is_empty());
+ let deps = dependencies("[dependencies]\na = \"\"\n");
+ assert_eq!(deps.len(), 1, "empty version strings still offer completion");
+ assert_eq!(deps[0].from, deps[0].to);
+}
+
+#[test]
+fn replaces_encoded_and_multiline_strings_without_damaging_quotes() {
+ for raw in [r#""0.\u0032""#, "\"\"\"\n0.2\"\"\"", "'''0.2'''"] {
+ let text = format!("[dependencies]\ntokio = {{ version = {raw}, features = [\"full\"] }}\n");
+ let dep = dependencies(&text).pop().unwrap();
+ assert_eq!(dep.requirement, "0.2");
+ let mut encoded: Vec<_> = text.encode_utf16().collect();
+ encoded.splice(dep.from as usize..dep.to as usize, "1.10".encode_utf16());
+ let edited = String::from_utf16(&encoded).unwrap();
+ assert!(edited.contains("features = [\"full\"]"));
+ assert_eq!(dependencies(&edited)[0].requirement, "1.10");
+ assert_eq!(edited.matches('"').count(), text.matches('"').count());
+ assert_eq!(edited.matches('\'').count(), text.matches('\'').count());
+ }
+}
diff --git a/crates/ide-workspace/src/dependencies/mod.rs b/crates/ide-workspace/src/dependencies/mod.rs
new file mode 100644
index 000000000..eef3a69a3
--- /dev/null
+++ b/crates/ide-workspace/src/dependencies/mod.rs
@@ -0,0 +1,41 @@
+//! Manifest dependencies and repository versions, independent of editor and transport.
+mod cache;
+pub mod cargo;
+
+pub use cache::VersionCache;
+use ide_core::{CancellationToken, IdeResult};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+/// A repository adapter; Maven/npm can use the same cache and editor protocol.
+pub trait DependencyVersionSource: Send + Sync {
+ /// A filesystem-safe, stable repository identifier.
+ fn id(&self) -> &'static str;
+ /// Non-yanked versions in descending semantic order.
+ fn fetch(&self, package: &str, cancel: &CancellationToken) -> IdeResult<Vec<String>>;
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct DependencyUpdate {
+ pub latest: String,
+ pub replacement: String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct ManifestDependency {
+ pub package: String,
+ pub requirement: String,
+ /// UTF-16 offsets of the string's contents (quotes excluded).
+ pub from: u32,
+ pub to: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct DependencyVersions {
+ pub dependency: ManifestDependency,
+ pub versions: Vec<String>,
+ pub update: Option<DependencyUpdate>,
+}
diff --git a/crates/ide-workspace/src/lib.rs b/crates/ide-workspace/src/lib.rs
index 1ab611e69..38ba30ca7 100644
--- a/crates/ide-workspace/src/lib.rs
+++ b/crates/ide-workspace/src/lib.rs
@@ -1,6 +1,7 @@
//! The project model that ties documents, settings and history together.
pub mod caches;
+pub mod dependencies;
pub mod devcontainer;
pub mod documents;
pub mod editorconfig;
diff --git a/src-tauri/src/commands/dependencies.rs b/src-tauri/src/commands/dependencies.rs
new file mode 100644
index 000000000..ae5e9bbb9
--- /dev/null
+++ b/src-tauri/src/commands/dependencies.rs
@@ -0,0 +1,17 @@
+//! Typed IPC adapters for manifest dependency versions.
+use crate::state::AppState;
+use ide_core::{DocId, IdeResult, RequestId};
+use ide_workspace::dependencies::DependencyVersions;
+use tauri::{State, Window};
+
+#[tauri::command]
+#[specta::specta]
+pub async fn dependency_versions(
+ window: Window,
+ state: State<'_, AppState>,
+ doc: DocId,
+ offset: Option<u32>,
+ request: RequestId,
+) -> IdeResult<Vec<DependencyVersions>> {
+ ide_host::ops::dependencies::dependency_versions(&state.host, window.label(), doc, offset, request).await
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index c71ce8405..2d37e23ea 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -16,6 +16,7 @@ pub mod clipboard;
pub mod coverage;
pub mod db;
pub mod debug;
+pub mod dependencies;
pub mod deploy;
pub mod doc;
pub mod docker;
@@ -190,6 +191,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
nav::fs_resolve_reference,
nav::path_completions,
nav::web_unresolved_references,
+ dependencies::dependency_versions,
spell::spell_check,
spell::spell_suggest,
search::search_start,
diff --git a/src/bindings.ts b/src/bindings.ts
index 645f8668a..e2a005bb4 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -327,6 +327,7 @@ export const commands = {
pathCompletions: (from: IpcPath, prefix: string) => typedError<PathCompletion[], IdeError>(__TAURI_INVOKE("path_completions", { from, prefix })),
/** Paths in an HTML document or stylesheet that name no existing file. */
webUnresolvedReferences: (doc: DocId) => typedError<FileReference[], IdeError>(__TAURI_INVOKE("web_unresolved_references", { doc })),
+ dependencyVersions: (doc: DocId, offset: number | null, request: RequestId) => typedError<DependencyVersions[], IdeError>(__TAURI_INVOKE("dependency_versions", { doc, offset, request })),
/**
* Misspelt words in the comments, string literals and declared names of
* `doc` that `scope` includes (all of its text for prose). Cancel with
@@ -2468,6 +2469,17 @@ export type DeletedBranch = {
unmerged: boolean,
};
+export type DependencyUpdate = {
+ latest: string,
+ replacement: string,
+};
+
+export type DependencyVersions = {
+ dependency: ManifestDependency,
+ versions: string[],
+ update: DependencyUpdate | null,
+};
+
/** Where a local file is deployed. */
export type DeployedPath = {
server: string,
@@ -4289,6 +4301,14 @@ export type MainToolbarSettings = {
hidden?: string[],
};
+export type ManifestDependency = {
+ package: string,
+ requirement: string,
+ /** UTF-16 offsets of the string's contents (quotes excluded). */
+ from: number,
+ to: number,
+};
+
export type Markup = {
/** `markdown` or `plaintext`. */
kind: string,
diff --git a/src/editor/api.ts b/src/editor/api.ts
index 9f2ab9a0f..9f0251cbf 100644
--- a/src/editor/api.ts
+++ b/src/editor/api.ts
@@ -21,6 +21,7 @@ import {
Annotation,
Compartment,
Facet,
+ StateEffect,
type EditorState,
type Extension,
type RangeSet,
@@ -332,14 +333,25 @@ export function contributedAt<T>(state: EditorState, key: string, pos: number):
return state.languageDataAt<T>(key, pos)[0];
}
-/** A context action a feature offers at the caret, listed by Show Context Actions (⌥↵) before the language server's. */
+/** A context action a feature offers at the caret, listed by Show Context Actions (⌥↵). */
export interface ContributedIntention {
id: string;
label: string;
icon?: string;
+ quickFix?: boolean;
run: () => void | Promise<void>;
}
+/** A background provider has new context actions for the current document. */
+export const intentionsChanged = StateEffect.define<null>();
+
+/** Local fixes of a diagnostic range (hover link and Apply Quick Fix). */
+export const quickFixProviders = Facet.define<(view: EditorView, from: number, to: number) => ContributedIntention[]>();
+
+export function contributedQuickFixes(view: EditorView, from: number, to: number): ContributedIntention[] {
+ return view.state.facet(quickFixProviders).flatMap((provider) => provider(view, from, to));
+}
+
/** Providers of `ContributedIntention`s for the caret of `view` (cheap and synchronous: also drives the light bulb). */
export const intentionProviders = Facet.define<(view: EditorView) => ContributedIntention[]>();
diff --git a/src/editor/lsp/diagnostics.ts b/src/editor/lsp/diagnostics.ts
index f4cc7850f..656912926 100644
--- a/src/editor/lsp/diagnostics.ts
+++ b/src/editor/lsp/diagnostics.ts
@@ -12,7 +12,7 @@ import type { Diagnostic, Severity } from "@/bindings";
import { commands, ideEventsReady, isTauri, onIdeEvent } from "@/platform/ipc";
import { useProject } from "@/platform/project";
import { publishLocalDiagnostics } from "@/platform/localDiagnostics";
-import { scrollbarMarks, type ScrollbarMark } from "@/editor/api";
+import { intentionsChanged, scrollbarMarks, type ScrollbarMark } from "@/editor/api";
import { rangeToOffsets } from "./positions";
import { lspDoc } from "./lsp";
import { showHint } from "./hint";
@@ -199,7 +199,10 @@ const diagnosticsSync = ViewPlugin.fromClass(
if (!path || !this.view.dom.isConnected) return;
const lint = toLintDiagnostics(this.view.state.doc, diagnosticsFor(path));
const tr = setDiagnostics(this.view.state, lint);
- this.view.dispatch({ ...tr, effects: [...[tr.effects ?? []].flat(), setMarks.of(diagnosticMarks(lint))] });
+ this.view.dispatch({
+ ...tr,
+ effects: [...[tr.effects ?? []].flat(), setMarks.of(diagnosticMarks(lint)), intentionsChanged.of(null)],
+ });
});
}
destroy() {
diff --git a/src/editor/lsp/hover.ts b/src/editor/lsp/hover.ts
index e6614dc28..4da03f152 100644
--- a/src/editor/lsp/hover.ts
+++ b/src/editor/lsp/hover.ts
@@ -98,7 +98,7 @@ function renderDiagnostics(view: EditorView, diags: PlacedDiagnostic[]): HTMLEle
fix.className = "cm-lsp-link-button";
const keys = shortcutLabel("code.showIntentions");
fix.textContent = keys ? `More actions… ${keys}` : "More actions…";
- if (d.severity === "error" || d.severity === "warning") offerQuickFix(view, meta, fix, from, to);
+ if (d.severity !== "hint") offerQuickFix(view, meta, fix, from, to);
fix.addEventListener("mousedown", (e) => e.preventDefault());
fix.addEventListener("click", () => {
view.dispatch({ selection: EditorSelection.cursor(from) });
diff --git a/src/editor/lsp/intentions.test.ts b/src/editor/lsp/intentions.test.ts
index bb913d157..a76d9b4a1 100644
--- a/src/editor/lsp/intentions.test.ts
+++ b/src/editor/lsp/intentions.test.ts
@@ -1,6 +1,7 @@
import { afterEach, describe, expect, it, vi } from "vitest";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
+import { setDiagnostics } from "@codemirror/lint";
import type { CodeAction } from "@/bindings";
const resolved: CodeAction = {
@@ -35,6 +36,7 @@ const {
intentionPreview,
lightsBulb,
listedCodeActions,
+ listedIntentions,
withInspectionControls,
} = await import("./intentions");
const { setFileDiagnostics } = await import("./diagnostics");
@@ -90,6 +92,27 @@ describe("inspection controls in ⌥↵ (issue #42)", () => {
setFileDiagnostics("/p/two.py", "ruff", []);
expect(withInspectionControls(view, [])).toEqual([]);
});
+
+ it.each(["info", "warning", "error"] as const)(
+ "uses the effective %s severity for local and LSP fixes",
+ (severity) => {
+ const path = `/p/severity-${severity}.py`;
+ setFileDiagnostics(path, "ruff", [{ ...unused, severity }]);
+ const view = editorAt(path);
+ view.dispatch(setDiagnostics(view.state, [{ from: 7, to: 9, severity, message: unused.message }]));
+ const items = listedIntentions(view, [
+ { id: "refactor", label: "Extract method", icon: "bulb", run: vi.fn() },
+ { id: "local", label: "Local fix", quickFix: true, run: vi.fn() },
+ { id: "lsp", label: "LSP fix", quickFix: true, emphasis: true, run: vi.fn() },
+ ]);
+ expect(items.map((i) => i.id)).toEqual(["lsp", "local", "refactor"]);
+ expect(items.slice(0, 2).map((i) => i.icon)).toEqual(Array(2).fill(severity === "error" ? "bulb-fix" : "bulb"));
+ const controls = withInspectionControls(view, items);
+ expect(controls.slice(0, 2).every((i) => i.submenu?.length === 2)).toBe(true);
+ expect(controls[2]!.submenu).toBeUndefined();
+ setFileDiagnostics(path, "ruff", []);
+ },
+ );
});
describe("intention preview", () => {
diff --git a/src/editor/lsp/intentions.ts b/src/editor/lsp/intentions.ts
index 07cb7d6dd..7dd584134 100644
--- a/src/editor/lsp/intentions.ts
+++ b/src/editor/lsp/intentions.ts
@@ -9,7 +9,13 @@ import { forEachDiagnostic } from "@codemirror/lint";
import { indentUnit } from "@codemirror/language";
import { diff } from "@codemirror/merge";
import { commands, isCancelled, type CodeAction } from "@/platform/ipc";
-import { contributedIntentions, intentionProviders, whenSynced } from "@/editor/api";
+import {
+ contributedIntentions,
+ contributedQuickFixes,
+ intentionProviders,
+ intentionsChanged,
+ whenSynced,
+} from "@/editor/api";
import { shortcutLabel } from "@/platform/keymap";
import { debounce, docOf, isUnavailable, lspRequest, reportLspError } from "./lsp";
import { offsetsToRange } from "./positions";
@@ -32,6 +38,27 @@ const codeActionBackoff = featureBackoff();
const isQuickFix = (a: CodeAction) => !!a.kind && (a.kind === "quickfix" || a.kind.startsWith("quickfix."));
+/** The red bulb is reserved for errors; other inspections use the ordinary bulb. */
+export function quickFixIcon(view: EditorView): "bulb" | "bulb-fix" {
+ const sel = view.state.selection.main;
+ const line = view.state.doc.lineAt(sel.head);
+ let error = false;
+ forEachDiagnostic(view.state, (d, from, to) => {
+ if (d.severity === "error" && from <= line.to && to >= line.from) error = true;
+ });
+ return error ? "bulb-fix" : "bulb";
+}
+
+const isFixItem = (item: ListPopupItem) => item.quickFix ?? item.icon === "bulb-fix";
+
+/** Local and language-server fixes share icons and the same stable ordering. */
+export function listedIntentions(view: EditorView, items: ListPopupItem[]): ListPopupItem[] {
+ const rank = (item: ListPopupItem) => (item.disabled ? 4 : 0) + (isFixItem(item) ? 0 : 2) + (item.emphasis ? 0 : 1);
+ return items
+ .map((item) => (isFixItem(item) ? { ...item, quickFix: true, icon: quickFixIcon(view) } : item))
+ .sort((a, b) => rank(a) - rank(b));
+}
+
/** IDEA ordering: quick fixes first, preferred before others, disabled last; stable otherwise. */
export function sortCodeActions(actions: readonly CodeAction[]): CodeAction[] {
const rank = (a: CodeAction) => (a.disabledReason ? 4 : 0) + (isQuickFix(a) ? 0 : 2) + (a.isPreferred ? 0 : 1);
@@ -104,15 +131,23 @@ async function fetchIntentions(view: EditorView): Promise<CodeAction[]> {
return actions;
}
-/** Enabled quick fixes of the problem at `from..to`, preferred first. */
-export async function quickFixesAt(view: EditorView, from: number, to: number): Promise<CodeAction[]> {
+export type EditorQuickFix = CodeAction | { title: string; run: () => void | Promise<void> };
+
+/** Enabled quick fixes of the problem at `from..to`, including local inspections. */
+export async function quickFixesAt(view: EditorView, from: number, to: number): Promise<EditorQuickFix[]> {
+ const local = contributedQuickFixes(view, from, to).map((fix) => ({ title: fix.label, run: fix.run }));
const doc = docOf(view);
- if (!doc) return [];
- await whenSynced(view);
- const actions = await lspRequest(() =>
- commands.lspCodeActions(doc.doc, offsetsToRange(view.state.doc, from, to), ["quickfix"]),
- );
- return sortCodeActions(actions.filter((a) => isQuickFix(a) && !a.disabledReason));
+ if (!doc) return local;
+ try {
+ await whenSynced(view);
+ const actions = await lspRequest(() =>
+ commands.lspCodeActions(doc.doc, offsetsToRange(view.state.doc, from, to), ["quickfix"]),
+ );
+ return [...local, ...sortCodeActions(actions.filter((a) => isQuickFix(a) && !a.disabledReason))];
+ } catch (e) {
+ if (local.length) return local;
+ throw e;
+ }
}
/**
@@ -144,7 +179,8 @@ export async function applyQuickFix(view: EditorView) {
showHint(view, "No quick fixes available");
}
-export async function applyCodeAction(view: EditorView, action: CodeAction) {
+export async function applyCodeAction(view: EditorView, action: EditorQuickFix) {
+ if ("run" in action) return action.run();
const doc = docOf(view);
if (!doc) return;
if (action.disabledReason) {
@@ -276,9 +312,10 @@ function actionItems(
resolved?: Map<CodeAction, Promise<CodeAction>>,
): ListPopupItem[] {
return listedCodeActions(actions).map((a, i) => ({
- id: `${i}`,
+ id: `lsp:${i}`,
label: a.title,
- icon: isQuickFix(a) ? "bulb-fix" : "bulb",
+ icon: isQuickFix(a) ? quickFixIcon(view) : "bulb",
+ quickFix: isQuickFix(a),
emphasis: a.isPreferred,
disabled: a.disabledReason,
// The edit the preview already resolved is applied as is.
@@ -344,7 +381,7 @@ export function withInspectionControls(view: EditorView, items: ListPopupItem[])
(i) => i.id !== SPELLING_INSPECTION,
);
if (!inspections.length) return items;
- const fixes = items.filter((i) => i.icon === "bulb-fix" && !i.submenu);
+ const fixes = items.filter((i) => isFixItem(i) && !i.submenu);
if (inspections.length === 1 && fixes.length) {
const submenu = intentionControls(inspections[0]!);
return items.map((i) => (fixes.includes(i) ? { ...i, submenu } : i));
@@ -364,7 +401,7 @@ export function withInspectionControls(view: EditorView, items: ListPopupItem[])
/** ⌥↵ */
export async function showIntentions(view: EditorView) {
try {
- // Typo fixes and feature-contributed actions come first and need no language server.
+ // Local inspections need no language server.
const local: ListPopupItem[] = [...spellingIntentions(view), ...contributedIntentions(view)];
let actions: CodeAction[] = [];
let failure: { error: unknown } | null = null;
@@ -376,7 +413,9 @@ export async function showIntentions(view: EditorView) {
}
const sorted = listedCodeActions(actions);
const resolved = new Map<CodeAction, Promise<CodeAction>>();
- const items = withInspectionControls(view, [...local, ...actionItems(view, sorted, resolved)]);
+ const serverItems = actionItems(view, sorted, resolved);
+ const previews = new Map(serverItems.map((item, i) => [item.id, sorted[i]!]));
+ const items = withInspectionControls(view, listedIntentions(view, [...local, ...serverItems]));
if (!items.length) {
if (failure) throw failure.error;
showHint(view, "No intentions available");
@@ -388,7 +427,7 @@ export async function showIntentions(view: EditorView) {
title: "Intentions",
items,
preview: (item, signal) => {
- const action = sorted[items.indexOf(item) - local.length];
+ const action = previews.get(item.id);
return action ? intentionPreview(view, action, resolved, signal) : Promise.resolve(null);
},
});
@@ -500,7 +539,13 @@ const bulbPlugin = ViewPlugin.fromClass(
this.lookup();
}
update(u: ViewUpdate) {
- if (u.docChanged || u.selectionSet || (u.focusChanged && u.view.hasFocus)) this.lookup();
+ if (
+ u.docChanged ||
+ u.selectionSet ||
+ (u.focusChanged && u.view.hasFocus) ||
+ u.transactions.some((tr) => tr.effects.some((e) => e.is(intentionsChanged)))
+ )
+ this.lookup();
else if (u.focusChanged) {
this.lookup.cancel();
// A blur dispatched from inside the update is not allowed.
@@ -516,16 +561,16 @@ const bulbPlugin = ViewPlugin.fromClass(
if (!doc || doc.readOnly || !this.view.dom.isConnected || !this.view.hasFocus) return;
const state = this.view.state;
const typoFix = spellingIntentions(this.view).length > 0;
- const local = typoFix || contributedIntentions(this.view).length > 0;
+ const selection = state.selection.main;
+ const ownFix = contributedQuickFixes(this.view, selection.from, selection.to).length > 0;
+ const local = typoFix || ownFix || contributedIntentions(this.view).length > 0;
const backoff = codeActionBackoff.active(doc.doc);
- if (backoff && !local) return;
let actions: CodeAction[] = [];
if (!backoff) {
try {
actions = await fetchIntentions(this.view);
} catch (e) {
if (isUnavailable(e)) codeActionBackoff.mark(doc.doc);
- if (!local) return;
}
}
if (this.view.state.doc !== state.doc || !this.view.state.selection.eq(state.selection) || !this.view.hasFocus)
@@ -533,7 +578,14 @@ const bulbPlugin = ViewPlugin.fromClass(
const line = state.doc.lineAt(state.selection.main.head).number;
const any = actions.some(lightsBulb) || local;
this.view.dispatch({
- effects: setBulb.of(any ? { line, quickFix: typoFix || actions.some(isQuickFix) } : null),
+ effects: setBulb.of(
+ any
+ ? {
+ line,
+ quickFix: (typoFix || ownFix || actions.some(isQuickFix)) && quickFixIcon(this.view) === "bulb-fix",
+ }
+ : null,
+ ),
});
}
destroy() {
diff --git a/src/editor/lsp/popupStore.ts b/src/editor/lsp/popupStore.ts
index e5276d6cc..a855ccd35 100644
--- a/src/editor/lsp/popupStore.ts
+++ b/src/editor/lsp/popupStore.ts
@@ -18,6 +18,8 @@ export interface ListPopupItem {
/** Second line / muted text after the label (code preview). */
preview?: string;
icon?: string;
+ /** Inspection fix, independent of the icon chosen for its severity. */
+ quickFix?: boolean;
/** Symbol badge kind (`ui/icons` `SymbolBadge`) shown instead of an icon. */
symbol?: string;
emphasis?: boolean;
diff --git a/src/features/dependencies/dependencies.test.ts b/src/features/dependencies/dependencies.test.ts
new file mode 100644
index 000000000..e3322c592
--- /dev/null
+++ b/src/features/dependencies/dependencies.test.ts
@@ -0,0 +1,210 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { CompletionContext } from "@codemirror/autocomplete";
+import type { DependencyVersions } from "@/bindings";
+
+const dependencyVersions = vi.fn();
+const cancelRequest = vi.fn(async () => {});
+const lspCodeActions = vi.fn(async () => ({ status: "error", error: { kind: "unavailable", message: "No server" } }));
+vi.mock("@/platform/ipc", async (orig) => {
+ const actual = await orig<typeof import("@/platform/ipc")>();
+ return {
+ ...actual,
+ isTauri: () => true,
+ commands: { ...actual.commands, dependencyVersions, cancelRequest, lspCodeActions },
+ };
+});
+const { activate, versionCompletions } = await import("./index");
+const { editorContributions, contributedIntentions } = await import("@/editor/api");
+const { diagnosticsFor } = await import("@/editor/lsp/diagnostics");
+const { lspDoc } = await import("@/editor/lsp/lsp");
+const { quickFixesAt, applyCodeAction, showIntentions } = await import("@/editor/lsp/intentions");
+const { useLspPopup, closePopup } = await import("@/editor/lsp/popupStore");
+const { useProject } = await import("@/platform/project");
+const { DEPENDENCY_INSPECTION } = await import("@/platform/inspections");
+const text = '# 中文 😀\n[dependencies]\ntokio = { version = "0.2", features = ["full"] }\n';
+const from = text.indexOf('"0.2"') + 1;
+const item: DependencyVersions = {
+ dependency: { package: "tokio", requirement: "0.2", from, to: from + 3 },
+ versions: ["2.0.0-beta.1", "1.10.0", "1.9.0", "0.2.1"],
+ update: { latest: "1.10.0", replacement: "1.10" },
+};
+let deactivate: () => void;
+const views: EditorView[] = [];
+beforeEach(() => {
+ vi.useFakeTimers();
+ dependencyVersions.mockResolvedValue({ status: "ok", data: [item] });
+ useProject.setState({ project: { root: "/p" } as never, settings: {} as never });
+ deactivate = activate();
+});
+afterEach(() => {
+ views.splice(0).forEach((view) => view.destroy());
+ deactivate();
+ closePopup();
+ useProject.setState({ project: null, settings: null });
+ vi.clearAllMocks();
+ vi.useRealTimers();
+});
+function editor(path = "/p/Cargo.toml", readOnly = false) {
+ const ctx = { doc: 7, path, language: "toml", uiMode: "TOML", readOnly };
+ const contribution = editorContributions().find((c) => c.id === "dependency-versions")!;
+ const view = new EditorView({
+ parent: document.body,
+ state: EditorState.create({
+ doc: text,
+ selection: { anchor: from },
+ extensions: [lspDoc.of(ctx), contribution.extensions(ctx)],
+ }),
+ });
+ views.push(view);
+ return view;
+}
+async function settle() {
+ await vi.advanceTimersByTimeAsync(550);
+}
+
+describe("Cargo dependency versions", () => {
+ it("publishes a weak warning and fixes only the version through context actions", async () => {
+ const view = editor();
+ await settle();
+ expect(dependencyVersions).toHaveBeenCalledWith(7, null, expect.any(Number));
+ expect(diagnosticsFor("/p/Cargo.toml")).toMatchObject([
+ {
+ severity: "info",
+ message: "A newer version is available: 1.10.0",
+ range: { start: { line: 2, col: 21 }, end: { line: 2, col: 24 } },
+ },
+ ]);
+ const [fix] = contributedIntentions(view);
+ expect(fix?.label).toBe("Update to 1.10");
+ await fix!.run();
+ expect(view.state.doc.toString()).toBe(text.replace('"0.2"', '"1.10"'));
+ expect(diagnosticsFor("/p/Cargo.toml")).toEqual([]);
+ });
+ it("provides direct and hover quick fixes even without a language server", async () => {
+ const view = editor();
+ await settle();
+ const [fix] = await quickFixesAt(view, from, from + 3);
+ expect(fix?.title).toBe("Update to 1.10");
+ await applyCodeAction(view, fix!);
+ expect(view.state.doc.toString()).toContain('version = "1.10", features = ["full"]');
+ });
+ it.each(["0.10", "^0.10", "=0.10.3"])(
+ "shows the exact replacement %s with weak-warning inspection controls",
+ async (replacement) => {
+ dependencyVersions.mockResolvedValue({
+ status: "ok",
+ data: [{ ...item, update: { latest: "0.10.3", replacement } }],
+ });
+ const view = editor();
+ await settle();
+ await showIntentions(view);
+ const popup = useLspPopup.getState().popup;
+ expect(popup?.kind).toBe("list");
+ if (popup?.kind !== "list") throw new Error("Missing intentions");
+ expect(popup.title).toBe("Intentions");
+ expect(popup.items).toHaveLength(1);
+ expect(popup.items[0]).toMatchObject({ label: `Update to ${replacement}`, icon: "bulb", quickFix: true });
+ expect(popup.items[0]!.submenu).toHaveLength(2);
+ await popup.items[0]!.run();
+ expect(view.state.doc.toString()).toBe(text.replace('"0.2"', `"${replacement}"`));
+ },
+ );
+ it("keeps diagnostics when one of two split editors closes", async () => {
+ editor();
+ const split = editor();
+ await settle();
+ split.destroy();
+ views.pop();
+ expect(diagnosticsFor("/p/Cargo.toml")).toHaveLength(1);
+ });
+ it("invalidates fixes immediately after edits and rejects a stale fix callback", async () => {
+ const view = editor();
+ await settle();
+ const [fix] = contributedIntentions(view);
+ view.dispatch({ changes: { from: 0, insert: "# edit\n" } });
+ expect(contributedIntentions(view)).toEqual([]);
+ await fix!.run();
+ expect(view.state.doc.toString()).toBe("# edit\n" + text);
+ });
+ it("discards delayed responses after an edit, project switch or editor close", async () => {
+ let resolve!: (value: unknown) => void;
+ dependencyVersions.mockImplementation(
+ () =>
+ new Promise((r) => {
+ resolve = r;
+ }),
+ );
+ const view = editor();
+ await settle();
+ view.dispatch({ changes: { from: 0, insert: "# edit\n" } });
+ resolve({ status: "ok", data: [item] });
+ await vi.advanceTimersByTimeAsync(0);
+ expect(diagnosticsFor("/p/Cargo.toml")).toEqual([]);
+ await settle();
+ useProject.setState({ project: { root: "/other" } as never });
+ resolve({ status: "ok", data: [item] });
+ await settle();
+ expect(diagnosticsFor("/p/Cargo.toml")).toEqual([]);
+ expect(cancelRequest).toHaveBeenCalled();
+ const other = editor("/other/Cargo.toml");
+ await settle();
+ other.destroy();
+ views.pop();
+ resolve({ status: "ok", data: [item] });
+ await settle();
+ expect(diagnosticsFor("/other/Cargo.toml")).toEqual([]);
+ });
+ it("stays silent offline, with compatible versions and for non-Cargo or readonly files", async () => {
+ dependencyVersions.mockRejectedValue(new Error("offline"));
+ editor();
+ await settle();
+ expect(diagnosticsFor("/p/Cargo.toml")).toEqual([]);
+ dependencyVersions.mockResolvedValue({ status: "ok", data: [{ ...item, update: null }] });
+ editor("/p/sub/Cargo.toml");
+ await settle();
+ expect(diagnosticsFor("/p/sub/Cargo.toml")).toEqual([]);
+ dependencyVersions.mockClear();
+ editor("/p/other.toml");
+ editor("/p/readonly/Cargo.toml", true);
+ await settle();
+ expect(dependencyVersions).not.toHaveBeenCalled();
+ });
+ it("honours the inspection profile and cleans up on close", async () => {
+ const view = editor();
+ await settle();
+ useProject.setState({
+ settings: { inspections: { default: { [DEPENDENCY_INSPECTION]: { enabled: false } } } } as never,
+ });
+ expect(diagnosticsFor("/p/Cargo.toml")).toEqual([]);
+ expect(contributedIntentions(view)).toEqual([]);
+ view.destroy();
+ views.pop();
+ await settle();
+ expect(diagnosticsFor("/p/Cargo.toml")).toEqual([]);
+ });
+ it("completes only at a parsed dependency version, preserving descending source order", async () => {
+ const view = editor();
+ const source = view.state.languageDataAt<(ctx: CompletionContext) => Promise<unknown>>(
+ "openideaCompletion",
+ from,
+ )[0]!;
+ const result = await source(new CompletionContext(view.state, from + 3, true, view));
+ expect(result).toMatchObject({
+ from,
+ to: from + 3,
+ filter: false,
+ options: item.versions.map((label) => ({ label })),
+ });
+ expect(dependencyVersions).toHaveBeenLastCalledWith(7, from + 3, expect.any(Number));
+ dependencyVersions.mockResolvedValue({ status: "ok", data: [] });
+ expect(await source(new CompletionContext(view.state, 0, true, view))).toBeNull();
+ });
+ it("replaces the whole version and retains a simple requirement operator", () => {
+ const state = EditorState.create({ doc: "^1.2" });
+ const context = new CompletionContext(state, 4, true);
+ const result = versionCompletions({ ...item, dependency: { ...item.dependency, from: 0, to: 4 } }, context);
+ expect(result.options[0]).toMatchObject({ label: "2.0.0-beta.1", apply: "^2.0.0-beta.1" });
+ });
+});
diff --git a/src/features/dependencies/index.ts b/src/features/dependencies/index.ts
new file mode 100644
index 000000000..3a47f969f
--- /dev/null
+++ b/src/features/dependencies/index.ts
@@ -0,0 +1,208 @@
+import { EditorState, StateEffect, StateField, type Extension } from "@codemirror/state";
+import { ViewPlugin, type EditorView } from "@codemirror/view";
+import type { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+import {
+ intentionProviders,
+ intentionsChanged,
+ quickFixProviders,
+ registerEditorContribution,
+ whenSynced,
+ type ContributedIntention,
+ type EditorDocContext,
+} from "@/editor/api";
+import { setFileDiagnostics } from "@/editor/lsp/diagnostics";
+import { offsetsToRange } from "@/editor/lsp/positions";
+import { call, commands, isTauri, nextRequestId, type DependencyVersions, type RequestId } from "@/platform/ipc";
+import {
+ DEPENDENCY_INSPECTION,
+ DEPENDENCY_PRODUCER,
+ inspectionProfile,
+ subscribeInspectionProfile,
+} from "@/platform/inspections";
+import { useProject } from "@/platform/project";
+import { tx } from "@/platform/i18n";
+
+const setVersions = StateEffect.define<DependencyVersions[]>();
+const versionsField = StateField.define<DependencyVersions[]>({
+ create: () => [],
+ update(value, tr) {
+ if (tr.docChanged) return [];
+ for (const effect of tr.effects) if (effect.is(setVersions)) return effect.value;
+ return value;
+ },
+});
+
+const viewers = new Map<string, number>();
+
+const enabled = () => inspectionProfile()[DEPENDENCY_INSPECTION]?.enabled !== false;
+
+export function dependencyFixes(view: EditorView, from: number, to: number): ContributedIntention[] {
+ if (!enabled() || view.state.readOnly) return [];
+ const text = view.state.doc;
+ return (view.state.field(versionsField, false) ?? []).flatMap(({ dependency, update }) => {
+ if (!update || from > dependency.to || to < dependency.from) return [];
+ const { replacement } = update;
+ return [
+ {
+ id: `dependency.update:${dependency.from}`,
+ label: tx`Update to ${replacement}`,
+ quickFix: true,
+ run: () => {
+ if (view.state.doc !== text) return;
+ view.dispatch({
+ changes: { from: dependency.from, to: dependency.to, insert: replacement },
+ userEvent: "input.dependency",
+ });
+ },
+ },
+ ];
+ });
+}
+
+export function versionCompletions(item: DependencyVersions, ctx: CompletionContext): CompletionResult {
+ const { dependency, versions } = item;
+ const typed = ctx.state.sliceDoc(dependency.from, ctx.pos);
+ const prefix = /^[\s^~<>=]*/.exec(typed)?.[0] ?? "";
+ const filter = typed.slice(prefix.length);
+ return {
+ from: dependency.from,
+ to: dependency.to,
+ filter: false,
+ options: versions
+ .filter((v) => ctx.explicit || v.startsWith(filter))
+ .map((version) => ({
+ label: version,
+ type: "constant",
+ detail: dependency.package,
+ apply: prefix + version,
+ })),
+ };
+}
+
+function extension(doc: EditorDocContext): Extension {
+ const plugin = ViewPlugin.define((view) => {
+ if (!isTauri()) return {};
+ viewers.set(doc.path, (viewers.get(doc.path) ?? 0) + 1);
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ let request: RequestId | null = null;
+ let sequence = 0;
+ let disposed = false;
+ const clear = () => setFileDiagnostics(doc.path, DEPENDENCY_PRODUCER, []);
+ const cancel = () => {
+ sequence++;
+ if (request !== null) void commands.cancelRequest(request);
+ request = null;
+ };
+ const run = async () => {
+ if (disposed || !enabled()) return;
+ const mine = sequence;
+ const text = view.state.doc;
+ const root = useProject.getState().project?.root;
+ const id = nextRequestId();
+ request = id;
+ try {
+ await whenSynced(view);
+ if (mine !== sequence || disposed) return;
+ const items = await call(commands.dependencyVersions(doc.doc, null, id));
+ if (mine !== sequence || disposed || view.state.doc !== text || useProject.getState().project?.root !== root)
+ return;
+ view.dispatch({ effects: [setVersions.of(items), intentionsChanged.of(null)] });
+ setFileDiagnostics(
+ doc.path,
+ DEPENDENCY_PRODUCER,
+ items.flatMap(({ dependency, update }) => {
+ if (!update) return [];
+ const { latest } = update;
+ return [
+ {
+ range: offsetsToRange(text, dependency.from, dependency.to),
+ severity: "info",
+ message: tx`A newer version is available: ${latest}`,
+ source: "Cargo",
+ code: null,
+ },
+ ];
+ }),
+ );
+ } catch {
+ // Offline registries and cancelled checks never interrupt editing.
+ } finally {
+ if (request === id) request = null;
+ }
+ };
+ const schedule = () => {
+ cancel();
+ clear();
+ clearTimeout(timer);
+ timer = setTimeout(() => void run(), 500);
+ };
+ schedule();
+ const offProfile = subscribeInspectionProfile(() => {
+ schedule();
+ view.dispatch({ effects: intentionsChanged.of(null) });
+ });
+ const offProject = useProject.subscribe((state, previous) => {
+ if (state.project?.root !== previous.project?.root) {
+ disposed = true;
+ cancel();
+ clearTimeout(timer);
+ clear();
+ }
+ });
+ return {
+ update: (u) => {
+ if (u.docChanged) schedule();
+ },
+ destroy: () => {
+ disposed = true;
+ cancel();
+ clearTimeout(timer);
+ offProfile();
+ offProject();
+ const remaining = (viewers.get(doc.path) ?? 1) - 1;
+ if (remaining) viewers.set(doc.path, remaining);
+ else {
+ viewers.delete(doc.path);
+ clear();
+ }
+ },
+ };
+ });
+ const completion = async (ctx: CompletionContext): Promise<CompletionResult | null> => {
+ if (!isTauri()) return null;
+ const id = nextRequestId();
+ const text = ctx.state.doc;
+ const root = useProject.getState().project?.root;
+ ctx.addEventListener("abort", () => void commands.cancelRequest(id));
+ try {
+ // The completion context is immutable; only use it while its document is current.
+ const view = ctx.view;
+ if (!view) return null;
+ await whenSynced(view);
+ if (ctx.aborted || view.state.doc !== text) return null;
+ const items = await call(commands.dependencyVersions(doc.doc, ctx.pos, id));
+ if (ctx.aborted || view.state.doc !== text || useProject.getState().project?.root !== root) return null;
+ const item = items.find(({ dependency }) => dependency.from <= ctx.pos && ctx.pos <= dependency.to);
+ return item ? versionCompletions(item, ctx) : null;
+ } catch {
+ return null;
+ }
+ };
+ return [
+ versionsField,
+ plugin,
+ intentionProviders.of((view) => {
+ const selection = view.state.selection.main;
+ return dependencyFixes(view, selection.from, selection.to);
+ }),
+ quickFixProviders.of(dependencyFixes),
+ EditorState.languageData.of(() => [{ openideaCompletion: completion }]),
+ ];
+}
+
+export function activate(): () => void {
+ return registerEditorContribution({
+ id: "dependency-versions",
+ extensions: (doc) => (!doc.virtual && !doc.readOnly && /(?:^|\/)Cargo\.toml$/.test(doc.path) ? extension(doc) : []),
+ });
+}
diff --git a/src/features/index.ts b/src/features/index.ts
index 2678ade51..6286ef087 100644
--- a/src/features/index.ts
+++ b/src/features/index.ts
@@ -10,6 +10,7 @@ import { activate as editorLsp } from "@/editor/lsp";
import { activate as welcome } from "./welcome";
import { activate as projectTree } from "./project-tree";
import { activate as search } from "./search";
+import { activate as dependencies } from "./dependencies";
import { activate as codeInsight } from "./code-insight";
import { activate as vcs, activateSettingsPages as vcsPages } from "./vcs";
import { activate as terminal } from "./terminal";
@@ -55,6 +56,7 @@ const features: Array<[string, Activate]> = [
["project-tree", projectTree],
["search", search],
["code-insight", codeInsight],
+ ["dependencies", dependencies],
["vcs", vcs],
["terminal", terminal],
["run", run],
diff --git a/src/platform/inspections.ts b/src/platform/inspections.ts
index 88fcfb512..8a0ed22e0 100644
--- a/src/platform/inspections.ts
+++ b/src/platform/inspections.ts
@@ -222,6 +222,9 @@ export interface BuiltinInspection {
export const SPELLING_PRODUCER = "spelling";
export const SPELLING_INSPECTION = "builtin:spelling";
+export const DEPENDENCY_PRODUCER = "dependency-versions";
+export const DEPENDENCY_INSPECTION = "builtin:dependency-versions";
+
/** IDEA's Typo options: which parts of source files are checked (plain text always is). */
export const SPELLING_OPTIONS = {
code: "processCode",
@@ -231,6 +234,14 @@ export const SPELLING_OPTIONS = {
/** Checks the IDE runs itself (not a language server). */
export const BUILTIN_INSPECTIONS: readonly BuiltinInspection[] = [
+ {
+ id: DEPENDENCY_INSPECTION,
+ producer: DEPENDENCY_PRODUCER,
+ name: "Newer dependency version available",
+ group: "Cargo",
+ description: "Reports newer crate versions that Cargo.toml requirements do not already allow.",
+ defaultLevel: "weakWarning",
+ },
{
id: "builtin:file-references",
producer: "file-references",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 839f1066e..b92b21660 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -1,4 +1,8 @@
{
+ "Newer dependency version available": "有更新的依赖版本可用",
+ "Reports newer crate versions that Cargo.toml requirements do not already allow.": "报告 Cargo.toml 版本要求尚未允许的较新 crate 版本。",
+ "Update to {latest}": "更新至 {latest}",
+ "A newer version is available: {latest}": "有新版本可用:{latest}",
"Kotlin bridge requires a Maven build root": "Kotlin 桥接需要 Maven 构建根目录",
"Kotlin bridge bundle is unavailable": "Kotlin 桥接扩展不可用",
"Kotlin bridge command did not acknowledge its library snapshot": "Kotlin 桥接命令未确认类库更新",
diff --git a/src/platform/locales/textCatalog.test.ts b/src/platform/locales/textCatalog.test.ts
index 3a418ebf5..2079d23aa 100644
--- a/src/platform/locales/textCatalog.test.ts
+++ b/src/platform/locales/textCatalog.test.ts
@@ -80,6 +80,7 @@ const BUILT_AT_RUNTIME = new Set<string>([]);
/** Text that stays as written in every locale: names, code, formats, shortcuts. */
const UNTRANSLATED = new Set<string>([
// Product names
+ "Cargo",
"CMake",
"Prettier",
"IntelliJ IDEA",