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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(lsp): open library classes behind jar: URIs (#1048)
l0ng-aid54ef98a59e6
diff --git a/Cargo.lock b/Cargo.lockindex 461692d39..196478cbc 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4387,6 +4387,7 @@ dependencies = ["tokio","toml 0.9.12+spec-1.1.0","tracing",+ "zip",][[package]]diff --git a/crates/ide-lsp/Cargo.toml b/crates/ide-lsp/Cargo.tomlindex 81cd83810..876c8130c 100644--- a/crates/ide-lsp/Cargo.toml+++ b/crates/ide-lsp/Cargo.toml@@ -24,6 +24,7 @@ globset.workspace = trueignore.workspace = truetoml.workspace = truepercent-encoding = "2"+zip.workspace = true[dev-dependencies]tempfile.workspace = truediff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rsindex 45bef903a..91de3dd31 100644--- a/crates/ide-lsp/src/lib.rs+++ b/crates/ide-lsp/src/lib.rs@@ -16,6 +16,7 @@ mod handler;mod inspect;pub mod jdtls;mod launch;+mod library_source;mod scope;mod server;mod tcp;@@ -273,6 +274,30 @@ impl<T> Outcome<T> {/// Implementation requests of one line-marker pass in flight at once.const IMPLEMENTATION_CONCURRENCY: usize = 4;+/// Library classes in `jar:` targets (the official Kotlin LSP) go to their source+/// in the artifact's sources jar when it is cached, at the declaration of the+/// name navigated from; [`LspManager::virtual_document`] serves it.+async fn library_sources(snap: &DocSnap, pos: Pos, locs: Vec<Location>) -> Vec<Location> {+ if !locs.iter().any(|l| l.uri.as_deref().is_some_and(|u| u.starts_with("jar:") && u.ends_with(".class"))) {+ return locs;+ }+ let name = library_source::identifier_at(snap.text.line(pos.line as usize), pos.col).map(str::to_owned);+ tokio::task::spawn_blocking(move || {+ locs.into_iter()+ .map(|loc| {+ let Some(uri) = loc.uri.as_deref().filter(|u| u.starts_with("jar:") && u.ends_with(".class")) else {+ return loc;+ };+ let Some((source, text)) = library_source::class_source(uri) else { return loc };+ let range = name.as_deref().map(|n| library_source::declaration_range(&text, n)).unwrap_or_default();+ Location { path: source.clone().into(), range, uri: Some(source) }+ })+ .collect()+ })+ .await+ .unwrap_or_default()+}+fn goto_method(kind: GotoKind) -> (&'static str, &'static str, &'static str) {match kind {GotoKind::Definition => ("textDocument/definition", "definitionProvider", "go to definition"),@@ -1187,6 +1212,7 @@ impl LspManager {{Ok(Some(r)) => {let locs = convert::goto_response(&self.conv(t.enc()), r);+ let locs = library_sources(snap, pos, locs).await;self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));if !locs.is_empty() {return Ok(locs);@@ -2218,12 +2244,35 @@ impl LspManager {/// Contents of a virtual document, from the server that owns `uri`:/// `workspace/textDocumentContent` (LSP 3.18) when the server serves the- /// scheme, jdtls' `java/classFileContents` for `jdt:` URIs. Cached.+ /// scheme, jdtls' `java/classFileContents` for `jdt:` URIs. A `jar:` entry+ /// is read from its archive, a `jar:` class shown as its library source+ /// (see [`library_source`]) or else decompiled by the server. Cached.pub async fn virtual_document(&self, uri: &str) -> IdeResult<VirtualDocument> {if let Some(d) = self.virtual_docs.lock().get(uri) {return Ok(d.clone());}let scheme = virtual_doc::scheme(uri).to_owned();+ let jar_class = scheme == "jar" && library_source::parse(uri).is_some_and(|e| e.entry.ends_with(".class"));+ if scheme == "jar" {+ let found = {+ let uri = uri.to_owned();+ tokio::task::spawn_blocking(move || match library_source::parse(&uri) {+ Some(e) if !e.entry.ends_with(".class") => {+ library_source::read_entry(&e.jar, &e.entry).map(|text| (e.entry, text))+ }+ Some(_) => library_source::class_source(&uri)+ .and_then(|(source, text)| Some((library_source::parse(&source)?.entry, text))),+ None => None,+ })+ .await+ .ok()+ .flatten()+ };+ if let Some((entry, text)) = found {+ let title = entry.rsplit('/').next().unwrap_or(&entry).to_owned();+ return Ok(self.store_virtual(uri, text, Some(title), &[], self.origin_server(uri).map(|s| s.id)));+ }+ }let class_file = scheme == "jdt" || (scheme == "file" && uri.ends_with(".class"));let origin = self.origin_server(uri);let mut servers: Vec<Arc<Server>> = origin.iter().cloned().collect();@@ -2246,6 +2295,25 @@ impl LspManager {} else if class_file && languages.iter().any(|l| l.as_str() == "java") {self.call::<_, Option<String>>(t, "java/classFileContents", json!({ "uri": uri }), None, LONG_TIMEOUT).await+ } else if jar_class && t.caps().commands().iter().any(|c| c == "decompile") {+ // The official Kotlin LSP: `decompile` answers `{ code, language }`.+ self.call::<_, Option<Value>>(+ t,+ "workspace/executeCommand",+ json!({ "command": "decompile", "arguments": [uri] }),+ None,+ LONG_TIMEOUT,+ )+ .await+ .map(|v| {+ v.and_then(|v| match v {+ Value::String(text) => Some(text),+ v => ["code", "text", "content"]+ .iter()+ .find_map(|k| v.get(k).and_then(Value::as_str))+ .map(str::to_owned),+ })+ })} else {continue;};@@ -2257,33 +2325,53 @@ impl LspManager {continue;}};- let decompiled = virtual_doc::is_decompiled(&text);- let title = virtual_doc::title(uri, decompiled);- let detected = self.languages.detect(Path::new(&title), None);- let language_id = if detected == LanguageId::plain_text() {- languages.first().cloned().unwrap_or(detected)- } else {- detected- };- let doc = VirtualDocument {- uri: uri.to_owned(),- text,- language_id,- title,- description: virtual_doc::description(uri),- decompiled,- };- self.virtual_origins.lock().entry(uri.to_owned()).or_insert(t.server.id);- let mut cache = self.virtual_docs.lock();- if cache.len() >= VIRTUAL_CACHE_LIMIT {- cache.clear();- }- cache.insert(uri.to_owned(), doc.clone());- return Ok(doc);+ return Ok(self.store_virtual(uri, text, None, &languages, Some(t.server.id)));+ }+ if jar_class && error.is_none() {+ return Err(IdeError::not_found(format!(+ "no source or decompiler is available for {}: its sources jar is not in the local Maven or Gradle cache, and no language server decompiles it",+ virtual_doc::title(uri, false)+ )));}Err(error.unwrap_or_else(|| IdeError::not_found(format!("no language server provides the contents of {uri}"))))}+ /// Caches `text` as the virtual document `uri`, titled `title` (else after the URI).+ fn store_virtual(+ &self,+ uri: &str,+ text: String,+ title: Option<String>,+ languages: &[LanguageId],+ server: Option<ide_core::ServerId>,+ ) -> VirtualDocument {+ let decompiled = virtual_doc::is_decompiled(&text);+ let title = title.unwrap_or_else(|| virtual_doc::title(uri, decompiled));+ let detected = self.languages.detect(Path::new(&title), None);+ let language_id = if detected == LanguageId::plain_text() {+ languages.first().cloned().unwrap_or(detected)+ } else {+ detected+ };+ let doc = VirtualDocument {+ uri: uri.to_owned(),+ text,+ language_id,+ title,+ description: virtual_doc::description(uri),+ decompiled,+ };+ if let Some(server) = server {+ self.virtual_origins.lock().entry(uri.to_owned()).or_insert(server);+ }+ let mut cache = self.virtual_docs.lock();+ if cache.len() >= VIRTUAL_CACHE_LIMIT {+ cache.clear();+ }+ cache.insert(uri.to_owned(), doc.clone());+ doc+ }+/// Called when a server sends `workspace/applyEdit`; installed by `src-tauri`/// so edits flow through `ide-workspace::Documents`.pub fn set_config_hook(&self, hook: Box<ConfigFn>) {diff --git a/crates/ide-lsp/src/library_source.rs b/crates/ide-lsp/src/library_source.rsnew file mode 100644index 000000000..50f91a441--- /dev/null+++ b/crates/ide-lsp/src/library_source.rs@@ -0,0 +1,299 @@+//! `jar:` URIs (`jar:///…/lib.jar!/pkg/Name.class`, also `jar:file:///…`) that+//! language servers return for library code: the official Kotlin LSP for the+//! classes of a dependency, Metals and others for entries of a sources jar.+//! Not every server can serve their contents (`workspace/textDocumentContent`),+//! so they are read here, where the jars are (also on a remote backend): an+//! entry as is, a class as its source from the artifact's `-sources.jar` next to+//! it in the Maven or Gradle cache.++use ide_core::{Pos, Range};+use percent_encoding::{AsciiSet, CONTROLS, percent_decode_str, utf8_percent_encode};+use std::io::Read;+use std::path::{Path, PathBuf};++/// An entry of an archive named by a `jar:` URI.+#[derive(Debug, Clone, PartialEq, Eq)]+pub(crate) struct JarEntry {+ /// The URI up to the archive path (`jar:///` or `jar:file:///`), kept for new URIs.+ prefix: String,+ pub jar: PathBuf,+ /// `/`-separated, without a leading `/`.+ pub entry: String,+}++pub(crate) fn parse(uri: &str) -> Option<JarEntry> {+ let rest = uri.strip_prefix("jar:")?;+ let (archive, entry) = rest.split_once("!/")?;+ let (prefix, path) = if let Some(path) = archive.strip_prefix("file://") {+ ("jar:file://", path)+ } else if let Some(path) = archive.strip_prefix("//") {+ ("jar://", path)+ } else {+ ("jar:", archive)+ };+ let path = percent_decode_str(path).decode_utf8().ok()?;+ let path = if cfg!(windows) {+ // `/C:/x` → `C:\x`+ let trimmed = path.strip_prefix('/').filter(|s| s.as_bytes().get(1) == Some(&b':')).unwrap_or(&path);+ PathBuf::from(trimmed.replace('/', "\\"))+ } else {+ PathBuf::from(path.into_owned())+ };+ let entry = percent_decode_str(entry.split(['?', '#']).next().unwrap_or(entry)).decode_utf8().ok()?;+ Some(JarEntry { prefix: prefix.to_owned(), jar: path, entry: entry.trim_start_matches('/').to_owned() })+}++const PATH: &AsciiSet = &CONTROLS.add(b' ').add(b'#').add(b'%').add(b'?').add(b'!');++impl JarEntry {+ /// The URI of `entry` in `jar`, written like the URI this one came from.+ fn uri_of(&self, jar: &Path, entry: &str) -> String {+ let mut path = jar.to_string_lossy().replace('\\', "/");+ if !path.starts_with('/') {+ path.insert(0, '/');+ }+ let encode = |s: &str| utf8_percent_encode(s, PATH).to_string();+ format!("{}{}!/{}", self.prefix, encode(&path), encode(entry))+ }+}++/// The text of `entry` in the archive `jar`, when it is a UTF-8 file.+pub(crate) fn read_entry(jar: &Path, entry: &str) -> Option<String> {+ let mut zip = zip::ZipArchive::new(std::fs::File::open(jar).ok()?).ok()?;+ let mut file = zip.by_name(entry).ok()?;+ let mut text = String::new();+ file.read_to_string(&mut text).ok()?;+ Some(text)+}++/// The library source for a class entry: its `.kt` / `.java` file in the+/// artifact's sources jar, as `(uri, text)`.+pub(crate) fn class_source(uri: &str) -> Option<(String, String)> {+ let jar = parse(uri)?;+ let class = jar.entry.strip_suffix(".class")?;+ for sources in sources_jars(&jar.jar) {+ if let Some((entry, text)) = source_entry(&sources, class) {+ return Some((jar.uri_of(&sources, &entry), text));+ }+ }+ None+}++/// Sources jars of the artifact `jar`: `<name>-sources.jar` next to it (Maven+/// repository), or in a sibling hash folder (Gradle `files-2.1/<g>/<a>/<v>/<hash>/`).+fn sources_jars(jar: &Path) -> Vec<PathBuf> {+ let (Some(dir), Some(stem)) = (jar.parent(), jar.file_stem().and_then(|s| s.to_str())) else { return vec![] };+ let name = format!("{stem}-sources.jar");+ let mut out: Vec<PathBuf> = vec![dir.join(&name)];+ if let Some(version_dir) = dir.parent()+ && version_dir.ancestors().any(|a| a.file_name().is_some_and(|n| n == "files-2.1"))+ && let Ok(entries) = std::fs::read_dir(version_dir)+ {+ out.extend(entries.flatten().map(|e| e.path().join(&name)));+ }+ out.retain(|p| p.is_file());+ out+}++/// The source file of `class` (`pkg/Name`, `pkg/Outer$Inner`, `pkg/FileKt`) in `sources`.+fn source_entry(sources: &Path, class: &str) -> Option<(String, String)> {+ let mut zip = zip::ZipArchive::new(std::fs::File::open(sources).ok()?).ok()?;+ let (package, name) = class.rsplit_once('/').unwrap_or(("", class));+ let outer = name.split('$').next().unwrap_or(name);+ let dir = if package.is_empty() { String::new() } else { format!("{package}/") };+ let mut candidates = vec![format!("{dir}{outer}.java"), format!("{dir}{outer}.kt")];+ // Top-level Kotlin declarations compile to a `<File>Kt` facade class.+ if let Some(file) = outer.strip_suffix("Kt").filter(|f| !f.is_empty()) {+ candidates.push(format!("{dir}{file}.kt"));+ }+ let read = |zip: &mut zip::ZipArchive<std::fs::File>, entry: &str| {+ let mut text = String::new();+ zip.by_name(entry).ok()?.read_to_string(&mut text).ok()?;+ Some(text)+ };+ for entry in &candidates {+ if let Some(text) = read(&mut zip, entry) {+ return Some((entry.clone(), text));+ }+ }+ // A facade renamed with `@file:JvmName("…")`.+ let kotlin_files: Vec<String> = zip+ .file_names()+ .filter_map(|n| n.ok().map(|n| n.into_owned()))+ .filter(|n| n.ends_with(".kt") && n.strip_prefix(&dir).is_some_and(|rest| !rest.contains('/')))+ .collect();+ let jvm_name = format!("@file:JvmName(\"{outer}\")");+ for entry in kotlin_files {+ if let Some(text) = read(&mut zip, &entry)+ && text.contains(&jvm_name)+ {+ return Some((entry, text));+ }+ }+ None+}++/// Where `name` is declared in a Kotlin or Java source `text` (the start of the+/// name), else the start of the file.+pub(crate) fn declaration_range(text: &str, name: &str) -> Range {+ const KEYWORDS: [&str; 9] = ["fun", "class", "interface", "object", "val", "var", "typealias", "enum", "record"];+ let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$';+ let mut fallback = None;+ for (line_no, line) in text.lines().enumerate() {+ let mut from = 0;+ while let Some(i) = line[from..].find(name) {+ let start = from + i;+ let end = start + name.len();+ from = end;+ let before = line[..start].chars().next_back();+ let after = line[end..].chars().next();+ if before.is_some_and(is_ident) || after.is_some_and(is_ident) {+ continue;+ }+ let head = &line[..start];+ let words: Vec<&str> = head.split(|c: char| !is_ident(c)).filter(|w| !w.is_empty()).collect();+ let col = head.encode_utf16().count() as u32;+ let range = Range {+ start: Pos::new(line_no as u32, col),+ end: Pos::new(line_no as u32, col + name.encode_utf16().count() as u32),+ };+ // Kotlin: `fun <T> Foo.name(`, `class Name`; Java: `… Type name(`.+ if words.iter().any(|w| KEYWORDS.contains(w)) {+ return range;+ }+ let java_member =+ after == Some('(') && !head.trim_end().ends_with('.') && !head.trim().is_empty() && !head.contains('=');+ if java_member && fallback.is_none() {+ fallback = Some(range);+ }+ }+ }+ fallback.unwrap_or_default()+}++/// The identifier around `col` (UTF-16) of `line`.+pub(crate) fn identifier_at(line: &str, col: u32) -> Option<&str> {+ let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$';+ let mut utf16 = 0u32;+ let mut at = line.len();+ for (i, c) in line.char_indices() {+ if utf16 >= col {+ at = i;+ break;+ }+ utf16 += c.len_utf16() as u32;+ }+ let start =+ line[..at].rfind(|c: char| !is_ident(c)).map_or(0, |i| i + line[i..].chars().next().map_or(1, char::len_utf8));+ let end = line[at..].find(|c: char| !is_ident(c)).map_or(line.len(), |i| at + i);+ let word = &line[start..end];+ (!word.is_empty() && !word.starts_with(|c: char| c.is_ascii_digit())).then_some(word)+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::io::Write;++ fn jar(path: &Path, entries: &[(&str, &str)]) {+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();+ let mut zip = zip::ZipWriter::new(std::fs::File::create(path).unwrap());+ for (name, text) in entries {+ zip.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();+ zip.write_all(text.as_bytes()).unwrap();+ }+ zip.finish().unwrap();+ }++ const EXTENSIONS: &str = "package org.springframework.boot\n\nimport kotlin.reflect.KClass\n\n/**\n * Top-level function acting as a Kotlin shortcut allowing to write\n * `runApplication<Foo>(arg1, arg2)` instead of `SpringApplication.run(Foo::class.java, arg1, arg2)`.\n */\ninline fun <reified T : Any> runApplication(vararg args: String): ConfigurableApplicationContext =\n\t\tSpringApplication.run(T::class.java, *args)\n";++ #[test]+ fn parses_both_jar_uri_forms() {+ for uri in [+ "jar:///home/me/.m2/repository/b/spring-boot-3.5.16.jar!/org/springframework/boot/SpringApplicationExtensionsKt.class",+ "jar:file:///home/me/.m2/repository/b/spring-boot-3.5.16.jar!/org/springframework/boot/SpringApplicationExtensionsKt.class",+ ] {+ let e = parse(uri).unwrap();+ if !cfg!(windows) {+ assert_eq!(e.jar, PathBuf::from("/home/me/.m2/repository/b/spring-boot-3.5.16.jar"));+ }+ assert_eq!(e.entry, "org/springframework/boot/SpringApplicationExtensionsKt.class");+ assert_eq!(e.uri_of(&e.jar, &e.entry), uri, "written back the same way");+ }+ let spaced = parse("jar:///tmp/my%20libs/a.jar!/A.class").unwrap();+ assert!(spaced.jar.to_string_lossy().contains("my libs"));+ assert_eq!(spaced.uri_of(&spaced.jar, "A.kt"), "jar:///tmp/my%20libs/a.jar!/A.kt");+ assert_eq!(parse("jdt://contents/a.jar/A.class"), None);+ assert_eq!(parse("jar:///no/entry.jar"), None);+ }++ #[test]+ fn finds_the_source_of_each_kind_of_class_in_maven_and_gradle_caches() {+ let tmp = tempfile::tempdir().unwrap();+ let m2 = tmp.path().join("m2/org/springframework/boot/spring-boot/3.5.16");+ let gradle = tmp.path().join("gradle/caches/modules-2/files-2.1/org.springframework.boot/spring-boot/3.5.16");+ let sources: &[(&str, &str)] = &[+ ("org/springframework/boot/SpringApplicationExtensions.kt", EXTENSIONS),+ ("org/springframework/boot/SpringApplication.java", "public class SpringApplication {}"),+ (+ "org/springframework/boot/Renamed.kt",+ "@file:JvmName(\"BootUtils\")\npackage org.springframework.boot\nfun util() {}",+ ),+ ("org/springframework/boot/Builder.kt", "class Builder"),+ ("Root.java", "class Root {}"),+ ];+ jar(&m2.join("spring-boot-3.5.16.jar"), &[]);+ jar(&m2.join("spring-boot-3.5.16-sources.jar"), sources);+ // Gradle keeps each file under its own hash folder.+ jar(&gradle.join("aaa/spring-boot-3.5.16.jar"), &[]);+ jar(&gradle.join("bbb/spring-boot-3.5.16-sources.jar"), sources);+ for binary in [m2.join("spring-boot-3.5.16.jar"), gradle.join("aaa/spring-boot-3.5.16.jar")] {+ let uri = |class: &str| format!("jar://{}!/{class}", binary.to_string_lossy().replace('\\', "/"));+ for (class, file) in [+ ("org/springframework/boot/SpringApplicationExtensionsKt.class", "SpringApplicationExtensions.kt"),+ ("org/springframework/boot/SpringApplication.class", "SpringApplication.java"),+ ("org/springframework/boot/SpringApplication$Running.class", "SpringApplication.java"),+ ("org/springframework/boot/BootUtils.class", "Renamed.kt"),+ ("org/springframework/boot/Builder.class", "Builder.kt"),+ ("Root.class", "Root.java"),+ ] {+ let (source_uri, text) = class_source(&uri(class)).unwrap_or_else(|| panic!("{class} in {binary:?}"));+ let dir = class.rsplit_once('/').map_or(String::new(), |(p, _)| format!("{p}/"));+ assert!(source_uri.ends_with(&format!("-sources.jar!/{dir}{file}")), "{source_uri}");+ assert_eq!(+ parse(&source_uri).and_then(|e| read_entry(&e.jar, &e.entry)).as_deref(),+ Some(text.as_str())+ );+ }+ assert_eq!(class_source(&uri("org/springframework/boot/Missing.class")), None);+ }+ // No sources jar: nothing to show from here.+ let lone = tmp.path().join("lone/x-1.jar");+ jar(&lone, &[]);+ assert_eq!(class_source(&format!("jar://{}!/X.class", lone.to_string_lossy().replace('\\', "/"))), None);+ }++ #[test]+ fn locates_declarations_in_kotlin_and_java_sources() {+ let at = |text: &str, name: &str| {+ let r = declaration_range(text, name);+ (r.start.line, r.start.col, r.end.col)+ };+ assert_eq!(at(EXTENSIONS, "runApplication"), (8, 29, 43), "the declaration, not the KDoc mention");+ let java = "package a;\n\npublic class SpringApplication {\n public static ConfigurableApplicationContext run(Class<?> source, String... args) {\n return run(new Class<?>[] { source }, args);\n }\n}\n";+ assert_eq!(at(java, "SpringApplication"), (2, 13, 30));+ assert_eq!(at(java, "run"), (3, 49, 52), "the member, not the call in its body");+ assert_eq!(at("val x = 1", "missing"), (0, 0, 0));+ assert_eq!(at("// é\nfun ü() {}", "ü"), (1, 4, 5), "UTF-16 columns");+ }++ #[test]+ fn identifier_under_the_caret() {+ let line = " runApplication<Application>(*args)";+ assert_eq!(identifier_at(line, 4), Some("runApplication"));+ assert_eq!(identifier_at(line, 10), Some("runApplication"));+ assert_eq!(identifier_at(line, 18), Some("runApplication"), "right after it");+ assert_eq!(identifier_at(line, 20), Some("Application"));+ assert_eq!(identifier_at("a + b", 2), None);+ }+}diff --git a/crates/ide-lsp/src/virtual_doc.rs b/crates/ide-lsp/src/virtual_doc.rsindex 110b206fd..f05354132 100644--- a/crates/ide-lsp/src/virtual_doc.rs+++ b/crates/ide-lsp/src/virtual_doc.rs@@ -60,6 +60,9 @@ pub fn title(uri: &str, decompiled: bool) -> String {/// Where the document comes from, e.g. the jar path of a `jdt://` class.pub fn description(uri: &str) -> Option<String> {+ if scheme(uri) == "jar" {+ return crate::library_source::parse(uri).map(|e| e.jar.to_string_lossy().into_owned());+ }if scheme(uri) != "jdt" {return None;}diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rsindex 7b46a9d6c..a535caee8 100644--- a/crates/ide-lsp/tests/mock_server.rs+++ b/crates/ide-lsp/tests/mock_server.rs@@ -1234,6 +1234,71 @@ async fn open_java_files_are_checked_again_after_a_project_update() {eventually(|| refreshed() == expected).await;}+#[tokio::test(flavor = "multi_thread")]+async fn library_classes_in_jars_open_as_their_source_or_decompiled() {+ use std::io::Write;+ let jar = |path: &Path, entries: &[(&str, &str)]| {+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();+ let mut zip = zip::ZipWriter::new(std::fs::File::create(path).unwrap());+ for (name, text) in entries {+ zip.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();+ zip.write_all(text.as_bytes()).unwrap();+ }+ zip.finish().unwrap();+ };+ let repo = tempfile::tempdir().unwrap();+ let dir = repo.path().join("org/springframework/boot/spring-boot/3.5.16");+ let source = "package org.springframework.boot\n\ninline fun <reified T : Any> runApplication(vararg args: String) =\n SpringApplication.run(T::class.java, *args)\n";+ jar(+ &dir.join("spring-boot-3.5.16.jar"),+ &[("org/springframework/boot/SpringApplicationExtensionsKt.class", "\u{0}")],+ );+ jar(+ &dir.join("spring-boot-3.5.16-sources.jar"),+ &[("org/springframework/boot/SpringApplicationExtensions.kt", source)],+ );+ let other = repo.path().join("acme/lib/1.0/lib-1.0.jar");+ jar(&other, &[("acme/Thing.class", "\u{0}")]);+ let jar_uri = |jar: &Path, entry: &str| format!("jar://{}!/{entry}", uri_of(jar).trim_start_matches("file://"));+ let r = |l: u32, c0: u32, c1: u32| json!({"start":{"line":l,"character":c0},"end":{"line":l,"character":c1}});++ let mut caps = incremental_caps();+ caps["executeCommandProvider"] = json!({ "commands": ["decompile"] });+ let h = harness_for("kotlin", "kt", &[("kotlin-lsp", caps)], &[]);+ let (doc, _) = h.open("Main.kt", "fun main(args: Array<String>) {\n runApplication<App>(*args)\n}\n");+ h.wait_status("kotlin-lsp", ServerStatus::Ready).await;+ let s = h.launcher.state("kotlin-lsp");++ // A class with a cached sources jar: navigation lands on the declaration in its source.+ let class =+ jar_uri(&dir.join("spring-boot-3.5.16.jar"), "org/springframework/boot/SpringApplicationExtensionsKt.class");+ s.respond("textDocument/definition", json!({ "uri": class, "range": r(7, 43, 57) }));+ let defs = h.mgr.goto(doc, Pos::new(1, 8), GotoKind::Definition).await.unwrap();+ let sources =+ jar_uri(&dir.join("spring-boot-3.5.16-sources.jar"), "org/springframework/boot/SpringApplicationExtensions.kt");+ assert_eq!(+ defs,+ vec![ide_core::Location { path: sources.clone().into(), range: rng(2, 29, 2, 43), uri: Some(sources.clone()) }]+ );+ let vd = h.mgr.virtual_document(&sources).await.unwrap();+ assert_eq!((vd.text.as_str(), vd.title.as_str(), vd.decompiled), (source, "SpringApplicationExtensions.kt", false));+ assert_eq!(vd.language_id.as_str(), "kotlin");+ // The class URI itself (from usages, say) shows the same source.+ assert_eq!(h.mgr.virtual_document(&class).await.unwrap().text, source);+ assert!(s.requested("workspace/executeCommand").is_empty(), "no server round trip for cached sources");++ // No sources jar: the server's `decompile` command.+ let thing = jar_uri(&other, "acme/Thing.class");+ s.respond("textDocument/definition", json!({ "uri": thing, "range": r(0, 6, 11) }));+ let defs = h.mgr.goto(doc, Pos::new(1, 8), GotoKind::Definition).await.unwrap();+ assert_eq!(defs[0].uri.as_deref(), Some(thing.as_str()), "kept as the server returned it");+ s.respond("workspace/executeCommand", json!({ "code": "package acme\n\nclass Thing", "language": "kotlin" }));+ let vd = h.mgr.virtual_document(&thing).await.unwrap();+ assert_eq!(vd.text, "package acme\n\nclass Thing");+ let asked = s.requested("workspace/executeCommand");+ assert_eq!(asked[0], json!({ "command": "decompile", "arguments": [thing] }));+}+#[tokio::test(flavor = "multi_thread")]async fn fallback_servers_only_run_when_the_preferred_one_is_missing() {// Preferred installed: the alternative is never started.diff --git a/src/platform/virtualDocs.test.ts b/src/platform/virtualDocs.test.tsindex 1154105f1..86293023c 100644--- a/src/platform/virtualDocs.test.ts+++ b/src/platform/virtualDocs.test.ts@@ -19,6 +19,15 @@ describe("virtual document URIs", () => {expect(virtualName(JDT)).toBe("SpringApplication.class");expect(virtualParent(JDT)).toBe("jdt://contents/spring-boot-4.1.1.jar/org.springframework.boot");expect(virtualContainer(JDT)).toBe("spring-boot-4.1.1.jar › org.springframework.boot");+ // `jar:` targets (official Kotlin LSP, sources jars), in both URI forms.+ for (const prefix of ["jar:///", "jar:file:///"])+ expect(+ virtualContainer(+ `${prefix}home/me/.m2/repository/spring-boot-3.5.16-sources.jar!/org/springframework/boot/SpringApplicationExtensions.kt`,+ ),+ ).toBe("spring-boot-3.5.16-sources.jar › org.springframework.boot");+ expect(virtualContainer("jar:///tmp/my%20libs/a.jar!/Root.class")).toBe("a.jar");+ expect(virtualName("jar:///tmp/a.jar!/org/x/Y.class")).toBe("Y.class");});it("makes path helpers URI-aware", () => {diff --git a/src/platform/virtualDocs.ts b/src/platform/virtualDocs.tsindex f0ced78e8..b464464cc 100644--- a/src/platform/virtualDocs.ts+++ b/src/platform/virtualDocs.ts@@ -37,6 +37,20 @@ export function virtualParent(uri: string): string {*/export function virtualContainer(uri: string): string {const scheme = uri.slice(0, uri.indexOf(":"));+ // `jar:///…/spring-boot-3.5.16.jar!/org/springframework/boot/X.class` → `spring-boot-3.5.16.jar › org.springframework.boot`+ const jar = scheme === "jar" ? /^jar:(?:file:)?(?:\/\/)?(.*?)!\/(.*)$/.exec(uri.split(/[?#]/)[0]!) : null;+ if (jar) {+ const decode = (s: string) => {+ try {+ return decodeURIComponent(s);+ } catch {+ return s;+ }+ };+ const archive = decode(jar[1]!.split("/").pop() ?? jar[1]!);+ const pkg = jar[2]!.split("/").slice(0, -1).map(decode).join(".");+ return pkg ? `${archive} › ${pkg}` : archive;+ }const rest = uri.replace(/^[^:]+:(\/\/)?/, "").split(/[?#]/)[0]!;const segs = rest.split("/")