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.

Editor: quick fixes, completion, navigation while typing, and split-pane drag (#109)

l0ng-ai357b728f1ddd
diff --git a/crates/ide-host/src/ops/lsp.rs b/crates/ide-host/src/ops/lsp.rs
index 6be7e2028..1d398e82c 100644
--- a/crates/ide-host/src/ops/lsp.rs
+++ b/crates/ide-host/src/ops/lsp.rs
@@ -241,6 +241,11 @@ pub fn lsp_servers(host: &Host, window: &str) -> IdeResult<Vec<ServerInfo>> {
Ok(host.project(window)?.lsp.servers())
}
+pub fn lsp_resend_diagnostics(host: &Host, window: &str) -> IdeResult<()> {
+ host.project(window)?.lsp.resend_diagnostics();
+ Ok(())
+}
+
pub async fn lsp_restart(host: &Host, window: &str, server: ServerId) -> IdeResult<()> {
host.project(window)?.lsp.restart(server).await
}
@@ -349,6 +354,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
lsp_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("direction")?).await
});
d.add("lsp_servers", |c| async move { lsp_servers(&c.host, &c.window) });
+ d.add("lsp_resend_diagnostics", |c| async move { lsp_resend_diagnostics(&c.host, &c.window) });
d.add("lsp_restart", |c| async move { lsp_restart(&c.host, &c.window, c.arg("server")?).await });
d.add("apply_workspace_edit", |c| async move { apply_workspace_edit(&c.host, &c.window, c.arg("edit")?) });
d.add("lsp_execute_command", |c| async move {
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index ee92e219c..53a36bcea 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -119,6 +119,7 @@ impl Host {
let effective = settings.effective();
ide_sdk::apply::server_launch_overrides(cfg, &effective);
ide_sdk::apply::configure_server(cfg, &root, server_root, &effective);
+ ide_sdk::java::cap_java_home(cfg, &ide_sdk::java::installed_jdks());
if cfg.name == "jdtls" {
let bundles: Vec<PathBuf> =
ide_tools::managed_bundle(&data_dir, "java-debug").into_iter().collect();
diff --git a/crates/ide-language/src/lib.rs b/crates/ide-language/src/lib.rs
index 0a016a6d1..ac0a3cf8f 100644
--- a/crates/ide-language/src/lib.rs
+++ b/crates/ide-language/src/lib.rs
@@ -91,6 +91,10 @@ pub struct LanguageServerConfig {
/// basedpyright): only used while none of those is installed.
#[serde(default)]
pub fallback: bool,
+ /// Newest Java release the server runs on (kotlin-language-server: 21). A
+ /// newer `JAVA_HOME` is replaced by the newest installed JDK that fits.
+ #[serde(default)]
+ pub max_java: Option<u32>,
/// Set by the settings hook when the server can't run here (jdtls without
/// a JDK 21+); reported as the failure instead of launching it.
#[serde(skip)]
diff --git a/crates/ide-language/src/syntax/literals.rs b/crates/ide-language/src/syntax/literals.rs
index 5914a9c11..29d0d2ece 100644
--- a/crates/ide-language/src/syntax/literals.rs
+++ b/crates/ide-language/src/syntax/literals.rs
@@ -79,20 +79,24 @@ fn is_name_leaf(kind: &str) -> bool {
kind.contains("identifier") || kind == "name"
}
+/// Node kinds whose `name` field is a use, not a declaration.
+const USE_PARENTS: &[&str] =
+ &["invocation", "call", "access", "scoped", "reference", "expression", "selector", "qualified", "use_", "import"];
+
/// Whether the identifier leaf under `cursor` is the name a declaration
/// introduces (`fn name`, `let pattern`, `int *declarator`, parameters,
/// `name = …` assignments) rather than a use of one.
fn declares(cursor: &TreeCursor<'_>, node: &Node<'_>) -> bool {
let parent = node.parent().map(|p| p.kind()).unwrap_or_default();
- // Paths and calls name what is declared elsewhere (`use a::b::name`, `a.name()`).
- let reference = ["scoped", "qualified", "invocation", "member_access", "use_", "import", "call"]
- .iter()
- .any(|k| parent.contains(k));
match cursor.field_name() {
- Some("name") => !reference,
+ // Uses name their target with a `name` field too: Java `s.substring()`,
+ // C# `a.Name`, Rust `use a::b::name`.
+ Some("name") => !USE_PARENTS.iter().any(|p| parent.contains(p)),
Some("pattern" | "declarator") => true,
Some("left") => parent.contains("assignment") || parent.contains("declarator"),
- _ => parent.contains("parameter"),
+ // A parameter's name, not its type (`String text`).
+ Some("type") => false,
+ _ => parent.contains("parameter") && !node.kind().contains("type"),
}
}
diff --git a/crates/ide-language/src/syntax/tests.rs b/crates/ide-language/src/syntax/tests.rs
index fb344abf4..02c0ff6de 100644
--- a/crates/ide-language/src/syntax/tests.rs
+++ b/crates/ide-language/src/syntax/tests.rs
@@ -1320,4 +1320,13 @@ fn spelling_regions_cover_declared_names_only() {
.map(|r| &rs[r.start..r.end])
.collect();
assert_eq!(names, ["run", "n"]);
+ let java = "class Bird { String fly(String text) { return text.substring(1); } }\n";
+ let names: Vec<&str> = syntax()
+ .spelling_regions(&lang("java"), java)
+ .unwrap()
+ .iter()
+ .filter(|r| r.kind == SpellingKind::Name)
+ .map(|r| &java[r.start..r.end])
+ .collect();
+ assert_eq!(names, ["Bird", "fly", "text"]);
}
diff --git a/crates/ide-lsp/src/handler.rs b/crates/ide-lsp/src/handler.rs
index 35be7f5b8..0a235a152 100644
--- a/crates/ide-lsp/src/handler.rs
+++ b/crates/ide-lsp/src/handler.rs
@@ -132,7 +132,11 @@ impl ClientHandler {
.iter()
// vtsls asks for the whole configuration as section `""`.
.map(|item| match item.get("section").and_then(Value::as_str).filter(|s| !s.is_empty()) {
- Some(section) if section == self.server.name => options.clone(),
+ // The server's own section: its block under `settings` (basedpyright asks
+ // `basedpyright` and `basedpyright.analysis`), else the options themselves.
+ Some(section) if section == self.server.name => {
+ options.get("settings").and_then(|s| s.get(section)).unwrap_or(&options).clone()
+ }
// Servers that take settings under `initializationOptions.settings`
// (jdtls) ask for the same sections later.
Some(section) => [&options, options.get("settings").unwrap_or(&Value::Null)]
diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rs
index f003d36df..d313d417b 100644
--- a/crates/ide-lsp/src/lib.rs
+++ b/crates/ide-lsp/src/lib.rs
@@ -56,6 +56,12 @@ use types::*;
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
const COMPLETION_TIMEOUT: Duration = Duration::from_secs(5);
const LONG_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// How long a server may take to answer `initialize`. Some import the whole
+/// build there (kotlin-lsp, jdtls on a large Gradle project) and need minutes
+/// on a cold start; the status shows "starting" meanwhile, and a crash still
+/// ends the wait at once.
+const INITIALIZE_TIMEOUT: Duration = Duration::from_secs(300);
/// How long a request waits for a server that is still initializing.
const START_WAIT: Duration = Duration::from_secs(10);
/// File moves may start a server (jdtls takes a while to import).
@@ -421,7 +427,7 @@ impl LspManager {
};
let init = self.initialize_params(&server);
- let result = tokio::time::timeout(Duration::from_secs(60), peer.request::<_, Value>("initialize", init, None))
+ let result = tokio::time::timeout(INITIALIZE_TIMEOUT, peer.request::<_, Value>("initialize", init, None))
.await
.unwrap_or(Err(RpcError::Timeout));
let caps = match result {
@@ -1953,6 +1959,24 @@ impl LspManager {
*self.apply_edit_hook.write() = Some(Arc::from(hook));
}
+ /// Emits every server's current diagnostics again: a UI that (re)loaded
+ /// after they were published has missed those events.
+ pub fn resend_diagnostics(&self) {
+ let servers: Vec<Arc<Server>> = self.servers.lock().clone();
+ for server in servers {
+ let encoding = server.running().map(|r| r.caps.read().encoding).unwrap_or_default();
+ let conv = self.conv(encoding);
+ for (path, items) in server.diagnostics_by_path() {
+ let items = items.into_iter().map(|d| convert::diagnostic(&conv, &path, d, &server.name)).collect();
+ self.sink.emit(ide_core::IdeEvent::Diagnostics {
+ path: path.into(),
+ source: server.name.clone(),
+ items,
+ });
+ }
+ }
+ }
+
pub fn servers(&self) -> Vec<ServerInfo> {
self.servers
.lock()
diff --git a/crates/ide-lsp/src/server.rs b/crates/ide-lsp/src/server.rs
index 04cbb9f84..43d522f72 100644
--- a/crates/ide-lsp/src/server.rs
+++ b/crates/ide-lsp/src/server.rs
@@ -461,6 +461,11 @@ impl Server {
d.iter().flat_map(|(p, items)| items.iter().map(move |i| (p.clone(), i.clone()))).collect()
}
+ /// The current diagnostics of each file that has some.
+ pub fn diagnostics_by_path(&self) -> Vec<(PathBuf, Vec<lsp::Diagnostic>)> {
+ self.diagnostics.lock().iter().map(|(p, d)| (p.clone(), d.clone())).collect()
+ }
+
pub fn take_diagnostic_paths(&self) -> Vec<PathBuf> {
self.published.lock().clear();
self.diagnostics.lock().drain().map(|(p, _)| p).collect()
diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rs
index 9ca8e202a..4f0da19c6 100644
--- a/crates/ide-lsp/tests/mock_server.rs
+++ b/crates/ide-lsp/tests/mock_server.rs
@@ -207,6 +207,7 @@ fn server_cfg(name: &str) -> LanguageServerConfig {
install_hint: Some(format!("install {name}")),
connect: None,
fallback: false,
+ max_java: None,
launch_error: None,
}
}
@@ -522,6 +523,15 @@ async fn diagnostics_become_events_and_feed_code_actions() {
assert_eq!(items[0].range, rng(0, 4, 0, 10));
}
+ // A reloaded UI asks for them again.
+ h.events.lock().clear();
+ h.mgr.resend_diagnostics();
+ let again = h.events.lock().iter().find_map(|e| match e {
+ IdeEvent::Diagnostics { path, items, .. } => Some((path.clone(), items.len())),
+ _ => None,
+ });
+ assert_eq!(again, Some((path.clone().into(), 2)));
+
s.respond(
"textDocument/codeAction",
json!([
diff --git a/crates/ide-lsp/tests/real_servers.rs b/crates/ide-lsp/tests/real_servers.rs
index 121bb0279..b0ea17015 100644
--- a/crates/ide-lsp/tests/real_servers.rs
+++ b/crates/ide-lsp/tests/real_servers.rs
@@ -74,6 +74,7 @@ async fn missing_binary_is_reported_with_install_hint() {
install_hint: Some("npm i -g nope-ls".into()),
connect: None,
fallback: false,
+ max_java: None,
launch_error: None,
};
let (mgr, events) = manager(dir.path(), LanguageRegistry::from_configs(vec![lang("nope", "nope", server)]));
@@ -203,6 +204,7 @@ async fn typescript_language_server_end_to_end() {
install_hint: None,
connect: None,
fallback: false,
+ max_java: None,
launch_error: None,
};
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![lang("typescript", "ts", server)]));
@@ -246,6 +248,7 @@ fn npm_server(tools: &Path, name: &str, bin: &str, init: Option<serde_json::Valu
install_hint: None,
connect: None,
fallback: false,
+ max_java: None,
launch_error: None,
}
}
diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rs
index 54329bf35..5d3c70cb1 100644
--- a/crates/ide-sdk/src/apply.rs
+++ b/crates/ide-sdk/src/apply.rs
@@ -342,6 +342,7 @@ fn custom_server(name: &str, ls: &LanguageServerSettings) -> LanguageServerConfi
}),
connect: None,
fallback: false,
+ max_java: None,
launch_error: None,
}
}
diff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rs
index 163427cb1..ae228dfcb 100644
--- a/crates/ide-sdk/src/java.rs
+++ b/crates/ide-sdk/src/java.rs
@@ -161,6 +161,19 @@ pub fn jdtls_jdks(min_java: u32) -> Arc<[Jdk]> {
}
}
+/// For a server with `max-java`: when the `JAVA_HOME` it would get (its env,
+/// else the IDE's) is a newer JDK, points it at the newest of `jdks` that fits.
+pub fn cap_java_home(cfg: &mut LanguageServerConfig, jdks: &[Jdk]) {
+ let Some(max) = cfg.max_java else { return };
+ let current = cfg.env.get("JAVA_HOME").cloned().or_else(|| std::env::var("JAVA_HOME").ok());
+ if current.as_deref().and_then(|h| jdk_at(Path::new(h))).is_some_and(|j| j.major <= max) {
+ return;
+ }
+ if let Some(jdk) = jdks.iter().filter(|j| j.major <= max).max_by_key(|j| j.major) {
+ cfg.env.insert("JAVA_HOME".into(), jdk.home.to_string_lossy().into_owned());
+ }
+}
+
/// Oldest Java version jdtls runs on when its install can't tell (its launcher's check).
pub const JDTLS_MIN_JAVA: u32 = 21;
diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rs
index fb6699609..ff7e157e1 100644
--- a/crates/ide-sdk/src/tests.rs
+++ b/crates/ide-sdk/src/tests.rs
@@ -32,6 +32,7 @@ fn server(name: &str) -> LanguageServerConfig {
install_hint: None,
connect: None,
fallback: false,
+ max_java: None,
launch_error: None,
}
}
@@ -598,3 +599,29 @@ fn vue_language_server_gets_a_typescript_with_the_language_service_api() {
let lib = project.join("node_modules/typescript/lib");
assert_eq!(cfg.args, [format!("--tsdk={}", lib.to_string_lossy())]);
}
+
+#[test]
+fn max_java_picks_an_older_jdk() {
+ let dir = tempfile::tempdir().unwrap();
+ let jdk = |major: u32| {
+ let home = dir.path().join(format!("jdk-{major}"));
+ std::fs::create_dir_all(home.join("bin")).unwrap();
+ std::fs::write(home.join("release"), format!("JAVA_VERSION=\"{major}.0.1\"\n")).unwrap();
+ std::fs::write(home.join("bin").join(exe("java")), "").unwrap();
+ crate::java::jdk_at(&home).unwrap()
+ };
+ let (j17, j21, j25) = (jdk(17), jdk(21), jdk(25));
+ let jdks = [j25.clone(), j21.clone(), j17];
+ let mut cfg = LanguageServerConfig { max_java: Some(21), ..server("kotlin-language-server") };
+ cfg.env.insert("JAVA_HOME".into(), j25.home.to_string_lossy().into_owned());
+ crate::java::cap_java_home(&mut cfg, &jdks);
+ assert_eq!(cfg.env["JAVA_HOME"], j21.home.to_string_lossy());
+
+ // A JAVA_HOME that fits, or no limit: left alone.
+ crate::java::cap_java_home(&mut cfg, &[]);
+ assert_eq!(cfg.env["JAVA_HOME"], j21.home.to_string_lossy());
+ let mut free = server("other");
+ free.env.insert("JAVA_HOME".into(), j25.home.to_string_lossy().into_owned());
+ crate::java::cap_java_home(&mut free, &jdks);
+ assert_eq!(free.env["JAVA_HOME"], j25.home.to_string_lossy());
+}
diff --git a/crates/ide-spell/src/dict/software.txt b/crates/ide-spell/src/dict/software.txt
index 478f3ddb6..2ab77be67 100644
--- a/crates/ide-spell/src/dict/software.txt
+++ b/crates/ide-spell/src/dict/software.txt
@@ -551,3 +551,15 @@ vulkan
wgpu
woff
woff2
+breakpoint
+sku
+dropdown
+navbar
+superclass
+typedef
+eslint
+unittest
+jvm
+jdk
+ux
+endpoint
diff --git a/crates/ide-spell/src/lib.rs b/crates/ide-spell/src/lib.rs
index 0ac12038b..67d54fa1f 100644
--- a/crates/ide-spell/src/lib.rs
+++ b/crates/ide-spell/src/lib.rs
@@ -162,6 +162,14 @@ fn software_terms() -> &'static HashSet<&'static str> {
})
}
+/// A software term, or its plural (`endpoints`, `regexes`).
+fn software_term(lower: &str) -> bool {
+ let terms = software_terms();
+ terms.contains(lower)
+ || lower.strip_suffix('s').is_some_and(|w| terms.contains(w))
+ || lower.strip_suffix("es").is_some_and(|w| terms.contains(w))
+}
+
/// Words of a custom dictionary file: a plain word list or a Hunspell `.dic`
/// (leading count line and `/FLAGS` ignored). Cached by modification time.
fn dictionary_file(path: &Path) -> Arc<HashSet<String>> {
@@ -230,9 +238,7 @@ impl Speller {
}
fn user_word(&self, lower: &str) -> bool {
- self.accepted.contains(lower)
- || software_terms().contains(lower)
- || self.custom.iter().any(|d| d.contains(lower))
+ self.accepted.contains(lower) || software_term(lower) || self.custom.iter().any(|d| d.contains(lower))
}
/// In a dictionary, in any case style.
@@ -439,6 +445,14 @@ mod tests {
assert!(!s.is_correct("lenght"));
}
+ #[test]
+ fn software_terms_and_their_plurals() {
+ let s = Speller::default();
+ for ok in ["breakpoint", "breakpoints", "endpoints", "datasets", "regexes"] {
+ assert!(s.is_correct(ok), "{ok}");
+ }
+ }
+
#[test]
fn agent_nouns_of_known_words() {
let s = Speller::default();
diff --git a/eslint.config.js b/eslint.config.js
index 0c59b7c3e..1e2febedd 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -3,7 +3,21 @@ import tseslint from "typescript-eslint";
import reactHooks from "eslint-plugin-react-hooks";
export default tseslint.config(
- { ignores: ["dist", "target", "src-tauri", "crates", "src/bindings.ts", "fixtures", "plugins", "test-results", "playwright-report"] },
+ {
+ ignores: [
+ "dist",
+ "target",
+ "src-tauri",
+ "crates",
+ "src/bindings.ts",
+ "fixtures",
+ "plugins",
+ "test-results",
+ "playwright-report",
+ // Agent worktrees: whole checkouts of the repo.
+ ".claude",
+ ],
+ },
js.configs.recommended,
...tseslint.configs.recommended,
{
diff --git a/languages/java.toml b/languages/java.toml
index 6dd7660f4..e8ec0caa5 100644
--- a/languages/java.toml
+++ b/languages/java.toml
@@ -38,6 +38,11 @@ eclipse = { downloadSources = true }
references = { includeDecompiledSources = true }
signatureHelp = { enabled = true }
configuration = { updateBuildConfiguration = "automatic" }
+# Generated code (implement methods, getters, toString…) indents like the editor (`indent` above).
+format = { insertSpaces = true, tabSize = 4 }
+# Calls complete as `name()` with the caret inside and parameter info, not guessed arguments;
+# JDK internals (`sun.*`, `com.sun.*`, `jdk.*`) and AWT's `List` stay out of completion and auto-import.
+completion = { guessMethodArguments = "off", filteredTypes = ["java.awt.List", "com.sun.*", "sun.*", "jdk.*", "org.graalvm.*", "io.micrometer.shaded.*"] }
[language-servers.initialization-options.settings.java.import]
# Keep Eclipse metadata (.project, .classpath, .settings) out of the project.
diff --git a/languages/kotlin.toml b/languages/kotlin.toml
index 74651b31d..212bb9505 100644
--- a/languages/kotlin.toml
+++ b/languages/kotlin.toml
@@ -19,6 +19,8 @@ name = "kotlin-language-server"
# Alternative: used only when the server above is not installed.
fallback = true
command = "kotlin-language-server"
+# Its bundled Kotlin compiler can't parse newer JDK versions ("25.0.4.1").
+max-java = 21
root-markers = ["settings.gradle.kts", "settings.gradle", "build.gradle.kts", "build.gradle", "pom.xml"]
install-hint = "brew install kotlin-language-server (https://github.com/fwcd/kotlin-language-server)"
diff --git a/languages/python.toml b/languages/python.toml
index 4f6a9a62c..3dd270bc8 100644
--- a/languages/python.toml
+++ b/languages/python.toml
@@ -15,6 +15,14 @@ args = ["--stdio"]
root-markers = ["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile", "pyrightconfig.json"]
install-hint = "pip install basedpyright (or: uv tool install basedpyright)"
+# basedpyright defaults to "recommended", which flags unannotated attributes and
+# every unknown type. "standard" reports real problems; a project's own
+# `[tool.basedpyright]` / pyrightconfig.json still takes precedence.
+[language-servers.initialization-options.settings.basedpyright.analysis]
+typeCheckingMode = "standard"
+# Off whenever analysis settings are sent without it: `src/` layouts would stop resolving.
+autoSearchPaths = true
+
[[language-servers]]
name = "pyright"
# Alternative: used only when the server above is not installed.
diff --git a/src-tauri/src/commands/lsp.rs b/src-tauri/src/commands/lsp.rs
index 44e8a4a71..40294164b 100644
--- a/src-tauri/src/commands/lsp.rs
+++ b/src-tauri/src/commands/lsp.rs
@@ -309,6 +309,13 @@ pub fn lsp_servers(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<
ide_host::ops::lsp::lsp_servers(&state.host, window.label())
}
+/// Re-emits the language servers' current diagnostics (the UI loaded after they arrived).
+#[tauri::command]
+#[specta::specta]
+pub fn lsp_resend_diagnostics(window: Window, state: State<'_, AppState>) -> IdeResult<()> {
+ ide_host::ops::lsp::lsp_resend_diagnostics(&state.host, window.label())
+}
+
#[tauri::command]
#[specta::specta]
pub async fn lsp_restart(window: Window, state: State<'_, AppState>, server: ServerId) -> IdeResult<()> {
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 7048be4a1..e60f2d4aa 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -174,6 +174,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
lsp::lsp_call_hierarchy,
lsp::lsp_type_hierarchy,
lsp::lsp_servers,
+ lsp::lsp_resend_diagnostics,
lsp::lsp_restart,
lsp::apply_workspace_edit,
lsp::lsp_execute_command,
diff --git a/src/bindings.ts b/src/bindings.ts
index f8e6e914f..ab7bb6fba 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -336,6 +336,8 @@ export const commands = {
lspCallHierarchy: (doc: DocId, pos: Pos, direction: HierarchyDirection) => typedError<HierarchyItem[], IdeError>(__TAURI_INVOKE("lsp_call_hierarchy", { doc, pos, direction })),
lspTypeHierarchy: (doc: DocId, pos: Pos, direction: HierarchyDirection) => typedError<HierarchyItem[], IdeError>(__TAURI_INVOKE("lsp_type_hierarchy", { doc, pos, direction })),
lspServers: () => typedError<ServerInfo[], IdeError>(__TAURI_INVOKE("lsp_servers")),
+ /** Re-emits the language servers' current diagnostics (the UI loaded after they arrived). */
+ lspResendDiagnostics: () => typedError<null, IdeError>(__TAURI_INVOKE("lsp_resend_diagnostics")),
lspRestart: (server: ServerId) => typedError<null, IdeError>(__TAURI_INVOKE("lsp_restart", { server })),
/** Applies a (previewed) workspace edit, e.g. after rename confirmation. */
applyWorkspaceEdit: (edit: WorkspaceEdit) => typedError<null, IdeError>(__TAURI_INVOKE("apply_workspace_edit", { edit })),
diff --git a/src/editor/api.ts b/src/editor/api.ts
index 78892027d..83bd11925 100644
--- a/src/editor/api.ts
+++ b/src/editor/api.ts
@@ -192,6 +192,12 @@ export function whenSynced(view: EditorView): Promise<void> {
return view.state.facet(documentSynced)?.() ?? Promise.resolve();
}
+/** Every open editor's edits reached the backend (language servers answer from its copy). */
+export function whenAllSynced(): Promise<void> {
+ const editors = useEditorRegistry.getState().editors;
+ return editors.size ? Promise.all([...editors].map((e) => whenSynced(e.view))).then(() => {}) : Promise.resolve();
+}
+
/** True for doc changes that did not originate from typing in *this* view. */
export function isExternalChange(tr: Transaction): boolean {
return !!tr.annotation(remoteChange) || !!tr.annotation(mirroredChange);
diff --git a/src/editor/core/controller.ts b/src/editor/core/controller.ts
index 50d35a6dc..363cb7335 100644
--- a/src/editor/core/controller.ts
+++ b/src/editor/core/controller.ts
@@ -52,6 +52,7 @@ import {
removePane,
reopenClosed,
setActivePane,
+ splitAtEdge,
sortTabs,
splitPane,
tabOptions,
@@ -784,7 +785,7 @@ export class EditorController implements SlotHost {
this.navSuppress++;
try {
let s = useTabs.getState();
- let paneId = s.activePane;
+ let paneId = o.pane && s.panes[o.pane] ? o.pane : s.activePane;
if (o.side) {
const right = neighbourPane(s, paneId);
if (right) paneId = right;
@@ -799,7 +800,7 @@ export class EditorController implements SlotHost {
}
const found = findTab(s, input.key, paneId);
let tabId: string;
- if (found && (!o.side || found.paneId === paneId)) {
+ if (found && (!(o.side || o.pane) || found.paneId === paneId)) {
paneId = found.paneId;
s = activateTab(setActivePane(s, paneId), paneId, found.tab.id);
if (!o.preview) s = promoteTab(s, paneId, found.tab.id);
@@ -935,6 +936,20 @@ export class EditorController implements SlotHost {
if (slot?.view) slot.focus();
else if (slot) slot.wantsFocus = true;
}
+ /** Files dropped on an editor: opened in that pane, or in a new split at `edge`. */
+ async openFilesIn(paths: readonly string[], paneId: string, edge: SplitEdge | "center") {
+ const s = useTabs.getState();
+ if (!s.panes[paneId] || !paths.length) return;
+ let target = paneId;
+ if (edge !== "center") {
+ const r = splitAtEdge(s, paneId, edge);
+ useTabs.setState(r.state, true);
+ target = r.paneId;
+ }
+ for (const [i, path] of paths.entries()) await this.openFile(path, { pane: target, focus: i === paths.length - 1 });
+ const pane = useTabs.getState().panes[target];
+ if (pane && !pane.tabs.length) this.apply((st) => removePane(st, target));
+ }
/** IDEA "Move to Opposite Group"; without a split, "Split and Move Right". */
moveToOpposite(paneId: string, tabId: string) {
const target = neighbourPane(useTabs.getState(), paneId);
diff --git a/src/editor/core/model/session.test.ts b/src/editor/core/model/session.test.ts
index 27aab7a45..11697d129 100644
--- a/src/editor/core/model/session.test.ts
+++ b/src/editor/core/model/session.test.ts
@@ -1,5 +1,5 @@
import { describe, expect, it } from "vitest";
-import { initialTabsState, moveTabToNewSplit, openTab, paneIds, splitPane, togglePin, type TabsState } from "./tabs";
+import { initialTabsState, moveTabToNewSplit, openTab, paneIds, splitAtEdge, splitPane, togglePin, type TabsState } from "./tabs";
import { loadSession, parseSession, restoreTabsState, serializeSession, slashPath } from "./session";
const file = (path: string) => ({ kind: "file", key: `file:${path}`, path });
@@ -145,3 +145,15 @@ describe("sessions saved with Windows backslash paths", () => {
}
});
});
+
+describe("splitAtEdge", () => {
+ it("adds an empty active pane on the given side", () => {
+ const s = open(initialTabsState(), "/a");
+ const pane = s.activePane;
+ const r = splitAtEdge(s, pane, "right");
+ expect(paneIds(r.state)).toEqual([pane, r.paneId]);
+ expect(r.state.panes[r.paneId]!.tabs).toEqual([]);
+ expect(r.state.activePane).toBe(r.paneId);
+ expect(paths(r.state, pane)).toEqual(["/a"]);
+ });
+});
diff --git a/src/editor/core/model/tabs.ts b/src/editor/core/model/tabs.ts
index 5e6ef31fe..7a8a52c2a 100644
--- a/src/editor/core/model/tabs.ts
+++ b/src/editor/core/model/tabs.ts
@@ -425,21 +425,29 @@ export function moveTabToNewSplit(
const tab = src?.tabs.find((t) => t.id === tabId);
if (!src || !tab || !s.panes[targetPane]) return null;
if (fromPane === targetPane && src.tabs.length === 1) return null;
- let next = { ...removeTabs(s, fromPane, new Set([tabId])), closed: s.closed };
+ const next = { ...removeTabs(s, fromPane, new Set([tabId])), closed: s.closed };
// The source pane may have collapsed away; split the target if it survived, else the active pane.
const anchor = next.panes[targetPane] ? targetPane : next.activePane;
- const id = nextId("pane");
const moved: Tab = { ...tab, preview: false };
- const pane: Pane = { id, tabs: [moved], active: moved.id, mru: [moved.id] };
+ return splitAtEdge(next, anchor, edge, { tabs: [moved], active: moved.id, mru: [moved.id] });
+}
+
+/** A new pane (empty unless `content` is given) at `edge` of `anchor`, made active. */
+export function splitAtEdge(
+ s: TabsState,
+ anchor: string,
+ edge: SplitEdge,
+ content: Omit<Pane, "id"> = { tabs: [], active: null, mru: [] },
+): { state: TabsState; paneId: string } {
+ const id = nextId("pane");
const dir = edge === "left" || edge === "right" ? "row" : "column";
const before = edge === "left" || edge === "top";
- const layout = mapLayout(next.layout, (n) => {
+ const layout = mapLayout(s.layout, (n) => {
if (n.kind === "pane" && n.paneId === anchor) {
const added: LayoutNode = { kind: "pane", paneId: id };
return { kind: "split", id: nextId("split"), dir, children: before ? [added, n] : [n, added] };
}
return n;
})!;
- next = { ...next, layout, panes: { ...next.panes, [id]: pane }, activePane: id };
- return { state: next, paneId: id };
+ return { state: { ...s, layout, panes: { ...s.panes, [id]: { id, ...content } }, activePane: id }, paneId: id };
}
diff --git a/src/editor/core/view/EditorArea.tsx b/src/editor/core/view/EditorArea.tsx
index 18a223169..ba47dd505 100644
--- a/src/editor/core/view/EditorArea.tsx
+++ b/src/editor/core/view/EditorArea.tsx
@@ -4,7 +4,7 @@
* decorations, middle-click close, Alt+click close others, double-click to
* keep a preview / maximize the editor, context menu) and the active editor.
*/
-import { Fragment, useMemo, useRef, useState, type DragEvent, type FocusEvent, type ReactNode } from "react";
+import { Fragment, useEffect, useMemo, useRef, useState, type FocusEvent, type ReactNode } from "react";
import clsx from "clsx";
import { useShallow } from "zustand/react/shallow";
import { executeAction } from "@/platform/actions";
@@ -32,6 +32,8 @@ import {
SplitPanel,
Tabs,
showContextMenu,
+ registerDropTarget,
+ FILES_DRAG,
type TabItem,
type TabsDnd,
} from "@/ui";
@@ -197,6 +199,33 @@ function PaneView({ paneId }: { paneId: string }) {
return { all: strip(0), rest: strip(pinnedCount) };
}, [ctrl, paneId, pinnedCount]);
+ // Dropping a tab or project files on the editor: an edge splits, the middle opens / moves here.
+ const contentRef = useRef<HTMLDivElement>(null);
+ const hasPane = !!pane;
+ useEffect(() => {
+ const el = contentRef.current;
+ if (!el) return;
+ const zoneAt = (x: number, y: number) => dropZoneAt(x, y, el.getBoundingClientRect());
+ return registerDropTarget(el, {
+ accepts: (type) => type === EDITOR_TAB_MIME || type === FILES_DRAG,
+ over: (_, x, y) => setDropZone(zoneAt(x, y)),
+ leave: () => setDropZone(null),
+ drop: (data, x, y) => {
+ const zone = zoneAt(x, y);
+ setDropZone(null);
+ if (data.type === FILES_DRAG) {
+ void ctrl.openFilesIn(data.payload.split("\n").filter(Boolean), paneId, zone);
+ return;
+ }
+ const p = parseTabPayload(data.payload);
+ if (!p) return;
+ const target = useTabs.getState().panes[paneId];
+ if (zone === "center") ctrl.moveTab(p.paneId, p.tabId, paneId, target?.tabs.length ?? 0);
+ else ctrl.moveTabToSplit(p.paneId, p.tabId, paneId, zone);
+ },
+ });
+ }, [ctrl, paneId, hasPane]);
+
if (!pane) return null;
const active = pane.tabs.find((t) => t.id === pane.active) ?? null;
@@ -208,33 +237,6 @@ function PaneView({ paneId }: { paneId: string }) {
if (!e.currentTarget.contains(e.relatedTarget as Node | null)) setContext("editorFocus", false);
};
- // Dropping a tab on the editor: an edge splits, the middle moves the tab here.
- const isTabDrag = (e: DragEvent) => [...e.dataTransfer.types].includes(EDITOR_TAB_MIME);
- const contentDnd = {
- onDragOverCapture: (e: DragEvent<HTMLDivElement>) => {
- if (!isTabDrag(e)) return;
- e.preventDefault();
- e.stopPropagation();
- e.dataTransfer.dropEffect = "move";
- const zone = dropZoneAt(e.clientX, e.clientY, e.currentTarget.getBoundingClientRect());
- if (zone !== dropZone) setDropZone(zone);
- },
- onDragLeave: (e: DragEvent<HTMLDivElement>) => {
- if (!e.currentTarget.contains(e.relatedTarget as Node | null)) setDropZone(null);
- },
- onDropCapture: (e: DragEvent<HTMLDivElement>) => {
- if (!isTabDrag(e)) return;
- e.preventDefault();
- e.stopPropagation();
- const zone = dropZoneAt(e.clientX, e.clientY, e.currentTarget.getBoundingClientRect());
- setDropZone(null);
- const p = parseTabPayload(e.dataTransfer.getData(EDITOR_TAB_MIME));
- if (!p) return;
- if (zone === "center") ctrl.moveTab(p.paneId, p.tabId, paneId, pane.tabs.length);
- else ctrl.moveTabToSplit(p.paneId, p.tabId, paneId, zone);
- },
- };
-
const hidden = tabPrefs.placement === "none" || distractionFree;
const strip = (stripItems: TabItem[], stripDnd: TabsDnd, trailing: ReactNode) => (
<Tabs
@@ -299,7 +301,7 @@ function PaneView({ paneId }: { paneId: string }) {
role="tabpanel"
id={active ? `editor-${paneId}-panel-${active.id}` : undefined}
aria-labelledby={active ? `editor-${paneId}-tab-${active.id}` : undefined}
- {...contentDnd}
+ ref={contentRef}
>
{active ? <PaneContent paneId={paneId} tab={active} /> : <EmptyEditor />}
{dropZone && <div className={clsx(styles.dropZone, styles[`drop-${dropZone}`])} aria-hidden="true" />}
diff --git a/src/editor/lsp/Popups.module.css b/src/editor/lsp/Popups.module.css
index c2fd3d95e..1a7f2965e 100644
--- a/src/editor/lsp/Popups.module.css
+++ b/src/editor/lsp/Popups.module.css
@@ -178,10 +178,6 @@
}
.bulb {
flex: none;
- color: var(--warning);
-}
-.bulbFix {
- color: var(--danger);
}
.empty {
font-size: var(--fs-ui);
diff --git a/src/editor/lsp/Popups.tsx b/src/editor/lsp/Popups.tsx
index 4873c5463..d302dbada 100644
--- a/src/editor/lsp/Popups.tsx
+++ b/src/editor/lsp/Popups.tsx
@@ -44,7 +44,7 @@ import { useUsagesStatus } from "./navigation";
import styles from "./Popups.module.css";
export function BulbIcon({ fix }: { fix?: boolean }) {
- return <Icon name="bulb" size={16} className={clsx(styles.bulb, fix && styles.bulbFix)} />;
+ return <Icon name={fix ? "bulb-fix" : "bulb"} size={16} className={styles.bulb} />;
}
function ItemIcon({ item }: { item: ListPopupItem }) {
diff --git a/src/editor/lsp/actions.ts b/src/editor/lsp/actions.ts
index 3f84c521e..158247ecc 100644
--- a/src/editor/lsp/actions.ts
+++ b/src/editor/lsp/actions.ts
@@ -10,7 +10,8 @@ import { quickDefinition, quickDocumentation } from "./hover";
import { expressionTypeInfo } from "./typeInfo";
import { gotoTargets, highlightUsages } from "./navigation";
import { gotoDiagnostic } from "./diagnostics";
-import { applyKindSilently, runKindAction, showIntentions } from "./intentions";
+import { applyKindSilently, applyQuickFix, runKindAction, showIntentions } from "./intentions";
+import { implementPythonAbstractMethods } from "./pythonMembers";
import { workflowSettings, type ActionsOnSaveValid } from "@/platform/workflowSettings";
import { startRename } from "./rename";
import { formatDocument, reformatDialog } from "./format";
@@ -154,6 +155,9 @@ export function registerLspActions(): () => void {
editorAction("code.showIntentions", "Show Context Actions", "Code", showIntentions, {
keywords: ["intention", "quick fix", "lightbulb"],
}),
+ editorAction("code.applyQuickFix", "Apply Quick Fix", "Code", applyQuickFix, {
+ keywords: ["fix error", "problem", "lightbulb"],
+ }),
editorAction("code.reformat", "Reformat Code", "Code", reformat, {
keywords: ["format", "prettier"],
}),
@@ -228,7 +232,12 @@ export function registerLspActions(): () => void {
// Implement / Override Methods: the server's code actions for them (jdtls "Override/Implement
// Methods…", rust-analyzer "Implement missing members", TS "Implement interface"…).
editorAction("code.implementMethods", "Implement Methods…", "Code", (v) =>
- runKindAction(v, "", { title: IMPLEMENT_TITLE, none: "Nothing to implement", label: "Implement Members" }),
+ runKindAction(v, "", {
+ title: IMPLEMENT_TITLE,
+ none: "Nothing to implement",
+ label: "Implement Members",
+ fallback: () => implementPythonAbstractMethods(v),
+ }),
),
editorAction("code.overrideMethods", "Override Methods…", "Code", (v) =>
runKindAction(v, "", { title: OVERRIDE_TITLE, none: "Nothing to override", label: "Override Members" }),
diff --git a/src/editor/lsp/availability.test.ts b/src/editor/lsp/availability.test.ts
new file mode 100644
index 000000000..d408ccf4e
--- /dev/null
+++ b/src/editor/lsp/availability.test.ts
@@ -0,0 +1,59 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { IdeEvent } from "@/bindings";
+
+const listeners = vi.hoisted(() => new Set<(e: IdeEvent) => void>());
+vi.mock("@/platform/ipc", async (orig) => {
+ const real = await orig<typeof import("@/platform/ipc")>();
+ return {
+ ...real,
+ isTauri: () => true,
+ onIdeEvent: (_type: string, fn: (e: IdeEvent) => void) => {
+ listeners.add(fn);
+ return () => listeners.delete(fn);
+ },
+ };
+});
+
+const { onServerSettled } = await import("./availability");
+
+const status = (s: string) => {
+ for (const fn of listeners) fn({ type: "languageServer", server: 1, status: s } as unknown as IdeEvent);
+};
+
+describe("onServerSettled", () => {
+ afterEach(() => {
+ vi.useRealTimers();
+ listeners.clear();
+ });
+
+ it("re-runs a callback that keeps the server busy only once", () => {
+ vi.useFakeTimers();
+ const fn = vi.fn();
+ onServerSettled(fn);
+ status("starting");
+ status("ready");
+ expect(fn).toHaveBeenCalledTimes(1);
+ for (let i = 0; i < 2; i++) {
+ status("busy");
+ vi.advanceTimersByTime(2000);
+ status("ready");
+ }
+ expect(fn).toHaveBeenCalledTimes(2);
+ // Indexing that starts later is a new settle.
+ vi.advanceTimersByTime(10_000);
+ status("busy");
+ vi.advanceTimersByTime(5000);
+ status("ready");
+ expect(fn).toHaveBeenCalledTimes(3);
+ });
+
+ it("ignores short busy spells", () => {
+ vi.useFakeTimers();
+ const fn = vi.fn();
+ onServerSettled(fn);
+ status("busy");
+ vi.advanceTimersByTime(100);
+ status("ready");
+ expect(fn).not.toHaveBeenCalled();
+ });
+});
diff --git a/src/editor/lsp/availability.ts b/src/editor/lsp/availability.ts
index f7ecef2e3..0c28cef5a 100644
--- a/src/editor/lsp/availability.ts
+++ b/src/editor/lsp/availability.ts
@@ -46,6 +46,43 @@ export function onLspRefresh(kind: LspRefreshKind, fn: () => void): () => void {
};
}
+/** A busy spell at least this long is indexing / a build, not the server answering a request. */
+const LONG_BUSY_MS = 1500;
+
+/** A busy spell starting this soon after `fn` ran may be `fn`'s own requests. */
+const ECHO_MS = 2000;
+
+/**
+ * Calls `fn` when a server becomes ready after starting or after a long busy
+ * spell (indexing), when earlier answers may have been incomplete. Short busy
+ * spells are ignored: jdtls reports progress for the very requests a caller
+ * sends, and re-asking on each of them would never stop. For the same reason
+ * a long spell that began right after `fn` ran (slow requests `fn` sent, or
+ * indexing right after start) re-runs it only once in a row.
+ */
+export function onServerSettled(fn: () => void): () => void {
+ if (!isTauri()) return () => {};
+ const since = new Map<number, number>();
+ const fired = new Map<number, { at: number; echoed: boolean }>();
+ return onIdeEvent("languageServer", (e) => {
+ if (e.status === "starting") {
+ since.set(e.server, -Infinity);
+ fired.delete(e.server);
+ } else if (e.status === "busy") {
+ if (!since.has(e.server)) since.set(e.server, Date.now());
+ } else if (e.status === "ready") {
+ const t = since.get(e.server);
+ since.delete(e.server);
+ if (t === undefined || Date.now() - t < LONG_BUSY_MS) return;
+ const last = fired.get(e.server);
+ const echo = !!last && t - last.at < ECHO_MS;
+ if (echo && last.echoed) return;
+ fired.set(e.server, { at: Date.now(), echoed: echo });
+ fn();
+ } else since.delete(e.server);
+ });
+}
+
export function installAvailabilityEvents(): () => void {
return onIdeEvent("languageServer", (e) => {
if (e.status === "ready") serverBackoff.clear();
diff --git a/src/editor/lsp/completion.test.ts b/src/editor/lsp/completion.test.ts
index 047dcf47b..369280b0f 100644
--- a/src/editor/lsp/completion.test.ts
+++ b/src/editor/lsp/completion.test.ts
@@ -1,8 +1,17 @@
import { afterEach, describe, expect, it, vi } from "vitest";
-import { EditorState } from "@codemirror/state";
+import { EditorState, StateEffect } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import type { CompletionItem } from "@/bindings";
-import { completionSymbolKind, identifierEnd, toCmCompletion, triggerCharacter } from "./completionItems";
+import type { EditorDocContext } from "@/editor/api";
+import { lspDoc } from "./lsp";
+import {
+ completionSymbolKind,
+ identifierEnd,
+ toCmCompletion,
+ triggerCharacter,
+ typeColumnText,
+ withoutDuplicates,
+} from "./completionItems";
import {
applyLspCompletion,
callParens,
@@ -63,6 +72,23 @@ describe("toCmCompletion", () => {
expect(c.displayLabel).toBe("@GetMapping");
});
+ it("filters on the label when filterText only adds the call or body", () => {
+ for (const filterText of ["String(${0})", "List<>()", "Runnable() {\n\t${0}\n};"]) {
+ const label = filterText.match(/^\w+/)![0];
+ const c = toCmCompletion(item({ label, filterText }));
+ expect(c.label).toBe(label);
+ expect(c.displayLabel).toBeUndefined();
+ }
+ expect(toCmCompletion(item({ label: "foo", filterText: "foo_bar" })).label).toBe("foo_bar");
+ });
+
+ it("lists identical items once", () => {
+ const ctor = item({ label: "String()", kind: "constructor", data: "1" });
+ const overload = item({ label: "String()", kind: "constructor", labelDetail: "(bytes: ByteArray)" });
+ const out = withoutDuplicates([ctor, { ...ctor, data: "2" }, overload, { ...ctor, server: 2 }]);
+ expect(out).toEqual([ctor, overload, { ...ctor, server: 2 }]);
+ });
+
it("boosts preselected and demotes deprecated items", () => {
expect(toCmCompletion(item({ preselect: true })).boost).toBe(99);
expect(toCmCompletion(item({ deprecated: true })).boost).toBeLessThan(0);
@@ -122,12 +148,31 @@ describe("applying completions", () => {
expect(view.state.selection.main.head).toBe(14);
});
+ it("keeps overloads sharing a filterText apart", () => {
+ const { req } = setup("x.ti|");
+ const [a, b] = ["times(other: Int)", "times(other: Long)"].map((label) =>
+ makeCompletion(item({ label, filterText: "times" }), req),
+ );
+ expect([a!.label, b!.label]).toEqual(["times", "times"]);
+ expect(a!.apply).not.toBe(b!.apply);
+ });
+
it("replaces the rest of the identifier with ⇥", () => {
const { view, req } = setup("service.cr|Order()");
applyLspCompletion(view, makeCompletion(item({ insertText: "create" }), req), 8, 10, "replace");
expect(view.state.doc.toString()).toBe("service.create()");
});
+ it("leaves the caret inside a call snippet without stops, past `)` once nothing takes arguments", async () => {
+ const { view, req } = setup("new Arr|");
+ view.dispatch({ effects: StateEffect.appendConfig.of(lspDoc.of({ doc: 1 } as EditorDocContext)) });
+ apply(view, makeCompletion(item({ kind: "constructor", insertText: "ArrayList<>()", isSnippet: true }), req), 4);
+ expect(view.state.doc.toString()).toBe("new ArrayList<>()");
+ expect(view.state.selection.main.head).toBe(16);
+ // Signature help fails outside Tauri: nothing to pass.
+ await vi.waitFor(() => expect(view.state.selection.main.head).toBe(17));
+ });
+
it("uses the server's ⇥ range when given", () => {
const { view, req } = setup("a.cr|Order.x");
const c = makeCompletion(
@@ -280,3 +325,27 @@ describe("explicit completion", () => {
view.destroy();
});
});
+
+describe("typeColumnText", () => {
+ const edit = (new_text: string) => [{ range: { start: { line: 0, col: 0 }, end: { line: 0, col: 0 } }, new_text }];
+
+ it("names the module an auto-import comes from", () => {
+ expect(typeColumnText({ detail: "Auto-import", additionalEdits: edit("\nfrom collections import OrderedDict") })).toBe(
+ "collections",
+ );
+ expect(typeColumnText({ detail: "Map<K, V>", additionalEdits: edit("import java.util.HashMap;\n") })).toBe(
+ "Map<K, V> (java.util)",
+ );
+ expect(typeColumnText({ detail: null, additionalEdits: edit("use std::collections::HashMap;\n") })).toBe(
+ "std::collections",
+ );
+ expect(typeColumnText({ detail: null, additionalEdits: edit('import { a } from "./money";\n') })).toBe("./money");
+ });
+
+ it("keeps a detail that already says where", () => {
+ expect(typeColumnText({ detail: "java.util.ArrayList", additionalEdits: edit("import java.util.ArrayList;\n") })).toBe(
+ "java.util.ArrayList",
+ );
+ expect(typeColumnText({ detail: "fn() ", additionalEdits: [] })).toBe("fn() ");
+ });
+});
diff --git a/src/editor/lsp/completion.ts b/src/editor/lsp/completion.ts
index 8b0213f7c..66d8c5740 100644
--- a/src/editor/lsp/completion.ts
+++ b/src/editor/lsp/completion.ts
@@ -35,14 +35,21 @@ import {
type RequestId,
} from "@/platform/ipc";
import { useProject } from "@/platform/project";
-import { completionSymbolKind, identifierEnd, toCmCompletion, triggerCharacter } from "./completionItems";
+import {
+ completionSymbolKind,
+ identifierEnd,
+ toCmCompletion,
+ triggerCharacter,
+ typeColumnText,
+ withoutDuplicates,
+} from "./completionItems";
import { lspSnippetToCm, snippetVariables } from "./snippet";
import { docOf, isUnavailable, lspDoc, lspRequest, reportLspError } from "./lsp";
import { offsetToPos, posToOffset, textEditsToChanges } from "./positions";
import { isEmptyMarkup, renderCode, renderMarkup } from "./markdown";
import { selectableText } from "@/ui/selectableText";
import { iconNode } from "./iconMarkup";
-import { triggerSignatureHelp } from "./signature";
+import { parameterInfoOrLeave, triggerSignatureHelp } from "./signature";
import { serverBackoff } from "./availability";
import { pathCompletionSource } from "./fileReferences";
import { editorPrefs } from "@/platform/editorSettings";
@@ -71,17 +78,42 @@ const isLsp = (c: Completion): c is LspCompletion => "lsp" in c;
// Resolve (documentation, lazily computed edits)
const resolving = new WeakMap<CompletionItem, Promise<CompletionItem>>();
+/** Items whose resolve has answered, for accepting them synchronously. */
+const resolvedItems = new WeakMap<CompletionItem, CompletionItem>();
function resolveItem(doc: number, item: CompletionItem): Promise<CompletionItem> {
if (item.data == null && !isEmptyMarkup(item.documentation)) return Promise.resolve(item);
let p = resolving.get(item);
if (!p) {
- p = lspRequest(() => commands.lspResolveCompletion(doc, item)).catch(() => item);
+ p = lspRequest(() => commands.lspResolveCompletion(doc, item)).then(
+ (r) => {
+ resolvedItems.set(item, r);
+ return r;
+ },
+ () => item,
+ );
resolving.set(item, p);
}
return p;
}
+/**
+ * Resolves the selected lookup item ahead of acceptance: some servers compute
+ * its extra edits (rust-analyzer's `use` import) only on resolve, against the
+ * text as it was, so resolving after the insertion finds nothing.
+ */
+const prefetchResolve = ViewPlugin.fromClass(
+ class {
+ private last: Completion | null = null;
+ update(u: ViewUpdate) {
+ const c = selectedCompletion(u.state);
+ if (c === this.last) return;
+ this.last = c;
+ if (c && isLsp(c) && c.lsp.data != null && !c.lsp.additionalEdits.length) void resolveItem(c.req.doc, c.lsp);
+ }
+ },
+);
+
/**
* F1 in the lookup (IDEA's documentation popup next to the lookup): docs then
* follow the selection until the lookup closes. Without the auto-popup setting
@@ -166,7 +198,7 @@ export function applyLspCompletion(
) {
if (!isLsp(completion)) return;
const { req } = completion;
- const item = completion.resolved ?? completion.lsp;
+ const item = completion.resolved ?? resolvedItems.get(completion.lsp) ?? completion.lsp;
const state = view.state;
const delta = to - req.pos;
const mapOld = (offset: number) =>
@@ -191,6 +223,7 @@ export function applyLspCompletion(
.filter((c) => c.to <= start || c.from >= end);
let insertedParens: ReturnType<typeof callParens> = null;
+ let bareCall: number | null = null;
if (item.isSnippet) {
if (extra.length) {
const tr = state.update({ changes: extra, userEvent: "input.complete" });
@@ -199,6 +232,19 @@ export function applyLspCompletion(
end = tr.changes.mapPos(end, 1);
}
snippet(lspSnippetToCm(item.insertText, snippetVariables(req.path)))(view, completion, start, end);
+ // A call snippet without a stop (`ArrayList<>()`): the caret goes inside until
+ // signature help says there is nothing to pass.
+ const head = view.state.selection.main.head;
+ if (
+ editorPrefs().completion.insertParentheses &&
+ CALLABLE.has(item.kind ?? "") &&
+ /\(\)$/.test(item.insertText) &&
+ !/\$/.test(item.insertText) &&
+ view.state.sliceDoc(head - 2, head) === "()"
+ ) {
+ view.dispatch({ selection: EditorSelection.cursor(head - 1) });
+ bareCall = head - 1;
+ }
} else {
const parens = editorPrefs().completion.insertParentheses
? callParens(item, state.doc.lineAt(start), start, end)
@@ -215,9 +261,15 @@ export function applyLspCompletion(
});
}
- if (!completion.resolved && !item.additionalEdits.length && item.data != null)
+ if (item === completion.lsp && !item.additionalEdits.length && item.data != null)
void applyLateEdits(view, completion, start);
- if (insertedParens === "inside" && !item.command) setTimeout(() => triggerSignatureHelp(view), 0);
+ // Parameter info for a call left open, plain (`()` added here) or a server snippet (`fly(${1})`).
+ const callSnippet = item.isSnippet && CALLABLE.has(item.kind ?? "") && /\(\$\{?\d/.test(item.insertText);
+ // Unless the item's command asks for it itself (other commands, like jdtls's
+ // `java.completion.onDidSelect`, are bookkeeping).
+ const hintsCommand = item.command?.command === "editor.action.triggerParameterHints";
+ if ((insertedParens === "inside" || callSnippet) && !hintsCommand) setTimeout(() => triggerSignatureHelp(view), 0);
+ else if (bareCall !== null) void parameterInfoOrLeave(view, bareCall);
runCommand(view, item);
}
@@ -314,7 +366,13 @@ export function makeCompletion(item: CompletionItem, req: RequestContext): LspCo
return Object.assign(cm, {
lsp: item,
req,
- apply: applyLsp,
+ // CodeMirror merges options with the same label, detail and `apply`: overloads
+ // sharing a filterText (`times(other: Int)`, `times(other: Long)`…) and the same
+ // name imported from different modules need their own.
+ apply:
+ cm.displayLabel || (item.filterText && item.filterText !== item.label) || item.additionalEdits.length
+ ? (...a: Parameters<typeof applyLsp>) => applyLsp(...a)
+ : applyLsp,
info: (c: Completion) => renderInfo(c as LspCompletion),
});
}
@@ -369,7 +427,10 @@ async function lspCompletionSource(ctx: CompletionContext): Promise<CompletionRe
});
let list;
try {
- list = await lspRequest(() => commands.lspCompletion(id, doc.doc, offsetToPos(ctx.state.doc, ctx.pos), trigger));
+ list = await lspRequest(
+ () => commands.lspCompletion(id, doc.doc, offsetToPos(ctx.state.doc, ctx.pos), trigger),
+ () => inflight === id,
+ );
} catch (e) {
if (isUnavailable(e)) {
serverBackoff.mark(doc.doc);
@@ -383,9 +444,18 @@ async function lspCompletionSource(ctx: CompletionContext): Promise<CompletionRe
const req: RequestContext = { doc: doc.doc, path: doc.path, language: doc.uiMode, pos: ctx.pos, text: ctx.state.doc };
const prefs = editorPrefs().completion;
const typed = word?.text ?? "";
- const items = prefs.matchCase
- ? list.items.filter((it) => matchesCase(it.filterText ?? it.label, typed, prefs.caseSensitivity))
- : list.items;
+ let items = withoutDuplicates(
+ prefs.matchCase
+ ? list.items.filter((it) => matchesCase(it.filterText ?? it.label, typed, prefs.caseSensitivity))
+ : list.items,
+ );
+ // A server snippet named like a live template (jdtls `sout`, `fori`) would be listed twice; the template wins.
+ if (items.some((it) => it.kind === "snippet")) {
+ const own = await contributedSource(ctx);
+ if (ctx.aborted) return null;
+ const names = new Set(own?.options.map((o) => o.label));
+ if (names.size) items = items.filter((it) => it.kind !== "snippet" || !names.has(it.label));
+ }
return {
from: word ? word.from : ctx.pos,
options: items.map((item) => makeCompletion(item, req)),
@@ -616,11 +686,11 @@ function kindBadge(c: Completion): Node | null {
}
function typeColumn(c: Completion): Node | null {
- const detail = isLsp(c) ? c.lsp.detail : (c as RichCompletion).typeText;
+ const detail = isLsp(c) ? typeColumnText(c.lsp) : (c as RichCompletion).typeText?.replace(/\s+/g, " ");
if (!detail) return null;
const span = document.createElement("span");
span.className = "cm-lsp-type";
- span.textContent = detail.replace(/\s+/g, " ");
+ span.textContent = detail;
return span;
}
@@ -684,6 +754,7 @@ const completionFooter = ViewPlugin.fromClass(
export function completionExtension() {
return [
lookupKeys,
+ prefetchResolve,
autocompletion({
override: [gated(lspCompletionSource), gated(contributedSource), gated(pathCompletionSource)],
icons: false,
diff --git a/src/editor/lsp/completionItems.ts b/src/editor/lsp/completionItems.ts
index 1064660b4..6aadb3ab6 100644
--- a/src/editor/lsp/completionItems.ts
+++ b/src/editor/lsp/completionItems.ts
@@ -41,7 +41,7 @@ export function completionSymbolKind(kind: CompletionKind | null): string {
* original label is shown through `displayLabel`.
*/
export function toCmCompletion(item: CompletionItem): Completion {
- const filter = item.filterText && item.filterText !== item.label ? item.filterText : null;
+ const filter = item.filterText && item.filterText !== item.label && !extendsLabel(item) ? item.filterText : null;
const c: Completion = {
label: filter ?? item.label,
type: completionSymbolKind(item.kind),
@@ -55,6 +55,62 @@ export function toCmCompletion(item: CompletionItem): Completion {
return c;
}
+/**
+ * A `filterText` that is the label plus what the item inserts after it (jdtls
+ * `String(${0})`, `List<>()`): typing a word never reaches that part, and
+ * matching on it would rank the exact `String` like `StringBuilder`.
+ */
+function extendsLabel(item: CompletionItem): boolean {
+ const rest = item.filterText!.slice(item.label.length);
+ return item.filterText!.startsWith(item.label) && /^[^\p{L}\p{N}_$]/u.test(rest);
+}
+
+/**
+ * Items that look and insert the same, listed once. kotlin-language-server
+ * repeats a class once per classpath entry declaring it (`String()` ×3);
+ * these all have their own `apply` (see `makeCompletion`), so CodeMirror
+ * wouldn't merge them.
+ */
+export function withoutDuplicates(items: readonly CompletionItem[]): CompletionItem[] {
+ const seen = new Set<string>();
+ return items.filter((it) => {
+ const key = JSON.stringify([it.server, it.label, it.labelDetail, it.detail, it.kind, it.insertText, it.additionalEdits]);
+ if (seen.has(key)) return false;
+ seen.add(key);
+ return true;
+ });
+}
+
+const IMPORT_SOURCE = [
+ /^\s*from\s+([\w.]+)\s+import\b/m, // Python
+ /^\s*import\s+(?:static\s+)?([\w.]+?)\.\w+;?\s*$/m, // Java, Kotlin
+ /^\s*use\s+([\w:]+)::/m, // Rust
+ /\bfrom\s+["']([^"']+)["']/, // JS / TS
+];
+
+/**
+ * Where an auto-import item comes from (`collections`, `java.util`): the
+ * module its import edit names. Servers like pyright put it nowhere else, so
+ * same-named items (`OrderedDict` from typing / collections) look identical.
+ */
+export function importSource(item: Pick<CompletionItem, "additionalEdits">): string | null {
+ for (const e of item.additionalEdits) {
+ for (const re of IMPORT_SOURCE) {
+ const m = re.exec(e.new_text);
+ if (m) return m[1]!;
+ }
+ }
+ return null;
+}
+
+/** Text of the right-aligned type column: the detail, with the import source when it lacks one. */
+export function typeColumnText(item: Pick<CompletionItem, "detail" | "additionalEdits">): string | null {
+ const detail = item.detail?.replace(/\s+/g, " ") || null;
+ const source = importSource(item);
+ if (!source || detail?.includes(source)) return detail;
+ return !detail || /^auto[- ]?import$/i.test(detail) ? source : `${detail} (${source})`;
+}
+
const WORD_CHAR = /[\p{L}\p{N}_$]/u;
/** End of the identifier starting at `pos` in `line` (for ⇥ Replace without a server range). */
diff --git a/src/editor/lsp/diagnostics.ts b/src/editor/lsp/diagnostics.ts
index a056182d4..320f3e17f 100644
--- a/src/editor/lsp/diagnostics.ts
+++ b/src/editor/lsp/diagnostics.ts
@@ -9,7 +9,8 @@ import { EditorSelection, StateEffect, StateField } from "@codemirror/state";
import { EditorView, ViewPlugin } from "@codemirror/view";
import { forEachDiagnostic, linter, setDiagnostics, type Diagnostic as LintDiagnostic } from "@codemirror/lint";
import type { Diagnostic, Severity } from "@/bindings";
-import { onIdeEvent } from "@/platform/ipc";
+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 { rangeToOffsets } from "./positions";
@@ -89,11 +90,20 @@ export function subscribeDiagnostics(path: string, l: Listener): () => void {
export function installDiagnosticsEvents(): () => void {
const off = onIdeEvent("diagnostics", (e) => storeDiagnostics(e.path, e.source, e.items));
+ // Diagnostics published before this window (re)loaded were missed: ask for them again.
+ const resend = () => {
+ if (isTauri()) void ideEventsReady().then(() => commands.lspResendDiagnostics()).catch(() => {});
+ };
+ if (useProject.getState().project) resend();
+ const offProject = useProject.subscribe((s, prev) => {
+ if (s.project?.root !== prev.project?.root && s.project) resend();
+ });
// Another inspection profile (or edits to it) re-filters every open file.
const offProfile = subscribeInspectionProfile(() => listeners.forEach((set) => set.forEach((l) => l())));
return () => {
off();
offProfile();
+ offProject();
};
}
@@ -118,13 +128,16 @@ export function toLintDiagnostics(doc: Text, items: readonly Diagnostic[]): Lint
to,
severity: d.severity,
message: d.message,
- source: [d.source, d.code].filter(Boolean).join(" ") || undefined,
+ source: [d.source, isInternalCode(d.code) ? null : d.code].filter(Boolean).join(" ") || undefined,
markClass: classes.length ? classes.join(" ") : undefined,
};
});
return out.sort((a, b) => a.from - b.from || SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity]);
}
+/** Problem ids that mean nothing to a reader (jdtls: `67109264`); short ones (TS `2322`) stay. */
+const isInternalCode = (code: string | null | undefined) => !!code && /^\d{6,}$/.test(code);
+
const MARK_COLOR: Partial<Record<Severity, string>> = {
error: "var(--danger)",
warning: "var(--warning)",
@@ -218,6 +231,13 @@ const lintTheme = EditorView.theme({
},
".cm-lintRange.cm-lsp-unnecessary *": { color: "var(--fg-unused, var(--fg-faint))" },
".cm-lintRange.cm-lsp-deprecated": { textDecoration: "line-through", textDecorationColor: "var(--fg-muted)" },
+ // An error or warning on the same range (merged into one mark) keeps its underline.
+ ".cm-lintRange-error.cm-lsp-typo, .cm-lintRange-error.cm-lsp-unnecessary": {
+ textDecoration: "var(--editor-error-decoration, underline wavy var(--danger))",
+ },
+ ".cm-lintRange-warning.cm-lsp-typo, .cm-lintRange-warning.cm-lsp-unnecessary": {
+ textDecoration: "var(--editor-warning-decoration, underline wavy var(--warning))",
+ },
".cm-lintRange-active": { backgroundColor: "transparent" },
".cm-lintRange-warning.cm-lintRange-active": { backgroundColor: "var(--editor-warning-background, transparent)" },
".cm-lintPoint:after": { display: "none" },
diff --git a/src/editor/lsp/format.test.ts b/src/editor/lsp/format.test.ts
index eb66b954a..75c31b429 100644
--- a/src/editor/lsp/format.test.ts
+++ b/src/editor/lsp/format.test.ts
@@ -7,7 +7,7 @@ import {
protectedRegions,
type FormatGuardOptions,
} from "@/platform/formatGuard";
-import { formattedLines } from "./format";
+import { dedentsToColumnZero, formattedLines } from "./format";
describe("formattedLines", () => {
const doc = Text.of(["fn main(){", "let x=1;", "}", "", "fn other() {}"]);
@@ -97,3 +97,11 @@ describe("formatter markers and Do not format", () => {
expect(formatExcluded("/p/other/docs.md", "/p", globs)).toBe(false);
});
});
+
+describe("dedentsToColumnZero", () => {
+ it("spots range formatting done without the surrounding code", () => {
+ expect(dedentsToColumnZero("\n override fun f() { }\n", "\noverride fun f() {}\n")).toBe(true);
+ expect(dedentsToColumnZero("\n\tfun f() {\n\t}\n", "\n fun f() {\n }\n")).toBe(false);
+ expect(dedentsToColumnZero("fun f() {}\n", "fun f() { }\n")).toBe(false);
+ });
+});
diff --git a/src/editor/lsp/format.ts b/src/editor/lsp/format.ts
index 013e94e89..64d299699 100644
--- a/src/editor/lsp/format.ts
+++ b/src/editor/lsp/format.ts
@@ -7,7 +7,7 @@
*/
import { indentUnit } from "@codemirror/language";
import { isolateHistory } from "@codemirror/commands";
-import type { Text } from "@codemirror/state";
+import type { EditorState, Text } from "@codemirror/state";
import type { EditorView } from "@codemirror/view";
import { commands } from "@/platform/ipc";
import { shortcutLabel } from "@/platform/keymap";
@@ -63,6 +63,12 @@ function formattedHint(view: EditorView, lines: number) {
});
}
+/** LSP `FormattingOptions`: with spaces the indent width is the indent unit, not the tab size. */
+export function formatOptionsOf(state: EditorState): { tabSize: number; insertSpaces: boolean } {
+ const unit = state.facet(indentUnit);
+ return unit.includes("\t") ? { tabSize: state.tabSize, insertSpaces: false } : { tabSize: unit.length || state.tabSize, insertSpaces: true };
+}
+
export async function formatDocument(
view: EditorView,
opts: { explicit: boolean; selectionOnly?: boolean } = { explicit: true },
@@ -90,7 +96,7 @@ async function format(view: EditorView, opts: { explicit: boolean; selectionOnly
const sel = state.selection.main;
const useSelection = (opts.selectionOnly ?? true) && !sel.empty;
const range = useSelection ? { start: offsetToPos(state.doc, sel.from), end: offsetToPos(state.doc, sel.to) } : null;
- const options = { tabSize: state.tabSize, insertSpaces: !state.facet(indentUnit).includes("\t") };
+ const options = formatOptionsOf(state);
let edits;
try {
edits = await lspRequest(() => commands.lspFormat(doc.doc, range, options));
@@ -116,6 +122,45 @@ async function format(view: EditorView, opts: { explicit: boolean; selectionOnly
return { applied: true, changes: changes.length, lines: formattedLines(state.doc, changes) };
}
+/** Whether `after` has a non-blank line at column 0 where all of `before` was indented. */
+export function dedentsToColumnZero(before: string, after: string): boolean {
+ const minIndent = (t: string) =>
+ Math.min(...t.split("\n").filter((l) => l.trim()).map((l) => l.length - l.trimStart().length));
+ return minIndent(before) > 0 && minIndent(after) === 0;
+}
+
+/**
+ * Reformats lines `from..to` silently (generated code: quick fixes, Generate),
+ * merged into the edit's undo step. False when the server can't format ranges.
+ */
+export async function formatLines(view: EditorView, from: number, to: number): Promise<boolean> {
+ const doc = docOf(view);
+ if (!doc || doc.readOnly) return false;
+ const { project, settings } = useProject.getState();
+ if (formatExcluded(doc.path, project?.root ?? null, formatGuardOptions(settings).doNotFormat)) return false;
+ await whenSynced(view);
+ const state = view.state;
+ const range = { start: offsetToPos(state.doc, from), end: offsetToPos(state.doc, to) };
+ const options = formatOptionsOf(state);
+ let edits;
+ try {
+ edits = await lspRequest(() => commands.lspFormat(doc.doc, range, options));
+ } catch {
+ return false;
+ }
+ if (view.state.doc !== state.doc) return false;
+ // Only inside the range: some servers answer a range request with whole-file edits.
+ const changes = textEditsToChanges(state.doc, edits).filter((c) => c.from >= from && c.to <= to && state.sliceDoc(c.from, c.to) !== c.insert);
+ if (!changes.length) return true;
+ // A server formatting the range out of context (kotlin-language-server) moves
+ // indented code to column 0: its answer is ignored then.
+ const delta = changes.reduce((d, c) => d + c.insert.length - (c.to - c.from), 0);
+ const next = state.update({ changes }).state.doc;
+ if (dedentsToColumnZero(state.sliceDoc(from, to), next.sliceString(from, to + delta))) return false;
+ view.dispatch({ changes, userEvent: "format", scrollIntoView: false });
+ return true;
+}
+
function applyContributedFormat(
view: EditorView,
format: ContributedFormatter,
diff --git a/src/editor/lsp/hover.ts b/src/editor/lsp/hover.ts
index 955efc28e..fefbdf97a 100644
--- a/src/editor/lsp/hover.ts
+++ b/src/editor/lsp/hover.ts
@@ -31,6 +31,7 @@ import { docWindowVisible, moveDocPopupToWindow, showInDocWindow } from "./docs"
import { structure } from "@/editor/structure";
import { basename } from "@/platform/project";
import { iconNode } from "./iconMarkup";
+import { applyCodeAction, quickFixesAt } from "./intentions";
import { editorPrefs } from "@/platform/editorSettings";
import { CONTRIBUTED_HOVER, contributedAt, type ContributedHover } from "@/editor/api";
import { navigationModifierHeld, onNavigationModifier, pointerTarget } from "@/platform/navigationModifier";
@@ -50,7 +51,10 @@ export async function requestHover(view: EditorView, pos: number): Promise<Hover
if (hoverRequest !== null && isTauri()) void commands.cancelRequest(hoverRequest);
const id = (hoverRequest = nextRequestId());
try {
- const h = await lspRequest(() => commands.lspHover(id, doc.doc, offsetToPos(view.state.doc, pos)));
+ const h = await lspRequest(
+ () => commands.lspHover(id, doc.doc, offsetToPos(view.state.doc, pos)),
+ () => hoverRequest === id,
+ );
return h && !isEmptyMarkup(h.contents) ? h : null;
} finally {
if (hoverRequest === id) hoverRequest = null;
@@ -60,7 +64,7 @@ export async function requestHover(view: EditorView, pos: number): Promise<Hover
function renderDiagnostics(view: EditorView, diags: PlacedDiagnostic[]): HTMLElement {
const box = document.createElement("div");
box.className = "cm-lsp-hover-diagnostics";
- for (const { diagnostic: d, from } of diags) {
+ for (const { diagnostic: d, from, to } of diags) {
const row = document.createElement("div");
row.className = `cm-lsp-diag cm-lsp-diag-${d.severity}`;
row.appendChild(
@@ -87,6 +91,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);
fix.addEventListener("mousedown", (e) => e.preventDefault());
fix.addEventListener("click", () => {
view.dispatch({ selection: EditorSelection.cursor(from) });
@@ -100,6 +105,28 @@ function renderDiagnostics(view: EditorView, diags: PlacedDiagnostic[]): HTMLEle
return box;
}
+/** IDEA's hover link to the problem's preferred quick fix, shown once the server named one. */
+function offerQuickFix(view: EditorView, meta: HTMLElement, before: HTMLElement, from: number, to: number) {
+ const doc = view.state.doc;
+ void quickFixesAt(view, from, to)
+ .then(([action]) => {
+ if (!action || view.state.doc !== doc || !before.isConnected) return;
+ const link = document.createElement("button");
+ link.type = "button";
+ link.className = "cm-lsp-link-button";
+ const keys = shortcutLabel("code.applyQuickFix");
+ link.textContent = keys ? `${action.title} ${keys}` : action.title;
+ link.addEventListener("mousedown", (e) => e.preventDefault());
+ link.addEventListener("click", () => {
+ view.dispatch({ effects: closeHoverTooltips });
+ view.focus();
+ void applyCodeAction(view, action);
+ });
+ meta.insertBefore(link, before);
+ })
+ .catch(() => {});
+}
+
/**
* Whether the plain hover (problems + quick documentation) stays out: while
* ⌘/Ctrl is held the ⌘-hover link and its brief info (`navigation.ts`) own the
diff --git a/src/editor/lsp/inlineCompletion.ts b/src/editor/lsp/inlineCompletion.ts
index 29d265481..65dde708e 100644
--- a/src/editor/lsp/inlineCompletion.ts
+++ b/src/editor/lsp/inlineCompletion.ts
@@ -163,8 +163,9 @@ export async function requestInline(view: EditorView, automatic: boolean): Promi
const id = (inflight = nextRequestId());
const caret = sel.main.head;
try {
- const items = await lspRequest(() =>
- commands.lspInlineCompletion(id, doc.doc, offsetToPos(state.doc, caret), automatic),
+ const items = await lspRequest(
+ () => commands.lspInlineCompletion(id, doc.doc, offsetToPos(state.doc, caret), automatic),
+ () => inflight === id,
);
if (view.state.doc !== state.doc || !view.state.selection.eq(sel)) return false;
const suggestions = toSuggestions(view.state, caret, items);
diff --git a/src/editor/lsp/intentions.test.ts b/src/editor/lsp/intentions.test.ts
index 6c83df20b..53b89ba16 100644
--- a/src/editor/lsp/intentions.test.ts
+++ b/src/editor/lsp/intentions.test.ts
@@ -28,7 +28,8 @@ vi.mock("@/platform/ipc", async (orig) => {
return { ...actual, isTauri: () => true, commands: { ...actual.commands, lspResolveCodeAction } };
});
-const { intentionPreview, withInspectionControls } = await import("./intentions");
+const { bulbLine, changedLines, indentUnderBrace, intentionPreview, lightsBulb, listedCodeActions, withInspectionControls } =
+ await import("./intentions");
const { setFileDiagnostics } = await import("./diagnostics");
const { lspDoc } = await import("./lsp");
@@ -109,3 +110,71 @@ describe("intention preview", () => {
expect(lspResolveCodeAction).toHaveBeenCalledOnce();
});
});
+
+describe("listedCodeActions", () => {
+ const action = (title: string, kind: string): CodeAction => ({ ...resolved, title, kind, edit: null });
+ it("lists one action per title, quick fixes first", () => {
+ const list = listedCodeActions([
+ action("Generate toString()", "quickassist"),
+ action("Add unimplemented methods", "quickfix"),
+ action("Generate toString()", "source.generate.toString"),
+ ]);
+ expect(list.map((a) => [a.title, a.kind])).toEqual([
+ ["Add unimplemented methods", "quickfix"],
+ ["Generate toString()", "quickassist"],
+ ]);
+ });
+});
+
+describe("changedLines", () => {
+ const text = (s: string) => EditorState.create({ doc: s }).doc;
+ it("spans the lines an edit inserted", () => {
+ expect(changedLines(text("class A {\n}\n"), text("class A {\n f() {\n }\n}\n"))).toEqual([{ from: 2, to: 3 }]);
+ });
+ it("keeps separate edits apart", () => {
+ const before = text("package p;\n\nclass A {\n int a;\n int b;\n void f() {\n }\n}\n");
+ const after = text("package p;\n\nimport java.util.List;\n\nclass A {\n int a;\n int b;\n void f() {\n List<String> x = null;\n x.size();\n }\n}\n");
+ expect(changedLines(before, after)).toEqual([
+ { from: 3, to: 4 },
+ { from: 9, to: 10 },
+ ]);
+ });
+ it("is empty for equal texts", () => {
+ expect(changedLines(text("a\nb"), text("a\nb"))).toEqual([]);
+ });
+});
+
+describe("bulbLine", () => {
+ const state = (s: string) => EditorState.create({ doc: s });
+ it("prefers an indented caret line, then the lines around it", () => {
+ expect(bulbLine(state(" x\ny"), 1)).toEqual({ line: 1, gutter: false });
+ expect(bulbLine(state("x\n\ny"), 1)).toEqual({ line: 2, gutter: false });
+ });
+ it("falls back to the gutter when no nearby line has room", () => {
+ expect(bulbLine(state("x\n y\nz"), 1)).toEqual({ line: 1, gutter: true });
+ });
+});
+
+describe("lightsBulb", () => {
+ const kinds = (k: string | null) => lightsBulb({ ...resolved, kind: k });
+ it("lights for fixes and refactorings only", () => {
+ expect([null, "quickfix", "refactor.extract", "quickassist"].map(kinds)).toEqual([true, true, true, true]);
+ expect(["source.organizeImports", "source.doc", "gopls.doc.features"].map(kinds)).toEqual([false, false, false]);
+ });
+});
+
+describe("indentUnderBrace", () => {
+ const text = (s: string) => EditorState.create({ doc: s }).doc;
+ it("moves code generated at the brace's column one level in", () => {
+ const doc = text("class A : B {\noverride fun f() {\n g()\n}\n}");
+ expect(indentUnderBrace(doc, 2, 4, " ").map((c) => [doc.lineAt(c.from).number, c.insert])).toEqual([
+ [2, " "],
+ [3, " "],
+ [4, " "],
+ ]);
+ });
+ it("leaves code already indented, or not under a brace", () => {
+ expect(indentUnderBrace(text("class A {\n f()\n}"), 2, 2, " ")).toEqual([]);
+ expect(indentUnderBrace(text("class A:\npass\nx"), 2, 3, " ")).toEqual([]);
+ });
+});
diff --git a/src/editor/lsp/intentions.ts b/src/editor/lsp/intentions.ts
index 7894f3c40..07b11dd6a 100644
--- a/src/editor/lsp/intentions.ts
+++ b/src/editor/lsp/intentions.ts
@@ -3,15 +3,19 @@
* intentions popup (quick fixes first, preferred in bold), Optimize Imports and
* Generate. Refactor This and the Refactor menu live in `@/editor/refactor`.
*/
-import { StateEffect, StateField, type Extension } from "@codemirror/state";
+import { StateEffect, StateField, type Extension, type Text } from "@codemirror/state";
import { EditorView, ViewPlugin, type ViewUpdate } from "@codemirror/view";
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, whenSynced } from "@/editor/api";
+import { contributedIntentions, intentionProviders, whenSynced } from "@/editor/api";
import { shortcutLabel } from "@/platform/keymap";
import { debounce, docOf, isUnavailable, lspRequest, reportLspError } from "./lsp";
import { offsetsToRange } from "./positions";
import { showHint } from "./hint";
+import { formatLines } from "./format";
+import { pythonMemberIntentions } from "./pythonMembers";
import { caretAnchor, openPopup, type ListPopupItem, type ListPreview } from "./popupStore";
import { editPreviewLines } from "./workspaceEdit";
import { serverBackoff } from "./availability";
@@ -88,6 +92,43 @@ 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[]> {
+ 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));
+}
+
+/**
+ * ⌥⇧↵: applies the preferred (else first) quick fix of the most severe problem
+ * at the caret, or of one elsewhere on the caret line.
+ */
+export async function applyQuickFix(view: EditorView) {
+ const state = view.state;
+ const caret = state.selection.main.head;
+ const line = state.doc.lineAt(caret);
+ const problems: Array<PlacedProblem & { rank: number }> = [];
+ forEachDiagnostic(state, (d, from, to) => {
+ if (d.severity === "hint" || to < line.from || from > line.to) return;
+ const rank = (d.severity === "error" ? 0 : d.severity === "warning" ? 1 : 2) + (from <= caret && caret <= to ? 0 : 3);
+ problems.push({ from, to, severity: d.severity, rank });
+ });
+ problems.sort((a, b) => a.rank - b.rank);
+ try {
+ for (const p of problems) {
+ const fix = (await quickFixesAt(view, p.from, p.to))[0];
+ if (view.state.doc !== state.doc) return;
+ if (fix) return applyCodeAction(view, fix);
+ }
+ } catch (e) {
+ reportLspError(view, e, true);
+ return;
+ }
+ showHint(view, "No quick fixes available");
+}
+
export async function applyCodeAction(view: EditorView, action: CodeAction) {
const doc = docOf(view);
if (!doc) return;
@@ -95,11 +136,82 @@ export async function applyCodeAction(view: EditorView, action: CodeAction) {
showHint(view, action.disabledReason);
return;
}
+ const before = view.state.doc;
try {
await lspRequest(() => commands.lspApplyCodeAction(doc.doc, action));
} catch (e) {
reportLspError(view, e, true);
+ return;
}
+ if (!action.kind?.startsWith("source.organizeImports") && !action.kind?.startsWith("source.fixAll"))
+ await reformatGenerated(view, before);
+}
+
+/**
+ * Code the server generated follows its own indentation (jdtls tabs,
+ * tsserver 4 spaces); like IDEA, the lines an action inserted are reformatted
+ * to the file's style.
+ */
+async function reformatGenerated(view: EditorView, before: Text) {
+ for (let i = 0; i < 100 && view.state.doc === before; i++) await new Promise((r) => setTimeout(r, 20));
+ // Bottom up, so the line numbers of the hunks above stay valid.
+ for (const lines of changedLines(before, view.state.doc).reverse()) {
+ if (lines.to - lines.from < 1) continue;
+ const doc = view.state.doc;
+ const shift = indentUnderBrace(doc, lines.from, lines.to, view.state.facet(indentUnit));
+ // A server that generated code without its context formats ranges the same
+ // way (back to column 0): its range formatting is skipped then.
+ if (shift.length) view.dispatch({ changes: shift, userEvent: "format", scrollIntoView: false });
+ else if (!(await formatLines(view, doc.line(lines.from).from, doc.line(lines.to).to)) && view.state.doc !== doc) return;
+ }
+}
+
+/**
+ * Generated lines right under a `{` line but not indented past it (servers
+ * that format the snippet on its own, kotlin-language-server): the block moves
+ * one level in, keeping its own nesting. Never applies to indentation-based
+ * languages, whose blocks don't open with `{`.
+ */
+export function indentUnderBrace(doc: Text, fromLine: number, toLine: number, unit: string): Array<{ from: number; insert: string }> {
+ if (fromLine < 2) return [];
+ const prev = doc.line(fromLine - 1).text;
+ if (!prev.trimEnd().endsWith("{")) return [];
+ const lead = (t: string) => t.slice(0, t.length - t.trimStart().length);
+ const target = lead(prev) + unit;
+ let first: string | null = null;
+ for (let n = fromLine; n <= toLine && first === null; n++) if (doc.line(n).text.trim()) first = lead(doc.line(n).text);
+ if (first === null || first.length > lead(prev).length || !target.startsWith(first)) return [];
+ const extra = target.slice(first.length);
+ const out: Array<{ from: number; insert: string }> = [];
+ for (let n = fromLine; n <= toLine; n++) {
+ const line = doc.line(n);
+ if (line.text.trim()) out.push({ from: line.from, insert: extra });
+ }
+ return out;
+}
+
+/**
+ * 1-based line spans of `after` that an edit changed, top to bottom: an added
+ * import and the code using it are separate spans, so the user's code between
+ * them is left alone.
+ */
+export function changedLines(before: Text, after: Text): Array<{ from: number; to: number }> {
+ if (before.eq(after)) return [];
+ const spans: Array<{ from: number; to: number }> = [];
+ const a = before.toString();
+ const b = after.toString();
+ for (const c of diff(a, b)) {
+ // Text inserted at a line's end or start (`{⏎ added`, `added⏎`) leaves that line as it was.
+ const lead = b[c.fromB] === "\n" && (c.toA === c.fromA || a[c.fromA] === "\n");
+ const trail = c.toB > c.fromB && b[c.toB - 1] === "\n" && (c.toA === c.fromA || a[c.toA - 1] === "\n");
+ const from = after.lineAt(lead ? c.fromB + 1 : c.fromB).number;
+ const end = trail ? c.toB - 1 : c.toB;
+ const to = Math.max(from, after.lineAt(end).number);
+ const last = spans[spans.length - 1];
+ if (last && from <= last.to + 1) last.to = Math.max(last.to, to);
+ else spans.push({ from, to });
+ }
+ return spans;
}
/**
@@ -127,8 +239,17 @@ export async function applyKindSilently(view: EditorView, kind: string): Promise
return true;
}
+/**
+ * Sorted, one action per title: servers can report the same action under two
+ * kinds (jdtls: "Generate toString()" as quickassist and source.generate).
+ */
+export function listedCodeActions(actions: readonly CodeAction[]): CodeAction[] {
+ const seen = new Set<string>();
+ return sortCodeActions(actions).filter((a) => !seen.has(a.title) && !!seen.add(a.title));
+}
+
function actionItems(view: EditorView, actions: CodeAction[], resolved?: Map<CodeAction, Promise<CodeAction>>): ListPopupItem[] {
- return sortCodeActions(actions).map((a, i) => ({
+ return listedCodeActions(actions).map((a, i) => ({
id: `${i}`,
label: a.title,
icon: isQuickFix(a) ? "bulb-fix" : "bulb",
@@ -217,7 +338,7 @@ export async function showIntentions(view: EditorView) {
} catch (e) {
failure = { error: e };
}
- const sorted = sortCodeActions(actions);
+ const sorted = listedCodeActions(actions);
const resolved = new Map<CodeAction, Promise<CodeAction>>();
const items = withInspectionControls(view, [...local, ...actionItems(view, sorted, resolved)]);
if (!items.length) {
@@ -305,6 +426,16 @@ function noActionReason(view: EditorView, none: string): string {
// ---------------------------------------------------------------------------
// Lightbulb
+/**
+ * Fixes and refactorings light the bulb; source actions (organize imports,
+ * generate…) and server extras (gopls "Browse documentation") are offered on
+ * almost every line and only appear in the ⌥↵ list.
+ */
+export function lightsBulb(a: CodeAction): boolean {
+ const kind = a.kind ?? "";
+ return !kind || kind === "quickassist" || /^(quickfix|refactor)(\.|$)/.test(kind);
+}
+
interface Bulb {
line: number;
quickFix: boolean;
@@ -331,11 +462,19 @@ const bulbPlugin = ViewPlugin.fromClass(
this.lookup();
}
update(u: ViewUpdate) {
- if (u.docChanged || u.selectionSet) this.lookup();
+ if (u.docChanged || u.selectionSet || (u.focusChanged && u.view.hasFocus)) this.lookup();
+ else if (u.focusChanged) {
+ this.lookup.cancel();
+ // A blur dispatched from inside the update is not allowed.
+ queueMicrotask(() => {
+ if (!this.view.hasFocus && this.view.state.field(bulbField, false)) this.view.dispatch({ effects: setBulb.of(null) });
+ });
+ }
}
async run() {
const doc = docOf(this.view);
- if (!doc || doc.readOnly || !this.view.dom.isConnected) return;
+ // As in IDEA, only the focused editor shows the bulb.
+ 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;
@@ -350,9 +489,9 @@ const bulbPlugin = ViewPlugin.fromClass(
if (!local) return;
}
}
- if (this.view.state.doc !== state.doc || !this.view.state.selection.eq(state.selection)) return;
+ if (this.view.state.doc !== state.doc || !this.view.state.selection.eq(state.selection) || !this.view.hasFocus) return;
const line = state.doc.lineAt(state.selection.main.head).number;
- const any = actions.length > 0 || local;
+ const any = actions.some(lightsBulb) || local;
this.view.dispatch({
effects: setBulb.of(any ? { line, quickFix: typoFix || actions.some(isQuickFix) } : null),
});
@@ -365,21 +504,20 @@ const bulbPlugin = ViewPlugin.fromClass(
/**
* New-UI bulb: floats at the start of the text on the caret line, or on the
- * line below / above when the caret line's text starts at the left edge.
+ * line below / above when the caret line's text starts at the left edge; in
+ * the gutter when none of them has room.
*/
const BULB_COLUMNS = 3;
-function bulbLine(state: EditorView["state"], line: number): number {
+export function bulbLine(state: EditorView["state"], line: number): { line: number; gutter: boolean } {
const doc = state.doc;
const free = (n: number) => {
if (n < 1 || n > doc.lines) return false;
const text = doc.line(n).text;
return text.length - text.trimStart().length >= BULB_COLUMNS || !text.trim();
};
- if (free(line)) return line;
- if (free(line + 1)) return line + 1;
- if (free(line - 1)) return line - 1;
- return line;
+ for (const n of [line, line + 1, line - 1]) if (free(n)) return { line: n, gutter: false };
+ return { line, gutter: true };
}
class FloatingBulb {
@@ -393,6 +531,7 @@ class FloatingBulb {
this.dom.setAttribute("aria-label", "Show intentions");
this.dom.style.display = "none";
this.dom.appendChild(iconNode("bulb", 16));
+ this.dom.appendChild(iconNode("bulb-fix", 16, "cm-lsp-bulb-fix-icon"));
this.dom.addEventListener("mousedown", (e) => {
e.preventDefault();
e.stopPropagation();
@@ -420,18 +559,24 @@ class FloatingBulb {
this.view.requestMeasure({
key: this,
read: (view) => {
- const line = view.state.doc.line(bulbLine(view.state, bulb.line));
- const block = view.lineBlockAt(line.from);
+ const at = bulbLine(view.state, bulb.line);
+ const line = view.state.doc.line(at.line);
const content = view.contentDOM.getBoundingClientRect();
const scroller = view.scrollDOM.getBoundingClientRect();
+ // The text row: the line's block also holds inline widgets above it (code vision).
+ const coords = view.coordsAtPos(line.from, 1);
+ const block = view.lineBlockAt(line.from);
+ const textTop = coords ? coords.top - scroller.top : block.top + view.documentTop - scroller.top;
return {
- top: block.top + (view.documentTop - scroller.top) + view.scrollDOM.scrollTop,
- left: content.left - scroller.left + view.scrollDOM.scrollLeft + 4,
- height: block.height,
+ top: textTop + view.scrollDOM.scrollTop,
+ left: content.left - scroller.left + view.scrollDOM.scrollLeft + (at.gutter ? -20 : 4),
+ height: coords ? coords.bottom - coords.top : block.height,
+ gutter: at.gutter,
};
},
- write: ({ top, left, height }) => {
+ write: ({ top, left, height, gutter }) => {
this.dom.style.display = "";
+ this.dom.classList.toggle("cm-lsp-bulb-gutter", gutter);
this.dom.style.top = `${top}px`;
this.dom.style.left = `${left}px`;
this.dom.style.height = `${Math.min(height, this.view.defaultLineHeight)}px`;
@@ -447,5 +592,5 @@ class FloatingBulb {
const floatingBulb = ViewPlugin.fromClass(FloatingBulb);
export function intentionsExtension(): Extension {
- return [bulbField, bulbPlugin, floatingBulb];
+ return [bulbField, bulbPlugin, floatingBulb, intentionProviders.of(pythonMemberIntentions)];
}
diff --git a/src/editor/lsp/lsp.test.ts b/src/editor/lsp/lsp.test.ts
new file mode 100644
index 000000000..057735b85
--- /dev/null
+++ b/src/editor/lsp/lsp.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it, vi } from "vitest";
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { _addEditor, _removeEditor, documentSynced, type EditorDocContext } from "@/editor/api";
+
+vi.mock("@/platform/ipc", async (orig) => {
+ const actual = await orig<typeof import("@/platform/ipc")>();
+ return { ...actual, isTauri: () => true };
+});
+
+const { lspRequest } = await import("./lsp");
+
+describe("lspRequest", () => {
+ it("waits until open editors' edits reached the backend", async () => {
+ let synced!: () => void;
+ const pending = new Promise<void>((r) => (synced = r));
+ const view = new EditorView({ state: EditorState.create({ extensions: documentSynced.of(() => pending) }) });
+ const handle = { view, ctx: {} as EditorDocContext };
+ _addEditor(handle);
+ const run = vi.fn(async () => ({ status: "ok" as const, data: 1 }));
+ const result = lspRequest(run);
+ await Promise.resolve();
+ expect(run).not.toHaveBeenCalled();
+ synced();
+ expect(await result).toBe(1);
+ _removeEditor(handle);
+ view.destroy();
+ });
+});
diff --git a/src/editor/lsp/lsp.ts b/src/editor/lsp/lsp.ts
index 63287a87f..76ac58a0f 100644
--- a/src/editor/lsp/lsp.ts
+++ b/src/editor/lsp/lsp.ts
@@ -1,7 +1,7 @@
/** Shared plumbing: per-editor document facet, IPC wrapper and error policy. */
import { Facet } from "@codemirror/state";
import type { EditorView } from "@codemirror/view";
-import type { EditorDocContext } from "@/editor/api";
+import { whenAllSynced, type EditorDocContext } from "@/editor/api";
import { IpcError, call, isCancelled, isTauri } from "@/platform/ipc";
import type { IdeError } from "@/bindings";
import { showHint } from "./hint";
@@ -20,10 +20,15 @@ type Result<T> = { status: "ok"; data: T } | { status: "error"; error: IdeError
/**
* Runs an LSP command. Synchronous throws (no Tauri runtime in a plain browser)
* become `unavailable` rejections so callers have a single error path.
+ * `wanted` is checked once pending edits are synced: a request cancelled
+ * meanwhile is not sent (the backend ignores cancelling an id it hasn't seen).
*/
-export async function lspRequest<T>(run: () => Promise<Result<T>>): Promise<T> {
+export async function lspRequest<T>(run: () => Promise<Result<T>>, wanted?: () => boolean): Promise<T> {
if (!isTauri()) throw new IpcError({ kind: "unavailable", message: "No language server available" });
try {
+ // Edits typed just before (⌘B right after typing) must reach the server first.
+ await whenAllSynced();
+ if (wanted && !wanted()) throw new IpcError({ kind: "cancelled", message: "cancelled" });
return await call(run());
} catch (e) {
if (e instanceof IpcError) throw e;
diff --git a/src/editor/lsp/navigation.ts b/src/editor/lsp/navigation.ts
index 2136f9631..c920b17a2 100644
--- a/src/editor/lsp/navigation.ts
+++ b/src/editor/lsp/navigation.ts
@@ -128,6 +128,22 @@ export function pinToFind(symbol: string, locations: readonly Location[]) {
};
}
+/** When each editor's document last changed (`performance.now()`). */
+const editedAt = new WeakMap<EditorView, number>();
+
+/**
+ * Some servers analyse an edit asynchronously and answer from the previous
+ * version meanwhile (kotlin-language-server: nothing for ~300 ms after typing).
+ * An empty answer right after an edit is asked again a few times.
+ */
+async function gotoAfterEdits(view: EditorView, request: () => Promise<DeclarationTarget[]>) {
+ for (let attempt = 0; ; attempt++) {
+ const locs = await request();
+ if (locs.length || attempt >= 3 || performance.now() - (editedAt.get(view) ?? -Infinity) > 1500) return locs;
+ await new Promise((r) => setTimeout(r, 250));
+ }
+}
+
export async function gotoTargets(view: EditorView, kind: GotoKind, at?: number) {
const offset = at ?? view.state.selection.main.head;
if (kind === "definition" || kind === "declaration") {
@@ -142,7 +158,7 @@ export async function gotoTargets(view: EditorView, kind: GotoKind, at?: number)
const declaration = kind === "definition" || kind === "declaration";
let serverDown = false;
try {
- locs = dedupeLocations(await lspRequest(() => commands.lspGoto(doc.doc, pos, kind)));
+ locs = dedupeLocations(await gotoAfterEdits(view, () => lspRequest(() => commands.lspGoto(doc.doc, pos, kind))));
} catch (e) {
if (isCancelled(e) || !declaration) {
reportLspError(view, e, true);
@@ -630,6 +646,9 @@ const highlightPlugin = ViewPlugin.fromClass(
export function navigationExtension(): Extension {
return [
+ EditorView.updateListener.of((u) => {
+ if (u.docChanged) editedAt.set(u.view, performance.now());
+ }),
linkField,
linkPlugin,
highlightField,
diff --git a/src/editor/lsp/pythonMembers.test.ts b/src/editor/lsp/pythonMembers.test.ts
new file mode 100644
index 000000000..df4a8f11f
--- /dev/null
+++ b/src/editor/lsp/pythonMembers.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { classMembers, enclosingClass, memberStubs } from "./pythonMembers";
+
+const src = `from abc import ABC, abstractmethod
+
+
+class Shape(ABC):
+ @property
+ @abstractmethod
+ def name(self) -> str: ...
+
+ @abstractmethod
+ def area(
+ self, scale: float = 1.0
+ ) -> float:
+ """Area."""
+
+ def describe(self) -> str:
+ return self.name
+
+
+class Square(Shape):
+ def __init__(self, side: float):
+ self.side = side
+`.split("\n");
+
+describe("python members", () => {
+ it("finds the class enclosing a line", () => {
+ expect(enclosingClass(src, 4)).toBe(4);
+ expect(enclosingClass(src, 13)).toBe(4);
+ expect(enclosingClass(src, 21)).toBe(19);
+ expect(enclosingClass(src, 1)).toBeNull();
+ });
+
+ it("lists methods with their decorators and signatures", () => {
+ const members = classMembers(src, 4);
+ expect(members.map((m) => [m.name, m.abstract])).toEqual([
+ ["name", true],
+ ["area", true],
+ ["describe", false],
+ ]);
+ expect(members[0]!.lines).toEqual(["@property", "def name(self) -> str:"]);
+ expect(members[1]!.lines).toEqual(["def area(", " self, scale: float = 1.0", ") -> float:"]);
+ });
+
+ it("stops at a nested class without bases", () => {
+ const nested = ["class Outer(Base):", " class Inner:", " x = 1", ""];
+ expect(enclosingClass(nested, 3)).toBeNull();
+ });
+
+ it("keeps a body going through an unindented string", () => {
+ const lines = [
+ "class A(ABC):",
+ " @abc.abstractproperty",
+ " def doc(self):",
+ ' return """',
+ "text",
+ '"""',
+ " @abstractmethod",
+ " def run(self): ...",
+ "x = 1",
+ ];
+ const members = classMembers(lines, 1);
+ expect(members.map((m) => m.lines)).toEqual([["@property", "def doc(self):"], ["def run(self):"]]);
+ expect(members.every((m) => m.abstract)).toBe(true);
+ });
+
+ it("writes stubs at the body's indentation", () => {
+ const [name] = classMembers(src, 4);
+ expect(memberStubs([name!], " ", " ")).toBe(" @property\n def name(self) -> str:\n pass");
+ });
+});
diff --git a/src/editor/lsp/pythonMembers.ts b/src/editor/lsp/pythonMembers.ts
new file mode 100644
index 000000000..1402c2d02
--- /dev/null
+++ b/src/editor/lsp/pythonMembers.ts
@@ -0,0 +1,209 @@
+/**
+ * Python "Implement abstract methods": Python servers (pyright, basedpyright)
+ * offer no such code action. The bases of the class at the caret are resolved
+ * with Go to Declaration; their `@abstractmethod`s the class lacks get stubs
+ * at the end of its body.
+ */
+import { indentUnit } from "@codemirror/language";
+import type { EditorView } from "@codemirror/view";
+import { commands } from "@/platform/ipc";
+import type { ContributedIntention } from "@/editor/api";
+import { docOf, lspRequest, reportLspError } from "./lsp";
+import { offsetToPos } from "./positions";
+import { readFileLines } from "./files";
+import { showHint } from "./hint";
+
+const CLASS_HEADER = /^(\s*)class\s+\w+\s*\((.*)\)\s*:/;
+const CLASS = /^\s*class\s/;
+const DEF = /^\s*(?:async\s+)?def\s+(\w+)/;
+
+const indentOf = (line: string) => line.length - line.trimStart().length;
+const isPython = (view: EditorView) => docOf(view)?.uiMode === "Python";
+
+/** 1-based number of the class header line enclosing `line` (or on it); null unless it has bases. */
+export function enclosingClass(lines: readonly string[], line: number): number | null {
+ let limit = Infinity;
+ for (let n = line; n >= 1; n--) {
+ const text = lines[n - 1]!;
+ if (!text.trim()) continue;
+ const indent = indentOf(text);
+ if (n !== line && indent >= limit) continue;
+ if (CLASS.test(text)) return CLASS_HEADER.test(text) ? n : null;
+ limit = Math.min(limit, indent);
+ if (indent === 0 && n !== line) return null;
+ }
+ return null;
+}
+
+/** Last 1-based line of the body of the class headed at `header`. */
+function bodyEnd(lines: readonly string[], header: number): number {
+ const indent = indentOf(lines[header - 1]!);
+ let last = header;
+ let quote: string | null = null;
+ for (let n = header + 1; n <= lines.length; n++) {
+ const text = lines[n - 1]!;
+ // Lines inside a triple-quoted string belong to it, however indented.
+ const inString = quote !== null;
+ for (const q of text.match(/"""|'''/g) ?? []) {
+ if (quote === null) quote = q;
+ else if (q === quote) quote = null;
+ }
+ if (inString) {
+ last = n;
+ continue;
+ }
+ if (!text.trim()) continue;
+ if (indentOf(text) <= indent) break;
+ last = n;
+ }
+ return last;
+}
+
+export interface PythonMember {
+ name: string;
+ abstract: boolean;
+ /** Decorators (without `@abstractmethod`) and the signature, dedented. */
+ lines: string[];
+}
+
+/** Methods declared directly in the class headed at `header` (1-based). */
+export function classMembers(lines: readonly string[], header: number): PythonMember[] {
+ const end = bodyEnd(lines, header);
+ const out: PythonMember[] = [];
+ let memberIndent = -1;
+ let decorators: string[] = [];
+ for (let n = header + 1; n <= end; n++) {
+ const text = lines[n - 1]!;
+ if (!text.trim()) continue;
+ const indent = indentOf(text);
+ if (memberIndent < 0) memberIndent = indent;
+ if (indent !== memberIndent) continue;
+ const trimmed = text.trim();
+ if (trimmed.startsWith("@")) {
+ decorators.push(trimmed);
+ continue;
+ }
+ const def = DEF.exec(text);
+ if (def) {
+ // The signature may span lines: up to the `:` closing it.
+ const sig: string[] = [];
+ let depth = 0;
+ for (let m = n; m <= end; m++) {
+ const part = lines[m - 1]!;
+ sig.push(part.slice(Math.min(memberIndent, indentOf(part))));
+ for (const ch of part) depth += ch === "(" || ch === "[" ? 1 : ch === ")" || ch === "]" ? -1 : 0;
+ if (depth <= 0 && /:\s*(#.*)?$|:\s*\.\.\.\s*$|:\s*\S/.test(part)) break;
+ }
+ // `def f(self) -> int: ...` keeps only the signature.
+ sig[sig.length - 1] = sig[sig.length - 1]!.replace(/:\s*(\.\.\.|pass)?\s*(#.*)?$/, ":");
+ const abstract = decorators.some((d) => /^@(abc\.)?abstract(method|property)\b/.test(d));
+ out.push({
+ name: def[1]!,
+ abstract,
+ lines: [
+ ...decorators
+ .filter((d) => !/^@(abc\.)?abstractmethod\b/.test(d))
+ .map((d) => d.replace(/^@(abc\.)?abstractproperty\b/, "@property")),
+ ...sig,
+ ],
+ });
+ }
+ decorators = [];
+ }
+ return out;
+}
+
+/** Base class names of a header and where each starts in the line. */
+function bases(header: string): Array<{ name: string; col: number }> {
+ const m = CLASS_HEADER.exec(header);
+ if (!m) return [];
+ const start = header.indexOf("(") + 1;
+ const out: Array<{ name: string; col: number }> = [];
+ for (const b of m[2]!.matchAll(/(?:^|,)\s*([A-Za-z_][\w.]*)\s*(?=,|$|\[)/g)) {
+ const name = b[1]!;
+ if (name === "object" || name.includes("=")) continue;
+ // The last segment of `abc.ABC`: that's what Go to Declaration resolves.
+ const col = start + b.index! + b[0].indexOf(name) + name.lastIndexOf(".") + 1;
+ out.push({ name, col });
+ }
+ return out;
+}
+
+/** Stub text for `members`, indented by `indent`. */
+export function memberStubs(members: readonly PythonMember[], indent: string, unit: string): string {
+ return members.map((m) => [...m.lines.map((l) => indent + l), `${indent}${unit}pass`].join("\n")).join("\n\n");
+}
+
+async function abstractMembersOfBases(view: EditorView, header: number): Promise<PythonMember[]> {
+ const doc = docOf(view)!;
+ const state = view.state;
+ const line = state.doc.line(header);
+ const out = new Map<string, PythonMember>();
+ for (const base of bases(line.text)) {
+ const pos = offsetToPos(state.doc, line.from + base.col);
+ const [loc] = await lspRequest(() => commands.lspGoto(doc.doc, pos, "definition"));
+ if (!loc) continue;
+ const lines = await readFileLines(loc.path);
+ if (!lines) continue;
+ const target = enclosingClass(lines, loc.range.start.line + 1);
+ if (!target) continue;
+ for (const m of classMembers(lines, target)) if (m.abstract && !out.has(m.name)) out.set(m.name, m);
+ }
+ return [...out.values()];
+}
+
+/** ⌃I / the intention: stubs for the abstract methods of the bases the class lacks. */
+export async function implementPythonAbstractMethods(view: EditorView): Promise<boolean> {
+ if (!isPython(view)) return false;
+ const lines = view.state.doc.toJSON();
+ const header = enclosingClass(lines, view.state.doc.lineAt(view.state.selection.main.head).number);
+ if (!header) return false;
+ let abstract: PythonMember[];
+ try {
+ abstract = await abstractMembersOfBases(view, header);
+ } catch (e) {
+ reportLspError(view, e, true);
+ return true;
+ }
+ const state = view.state;
+ if (state.doc.toJSON().join("\n") !== lines.join("\n")) return true;
+ const own = new Set(classMembers(lines, header).map((m) => m.name));
+ const missing = abstract.filter((m) => !own.has(m.name));
+ if (!missing.length) {
+ showHint(view, "No abstract methods to implement");
+ return true;
+ }
+ const end = bodyEnd(lines, header);
+ const unit = state.facet(indentUnit) || " ";
+ const bodyLines = [];
+ for (let n = header + 1; n <= end; n++) if (lines[n - 1]!.trim()) bodyLines.push(n);
+ const first = bodyLines[0] ? lines[bodyLines[0] - 1]! : null;
+ const indent = first
+ ? first.slice(0, indentOf(first))
+ : lines[header - 1]!.slice(0, indentOf(lines[header - 1]!)) + unit;
+ const stubs = memberStubs(missing, indent, unit);
+ // A body that is only `pass` / `...` is replaced.
+ const placeholder = bodyLines.length === 1 && /^\s*(pass|\.\.\.)\s*$/.test(first!);
+ const changes = !bodyLines.length
+ ? { from: state.doc.line(header).to, insert: `\n${stubs}` }
+ : placeholder
+ ? { from: state.doc.line(bodyLines[0]!).from, to: state.doc.line(end).to, insert: stubs }
+ : { from: state.doc.line(end).to, insert: `\n\n${stubs}` };
+ view.dispatch({ changes, userEvent: "input.complete", scrollIntoView: true });
+ return true;
+}
+
+/** The bulb on a Python class header with bases. */
+export function pythonMemberIntentions(view: EditorView): ContributedIntention[] {
+ if (!isPython(view)) return [];
+ const line = view.state.doc.lineAt(view.state.selection.main.head);
+ if (!bases(line.text).length) return [];
+ return [
+ {
+ id: "python.implementAbstract",
+ label: "Implement abstract methods",
+ icon: "bulb",
+ run: () => void implementPythonAbstractMethods(view),
+ },
+ ];
+}
diff --git a/src/editor/lsp/signature.ts b/src/editor/lsp/signature.ts
index e4313328b..061da0bbe 100644
--- a/src/editor/lsp/signature.ts
+++ b/src/editor/lsp/signature.ts
@@ -107,6 +107,25 @@ async function fetchSignature(view: EditorView, explicit: boolean) {
}
}
+/**
+ * The caret was left inside the `()` of a completed call whose snippet doesn't
+ * say whether it takes arguments (jdtls `new ArrayList<>()`): parameter info
+ * when some signature has parameters, else the caret moves past `)`.
+ */
+export async function parameterInfoOrLeave(view: EditorView, inside: number) {
+ const doc = docOf(view);
+ const state = view.state;
+ let help: SignatureHelp | null = null;
+ try {
+ if (doc) help = await lspRequest(() => commands.lspSignatureHelp(doc.doc, offsetToPos(state.doc, inside)));
+ } catch {
+ // No signature help: treated as nothing to fill in.
+ }
+ if (view.state.doc !== state.doc || view.state.selection.main.head !== inside) return;
+ if (help?.signatures.some((sig) => sig.parameters.length)) view.dispatch({ effects: setSignature.of({ pos: inside, help }) });
+ else view.dispatch({ selection: EditorSelection.cursor(inside + 1) });
+}
+
/** ⌘P or the completion command `editor.action.triggerParameterHints`. */
export function triggerSignatureHelp(view: EditorView, explicit = false) {
void fetchSignature(view, explicit);
diff --git a/src/editor/lsp/syntaxFallback.test.ts b/src/editor/lsp/syntaxFallback.test.ts
index 903e5438b..d43144fa0 100644
--- a/src/editor/lsp/syntaxFallback.test.ts
+++ b/src/editor/lsp/syntaxFallback.test.ts
@@ -447,6 +447,7 @@ describe("modifier-hover navigation recovery", () => {
await vi.advanceTimersByTimeAsync(3001);
cmd.lspGoto.mockReturnValueOnce(ok([target]));
move(view);
+ await vi.advanceTimersByTimeAsync(0);
expect(cmd.lspGoto).toHaveBeenCalledTimes(2);
} finally {
vi.useRealTimers();
diff --git a/src/editor/lsp/theme.ts b/src/editor/lsp/theme.ts
index 2ddc2cdfb..38072f31d 100644
--- a/src/editor/lsp/theme.ts
+++ b/src/editor/lsp/theme.ts
@@ -202,7 +202,8 @@ export const lspTheme = EditorView.theme({
".cm-lsp-diag-warning .cm-lsp-diag-icon": { color: "var(--warning)" },
".cm-lsp-diag-info .cm-lsp-diag-icon, .cm-lsp-diag-hint .cm-lsp-diag-icon": { color: "var(--info)" },
".cm-lsp-diag-message": { color: "var(--fg-strong)", whiteSpace: "pre-wrap", lineHeight: "18px" },
- ".cm-lsp-diag-meta": { display: "flex", gap: "12px", marginTop: "6px", alignItems: "baseline" },
+ ".cm-lsp-diag-meta": { display: "flex", flexWrap: "wrap", columnGap: "12px", rowGap: "2px", marginTop: "6px", alignItems: "baseline" },
+ ".cm-lsp-diag-meta > *": { whiteSpace: "nowrap" },
".cm-lsp-diag-source": { color: "var(--fg-subtle)", fontSize: "var(--fs-small)" },
".cm-lsp-link-button": {
border: "none",
@@ -311,9 +312,12 @@ export const lspTheme = EditorView.theme({
color: "var(--fg-bulb, var(--warning))",
cursor: "pointer",
},
+ // Above the sticky gutters (z-index 200).
+ ".cm-lsp-bulb-gutter": { zIndex: "201", backgroundColor: "var(--bg-editor-gutter, var(--bg-editor))" },
".cm-lsp-bulb .cm-openidea-icon": { display: "inline-flex", borderRadius: "var(--radius-small)", padding: "1px" },
".cm-lsp-bulb:hover .cm-openidea-icon": { backgroundColor: "var(--bg-toolbar-hover)" },
- ".cm-lsp-bulb-fix": { color: "var(--danger)" },
+ ".cm-lsp-bulb .cm-lsp-bulb-fix-icon, .cm-lsp-bulb-fix .cm-openidea-icon:first-child": { display: "none" },
+ ".cm-lsp-bulb-fix .cm-lsp-bulb-fix-icon": { display: "inline-flex" },
// --- inlay hints (rounded grey chips) -------------------------------------
".cm-lsp-inlay": {
diff --git a/src/editor/navigation/implementationGutter.ts b/src/editor/navigation/implementationGutter.ts
index b21bec478..a4898cbe1 100644
--- a/src/editor/navigation/implementationGutter.ts
+++ b/src/editor/navigation/implementationGutter.ts
@@ -14,7 +14,7 @@ import { RangeSet, StateEffect, StateField, type Extension, type Text } from "@c
import { EditorView, GutterMarker, ViewPlugin, gutter, type ViewUpdate } from "@codemirror/view";
import type { EditorDocContext } from "@/editor/api";
import { docOf, debounce, isUnavailable, lspRequest } from "@/editor/lsp/lsp";
-import { serverBackoff } from "@/editor/lsp/availability";
+import { onServerSettled, serverBackoff } from "@/editor/lsp/availability";
import { readManyFileLines, withDocument } from "@/editor/lsp/files";
import { locationItems, navigateTo, pinToFind } from "@/editor/lsp/navigation";
import { openPopup } from "@/editor/lsp/popupStore";
@@ -22,7 +22,6 @@ import {
commands,
isCancelled,
nextRequestId,
- onIdeEvent,
type HierarchyItem,
type Location,
type OutlineItem,
@@ -241,8 +240,7 @@ class MarkersPlugin {
if (s.settings !== prev.settings) this.refresh();
});
// Answers given while a server was starting or indexing may be incomplete.
- this.offServers = onIdeEvent("languageServer", (e) => {
- if (e.status !== "ready") return;
+ this.offServers = onServerSettled(() => {
this.invalidate();
this.refresh();
});
diff --git a/src/features/code-insight/ServerStatus.tsx b/src/features/code-insight/ServerStatus.tsx
index eb433ae5e..ab9ea7117 100644
--- a/src/features/code-insight/ServerStatus.tsx
+++ b/src/features/code-insight/ServerStatus.tsx
@@ -5,7 +5,7 @@ import { getAction, executeAction } from "@/platform/actions";
import { BarButton, Button, IconButton, Popup, T } from "@/ui";
import { downloadJdkActions } from "@/platform/jdk";
import { relativePath, useProject } from "@/platform/project";
-import { STATUS_LABEL, restartServer, serversSummary, useServers } from "./servers";
+import { STATUS_LABEL, restartServer, servedByOther, serversSummary, useServers } from "./servers";
import styles from "./ServerStatus.module.css";
import { tx } from "@/platform/i18n";
@@ -49,7 +49,10 @@ export function ServerStatus() {
return (
<div key={s.id} className={styles.server}>
<div className={styles.line}>
- <span className={clsx(styles.dot, styles[toneOf(s.status)])} aria-hidden />
+ <span
+ className={clsx(styles.dot, styles[s.status === "missing" && servedByOther(s, servers) ? "idle" : toneOf(s.status)])}
+ aria-hidden
+ />
<span className={styles.name}>{s.name}</span>
<span className={styles.status}>{STATUS_LABEL[s.status]}</span>
<span className={styles.spacer} />
diff --git a/src/features/code-insight/servers.test.ts b/src/features/code-insight/servers.test.ts
index 53ecc29f5..4ad01d45c 100644
--- a/src/features/code-insight/servers.test.ts
+++ b/src/features/code-insight/servers.test.ts
@@ -20,7 +20,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
const { emitLocalIdeEvent } = await import("@/platform/ipc");
const { useProject } = await import("@/platform/project");
-const { installServerEvents, useServers } = await import("./servers");
+const { installServerEvents, serversSummary, useServers } = await import("./servers");
describe("server status", () => {
let dispose = () => {};
@@ -40,3 +40,18 @@ describe("server status", () => {
expect(useServers.getState().servers.get(id)).toMatchObject({ status: "missing", message: "install jdtls" });
});
});
+
+describe("serversSummary", () => {
+ const entry = (id: number, name: string, status: ServerInfo["status"]) => ({
+ id: id as ServerId,
+ name,
+ status,
+ message: null,
+ languages: ["typescript"],
+ root: "/p",
+ });
+ it("doesn't flag a missing server whose languages another one serves", () => {
+ expect(serversSummary([entry(1, "vtsls", "missing"), entry(2, "typescript-language-server", "ready")])?.tone).toBe("ok");
+ expect(serversSummary([entry(1, "vtsls", "missing")])?.tone).toBe("error");
+ });
+});
diff --git a/src/features/code-insight/servers.ts b/src/features/code-insight/servers.ts
index 38f3ede09..4cbf940aa 100644
--- a/src/features/code-insight/servers.ts
+++ b/src/features/code-insight/servers.ts
@@ -129,10 +129,23 @@ export const STATUS_LABEL: Record<ServerStatus, string> = {
misconfigured: "Not started",
};
+/**
+ * A missing server whose languages another installed one serves (vtsls missing,
+ * typescript-language-server running as its fallback) is not a problem.
+ */
+export function servedByOther(server: ServerEntry, servers: readonly ServerEntry[]): boolean {
+ return (
+ server.languages.length > 0 &&
+ server.languages.every((l) => servers.some((o) => o !== server && o.status !== "missing" && o.languages.includes(l)))
+ );
+}
+
/** One-line summary for the status bar. */
export function serversSummary(servers: readonly ServerEntry[]): { text: string; tone: "ok" | "busy" | "error" | "idle" } | null {
if (!servers.length) return null;
- const bad = servers.filter((s) => s.status === "crashed" || s.status === "missing" || s.status === "misconfigured");
+ const bad = servers.filter(
+ (s) => s.status === "crashed" || s.status === "misconfigured" || (s.status === "missing" && !servedByOther(s, servers)),
+ );
const busy = servers.filter((s) => s.status === "starting" || s.status === "busy");
const tone = bad.length ? "error" : busy.length ? "busy" : servers.some((s) => s.status === "ready") ? "ok" : "idle";
const names = [...new Set(servers.map((s) => s.name))];
diff --git a/src/features/project-tree/ProjectView.tsx b/src/features/project-tree/ProjectView.tsx
index 3756fb245..69dd5c014 100644
--- a/src/features/project-tree/ProjectView.tsx
+++ b/src/features/project-tree/ProjectView.tsx
@@ -28,14 +28,17 @@ import { useEffectiveRoots } from "@/platform/projectRoots";
import { macStroke, strokeOf } from "@/platform/keymap";
import { prepareMenuGroups, useFileDecoration } from "@/workbench/contributions";
import {
+ FILES_DRAG,
HighlightedText,
Icon,
Popup,
+ dragSession,
Tree,
acquirePopup,
fileIconName,
folderIconName,
showContextMenu,
+ type DragSession,
type TreeHandle,
type TreeRowState,
} from "@/ui";
@@ -443,6 +446,8 @@ export function ProjectView() {
startY = e.clientY;
let active = false;
let paths: string[] = [];
+ // Files (not folders) can also be dropped on an editor to open them there.
+ let files: DragSession | null = null;
const move = (ev: PointerEvent) => {
if (!active) {
if (Math.hypot(ev.clientX - startX, ev.clientY - startY) < DRAG_THRESHOLD) return;
@@ -454,10 +459,14 @@ export function ProjectView() {
const nodes = keys.map((k) => m.byKey.get(k)).filter((n): n is ProjectNode => !!n && !n.root && !n.placeholder);
paths = nodes.map((n) => n.path);
if (!paths.length) return cleanup();
+ const filePaths = nodes.filter((n) => !n.dir).map((n) => n.path);
+ if (filePaths.length) files = dragSession({ type: FILES_DRAG, payload: filePaths.join("\n") });
}
const target = folderAt(containerRef.current, ev.clientX, ev.clientY);
const valid = target && !paths.some((p) => target.path === p || isInside(target.path, p));
setDropTarget(valid ? target.key : null);
+ if (target) files?.cancel();
+ else files?.move(ev.clientX, ev.clientY);
setDrag({
paths,
label: paths.length === 1 ? nameOf(paths[0]!) : tx`${paths.length} items`,
@@ -469,8 +478,11 @@ export function ProjectView() {
const up = (ev: PointerEvent) => {
const target = active ? folderAt(containerRef.current, ev.clientX, ev.clientY) : null;
const valid = target && !paths.some((p) => target.path === p || isInside(target.path, p));
+ const session = files;
+ files = null;
cleanup();
if (active && valid) void dropPaths(paths, target.path, ev.altKey);
+ else if (active && !target) session?.drop(ev.clientX, ev.clientY);
};
const key = (ev: KeyboardEvent) => {
if (ev.key === "Escape" && active) {
@@ -483,6 +495,7 @@ export function ProjectView() {
window.removeEventListener("pointermove", move);
window.removeEventListener("pointerup", up);
window.removeEventListener("keydown", key, true);
+ files?.cancel();
setDropTarget(null);
setDrag(null);
};
diff --git a/src/features/settings/appearanceRuntime.ts b/src/features/settings/appearanceRuntime.ts
index 2e79663fe..f0458947b 100644
--- a/src/features/settings/appearanceRuntime.ts
+++ b/src/features/settings/appearanceRuntime.ts
@@ -8,6 +8,7 @@
import { executeAction, type Action } from "@/platform/actions";
import { call, commands, isTauri } from "@/platform/ipc";
import { useProject } from "@/platform/project";
+import { setDragRequiresAlt } from "@/ui";
import { ZOOM_LIMITS } from "./model/behaviorSchema";
import { DEFAULT_SETTINGS, validateSettings, type ValidSettings } from "./model/schema";
@@ -126,16 +127,9 @@ export function zoomActions(): Action[] {
// ---------------------------------------------------------------------------
// Drag-and-drop with Alt pressed only (tool window buttons and editor tabs)
-const DRAG_SOURCES = "[data-stripe-button], [role='tab']";
-
export function installAltDragGuard(enabled: () => boolean): () => void {
- const onDragStart = (e: DragEvent) => {
- if (!enabled() || e.altKey) return;
- const el = e.target instanceof Element ? e.target : null;
- if (el?.closest(DRAG_SOURCES)) e.preventDefault();
- };
- document.addEventListener("dragstart", onDragStart, true);
- return () => document.removeEventListener("dragstart", onDragStart, true);
+ setDragRequiresAlt(enabled);
+ return () => setDragRequiresAlt(() => false);
}
// ---------------------------------------------------------------------------
diff --git a/src/features/vcs/CommitView.tsx b/src/features/vcs/CommitView.tsx
index e0187afb6..282d4f0d3 100644
--- a/src/features/vcs/CommitView.tsx
+++ b/src/features/vcs/CommitView.tsx
@@ -1,6 +1,6 @@
/** Commit tool window: change list with inclusion checkboxes, message, stashes. */
import { useWorkflowSettings } from "@/platform/workflowSettings";
-import { useCallback, useEffect, useMemo, useRef, useState, type DragEvent, type MouseEvent } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState, type MouseEvent, type PointerEvent } from "react";
import { tx } from "@/platform/i18n";
import clsx from "clsx";
import { executeAction } from "@/platform/actions";
@@ -18,7 +18,9 @@ import {
Tabs,
Tree,
fileIconName,
+ registerDropTarget,
showContextMenu,
+ startPointerDrag,
type MenuItem,
type TreeHandle,
T,
@@ -424,35 +426,38 @@ function ChangesPanel() {
{n.label}
</span>
);
+ // Pointer-driven (HTML5 drag and drop never reaches the Tauri webview):
+ // files and folders drag; any row takes them into its changelist.
+ const list = n.changelist;
const dnd =
- n.changelist !== undefined
- ? {
- draggable: n.type !== "group",
- onDragStart: (e: DragEvent<HTMLSpanElement>) => {
- const paths =
- selected.has(n.key) && selected.size > 1
- ? filesOf(selectedNodes()).map((f) => f.path)
- : n.files.map((f) => f.path);
- e.dataTransfer.setData(CHANGES_MIME, paths.map(stripSlash).join("\n"));
- e.dataTransfer.effectAllowed = "move";
- },
- onDragOver: (e: DragEvent<HTMLSpanElement>) => {
- if (![...e.dataTransfer.types].includes(CHANGES_MIME)) return;
- e.preventDefault();
- e.dataTransfer.dropEffect = "move";
- if (dropTarget !== n.changelist) setDropTarget(n.changelist ?? null);
- },
- onDragLeave: () => setDropTarget(null),
- onDrop: (e: DragEvent<HTMLSpanElement>) => {
- const data = e.dataTransfer.getData(CHANGES_MIME);
- setDropTarget(null);
- if (!data || !n.changelist) return;
- e.preventDefault();
- moveToChangelist(data.split("\n"), n.changelist);
- },
- onDragEnd: () => setDropTarget(null),
- }
- : {};
+ list === undefined
+ ? {}
+ : {
+ ref: (el: HTMLSpanElement | null) =>
+ el
+ ? registerDropTarget(el, {
+ accepts: (type) => type === CHANGES_MIME,
+ over: () => setDropTarget(list),
+ leave: () => setDropTarget(null),
+ drop: (data) => {
+ setDropTarget(null);
+ moveToChangelist(data.payload.split("\n"), list);
+ },
+ })
+ : undefined,
+ ...(n.type !== "group" && {
+ onPointerDown: (e: PointerEvent<HTMLSpanElement>) => {
+ const paths =
+ selected.has(n.key) && selected.size > 1
+ ? filesOf(selectedNodes()).map((f) => f.path)
+ : n.files.map((f) => f.path);
+ startPointerDrag(e, e.currentTarget, {
+ type: CHANGES_MIME,
+ payload: paths.map(stripSlash).join("\n"),
+ });
+ },
+ }),
+ };
return (
<span
className={clsx(
diff --git a/src/platform/ipc.ts b/src/platform/ipc.ts
index f9723f272..47cab688b 100644
--- a/src/platform/ipc.ts
+++ b/src/platform/ipc.ts
@@ -57,6 +57,12 @@ function ensureListening() {
});
}
+/** Resolves once backend events reach this window's handlers. */
+export async function ideEventsReady(): Promise<void> {
+ ensureListening();
+ await unlisten;
+}
+
/** Subscribes to one backend event type (or `"*"`); returns an unsubscribe function. */
export function onIdeEvent<K extends IdeEvent["type"]>(type: K | "*", handler: (event: EventOf<K>) => void): () => void {
ensureListening();
diff --git a/src/platform/keymaps/intellij-macos.ts b/src/platform/keymaps/intellij-macos.ts
index 9290b8650..41d8c1db1 100644
--- a/src/platform/keymaps/intellij-macos.ts
+++ b/src/platform/keymaps/intellij-macos.ts
@@ -82,6 +82,7 @@ export const intellijMacos: Record<string, string[]> = {
"code.quickDocumentation": ["F1", "Ctrl+J"],
"code.quickDefinition": ["Alt+Space", "Meta+Y"],
"code.showIntentions": ["Alt+Enter"],
+ "code.applyQuickFix": ["Alt+Shift+Enter"],
"code.reformat": ["Meta+Alt+L"],
"code.reformatDialog": ["Meta+Alt+Shift+L"],
"code.optimizeImports": ["Ctrl+Alt+O"],
diff --git a/src/platform/keymaps/intellij-windows.ts b/src/platform/keymaps/intellij-windows.ts
index f2ca0ee3d..341450d8f 100644
--- a/src/platform/keymaps/intellij-windows.ts
+++ b/src/platform/keymaps/intellij-windows.ts
@@ -83,6 +83,7 @@ export const intellijWindows: Record<string, string[]> = {
"code.quickDocumentation": ["Ctrl+Q"],
"code.quickDefinition": ["Ctrl+Shift+I"],
"code.showIntentions": ["Alt+Enter"],
+ "code.applyQuickFix": ["Alt+Shift+Enter"],
"code.reformat": ["Ctrl+Alt+L"],
"code.reformatDialog": ["Ctrl+Alt+Shift+L"],
"code.optimizeImports": ["Ctrl+Alt+O"],
diff --git a/src/platform/keymaps/vscode-macos.ts b/src/platform/keymaps/vscode-macos.ts
index 28a3d7dfb..f1f2b861a 100644
--- a/src/platform/keymaps/vscode-macos.ts
+++ b/src/platform/keymaps/vscode-macos.ts
@@ -83,6 +83,7 @@ export const vscodeMacos: Record<string, string[]> = {
"code.quickDocumentation": ["Meta+K Meta+I"],
"code.quickDefinition": ["Alt+F12"],
"code.showIntentions": ["Meta+."],
+ "code.applyQuickFix": [],
"code.generate": [],
"code.reformat": ["Alt+Shift+F"],
"code.reformatDialog": [],
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index d09f15885..c2ffd4185 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -3141,6 +3141,10 @@
"The file changed; rename cancelled": "文件已更改,重命名已取消",
"No suggestions": "无建议",
"No intentions available": "没有可用的意图操作",
+ "No quick fixes available": "没有可用的快速修复",
+ "No abstract methods to implement": "没有需要实现的抽象方法",
+ "Implement abstract methods": "实现抽象方法",
+ "Apply Quick Fix": "应用快速修复",
"The document changed; invoke the refactoring again": "文档已更改,请重新调用重构",
"The document changed; the name was not applied": "文档已更改,名称未应用",
"The file changed; Safe Delete cancelled": "文件已更改,安全删除已取消",
diff --git a/src/ui/Tabs.tsx b/src/ui/Tabs.tsx
index a768acf23..251eef50f 100644
--- a/src/ui/Tabs.tsx
+++ b/src/ui/Tabs.tsx
@@ -11,7 +11,6 @@ import {
useRef,
useState,
type CSSProperties,
- type DragEvent,
type KeyboardEvent,
type MouseEvent,
type ReactNode,
@@ -21,6 +20,7 @@ import { Icon, type IconName } from "./icons";
import { IconButton } from "./Button";
import { Menu, type MenuItem } from "./Menu";
import { tooltipAttrs } from "./Tooltip";
+import { registerDropTarget, startPointerDrag } from "./pointerDrag";
import { T } from "./T";
import styles from "./Tabs.module.css";
import { tx } from "@/platform/i18n";
@@ -148,37 +148,36 @@ export function Tabs({
[register],
);
- const accepts = (e: DragEvent) => !!dnd && [...e.dataTransfer.types].includes(dnd.type);
- const indexAt = (e: DragEvent) =>
- dropIndex(
- vertical ? e.clientY : e.clientX,
- items.map((it) => {
- const r = tabRefs.current.get(it.id)?.parentElement?.getBoundingClientRect();
- return vertical ? { left: r?.top ?? 0, width: r?.height ?? 0 } : { left: r?.left ?? 0, width: r?.width ?? 0 };
- }),
- );
- const dropHandlers = dnd
- ? {
- onDragOver: (e: DragEvent<HTMLDivElement>) => {
- if (!accepts(e)) return;
- e.preventDefault();
- e.dataTransfer.dropEffect = "move";
- const i = indexAt(e);
- if (i !== drop) setDrop(i);
- },
- onDragLeave: (e: DragEvent<HTMLDivElement>) => {
- if (!e.currentTarget.contains(e.relatedTarget as Node | null)) setDrop(null);
- },
- onDrop: (e: DragEvent<HTMLDivElement>) => {
- if (!accepts(e)) return;
- e.preventDefault();
- const payload = e.dataTransfer.getData(dnd.type);
- const i = indexAt(e);
- setDrop(null);
- if (payload) dnd.onDrop(payload, i);
- },
- }
- : {};
+ const stripRef = useRef<HTMLDivElement>(null);
+ // Re-read on every drag event: items and handlers change while the strip stays registered.
+ const dropState = useRef({ items, dnd, vertical });
+ useLayoutEffect(() => {
+ dropState.current = { items, dnd, vertical };
+ });
+ const dndType = dnd?.type;
+ useEffect(() => {
+ const el = stripRef.current;
+ if (!el || !dndType) return;
+ const indexAt = (x: number, y: number) => {
+ const { items, vertical } = dropState.current;
+ return dropIndex(
+ vertical ? y : x,
+ items.map((it) => {
+ const r = tabRefs.current.get(it.id)?.parentElement?.getBoundingClientRect();
+ return vertical ? { left: r?.top ?? 0, width: r?.height ?? 0 } : { left: r?.left ?? 0, width: r?.width ?? 0 };
+ }),
+ );
+ };
+ return registerDropTarget(el, {
+ accepts: (type) => type === dropState.current.dnd?.type,
+ over: (_, x, y) => setDrop(indexAt(x, y)),
+ leave: () => setDrop(null),
+ drop: (data, x, y) => {
+ setDrop(null);
+ dropState.current.dnd?.onDrop(data.payload, indexAt(x, y));
+ },
+ });
+ }, [dndType]);
useLayoutEffect(() => {
const el = scrollRef.current;
@@ -249,7 +248,7 @@ export function Tabs({
closePosition === "left" && styles.closeLeft,
className,
)}
- {...dropHandlers}
+ ref={stripRef}
>
{vertical && trailing && <div className={styles.trailing}>{trailing}</div>}
<div
@@ -279,17 +278,17 @@ export function Tabs({
item.tint && styles.tinted,
)}
style={item.tint ? ({ "--tab-tint": item.tint } as CSSProperties) : undefined}
- draggable={!!dnd}
- onDragStart={
+ onPointerDown={
dnd
? (e) => {
- e.dataTransfer.setData(dnd.type, dnd.payload(item.id));
- e.dataTransfer.effectAllowed = "move";
- setDragging(item.id);
+ if ((e.target as Element).closest("[data-tab-close]")) return;
+ startPointerDrag(e, e.currentTarget, { type: dnd.type, payload: dnd.payload(item.id) }, {
+ onStart: () => setDragging(item.id),
+ onEnd: () => setDragging(null),
+ });
}
: undefined
}
- onDragEnd={dnd ? () => (setDragging(null), setDrop(null)) : undefined}
onMouseDown={(e) => {
if (e.button === 1 && closable) {
e.preventDefault();
@@ -324,7 +323,7 @@ export function Tabs({
{item.modified && !closable && <span className={styles.modified} aria-label="Modified" />}
</button>
{closable && (
- <span className={styles.closeSlot}>
+ <span className={styles.closeSlot} data-tab-close>
{item.modified && <span className={styles.modified} aria-label="Modified" />}
<IconButton
icon="close"
diff --git a/src/ui/expui/codeInsight/quickfixBulb.svg b/src/ui/expui/codeInsight/quickfixBulb.svg
new file mode 100644
index 000000000..fab341ba4
--- /dev/null
+++ b/src/ui/expui/codeInsight/quickfixBulb.svg
@@ -0,0 +1,6 @@
+<!-- Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect x="5.70142" y="12" width="4.6" height="1" fill="#6C707E"/>
+<path d="M6 14H10C10 14.5523 9.55228 15 9 15H7C6.44772 15 6 14.5523 6 14Z" fill="#6C707E"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M10.8704 9.14748C12.0417 8.27221 12.8 6.87465 12.8 5.3C12.8 2.64903 10.6509 0.5 7.99995 0.5C5.34898 0.5 3.19995 2.64903 3.19995 5.3C3.19995 6.87464 3.95817 8.27218 5.12943 9.14746L5.49994 11H10.4999L10.8704 9.14748Z" fill="#E55765"/>
+</svg>
diff --git a/src/ui/expui/codeInsight/quickfixBulb_dark.svg b/src/ui/expui/codeInsight/quickfixBulb_dark.svg
new file mode 100644
index 000000000..58a32769c
--- /dev/null
+++ b/src/ui/expui/codeInsight/quickfixBulb_dark.svg
@@ -0,0 +1,6 @@
+<!-- Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -->
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect x="5.70142" y="12" width="4.6" height="1" fill="#CED0D6"/>
+<path d="M6 14H10C10 14.5523 9.55228 15 9 15H7C6.44772 15 6 14.5523 6 14Z" fill="#CED0D6"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M10.8704 9.14748C12.0417 8.27221 12.8 6.87465 12.8 5.3C12.8 2.64903 10.6509 0.5 7.99995 0.5C5.34898 0.5 3.19995 2.64903 3.19995 5.3C3.19995 6.87464 3.95817 8.27218 5.12943 9.14746L5.49994 11H10.4999L10.8704 9.14748Z" fill="#DB5C5C"/>
+</svg>
diff --git a/src/ui/icons.tsx b/src/ui/icons.tsx
index 0f43b3cc8..fdb5e88b3 100644
--- a/src/ui/icons.tsx
+++ b/src/ui/icons.tsx
@@ -247,6 +247,7 @@ const ICONS = {
list: "general/listFiles",
keyboard: "general/keyboard",
bulb: "codeInsight/intentionBulb",
+ "bulb-fix": "codeInsight/quickfixBulb",
package: "nodes/package",
plugin: "nodes/plugin",
"soft-wrap": "general/softWrap",
diff --git a/src/ui/index.ts b/src/ui/index.ts
index c17fd51e9..91c75f372 100644
--- a/src/ui/index.ts
+++ b/src/ui/index.ts
@@ -6,6 +6,7 @@ export * from "./Input";
export * from "./Checkbox";
export * from "./Select";
export * from "./Tabs";
+export { FILES_DRAG, dragRequiresAlt, dragSession, registerDropTarget, setDragRequiresAlt, startPointerDrag, type DragData, type DragSession, type DropTarget } from "./pointerDrag";
export * from "./Tree";
export * from "./List";
export * from "./Popup";
diff --git a/src/ui/pointerDrag.module.css b/src/ui/pointerDrag.module.css
new file mode 100644
index 000000000..afe8ecde2
--- /dev/null
+++ b/src/ui/pointerDrag.module.css
@@ -0,0 +1,19 @@
+.ghost {
+ position: fixed;
+ z-index: var(--z-tooltip);
+ margin: 0;
+ opacity: 0.85;
+ pointer-events: none;
+ box-shadow: var(--shadow-tooltip);
+ background: var(--bg-popup);
+}
+
+.noTarget {
+ opacity: 0.5;
+}
+
+.dragging,
+.dragging * {
+ cursor: grabbing !important;
+ user-select: none !important;
+}
diff --git a/src/ui/pointerDrag.ts b/src/ui/pointerDrag.ts
new file mode 100644
index 000000000..4edb0dc14
--- /dev/null
+++ b/src/ui/pointerDrag.ts
@@ -0,0 +1,156 @@
+/**
+ * Pointer-driven drag & drop between components. HTML5 drag and drop can't be
+ * used: with the window's native file drop enabled, the webview never sees
+ * dragover / drop for drags that start inside it. Sources start a drag with
+ * `startPointerDrag` (or drive a `DragSession` themselves); targets register
+ * an element with `registerDropTarget` and are told about drags over it.
+ */
+import styles from "./pointerDrag.module.css";
+
+/** What is dragged: `type` is matched by targets (e.g. `application/x-openidea-editor-tab`). */
+export interface DragData {
+ type: string;
+ payload: string;
+}
+
+/** Project files dragged from the Project view: `payload` is the paths joined by `\n`. */
+export const FILES_DRAG = "application/x-openidea-files";
+
+export interface DropTarget {
+ accepts(type: string): boolean;
+ /** The pointer moved over the target. */
+ over(data: DragData, x: number, y: number): void;
+ /** The pointer left the target, or the drag ended elsewhere / was cancelled. */
+ leave(): void;
+ drop(data: DragData, x: number, y: number): void;
+}
+
+const targets = new Map<Element, DropTarget>();
+
+export function registerDropTarget(el: Element, target: DropTarget): () => void {
+ targets.set(el, target);
+ return () => {
+ if (targets.get(el) === target) targets.delete(el);
+ };
+}
+
+/** The innermost registered target under (x, y) accepting `type`. */
+function targetAt(type: string, x: number, y: number): DropTarget | null {
+ for (let el = document.elementFromPoint(x, y); el; el = el.parentElement) {
+ const t = targets.get(el);
+ if (t?.accepts(type)) return t;
+ }
+ return null;
+}
+
+export interface DragSession {
+ /** Updates hover feedback; true when a target under (x, y) accepts the drag. */
+ move(x: number, y: number): boolean;
+ /** Drops on the target under (x, y); false when there is none. */
+ drop(x: number, y: number): boolean;
+ cancel(): void;
+}
+
+export function dragSession(data: DragData): DragSession {
+ let current: DropTarget | null = null;
+ const enter = (t: DropTarget | null) => {
+ if (t === current) return;
+ current?.leave();
+ current = t;
+ };
+ return {
+ move(x, y) {
+ enter(targetAt(data.type, x, y));
+ current?.over(data, x, y);
+ return !!current;
+ },
+ drop(x, y) {
+ const t = targetAt(data.type, x, y);
+ enter(null);
+ t?.drop(data, x, y);
+ return !!t;
+ },
+ cancel: () => enter(null),
+ };
+}
+
+/** Movement before a press becomes a drag, px. */
+const DRAG_THRESHOLD = 4;
+
+/** Settings › Appearance › "Drag-and-drop with Alt pressed only" for tabs and stripe buttons. */
+let requiresAlt = () => false;
+export function setDragRequiresAlt(fn: () => boolean) {
+ requiresAlt = fn;
+}
+export const dragRequiresAlt = () => requiresAlt();
+
+/**
+ * Starts a drag from a primary-button press on `source` once the pointer moved
+ * past the threshold; a ghost copy of `source` follows the pointer. Escape
+ * cancels. `onEnd` gets whether the drag happened (to swallow the click).
+ */
+export function startPointerDrag(
+ e: { button: number; clientX: number; clientY: number; altKey: boolean },
+ source: HTMLElement,
+ data: DragData,
+ opts: { onStart?: () => void; onEnd?: (dragged: boolean) => void } = {},
+) {
+ if (e.button !== 0 || (requiresAlt() && !e.altKey)) return;
+ const start = { x: e.clientX, y: e.clientY };
+ let ghost: HTMLElement | null = null;
+ const session = dragSession(data);
+ const onMove = (ev: PointerEvent) => {
+ if (!ghost) {
+ if (Math.hypot(ev.clientX - start.x, ev.clientY - start.y) < DRAG_THRESHOLD) return;
+ const r = source.getBoundingClientRect();
+ ghost = source.cloneNode(true) as HTMLElement;
+ ghost.removeAttribute("id");
+ ghost.querySelectorAll("[id]").forEach((n) => n.removeAttribute("id"));
+ ghost.classList.add(styles.ghost!);
+ ghost.setAttribute("aria-hidden", "true");
+ Object.assign(ghost.style, {
+ left: `${r.left}px`,
+ top: `${r.top}px`,
+ width: `${r.width}px`,
+ height: `${r.height}px`,
+ });
+ document.body.appendChild(ghost);
+ document.documentElement.classList.add(styles.dragging!);
+ opts.onStart?.();
+ }
+ ghost.style.transform = `translate(${ev.clientX - start.x}px, ${ev.clientY - start.y}px)`;
+ ghost.classList.toggle(styles.noTarget!, !session.move(ev.clientX, ev.clientY));
+ };
+ const onUp = (ev: PointerEvent) => {
+ const dragged = !!ghost;
+ cleanup();
+ if (dragged) session.drop(ev.clientX, ev.clientY);
+ opts.onEnd?.(dragged);
+ };
+ const onKey = (ev: KeyboardEvent) => {
+ if (ev.key !== "Escape" || !ghost) return;
+ ev.preventDefault();
+ ev.stopPropagation();
+ session.cancel();
+ cleanup();
+ opts.onEnd?.(true);
+ };
+ const cleanup = () => {
+ window.removeEventListener("pointermove", onMove);
+ window.removeEventListener("pointerup", onUp);
+ window.removeEventListener("pointercancel", onCancel);
+ window.removeEventListener("keydown", onKey, true);
+ ghost?.remove();
+ document.documentElement.classList.remove(styles.dragging!);
+ };
+ const onCancel = () => {
+ session.cancel();
+ const dragged = !!ghost;
+ cleanup();
+ opts.onEnd?.(dragged);
+ };
+ window.addEventListener("pointermove", onMove);
+ window.addEventListener("pointerup", onUp);
+ window.addEventListener("pointercancel", onCancel);
+ window.addEventListener("keydown", onKey, true);
+}
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index 0c67e9161..c7f25dc15 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -379,6 +379,8 @@ export interface OpenOptions {
preview?: boolean;
/** Open to the side (split right). */
side?: boolean;
+ /** Open in this editor pane, in a tab of its own even when another pane shows the file. */
+ pane?: string;
focus?: boolean;
/** Open in the text editor even when a file editor provider claims the file (SVG as text). */
asText?: boolean;
diff --git a/src/workbench/toolwindows/ToolWindows.tsx b/src/workbench/toolwindows/ToolWindows.tsx
index 63c840795..7d2b746bc 100644
--- a/src/workbench/toolwindows/ToolWindows.tsx
+++ b/src/workbench/toolwindows/ToolWindows.tsx
@@ -15,7 +15,7 @@ import { create } from "zustand";
import { call, commands } from "@/platform/ipc";
import { shortcutLabel } from "@/platform/keymap";
import { useProject } from "@/platform/project";
-import { Icon, IconButton, Menu, showContextMenu, tooltipAttrs, type MenuItem, T } from "@/ui";
+import { dragRequiresAlt, Icon, IconButton, Menu, showContextMenu, tooltipAttrs, type MenuItem, T } from "@/ui";
import { FOCUSABLE } from "@/ui/popupState";
import { TabStripRegistry } from "@/ui/Tabs";
import { useContributions, type ToolWindowAnchor, type ToolWindowContribution } from "../contributions";
@@ -303,7 +303,7 @@ function stripeDropAt(x: number, y: number): StripeDrop | null {
}
function startStripeDrag(e: PointerEvent<HTMLButtonElement>, id: string) {
- if (e.button !== 0) return;
+ if (e.button !== 0 || (dragRequiresAlt() && !e.altKey)) return;
const button = e.currentTarget;
const start = { x: e.clientX, y: e.clientY };
let ghost: HTMLElement | null = null;