Порівняти коміти

..
Автор SHA1 Повідомлення Дата
l0ng-ai e091561937 style(cucumber): format the Python step files 2026-11-21 01:22:20 +08:00
l0ng-ai 423bf2c733 fix(settings): align Code Completion case choices (#4852)
Settings > Editor > General > Code Completion shows both case-matching choices beside the Match case checkbox; the options wrap when space is limited and stay visible when disabled, so the saved choice is easy to see.
2026-11-21 01:11:23 +08:00
l0ng-ai 73d1470940 fix(settings): align Actions on Save in a table (#4848)
Settings > Tools > Actions on Save groups the three save preferences in a table: each row keeps its description with the checkbox and shows Save or Save All in the trigger column while enabled; the scope switch and the whitespace settings link stay below the table.
2026-11-21 00:57:56 +08:00
l0ng-ai c83b0b1442 fix(settings): pair postfix templates with a code preview (#4843)
Settings > Editor > General > Postfix Completion puts the template list beside a preview of the selected template, showing the typed expression and its expansion from the existing template body; in narrow panes the preview moves below the list.
2026-11-21 00:41:46 +08:00
l0ng-ai d16993e175 fix(lsp): end a cancelled server task the server never ends (#4842)
Cancelling a server-reported background task (window/workDoneProgress/cancel) left it on Cancelling for good when the server never sent end, e.g. Pyright stuck before loading its workspace. The server now gets five seconds to end the task; after that the IDE ends it and clears the server's busy state, ignoring later reports on that token.
2026-11-21 00:36:53 +08:00
l0ng-ai 5d4cdac3c7 fix(settings): align the File Colors rules table (#4839)
Settings > Editor > File Colors puts the placement switches together above the rules; a table keeps scope names aligned with their swatches and colour names, with the toolbar and headings sticky while the rules scroll. The selected rule's editor sits directly below the table, and the colour controls wrap in narrow panes so the full hex value stays visible.
2026-11-21 00:25:48 +08:00
l0ng-ai 9c414cc75c fix(settings): align Editor General controls (#4827)
Settings > Editor > General: the mouse-wheel zoom scope choices sit beneath their checkbox as radio buttons, the soft-wrap file patterns field sits beside its checkbox (wrapping underneath in a narrow pane), and Scrolling follows Virtual Space with each caret behaviour on its own line.
2026-11-21 00:10:18 +08:00
Vladislav Kuzmin 3bbc90d750 test(debugger): expect watch for explicit Quick Evaluate (#4837)
Explicit Quick Evaluate sends DAP context watch since #4801 so method calls can run; the layout e2e test now expects watch for both evaluations.

Co-authored-by: principalwater <[email protected]>

Co-authored-by: principalwater <[email protected]>
2026-11-21 00:03:02 +08:00
ntbang0901 6d157c8b71 fix(debugger): stop at an uncaught exception from a traced stream so its records stay (#4851)
When a traced stream's terminal operation threw something the program does not catch, the trace lost its records: ide-dap reads them in the stop after its stepOut, and an uncaught exception ends the thread without one. Before parking a trace whose terminal threw, the jvm-inspect bundle now adds an uncaught-only ExceptionRequest on the traced thread (unless an enabled java-debug request already stops there), so the program stops at that throw and the trace shows the records with the exception. Bundle 1.1.1; the jar was rebuilt from source and matches byte for byte.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:57:05 +08:00
l0ng-ai f2c0fcdc96 fix(settings): align Smart Keys backspace and paste controls (#4823)
Settings > Editor > General > Smart Keys places the Backspace and paste formatting controls directly below the Enter options; the two controls share a label column and the paste escaping option sits below the formatting control.
2026-11-20 23:54:10 +08:00
ntbang0901 a4574fdc92 fix(debugger): show toString() of Java values instead of a nameless child row (#4857)
Java values whose class overrides toString() showed without their text, and opening them showed one nameless row with the fields a level deeper. java-debug marks these values with DAP presentationHint.lazy and the IDE ignored it. Variables now carry lazy; debug_resolve_variable merges the adapter's single inner variable into the row; debugger configs can declare resolve-lazy-variables (on for java-debug) so variables/evaluate return resolved values; other adapters resolve a lazy row in place when it is opened or its (...) marker is clicked.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:53:34 +08:00
ntbang0901 4bc87f5d84 fix(debugger): stay suspended on a thread its breakpoint still holds after another resumes (#4858)
Java debugging suspends only the thread that hits a breakpoint, but the Debug window tracked one stopped thread: after resuming it, the window showed Running with Resume and Step disabled while another thread was still stopped. The session now tracks every thread stopped alone (stopped adds, continued removes) and moves to a remaining stopped thread when the shown one continues; steps report all_threads_continued false since they run only their thread.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:50:14 +08:00
ntbang0901 39671ff55b fix(vcs): merge and rebase branches by their short name (#4850)
Merging a branch from the Branches popup recorded "Merge branch 'refs/heads/feature'" (and the rebase reflog "checkout refs/heads/feature") because the popup passes the full ref to avoid tags of the same name. Merge and rebase now pass the short name when it resolves to that same branch, and keep the full ref when a tag shares the name.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:47:32 +08:00
ntbang0901 881812547d fix(vcs): open the Conflicts dialog when an unstash stops on conflicts (#4849)
Applying or popping a stash that conflicts with the working tree showed an error balloon instead of the conflict resolver. unstash() was the only operation that can stop on conflicts without the conflict handler; it now uses conflictsInstead like merge, rebase and unshelve, so the Conflicts dialog opens. Other unstash failures still report the error.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:46:47 +08:00
ntbang0901 9c145ea258 fix(run): run a Gradle subproject's tests with that subproject's test task (#4846)
In a Gradle multi-project build, gutter class/method runs, Run on a test file and JUnit configurations used the build's plain test task, so --tests filtered every subproject and the first one without a match failed the build before the subproject holding the test ran. They now share inGradleModule (the lookup directory runs already used) and run :<subproject>:test --tests ...; reruns and test-tree selections inherit that task.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:45:45 +08:00
ntbang0901 4f192a12bc fix(run): let Maven reactor modules without the selected tests pass in every test run (#4845)
In a Maven multi-module project, Rerun Failed Tests and Run on a test file failed before the selected tests ran: -Dtest reached the first module without a matching test and Surefire stopped the build, skipping the module with the test. Those two paths built -Dtest themselves without -Dsurefire.failIfNoSpecifiedTests=false; every Maven test selection now goes through withMavenTests, which replaces an earlier -Dtest and always adds the flag.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:44:02 +08:00
ntbang0901 1d857375dc fix(vcs): open a multi-line selection's lines on the Git remote from Open In (#4844)
Editor > Open In > GitHub / GitLab / Bitbucket opened only the caret line even with several lines selected. The editor menu passed the caret line only and vcs.openOnRemote dropped endLine; the menu now takes its lines from the helper Copy Path/Reference uses (moved to selectedLines.ts) and Open In keeps endLine.

Co-authored-by: ntbang0901 <[email protected]>

Co-authored-by: ntbang0901 <[email protected]>
2026-11-20 23:43:20 +08:00
Vladislav Kuzmin 6543cdb36b test(debugger): expect unquoted strings in the value dialog (#4836)
The full-value dialog shows a string without its adapter quotes; the debugger layout e2e test now asserts the unquoted text there and keeps the quoted value in the Variables row.

Co-authored-by: principalwater <[email protected]>

Co-authored-by: principalwater <[email protected]>
2026-11-20 23:42:46 +08:00
Vladislav Kuzmin 684c92ce90 test(settings): target the exact font preview textbox (#4833)
The font-family e2e test matched both the editable preview and its resize handle through a substring label lookup; it now targets the textbox by its exact accessible name.

Co-authored-by: principalwater <[email protected]>

Co-authored-by: principalwater <[email protected]>
2026-11-20 23:42:38 +08:00
l0ng-ai 9a77a95180 feat(cucumber): behave and pytest-bdd step definitions in Python (#4859)
Python step definitions for Gherkin: behave decorators with its parse / cfparse / re matchers (use_step_matcher switches them), and pytest-bdd's exact strings and parsers.parse / cfparse / re. Covers navigation both ways, the Undefined step check and Create step definition (pending step_impl for behave, def _() for pytest-bdd, decorator added to the existing import). The backend scan reads .py files with a step decorator and skips site-packages.
2026-11-20 23:41:43 +08:00
l0ng-ai 1000ef0fa0 fix(editor): align code folding controls and arrow visibility (#4820)
Settings > Editor > General > Code Folding puts the outline visibility next to Show code folding outline (On hover / Always, new editor setting folding.outlineVisibility, default On hover) and lists the Fold by default options in one column. With Always, open fold arrows stay visible without hovering the gutter.
2026-11-20 23:40:32 +08:00
l0ng-ai 654da3e1ef feat(editor): spinner in progress hints (#4854)
Pending editor hints (Finding navigation target and other progress hints) start with the ring spinner used elsewhere in the UI; final hints are unchanged.
2026-11-20 23:21:16 +08:00
l0ng-ai ba6ccaf9b2 feat(vcs): option to open diffs in a separate window (#4853)
Adds Settings > Version Control > Confirmation > Open diff as editor tab (default on, client-side workflow setting vcs.diffAsEditorTab). When off, diffs opened from the Commit tool window, history, log and Compare show in a separate Diff window; combined multi-file diffs still open as a tab.
2026-11-20 23:17:37 +08:00
l0ng-ai 3ec631f0c0 fix(settings): pair inlay hint categories with a preview (#4815)
Settings › Editor › Inlay Hints lists the hint categories beside the selected category's toggle and a preview that uses the editor font and shows or hides the sample hint, instead of nested checkboxes. Searching selects the matching category.
2026-11-20 22:48:54 +08:00
Bert Verhelstтаbertyhell f64796607c fix(linux): keep selections while a dead key is pending on Wayland with IBus (#4830)
On Linux Wayland with IBus, a pending dead key made WebKitGTK collapse every new selection in the window (Select All, mouse drags, text fields) through GTK's compositor input method (text-input-v3). Startup now selects GTK's own IBus module (GTK_IM_MODULE=ibus) on a Wayland session whose input method is IBus, unless GTK_IM_MODULE is already set or ibus-gtk3 isn't installed.

Co-authored-by: bertyhell <[email protected]>
2026-11-20 22:45:56 +08:00
Shohruh Ismoilovтаshohruh-genius 5baaf5b7de fix(vcs): keep recent commits visible in workspace Git Log (#4826)
With Incoming Commits First, an older branch at the front of one repository's history could push that repository's latest commits out of the first page of a workspace Git Log. Each row now carries the newest commit time at or after it (logMergeTimeMs), and the multi-repository merge ranks by it, so recent commits stay visible while each repository keeps its selected order.

Co-authored-by: shohruh-genius <[email protected]>
2026-11-20 22:43:30 +08:00
faysouтаfaysou 95f88f6ffb fix(vcs): clarify Project tree Git indicators (#4818)
The Project tree's Git suffix shows the branch, then the incoming / outgoing commit counts, then the working-tree state after a slash: ∅ when no files changed (also when the branch is ahead or behind), else the changed-file count with Δ. The color scheme preview shows the same markers. The changed-files tooltip keeps its text-catalog key.

Co-authored-by: faysou <[email protected]>
2026-11-20 22:40:29 +08:00
Bert Verhelstтаbertyhell 06b7c3a826 feat(keymap): find actions by typing their shortcut in the search field (#4817)
The Keymap search field also matches typed shortcut text: ctrl+shift+n, Shift+Ctrl+N, ctrl shift n, cmd+shift+o and ⇧⌘O all work, with aliases such as control, cmd, option and esc. Modifiers alone list every shortcut holding them; once a key is typed the modifiers must match exactly, and chords match stroke by stroke. Plain words still search action names only.

Co-authored-by: bertyhell <[email protected]>
2026-11-20 22:40:19 +08:00
Vladislav Kuzmin e9335f032d fix(database): support strict read-only ClickHouse without affinity (#4788)
A strict read-only ClickHouse account rejects the driver's per-request result settings (code 164), so stateless sources behind a load balancer could not connect. With use_http_session=false and Read-only enabled, the connection check is repeated without the driver's result-limit and number-format settings; every request still sends readonly=1, the client-side write guard stays on, the grid keeps only the requested rows, and KILL QUERY also carries readonly=1.

Closes #4783

Co-authored-by: principalwater <[email protected]>
2026-11-20 22:36:23 +08:00
Vladislav Kuzmin d09fdc8c7e fix(database): clarify the JDBC cancellation timeout (#4749)
When a JDBC statement misses the cancellation deadline the session is closed; the error now says to check the statement's status on the server before running it again and that the next query reconnects on its own, instead of asking for a manual reconnect.

Closes #4742

Co-authored-by: principalwater <[email protected]>
2026-11-20 22:35:52 +08:00
l0ng-ai 54e69973c8 fix(settings): fit notification group controls in the settings pane (#4810)
Settings › Appearance & Behavior › Notifications shows the notification groups as a list beside the selected group's popup type and tool window option instead of a wide table, and stacks them in a narrow settings pane. Searching selects the matching group.
2026-11-20 22:32:08 +08:00
l0ng-ai 91d37aa4bf fix(templates): fit File and Code Templates in narrow settings (#4805)
Settings › Editor › File and Code Templates uses the shared compact tabs and a resizable list / editor split that keeps the editor usable in narrow settings windows.
2026-11-20 22:30:34 +08:00
l0ng-ai e149ba2ab3 fix(editor): keep completion aligned on first paint (#4797)
The completion list could paint one icon column right of the caret and then jump into place. The editor now positions it before the first paint, also when local suggestions arrive while a language server is still responding, and repositions it in the same frame when its size changes.
2026-11-20 22:28:14 +08:00
l0ng-ai fc6de7d0e4 fix(lsp): send language servers their configuration once initialized (#4831)
Pyright, given a client with workspace folders, asks for its configuration and loads the workspace only after workspace/didChangeConfiguration. The notification was sent only when a server had user settings, so Pyright stayed idle and navigation, references and diagnostics never answered. Send it to every server after initialized.
2026-11-20 22:27:10 +08:00
l0ng-ai 76ef8c9b05 fix(templates): stack the Live Templates list and editor (#4802)
Settings › Editor › Live Templates stacks the template list above the editor in a resizable split, puts Abbreviation and Description on one row (stacked in narrow settings), labels the template text, and keeps the variables table within the pane.
2026-11-20 22:25:10 +08:00
l0ng-ai 0344553652 fix(refactor): align the Safe Delete dialogs (#4800)
The Safe Delete confirmation and the Usages Detected question use the form layout: the usage count as a heading, the detail below it, and no question icon.
2026-11-20 22:19:48 +08:00
l0ng-ai cf15013b49 fix(templates): align and scroll the Surround With menu (#4796)
Surround With gets a separate shortcut column and uses the UI font for action labels. The list scrolls within the space beside the caret, and the title stays visible while the keyboard moves through it.
2026-11-20 22:18:11 +08:00
l0ng-ai eb985cda28 fix(project-view): keep the tree from scrolling sideways while dragging (#4828)
WebKit autoscrolls the pressed tree toward a pointer right of it, so dragging a file to the editor, terminal or out of the window scrolled long rows out of view. The drag now holds the horizontal scroll position for its whole length, as it already held the vertical one outside the tree.
2026-11-20 22:12:42 +08:00
Bert Verhelstтаbertyhell 212ee03d71 feat(project-view): drag files out to other apps (#4245)
When a drag from the Project view leaves the window it becomes an OS file drag (copy only) of the selected local files and folders: AppKit dragging session on macOS, OLE CF_HDROP on Windows, GTK on Linux, in the new ide-drag-out crate behind the window_drag_files command. A drop back on the window itself is ignored, and remote projects keep the in-window drag only.

Closes #2867

Co-authored-by: bertyhell <[email protected]>
2026-11-20 22:10:02 +08:00
l0ng-ai b721fe09db fix(debugger): drop grandchild sessions and overwrite progress lines (#4825)
Removing a debug session dropped only its direct children, so js-debug's grandchild sessions (pnpm run dev -> pnpm.cjs -> rspack.js) were orphaned and piled up with every rerun; a session now goes with all its descendants. The debug console also appended text after a carriage return instead of replacing the line; as in the Run console, a carriage return or erase-line now makes the next text replace it, so progress bars update in place.
2026-11-20 21:57:09 +08:00
l0ng-ai 6ffb4c22f0 fix(editor): keep syntax highlighting after reformatting JavaScript (#4822)
Re-parsing after an edit could reuse a whole doc comment (a skipped node) from the old tree. @lezer/lr's Stack.useNode then moved reducePos past it and storeNode didn't move reused skipped nodes out of the node being reduced, so the declaration before the comment swallowed the rest of the file and highlighting vanished until the next edit. A pnpm patch for @lezer/lr fixes both; a regression test compares the incremental tree with a fresh parse.
2026-11-20 21:50:50 +08:00
l0ng-ai dc38b0b081 fix(vcs): stop Git Log panes flashing a scrollbar while resizing (#4821)
The split panels' own overflow: auto showed a native scrollbar whenever a fractional panel height left 1px of rounding overflow, so it flickered while the tool window was dragged. The log's panes scroll themselves; their panels now clip instead.
2026-11-20 21:45:39 +08:00
l0ng-ai 3cbc9d7f75 perf(index,vcs): cut backend memory after indexing large folders (#4814)
Opening a folder with many large Git repositories kept the backend at about 2.2 GB after indexing. redb's page caches (1 GiB default per database) are capped at 64 MiB for the symbol index and 32 MiB per repository commit log, and after a full scan the backend returns freed heap pages to the OS (malloc_zone_pressure_relief on macOS, malloc_trim on glibc). On 16 repositories / 152k files the footprint after a cold index dropped from 2226 MB to 1078 MB with unchanged index and log query times.
2026-11-20 21:02:17 +08:00
l0ng-ai 2ec2a6c262 feat(run): insert path macros into a run configuration's working directory (#4816)
A + button next to the working directory field lists the supported path macros ($USER_HOME$ only on a local project) and inserts the chosen one at the caret.
2026-11-20 20:50:49 +08:00
C3B6 11dca3ab42 feat(agents): check and update local npm CLI installs (#4778)
A built-in agent's settings page can check its global npm installation for a newer release and update it. The backend (ide-agent cli_update) runs npm prefix/view/install as cancellable requests, and only touches the installation the launcher actually runs: the executable must be the npm-generated link of that exact package, the prefix must be writable, and the install verifies the version afterwards. Native installs and pre-release channels are left to their own installers.

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-20 20:43:50 +08:00
faysouтаfaysou f9044dcc00 fix(markdown): scope the split divider cursor (#4811)
The splitter library applied a document-wide resize cursor while the pointer was near the divider, so it showed over the source editor's scrollbar. The Markdown split now keeps the divider's own hover cursor and shows the resize cursor only inside the split while dragging.

Co-authored-by: faysou <[email protected]>
2026-11-20 20:38:01 +08:00
l0ng-ai a7d7293b2f feat(run): expand path macros in a run configuration's working directory (#4813)
A run configuration's working directory may use $PROJECT_DIR$, $ContentRoot$, $MODULE_DIR$, $MODULE_WORKING_DIR$ and $USER_HOME$, expanded when it runs or is debugged; the stored value keeps them. An unknown macro, or one without a value in a remote project, stops the start with a notification naming it.
2026-11-20 20:35:24 +08:00
faysouтаfaysou a5280c50f7 feat(vcs): show changed file counts for repos and folders (#4806)
The Changes tree showed a file count only on change-list groups. Repository and directory rows now show how many changed files they hold, subdirectories included; repository rows keep the branch after the count.

Co-authored-by: faysou <[email protected]>
2026-11-20 20:23:47 +08:00
l0ng-ai dd0578979a feat(spelling): load custom Hunspell dictionaries with their affix rules (#4808)
Custom .dic files were read as flat word lists, dropping /FLAGS and ignoring the .aff beside them, so inflected forms and compounds were flagged and suggestions were English only. A .dic with a sibling .aff now loads as a full Hunspell dictionary, and suggestions merge the English and custom Hunspell dictionaries.
2026-11-20 20:22:23 +08:00
l0ng-ai e96b0483ac feat(go): show the values of constants as inlay hints (#4807)
gopls computes constant values, iota sequences included, but reports them as inlay hints only with its constantValues hint on; the Go language definition now enables it.
2026-11-20 20:16:41 +08:00
Yann 608b292510 fix(agents): keep context menus from switching conversations (#4804)
Right-clicking another task in Agents selected it through the same callback that opens conversations, replacing the current chat or file. Tree now marks context-menu selections (right-click, and Control-click on macOS) so the Agents view updates the menu target without navigating; ordinary clicks, keyboard activation and multi-selection are unchanged.

Co-authored-by: YannABC <[email protected]>
2026-11-20 20:02:25 +08:00
l0ng-ai dd6d83fd2c feat(services): show the debugger of a service in the Services tool window (#4803)
Debugging from Services showed only the console in the detail pane and the first breakpoint switched to the Debug tool window. The detail pane of a configuration being debugged now shows the whole debugger for that session (an attached run's console stays its Console tab), and a session started in place from Services reveals Services on a stop and reruns in place.
2026-11-20 20:01:08 +08:00
205 змінених файлів з 7335 додано та 1211 видалено

No files matched your search

Створено
+17
Переглянути файл
@@ -4156,6 +4156,8 @@ dependencies = [
"ide-vcs",
"ide-vfs",
"parking_lot",
"rustix",
"semver",
"serde",
"serde_json",
"specta",
@@ -4357,6 +4359,20 @@ dependencies = [
"which",
]
[[package]]
name = "ide-drag-out"
version = "0.1.49"
dependencies = [
"gtk",
"objc2 0.6.5",
"objc2-app-kit 0.3.2",
"objc2-foundation 0.3.2",
"raw-window-handle",
"tempfile",
"windows",
"windows-core",
]
[[package]]
name = "ide-extension"
version = "0.1.49"
@@ -6698,6 +6714,7 @@ dependencies = [
"ide-dap",
"ide-db",
"ide-docker",
"ide-drag-out",
"ide-extension",
"ide-fonts",
"ide-github",
+1
Переглянути файл
@@ -38,6 +38,7 @@ ide-web = { path = "crates/ide-web" }
ide-spell = { path = "crates/ide-spell" }
ide-agent = { path = "crates/ide-agent" }
ide-clipboard = { path = "crates/ide-clipboard" }
ide-drag-out = { path = "crates/ide-drag-out" }
ide-fonts = { path = "crates/ide-fonts" }
ide-ssh = { path = "crates/ide-ssh" }
ide-remote = { path = "crates/ide-remote" }
+4
Переглянути файл
@@ -25,6 +25,10 @@ dunce.workspace = true
uuid.workspace = true
tempfile.workspace = true
which = "8"
semver = "1"
[target.'cfg(unix)'.dependencies]
rustix = { version = "1", features = ["fs"] }
[dev-dependencies]
tokio = { workspace = true, features = ["test-util"] }
+395
Переглянути файл
@@ -0,0 +1,395 @@
//! Checks and updates only the global npm installation selected by the agent launcher.
use crate::{AgentManager, AgentSource, provider};
use ide_core::{CancellationToken, IdeError, IdeResult, error::ErrorKind};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::{
fs, io,
path::{Path, PathBuf},
process::Command,
};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
pub struct AgentCliOffer {
pub current: String,
pub latest: String,
pub prefix: PathBuf,
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "status", rename_all = "camelCase")]
pub enum AgentCliUpdateResult {
Available(AgentCliOffer),
Permission(AgentCliOffer),
Current { current: String },
Channel { current: String },
Updated { current: String },
Unmanaged,
Error { code: String },
}
pub(crate) fn package(id: &str) -> Option<&'static str> {
Some(match id {
"claude" => "@anthropic-ai/claude-code",
"codex" => "@openai/codex",
"gemini" => "@google/gemini-cli",
"opencode" => "opencode-ai",
"copilot" => "@github/copilot",
"qwen" => "@qwen-code/qwen-code",
"auggie" => "@augmentcode/auggie",
"qoder" => "@qoder-ai/qodercli",
"omp" => "@oh-my-pi/pi-coding-agent",
_ => return None,
})
}
impl AgentManager {
pub fn cli_update(
&self,
id: &str,
offer: Option<&AgentCliOffer>,
cancel: &CancellationToken,
) -> IdeResult<AgentCliUpdateResult> {
let spec = self.shared.spec(id).ok_or_else(|| IdeError::invalid(format!("unknown agent {id}")))?;
let (Some(pkg), Some(builtin)) = (package(id), provider::builtin_spec(id)) else {
return Ok(AgentCliUpdateResult::Unmanaged);
};
if spec.source != AgentSource::Builtin {
return Ok(AgentCliUpdateResult::Unmanaged);
}
let Ok(npm) = which::which("npm") else { return Ok(AgentCliUpdateResult::Unmanaged) };
let program = spec.resolve_for_launch(&self.shared.paths.project_root).command;
match maintain(&npm, Path::new(&program), &builtin.command, pkg, offer, cancel) {
Err(e) if e.kind == ErrorKind::Unavailable => Ok(AgentCliUpdateResult::Error { code: e.message }),
result => result,
}
}
}
struct Installation {
modules: PathBuf,
folder: PathBuf,
link: PathBuf,
}
impl Installation {
fn at(prefix: &Path, pkg: &str, bin: &str) -> Self {
let modules = prefix.join(if cfg!(windows) { "node_modules" } else { "lib/node_modules" });
let link = if cfg!(windows) { prefix.join(format!("{bin}.cmd")) } else { prefix.join("bin").join(bin) };
Self { folder: modules.join(pkg), modules, link }
}
fn version(&self, program: &Path, pkg: &str, bin: &str) -> IdeResult<Option<String>> {
if !program.is_absolute() || !self.folder.try_exists()? || !self.link.try_exists()? || !program.try_exists()? {
return Ok(None);
}
let folder = dunce::canonicalize(&self.folder)?;
if fs::symlink_metadata(&self.folder)?.is_symlink()
|| dunce::canonicalize(program)? != dunce::canonicalize(&self.link)?
{
return Ok(None);
}
let manifest = self.folder.join("package.json");
if !manifest.try_exists()? {
return Ok(None);
}
let manifest: Value = serde_json::from_slice(&fs::read(manifest)?)
.map_err(|_| IdeError::invalid("Invalid npm package manifest"))?;
let entry = manifest["bin"].as_str().or_else(|| manifest["bin"][bin].as_str());
let Some(entry) = entry.filter(|_| manifest["name"] == pkg) else { return Ok(None) };
let Some(version) = manifest["version"].as_str() else {
return Err(IdeError::invalid("Missing npm package version"));
};
let entry = folder.join(entry);
if !entry.try_exists()? {
return Ok(None);
}
let entry = dunce::canonicalize(entry)?;
if !entry.starts_with(&folder) {
return Ok(None);
}
#[cfg(unix)]
let owns = fs::symlink_metadata(&self.link)?.is_symlink() && dunce::canonicalize(&self.link)? == entry;
#[cfg(windows)]
let owns = {
let prefix = dunce::canonicalize(self.link.parent().unwrap())?;
let Ok(target) = entry.strip_prefix(prefix) else { return Ok(None) };
let needle = format!("%dp0%\\{}\"", target.display()).to_lowercase();
fs::read_to_string(&self.link)?.replace('/', "\\").to_lowercase().contains(&needle)
};
Ok(owns.then(|| version.to_owned()))
}
fn writable(&self) -> io::Result<bool> {
for dir in [&*self.folder, self.folder.parent().unwrap(), &self.modules, self.link.parent().unwrap()] {
#[cfg(unix)]
let access: io::Result<()> =
rustix::fs::accessat(rustix::fs::CWD, dir, rustix::fs::Access::WRITE_OK, rustix::fs::AtFlags::empty())
.map_err(Into::into);
#[cfg(windows)]
let access = tempfile::tempfile_in(dir).map(drop);
match access {
Err(e) if matches!(e.kind(), io::ErrorKind::PermissionDenied | io::ErrorKind::ReadOnlyFilesystem) => {
return Ok(false);
}
other => other?,
}
}
Ok(true)
}
}
fn stable(version: &str) -> Option<semver::Version> {
semver::Version::parse(version).ok().filter(|v| v.pre.is_empty() && v.build.is_empty())
}
fn maintain(
npm: &Path,
program: &Path,
bin: &str,
pkg: &str,
approved: Option<&AgentCliOffer>,
cancel: &CancellationToken,
) -> IdeResult<AgentCliUpdateResult> {
use AgentCliUpdateResult::*;
let run = |args: &[&str]| {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
let mut cmd = Command::new(npm);
cmd.args(args)
.current_dir(npm.parent().unwrap())
.env("NPM_CONFIG_UPDATE_NOTIFIER", "false")
.env("NPM_CONFIG_LOGLEVEL", "error");
ide_tools::run_streamed(cmd, cancel, &|_| {}).map_err(|e| {
if e.kind == ErrorKind::Cancelled {
return e;
}
// npm diagnostics can contain private registry URLs; expose only known codes.
let code = e
.message
.split(|c: char| !c.is_ascii_alphanumeric() && c != '_')
.find(|w| {
matches!(
*w,
"EACCES"
| "EPERM"
| "EROFS"
| "ENOTFOUND"
| "EAI_AGAIN"
| "ETIMEDOUT"
| "E404"
| "E401"
| "E403"
)
})
.unwrap_or("npm");
IdeError::unavailable(code)
})
};
let output = run(&["prefix", "-g"])?;
let prefix = Path::new(output.trim_end());
if !prefix.is_absolute() {
return Err(IdeError::invalid("Invalid npm global prefix"));
}
let installation = Installation::at(prefix, pkg, bin);
let Some(current) = installation.version(program, pkg, bin)? else { return Ok(Unmanaged) };
let latest: String = serde_json::from_str(&run(&["view", &format!("{pkg}@latest"), "version", "--json"])?)
.map_err(|_| IdeError::invalid("Invalid npm version response"))?;
let (Some(before), Some(after)) = (stable(&current), stable(&latest)) else {
return Ok(Channel { current });
};
if before >= after {
return Ok(Current { current });
}
let offer = AgentCliOffer { current, latest, prefix: prefix.to_owned() };
if !installation.writable()? {
return Ok(Permission(offer));
}
if approved != Some(&offer) {
return Ok(Available(offer));
}
run(&[
"install",
"-g",
"--prefix",
prefix.to_str().unwrap(),
"--no-audit",
"--no-fund",
&format!("{pkg}@{}", offer.latest),
])?;
if installation.version(program, pkg, bin)?.as_ref() != Some(&offer.latest) {
return Err(IdeError::invalid("npm installation verification failed"));
}
Ok(Updated { current: offer.latest })
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use tempfile::TempDir;
const PKG: &str = "@anthropic-ai/claude-code";
struct Fixture {
root: TempDir,
install: Installation,
}
impl Fixture {
fn new() -> Self {
let root = tempfile::Builder::new().prefix("全局 prefix ").tempdir().unwrap();
let install = Installation::at(root.path(), PKG, "claude");
fs::create_dir_all(&install.folder).unwrap();
fs::create_dir_all(install.link.parent().unwrap()).unwrap();
fs::write(install.folder.join("entry.js"), "").unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(install.folder.join("entry.js"), &install.link).unwrap();
#[cfg(windows)]
fs::write(&install.link, r#"@"%dp0%\node_modules\@anthropic-ai\claude-code\entry.js""#).unwrap();
let fixture = Self { root, install };
fixture.manifest(PKG, "2.1.9");
fixture
}
fn manifest(&self, name: &str, version: &str) {
fs::write(
self.install.folder.join("package.json"),
json!({"name":name,"version":version,"bin":{"claude":"entry.js"}}).to_string(),
)
.unwrap();
}
fn version(&self) -> Option<String> {
self.install.version(&self.install.link, PKG, "claude").unwrap()
}
#[cfg(unix)]
fn npm(&self, script: &str) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = self.root.path().join("npm");
fs::write(&path, format!("#!/bin/sh\nset -eu\n{script}\n")).unwrap();
fs::set_permissions(&path, fs::Permissions::from_mode(0o755)).unwrap();
path
}
}
#[test]
fn requires_the_selected_install_and_its_exact_package_entry() {
let f = Fixture::new();
assert_eq!(f.version().as_deref(), Some("2.1.9"));
let other = f.root.path().join("other");
fs::write(&other, "").unwrap();
assert_eq!(f.install.version(&other, PKG, "claude").unwrap(), None);
f.manifest("other-package", "2.1.9");
assert_eq!(f.version(), None);
f.manifest(PKG, "2.1.9");
fs::remove_file(&f.install.link).unwrap();
#[cfg(unix)]
std::os::unix::fs::symlink(&other, &f.install.link).unwrap();
#[cfg(windows)]
fs::write(&f.install.link, r#"@"%dp0%\other""#).unwrap();
assert_eq!(f.version(), None);
}
#[cfg(unix)]
const NPM: &str = r#"case "$1" in
prefix) pwd -P ;;
view) cat latest ;;
install)
test "$2" = "-g" && test "$3" = "--prefix" && test "$4" = "$(pwd -P)"
test "$7" = "@anthropic-ai/[email protected]"
cp updated.json "$4/lib/node_modules/@anthropic-ai/claude-code/package.json"
touch installed ;;
*) exit 2 ;;
esac"#;
#[cfg(unix)]
#[test]
fn installs_only_the_confirmed_offer_and_rechecks_ownership() {
use AgentCliUpdateResult::*;
let f = Fixture::new();
let npm = f.npm(NPM);
let cancel = CancellationToken::new();
let run =
|offer: Option<&AgentCliOffer>| maintain(&npm, &f.install.link, "claude", PKG, offer, &cancel).unwrap();
let latest = f.root.path().join("latest");
fs::write(&latest, r#""2.1.12""#).unwrap();
let Available(offer) = run(None) else { panic!("expected an offer") };
for different in [
AgentCliOffer { prefix: PathBuf::from("/other"), ..offer.clone() },
AgentCliOffer { current: "2.0.0".into(), ..offer.clone() },
] {
assert_eq!(run(Some(&different)), Available(offer.clone()));
}
fs::write(&latest, r#""2.2.0""#).unwrap();
assert!(matches!(run(Some(&offer)), Available(new) if new.latest == "2.2.0"));
fs::write(&latest, r#""2.0.0""#).unwrap();
assert!(matches!(run(Some(&offer)), Current { .. }));
fs::write(&latest, r#""2.2.0-beta.1""#).unwrap();
assert!(matches!(run(Some(&offer)), Channel { .. }));
fs::write(&latest, r#""2.1.12""#).unwrap();
f.manifest("other-package", "2.1.9");
assert_eq!(run(Some(&offer)), Unmanaged);
assert!(!f.root.path().join("installed").exists());
f.manifest(PKG, "2.1.12");
fs::copy(f.install.folder.join("package.json"), f.root.path().join("updated.json")).unwrap();
f.manifest(PKG, "2.1.9");
assert_eq!(run(Some(&offer)), Updated { current: "2.1.12".into() });
assert!(f.root.path().join("installed").exists());
assert_eq!(run(None), Current { current: "2.1.12".into() });
}
#[cfg(unix)]
#[test]
fn permission_failure_never_starts_an_install() {
use std::os::unix::fs::PermissionsExt;
let f = Fixture::new();
let npm = f.npm(NPM);
fs::write(f.root.path().join("latest"), r#""2.1.12""#).unwrap();
let run = |offer: Option<&AgentCliOffer>| {
maintain(&npm, &f.install.link, "claude", PKG, offer, &CancellationToken::new()).unwrap()
};
let AgentCliUpdateResult::Available(offer) = run(None) else { panic!("expected an offer") };
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o555)).unwrap();
// root can write even when no mode bit grants write permission.
if tempfile::tempfile_in(&f.install.folder).is_err() {
assert_eq!(run(Some(&offer)), AgentCliUpdateResult::Permission(offer));
}
fs::set_permissions(&f.install.folder, fs::Permissions::from_mode(0o755)).unwrap();
assert!(!f.root.path().join("installed").exists());
}
#[cfg(unix)]
#[test]
fn cancellation_stops_a_running_npm_process() {
use std::time::{Duration, Instant};
let f = Fixture::new();
let npm = f.npm(
r#"case "$1" in
prefix) pwd -P ;;
view) echo '"2.1.12"' ;;
install) touch started; exec sleep 30 ;;
esac"#,
);
let cancel = CancellationToken::new();
let AgentCliUpdateResult::Available(offer) =
maintain(&npm, &f.install.link, "claude", PKG, None, &cancel).unwrap()
else {
panic!("expected an offer")
};
let started = f.root.path().join("started");
std::thread::scope(|s| {
let op = s.spawn(|| maintain(&npm, &f.install.link, "claude", PKG, Some(&offer), &cancel));
let deadline = Instant::now() + Duration::from_secs(5);
while !started.exists() && Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
cancel.cancel();
assert!(started.exists());
assert_eq!(op.join().unwrap().unwrap_err().kind, ErrorKind::Cancelled);
});
assert_eq!(f.version().as_deref(), Some("2.1.9"));
}
}
+2
Переглянути файл
@@ -10,6 +10,7 @@
mod acp;
mod async_questions;
mod catalogs;
mod cli_update;
mod config;
mod conversation;
mod elicitation;
@@ -27,6 +28,7 @@ mod timeline;
mod worktree;
pub use catalogs::AgentCatalogs;
pub use cli_update::{AgentCliOffer, AgentCliUpdateResult};
pub use external::ExternalSession;
pub use model::*;
+3
Переглянути файл
@@ -614,6 +614,9 @@ pub struct AgentProvider {
pub command_read_only_reason: Option<AgentCommandReadOnlyReason>,
/// Whether the command was found (on `PATH`).
pub installed: bool,
/// The built-in command can be owned by a global npm package.
#[serde(default)]
pub can_check_cli_update: bool,
/// Environment variables it starts with (from its agent file).
pub env: BTreeMap<String, String>,
/// Settings (models, modes…) the agent offered last time it ran; empty before its first session.
+1
Переглянути файл
@@ -373,6 +373,7 @@ pub(crate) fn describe(spec: &ProviderSpec) -> AgentProvider {
command_editable: reason.is_none(),
command_read_only_reason: reason,
installed: installed(&spec.command),
can_check_cli_update: spec.source == AgentSource::Builtin && crate::cli_update::package(&spec.id).is_some(),
env: spec.env.iter().cloned().collect(),
config: vec![],
thought_levels: BTreeMap::new(),
+37 -1
Переглянути файл
@@ -197,6 +197,7 @@ pub enum ImportsOnPaste {
#[serde(default, rename_all = "camelCase")]
pub struct FoldingSettings {
pub show_outline: bool,
pub outline_visibility: FoldingOutlineVisibility,
pub file_header: bool,
pub imports: bool,
pub doc_comments: bool,
@@ -204,10 +205,24 @@ pub struct FoldingSettings {
impl Default for FoldingSettings {
fn default() -> Self {
Self { show_outline: true, file_header: true, imports: true, doc_comments: false }
Self {
show_outline: true,
outline_visibility: FoldingOutlineVisibility::Hover,
file_header: true,
imports: true,
doc_comments: false,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum FoldingOutlineVisibility {
#[default]
Hover,
Always,
}
/// Editor › General › Editor Tabs.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
@@ -543,3 +558,24 @@ mod auto_import_tests {
}
}
}
#[cfg(test)]
mod folding_tests {
use super::{FoldingOutlineVisibility, FoldingSettings};
#[test]
fn folding_outline_defaults_to_hover_for_existing_settings() {
let settings: FoldingSettings = serde_json::from_str(r#"{"showOutline":false}"#).unwrap();
assert!(!settings.show_outline);
assert_eq!(settings.outline_visibility, FoldingOutlineVisibility::Hover);
}
#[test]
fn folding_outline_visibility_round_trips() {
for mode in ["hover", "always"] {
let json = serde_json::json!({ "outlineVisibility": mode });
let settings: FoldingSettings = serde_json::from_value(json).unwrap();
assert_eq!(serde_json::to_value(settings).unwrap()["outlineVisibility"], mode);
}
}
}
+1
Переглянути файл
@@ -15,6 +15,7 @@ pub mod inspection_settings;
pub mod ipc_path;
pub mod java_runtime;
pub mod jsonc;
pub mod memory;
pub mod output_encoding;
pub mod platform;
pub mod process;
+20
Переглянути файл
@@ -0,0 +1,20 @@
//! Returning freed heap pages to the OS.
/// Hands pages the allocator has freed but kept back to the OS. Call after a burst of
/// short-lived allocations (a full index scan); until then they still count towards the
/// process's memory footprint.
pub fn release_free_pages() {
#[cfg(target_os = "macos")]
{
unsafe extern "C" {
fn malloc_zone_pressure_relief(zone: *mut std::ffi::c_void, goal: usize) -> usize;
}
// SAFETY: a null zone covers every zone; a zero goal releases as much as possible.
unsafe { malloc_zone_pressure_relief(std::ptr::null_mut(), 0) };
}
#[cfg(all(target_os = "linux", target_env = "gnu"))]
// SAFETY: malloc_trim only returns free memory to the OS.
unsafe {
libc::malloc_trim(0);
}
}
+3
Переглянути файл
@@ -11,6 +11,8 @@ use std::collections::BTreeMap;
pub struct VcsSettings {
/// Colour folders that contain changed files (project tree, tabs).
pub show_dirty_directories: bool,
/// Diffs the user opens show in an editor tab; off, in a separate window.
pub diff_as_editor_tab: bool,
/// Stop file history (Show History) after `history_limit` commits.
pub limit_history: bool,
pub history_limit: u32,
@@ -55,6 +57,7 @@ impl Default for VcsSettings {
Self {
// IDEA's VcsConfiguration.SHOW_DIRTY_RECURSIVELY is off by default.
show_dirty_directories: false,
diff_as_editor_tab: true,
limit_history: true,
history_limit: 1000,
git: GitSettings::default(),
+13 -6
Переглянути файл
@@ -49,6 +49,8 @@ pub struct AdapterSpec {
pub connect: Option<String>,
/// A plugin language's adapter: start exactly this approved program.
pub pinned: Option<ProgramPin>,
/// See [`DebuggerConfig::resolve_lazy_variables`].
pub resolve_lazy_variables: bool,
}
/// Built-in adapters used when no language definition names `adapter`.
@@ -60,6 +62,7 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
transport: transport.to_owned(),
connect: None,
install_hint: Some(hint.to_owned()),
resolve_lazy_variables: false,
pinned: None,
};
Some(match adapter {
@@ -130,12 +133,15 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
),
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
"java-debug" => cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
),
"java-debug" => DebuggerConfig {
resolve_lazy_variables: true,
..cfg(
"com.microsoft.java.debug.plugin.jar",
&[],
"tcp",
"Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers)",
)
},
// The Java language server's own debugger, for modules jdtls doesn't serve; the host
// runs the executable of the java-analyzer serving the module.
JAVA_ANALYZER => cfg(
@@ -186,6 +192,7 @@ pub fn resolve(config: &DebuggerConfig, cwd: PathBuf) -> AdapterSpec {
server_host: None,
connect: config.connect.clone(),
pinned: config.pinned.clone(),
resolve_lazy_variables: config.resolve_lazy_variables,
}
}
+1
Переглянути файл
@@ -102,6 +102,7 @@ pub(crate) fn bare_session_of(name: &str, request: &str) -> BareSession {
server_host: None,
connect: None,
pinned: None,
resolve_lazy_variables: false,
};
let session = Session::new(
DebugSessionId(1),
+64 -14
Переглянути файл
@@ -236,6 +236,11 @@ pub struct Variable {
/// > 0 when expandable.
pub variables_reference: i64,
pub evaluate_name: Option<String>,
/// `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
/// `variables` returns for `variables_reference` holds the value and its children.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
#[specta(optional)]
pub lazy: bool,
}
/// A completion the adapter offers for an expression (DAP `completions`).
@@ -727,9 +732,46 @@ pub(crate) fn variable_from(v: &Value) -> Variable {
type_name: s("type").filter(|t| !t.is_empty()),
variables_reference: v.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: s("evaluateName"),
lazy: v.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
}
}
async fn session_variables(session: &Session, reference: i64) -> IdeResult<Vec<Variable>> {
let body =
session.conn.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT).await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
}
async fn resolve_in(session: &Session, variable: Variable) -> IdeResult<Variable> {
if !variable.lazy || variable.variables_reference <= 0 {
return Ok(variable);
}
let mut inner = session_variables(session, variable.variables_reference).await?;
Ok(match (inner.pop(), inner.is_empty()) {
(Some(value), true) => Variable {
type_name: value.type_name.or(variable.type_name),
evaluate_name: variable.evaluate_name.or(value.evaluate_name),
name: variable.name,
value: value.value,
variables_reference: value.variables_reference,
lazy: value.lazy,
},
_ => variable,
})
}
/// A value that cannot be computed stays lazy, so the row can still be opened by hand.
async fn resolve_lazy(session: &Session, variable: Variable) -> Variable {
if !variable.lazy {
return variable;
}
resolve_in(session, variable.clone()).await.unwrap_or(variable)
}
impl DebugManager {
pub fn new(languages: Arc<LanguageRegistry>) -> Arc<Self> {
Self::with_launcher(languages, Arc::new(ProcessLauncher))
@@ -1497,6 +1539,7 @@ impl DebugManager {
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: evaluate_name.or(Some(name)),
lazy: false,
})
}
@@ -1567,16 +1610,18 @@ impl DebugManager {
}
pub async fn variables(&self, s: DebugSessionId, reference: i64) -> IdeResult<Vec<Variable>> {
let body = self
.session(s)?
.conn
.request_timeout("variables", json!({ "variablesReference": reference }), REQUEST_TIMEOUT)
.await?;
Ok(body
.get("variables")
.and_then(Value::as_array)
.map(|v| v.iter().map(variable_from).collect())
.unwrap_or_default())
let session = self.session(s)?;
let vars = session_variables(&session, reference).await?;
if !session.spec.resolve_lazy_variables {
return Ok(vars);
}
Ok(join_all(vars.into_iter().map(|v| resolve_lazy(&session, v))).await)
}
/// Computes a lazy variable's value (DAP `presentationHint.lazy`); any other variable, or one
/// whose value the adapter does not give as a single variable, comes back unchanged.
pub async fn resolve_variable(&self, s: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
resolve_in(&*self.session(s)?, variable).await
}
/// Evaluates in the `repl` context.
@@ -1602,13 +1647,18 @@ impl DebugManager {
args["frameId"] = f.into();
}
let body = session.conn.request_timeout("evaluate", args, REQUEST_TIMEOUT).await?;
Ok(Variable {
let result = Variable {
name: expression.clone(),
value: body.get("result").and_then(Value::as_str).unwrap_or_default().to_owned(),
type_name: body.get("type").and_then(Value::as_str).filter(|t| !t.is_empty()).map(str::to_owned),
variables_reference: body.get("variablesReference").and_then(Value::as_i64).unwrap_or(0),
evaluate_name: Some(expression),
})
lazy: body.pointer("/presentationHint/lazy").and_then(Value::as_bool).unwrap_or(false),
};
if !session.spec.resolve_lazy_variables {
return Ok(result);
}
Ok(resolve_lazy(&session, result).await)
}
/// Completions for `text` at `line` / `column` (0-based, UTF-16) in the frame's scope; none
@@ -1713,7 +1763,7 @@ impl DebugManager {
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
Ok(())
}
@@ -1825,7 +1875,7 @@ impl DebugManager {
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: false });
Ok(())
}
+71 -7
Переглянути файл
@@ -505,13 +505,29 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
"scopes" => {
ok!(msg, json!({"scopes": [{"name": "Locals", "variablesReference": 100, "expensive": false}]}))
}
"variables" => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
// 200 holds a lazy value (java-debug's toString(), js-debug's getters): asked for, its
// reference answers one nameless child with the value and the reference of its fields.
"variables" => match msg["arguments"]["variablesReference"].as_i64() {
Some(200) => ok!(
msg,
json!({"variables": [
{"name": "order", "value": "Order@7", "type": "Order", "variablesReference": 201,
"evaluateName": "order", "presentationHint": {"lazy": true}},
{"name": "n", "value": "2", "type": "int", "variablesReference": 0, "presentationHint": {"lazy": false}},
]})
),
Some(201) => ok!(
msg,
json!({"variables": [{"name": "", "value": "Order@7 \"Order(1)\"", "variablesReference": 202, "evaluateName": "order"}]})
),
_ => ok!(
msg,
json!({"variables": [
{"name": "x", "value": "1", "type": "int", "variablesReference": 0},
{"name": "req", "value": "{Req}", "type": "Req", "variablesReference": 101, "evaluateName": "req"},
]})
),
},
"evaluate" => ok!(msg, json!({"result": "42", "type": "int", "variablesReference": 0})),
"completions" => ok!(
msg,
@@ -2020,6 +2036,7 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
transport: "tcp".into(),
connect: Some(format!("127.0.0.1:{port}")),
install_hint: Some("Open the project in the Godot editor".into()),
resolve_lazy_variables: false,
pinned: None,
}),
};
@@ -2763,6 +2780,53 @@ async fn step_of_one_thread_keeps_the_others_suspended() {
assert_eq!(session.suspended.ticket(), ticket + 1);
h.manager.step_in_target(id, 7, 1).await.unwrap();
assert!(!session.suspended.get());
// The UI stays on a thread that is still stopped only when told the step ran one thread.
for thread in [7, 8] {
let continued =
h.wait_event(|e| matches!(e, DebugEvent::Continued { thread_id, .. } if *thread_id == thread)).await;
assert!(matches!(continued, DebugEvent::Continued { all_threads_continued: false, .. }), "{continued:?}");
}
}
#[tokio::test]
async fn lazy_variables_are_resolved_when_the_adapter_declares_them_safe() {
let h = harness(Script::default());
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
let order = &vars[0];
assert_eq!(
(order.name.as_str(), order.value.as_str(), order.type_name.as_deref()),
("order", "Order@7 \"Order(1)\"", Some("Order"))
);
assert_eq!((order.variables_reference, order.lazy), (202, false));
assert_eq!(order.evaluate_name.as_deref(), Some("order"));
assert_eq!((vars[1].name.as_str(), vars[1].lazy), ("n", false));
}
#[tokio::test]
async fn lazy_variables_stay_lazy_for_other_adapters() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
let vars = h.manager.variables(id, 200).await.unwrap();
assert_eq!((vars[0].value.as_str(), vars[0].variables_reference, vars[0].lazy), ("Order@7", 201, true));
assert_eq!(requests(&h, "variables").len(), 1, "nothing is computed until asked for");
let order = h.manager.resolve_variable(id, vars[0].clone()).await.unwrap();
assert_eq!((order.name.as_str(), order.value.as_str()), ("order", "Order@7 \"Order(1)\""));
assert_eq!((order.variables_reference, order.lazy), (202, false));
let n = h.manager.resolve_variable(id, vars[1].clone()).await.unwrap();
assert_eq!((n.value.as_str(), requests(&h, "variables").len()), ("2", 2), "only lazy values are computed");
}
#[test]
fn java_debug_declares_its_lazy_variables_safe_to_resolve() {
let languages = LanguageRegistry::load(None).unwrap();
for registry in [&languages, &LanguageRegistry::from_configs(Vec::new())] {
assert!(adapter::find_config(registry, "java-debug").unwrap().resolve_lazy_variables);
assert!(!adapter::find_config(registry, "js-debug").unwrap().resolve_lazy_variables);
}
}
#[tokio::test]
+148 -72
Переглянути файл
@@ -145,30 +145,38 @@ impl ClickhousePool {
let cancel = CancellationToken::new();
let initialize = async {
if let Err(error) = pool.execute("SELECT 1", 1, &cancel).await {
if !rejects_driver_setting(&error) {
let Some(setting) = rejected_driver_setting(&error) else {
return Err(error);
}
};
if !use_http_session {
return Err(IdeError::new(
error.kind,
format!(
"{}; use_http_session=false requires per-request read-only and result-limit settings. Strict read-only fallback requires an HTTP session on one node or session affinity",
error.message
),
));
}
// Retry only the connection probe. Keep relying on the server for write protection
// only after verifying strict read-only mode in this same session.
{
let mut session = pool.0.session.lock().await;
// Start the proof in a fresh session: the rejected probe may have left
// its id on another replica without applying the configured database.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
if setting == "readonly" {
return Err(error);
}
if !source.read_only {
return Err(IdeError::new(
error.kind,
format!(
"{}; enable Read-only for independent queries on a strict read-only server",
error.message
),
));
}
// Every request still sends readonly=1, regardless of which node answers.
pool.0.session.lock().await.strict_read_only = true;
pool.execute("SELECT 1", 1, &cancel).await?;
} else {
// Only rely on the server's write protection after proving strict read-only
// in this same named session.
{
let mut session = pool.0.session.lock().await;
// The rejected probe may have opened a session on a different node.
session.id = Some(uuid::Uuid::new_v4().to_string());
session.strict_read_only = true;
}
let result = pool.execute("SELECT getSetting('readonly')", 1, &cancel).await?;
if result.rows.first().and_then(|row| row.first()).and_then(Option::as_deref) != Some("1") {
return Err(error);
}
}
}
// The HTTP database parameter applies to one request. A named session needs
@@ -236,7 +244,7 @@ impl ClickhousePool {
if !self.0.database.is_empty() && (session.id.is_none() || !session.initialized) {
request = request.query(&[("database", &self.0.database)]);
}
if self.0.read_only && !session.strict_read_only {
if self.0.read_only && (session.id.is_none() || !session.strict_read_only) {
request = request.query(&[("readonly", "1")]);
}
request
@@ -324,7 +332,7 @@ impl ClickhousePool {
result
}
None => {
let killed = self.kill(&client, &query_id).await;
let killed = self.kill(&client, &query_id, &session).await;
match killed {
Ok(()) => Err(IdeError::cancelled()),
Err(error) => Err(IdeError::new(
@@ -336,15 +344,16 @@ impl ClickhousePool {
}
}
async fn kill(&self, client: &Client, query_id: &str) -> IdeResult<()> {
let response = client
async fn kill(&self, client: &Client, query_id: &str, session: &Session) -> IdeResult<()> {
let mut request = client
.post(self.0.endpoint.clone())
.basic_auth(&self.0.user, Some(&self.0.password))
.timeout(Duration::from_secs(3))
.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC"))
.send()
.await
.map_err(http_error)?;
.timeout(Duration::from_secs(3));
if self.0.read_only && session.id.is_none() {
request = request.query(&[("readonly", "1")]);
}
let response =
request.body(format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")).send().await.map_err(http_error)?;
let status = response.status();
let code = response
.headers()
@@ -551,13 +560,14 @@ fn read_pem(path: &str, label: &str) -> IdeResult<Vec<u8>> {
.map_err(|error| IdeError::new(ErrorKind::Io, format!("cannot read ClickHouse {label}: {error}")))
}
fn rejects_driver_setting(error: &IdeError) -> bool {
fn rejected_driver_setting(error: &IdeError) -> Option<&str> {
error
.message
.split_once(": ")
.and_then(|(_, detail)| detail.strip_prefix("Code: 164. DB::Exception: Cannot modify '"))
.and_then(|detail| detail.split_once("' setting in readonly mode"))
.is_some_and(|(name, _)| {
.map(|(name, _)| name)
.filter(|&name| {
matches!(
name,
"output_format_json_quote_denormals" | "max_result_rows" | "result_overflow_mode" | "readonly"
@@ -953,19 +963,77 @@ mod tests {
}
#[tokio::test]
async fn stateless_connections_never_fall_back_to_session_readonly_proof() {
for read_only in [false, true] {
let (port, requests) = server(vec![(
async fn strict_stateless_connections_keep_readonly_on_every_request() {
let denied = "Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)";
let (port, requests) = server(vec![
("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", denied),
("200 OK", "", ONE),
(
"500 Internal Server Error",
"X-ClickHouse-Exception-Code: 164\r\n",
"Code: 164. DB::Exception: Cannot execute query in readonly mode. (READONLY)",
),
("200 OK", "", "[\"n\"]\n[\"UInt64\"]\n[0]\n[1]\n[2]\n"),
])
.await;
let source = DataSource {
database: "fixture_database".into(),
read_only: true,
properties: vec![property("use_http_session", "false"), property("max_threads", "2")],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let cancel = CancellationToken::new();
let write = "CREATE TABLE fixture_table (n UInt8) ENGINE=Memory";
assert!(pool.execute(write, 1, &cancel).await.unwrap_err().message.contains("Code: 164"));
let sql = "SELECT number AS n FROM numbers(3) LIMIT 3";
let result = pool.execute(sql, 1, &cancel).await.unwrap();
assert_eq!(result.rows, vec![vec![Some("0".into())]]);
assert!(result.has_more);
let requests = requests.await.unwrap();
assert!(requests[0].ends_with("SELECT 1"));
assert!(requests[1].ends_with("SELECT 1"));
assert!(requests[2].ends_with(write));
assert!(requests[3].ends_with(sql));
for (index, request) in requests.iter().enumerate() {
let url = request_url(request);
for name in ["session_id", "session_check", "session_timeout", "use_http_session"] {
assert_eq!(query_value(&url, name), None, "{name}");
}
assert_eq!(query_value(&url, "readonly").as_deref(), Some("1"));
assert_eq!(query_value(&url, "database").as_deref(), Some("fixture_database"));
assert_eq!(query_value(&url, "max_threads").as_deref(), Some("2"));
assert_eq!(query_value(&url, "max_result_rows").as_deref(), (index == 0).then_some("2"));
assert_eq!(query_value(&url, "result_overflow_mode").as_deref(), (index == 0).then_some("break"));
assert_eq!(query_value(&url, "output_format_json_quote_denormals").as_deref(), (index == 0).then_some("1"));
}
}
#[tokio::test]
async fn stateless_connections_require_readonly_and_only_relax_driver_result_settings() {
for (read_only, detail, body) in [
(
false,
"enable Read-only",
"Code: 164. DB::Exception: Cannot modify 'max_result_rows' setting in readonly mode. (READONLY)",
)])
.await;
),
(
true,
"Cannot modify 'readonly'",
"Code: 164. DB::Exception: Cannot modify 'readonly' setting in readonly mode. (READONLY)",
),
(
true,
"Cannot modify 'max_threads'",
"Code: 164. DB::Exception: Cannot modify 'max_threads' setting in readonly mode. (READONLY)",
),
] {
let (port, requests) =
server(vec![("500 Internal Server Error", "X-ClickHouse-Exception-Code: 164\r\n", body)]).await;
let source =
DataSource { read_only, properties: vec![property("use_http_session", "false")], ..source(port) };
let error = Pool::connect(&source, None, None).await.err().expect("stateless fallback must be rejected");
assert!(error.message.contains("Cannot modify 'max_result_rows'"));
assert!(error.message.contains("use_http_session=false requires per-request"));
assert!(error.message.contains(detail), "{}", error.message);
let requests = requests.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].ends_with("SELECT 1"));
@@ -1041,7 +1109,7 @@ mod tests {
let error = IdeError::invalid(format!(
"ClickHouse HTTP 500: Code: {code}. DB::Exception: Cannot modify '{setting}' setting in readonly mode. (READONLY)"
));
assert_eq!(rejects_driver_setting(&error), expected, "{setting}");
assert_eq!(rejected_driver_setting(&error).is_some(), expected, "{setting}");
}
}
@@ -1084,37 +1152,45 @@ mod tests {
#[tokio::test]
async fn cancellation_sends_kill_outside_the_busy_session() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (started, received) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut health, _) = listener.accept().await.unwrap();
read_request(&mut health).await;
reply(&mut health, "200 OK", "", ONE).await;
drop(health);
let (mut query, _) = listener.accept().await.unwrap();
let request = read_request(&mut query).await;
started.send(()).unwrap();
let (mut kill, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
let kill_request = read_request(&mut kill).await;
reply(&mut kill, "200 OK", "", "").await;
(request, kill_request)
});
let pool = Pool::connect(&source(port), None, None).await.unwrap();
let cancel = CancellationToken::new();
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
let cancelled = async {
received.await.unwrap();
cancel.cancel();
};
let (result, ()) = tokio::join!(query, cancelled);
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
let (query, kill) = server.await.unwrap();
let target = query.lines().next().unwrap().split_whitespace().nth(1).unwrap();
let url = Url::parse(&format!("http://localhost{target}")).unwrap();
let query_id = url.query_pairs().find(|(k, _)| k == "query_id").unwrap().1.into_owned();
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
assert!(!kill.contains("session_id="));
for stateless in [false, true] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
let (started, received) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut health, _) = listener.accept().await.unwrap();
read_request(&mut health).await;
reply(&mut health, "200 OK", "", ONE).await;
drop(health);
let (mut query, _) = listener.accept().await.unwrap();
let request = read_request(&mut query).await;
started.send(()).unwrap();
let (mut kill, _) =
tokio::time::timeout(Duration::from_secs(5), listener.accept()).await.unwrap().unwrap();
let kill_request = read_request(&mut kill).await;
reply(&mut kill, "200 OK", "", "").await;
(request, kill_request)
});
let source = DataSource {
read_only: true,
properties: vec![property("use_http_session", if stateless { "false" } else { "true" })],
..source(port)
};
let pool = Pool::connect(&source, None, None).await.unwrap();
let cancel = CancellationToken::new();
let query = pool.execute("SELECT sleep(30)", 1, &cancel);
let cancelled = async {
received.await.unwrap();
cancel.cancel();
};
let (result, ()) = tokio::join!(query, cancelled);
assert_eq!(result.unwrap_err().kind, ErrorKind::Cancelled);
let (query, kill) = server.await.unwrap();
let query_id = query_value(&request_url(&query), "query_id").unwrap();
assert!(kill.ends_with(&format!("KILL QUERY WHERE query_id = '{query_id}' SYNC")));
let url = request_url(&kill);
assert_eq!(query_value(&url, "session_id"), None);
assert_eq!(query_value(&url, "readonly").as_deref(), stateless.then_some("1"));
}
}
#[tokio::test]
+3 -1
Переглянути файл
@@ -303,7 +303,9 @@ async fn read_frame(output: &mut (impl AsyncRead + Unpin)) -> IdeResult<Vec<u8>>
const CANCEL_GRACE: Duration = Duration::from_secs(3);
fn cancel_timeout() -> IdeError {
IdeError::invalid("The JDBC driver did not stop in time. The session was closed. Reconnect to continue.")
IdeError::invalid(
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect.",
)
}
async fn exchange(
+7 -3
Переглянути файл
@@ -210,9 +210,13 @@ async fn unresponsive_driver_closes_before_reconnect() -> IdeResult<()> {
})
.await
.expect("driver cancellation must be bounded");
assert!(result.unwrap_err().message.contains("Reconnect"));
db.disconnect("test").await;
assert_eq!(db.execute("test", "after reconnect", 1, &normal).await?.affected, Some(1.0));
assert_eq!(
result.unwrap_err().message,
"Cancellation timed out and the JDBC session was closed. Check the statement's status on the server before running it again. The next query will try to reconnect."
);
assert!(db.connected().is_empty());
assert_eq!(db.execute("test", "after cancellation", 1, &normal).await?.affected, Some(1.0));
assert_eq!(db.connected(), ["test"]);
db.disconnect("test").await;
Ok(())
}
+54
Переглянути файл
@@ -0,0 +1,54 @@
[package]
name = "ide-drag-out"
description = "OS file drags out of an app window, so file managers and transfer clients copy the files: GTK on Linux, OLE on Windows, AppKit on macOS"
version.workspace = true
edition.workspace = true
license.workspace = true
[dependencies]
[target.'cfg(target_os = "linux")'.dependencies]
gtk = "0.18"
[target.'cfg(any(windows, target_os = "macos"))'.dependencies]
raw-window-handle = "0.6"
[target.'cfg(windows)'.dependencies]
windows = { version = "0.62", features = [
"Win32_Foundation",
"Win32_Graphics_Gdi",
"Win32_System_Com",
"Win32_System_Com_StructuredStorage",
"Win32_System_Memory",
"Win32_System_Ole",
"Win32_System_SystemServices",
"Win32_UI_Shell",
"Win32_UI_Shell_Common",
] }
# `#[implement]` expands to paths into `windows_core`.
windows-core = "0.62"
[target.'cfg(target_os = "macos")'.dependencies]
objc2 = { version = "0.6", default-features = false, features = ["std"] }
objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSGeometry", "NSObject", "NSString", "NSURL"] }
objc2-app-kit = { version = "0.3", default-features = false, features = [
"std",
"objc2-core-foundation",
"NSApplication",
"NSDragging",
"NSDraggingItem",
"NSDraggingSession",
"NSEvent",
"NSGraphics",
"NSGraphicsContext",
"NSImage",
"NSPasteboard",
"NSPasteboardItem",
"NSResponder",
"NSView",
"NSWindow",
"NSWorkspace",
] }
[dev-dependencies]
tempfile.workspace = true
+122
Переглянути файл
@@ -0,0 +1,122 @@
//! macOS: an AppKit dragging session with one pasteboard item per path, each a file URL.
use super::Outcome;
use objc2::rc::Retained;
use objc2::runtime::ProtocolObject;
use objc2::{AnyThread, DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
use objc2_app_kit::{
NSApplication, NSDragOperation, NSDraggingContext, NSDraggingItem, NSDraggingSession, NSDraggingSource, NSEvent,
NSEventModifierFlags, NSEventType, NSPasteboardItem, NSPasteboardTypeFileURL, NSView, NSWorkspace,
};
use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSPoint, NSRect, NSSize, NSString, NSURL};
use raw_window_handle::{HasWindowHandle, RawWindowHandle};
use std::cell::Cell;
use std::io;
use std::path::PathBuf;
/// The size of each file's icon under the pointer, in points.
const ICON_SIZE: f64 = 32.0;
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`, each shown with its
/// Finder icon; `done` runs on the main thread when the drag ends.
pub fn start<W: HasWindowHandle>(
window: &W,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
let mtm = MainThreadMarker::new().ok_or_else(|| io::Error::other("a drag starts on the main thread"))?;
let RawWindowHandle::AppKit(handle) =
window.window_handle().map_err(|error| io::Error::other(error.to_string()))?.as_raw()
else {
return Err(io::Error::other("not an AppKit window"));
};
// SAFETY: the handle names this window's view, alive while `window` is borrowed.
let view = unsafe { handle.ns_view.cast::<NSView>().as_ref() };
let window = view.window().ok_or_else(|| io::Error::other("the view has no window"))?;
let content = window.contentView().ok_or_else(|| io::Error::other("the window has no content view"))?;
// In window coordinates, which are the content view's.
let pointer = window.mouseLocationOutsideOfEventStream();
let frame = NSRect::new(
NSPoint::new(pointer.x - ICON_SIZE / 2.0, pointer.y - ICON_SIZE / 2.0),
NSSize::new(ICON_SIZE, ICON_SIZE),
);
let workspace = NSWorkspace::sharedWorkspace();
let mut items = Vec::with_capacity(paths.len());
for path in &paths {
let path = NSString::from_str(&path.to_string_lossy());
let url = NSURL::fileURLWithPath(&path)
.absoluteString()
.ok_or_else(|| io::Error::other(format!("not a file URL: {path}")))?;
let item = NSPasteboardItem::new();
if !item.setString_forType(&url, unsafe { NSPasteboardTypeFileURL }) {
return Err(io::Error::other(format!("cannot put {path} on the pasteboard")));
}
let drag_item =
NSDraggingItem::initWithPasteboardWriter(NSDraggingItem::alloc(), ProtocolObject::from_ref(&*item));
let icon = workspace.iconForFile(&path);
unsafe { drag_item.setDraggingFrame_contents(frame, Some(&icon)) };
items.push(drag_item);
}
// The session starts from a drag event at the pointer: the web view's own mouse events
// went to WebKit, and the current event may be a later one.
let timestamp = NSApplication::sharedApplication(mtm).currentEvent().map_or(0.0, |event| event.timestamp());
let event = NSEvent::mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure(
NSEventType::LeftMouseDragged,
pointer,
NSEventModifierFlags::empty(),
timestamp,
window.windowNumber(),
None,
0,
1,
1.0,
)
.ok_or_else(|| io::Error::other("cannot make the drag event"))?;
let source = DragSource::new(Box::new(done), mtm);
content.beginDraggingSessionWithItems_event_source(
&NSArray::from_retained_slice(&items),
&event,
ProtocolObject::from_ref(&*source),
);
Ok(())
}
type Done = Box<dyn FnOnce(Outcome)>;
struct Ivars {
done: Cell<Option<Done>>,
}
define_class!(
#[unsafe(super(NSObject))]
#[thread_kind = MainThreadOnly]
#[name = "OpenIdeaDragOutSource"]
#[ivars = Ivars]
struct DragSource;
unsafe impl NSObjectProtocol for DragSource {}
unsafe impl NSDraggingSource for DragSource {
#[unsafe(method(draggingSession:sourceOperationMaskForDraggingContext:))]
fn operation_mask(&self, session: &NSDraggingSession, _context: NSDraggingContext) -> NSDragOperation {
session.setAnimatesToStartingPositionsOnCancelOrFail(true);
NSDragOperation::Copy
}
#[unsafe(method(draggingSession:endedAtPoint:operation:))]
fn ended(&self, _session: &NSDraggingSession, _point: NSPoint, operation: NSDragOperation) {
if let Some(done) = self.ivars().done.take() {
done(if operation == NSDragOperation::None { Outcome::Cancelled } else { Outcome::Dropped });
}
}
}
);
impl DragSource {
fn new(done: Done, mtm: MainThreadMarker) -> Retained<Self> {
let this = Self::alloc(mtm).set_ivars(Ivars { done: Cell::new(Some(done)) });
unsafe { msg_send![super(this), init] }
}
}
+190
Переглянути файл
@@ -0,0 +1,190 @@
//! OS file drags out of an app window: the app the files are dropped on (Explorer,
//! Finder, a file manager, an SFTP client such as Xftp) copies them, as when they are
//! dragged from IDEA's Project view (#2867).
//!
//! Linux starts a GTK drag offering `text/uri-list`, Windows an OLE `DoDragDrop` of a
//! `CF_HDROP` data object, macOS an AppKit dragging session of file URLs. A drag is
//! always a copy, never a move, so no target can take project files away.
//!
//! [`start`] runs on the UI thread while the primary button is still held. It returns
//! once the drag has begun (Linux, macOS) or ended (Windows); `done` gets the outcome
//! when it ends, or is dropped without being called when the backend lost track of it.
use std::io;
use std::path::PathBuf;
/// How a drag ended.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Outcome {
/// A target accepted the drop.
Dropped,
/// Released where nothing accepted it, or cancelled with Escape.
Cancelled,
}
/// The paths a drag may carry: at least one, each an absolute path to a file or folder
/// on this machine. A remote project's paths name files on its server and fail here.
/// Windows also refuses paths of `MAX_PATH` or more: Explorer can't copy from them.
/// Network shares (`\\server\share\…`) are local paths here and drag like any other.
pub fn local_paths<S: Into<PathBuf>>(paths: impl IntoIterator<Item = S>) -> io::Result<Vec<PathBuf>> {
let paths: Vec<PathBuf> = paths.into_iter().map(Into::into).collect();
if paths.is_empty() {
return Err(io::Error::new(io::ErrorKind::InvalidInput, "no files to drag"));
}
for path in &paths {
if !path.is_absolute() || std::fs::symlink_metadata(path).is_err() {
return Err(io::Error::new(io::ErrorKind::NotFound, format!("not a local file: {}", path.display())));
}
if cfg!(windows) && !fits_max_path(path) {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
format!("path too long to drag: {}", path.display()),
));
}
}
Ok(paths)
}
/// Whether `path` is shorter than Windows' `MAX_PATH` (260 UTF-16 units with the NUL).
fn fits_max_path(path: &std::path::Path) -> bool {
path.as_os_str().to_string_lossy().encode_utf16().count() < 260
}
#[cfg(target_os = "linux")]
pub use gtk_impl::start;
#[cfg(target_os = "linux")]
mod gtk_impl {
use super::Outcome;
use gtk::glib::{self, SignalHandlerId};
use gtk::prelude::*;
use gtk::{TargetList, gdk};
use std::cell::{Cell, RefCell};
use std::io;
use std::path::PathBuf;
use std::rc::Rc;
/// Starts dragging `paths` (see [`super::local_paths`]) from `window`; `done` runs on
/// the UI thread when the drag ends.
pub fn start(
window: &gtk::ApplicationWindow,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
// `file://` URIs with every reserved or non-ASCII byte escaped.
let uris = paths
.iter()
.map(|path| glib::filename_to_uri(path, None).map(|uri| uri.to_string()))
.collect::<Result<Vec<_>, _>>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error.to_string()))?;
let targets = TargetList::new(&[]);
targets.add_uri_targets(0);
// The button that started the drag (1), not its mask: GTK ends the drag on that
// button's release.
let context = window
.drag_begin_with_coordinates(&targets, gdk::DragAction::COPY, 1, None, -1, -1)
.ok_or_else(|| io::Error::other("the window system refused to start a drag"))?;
let outcome = Rc::new(Cell::new(Outcome::Cancelled));
context.connect_drop_performed({
let outcome = outcome.clone();
move |_, _| outcome.set(Outcome::Dropped)
});
let handlers: Rc<RefCell<Vec<SignalHandlerId>>> = Rc::default();
let data = window.connect_drag_data_get({
let context = context.clone();
move |_, ctx, selection, _, _| {
if *ctx == context {
let uris: Vec<&str> = uris.iter().map(String::as_str).collect();
selection.set_uris(&uris);
}
}
});
// The target asks for the data after the drop (XDND is asynchronous), so the data
// handler stays connected until `drag-end`, which GTK emits last.
let done = Cell::new(Some(done));
let end = window.connect_drag_end({
let handlers = handlers.clone();
move |window, ctx| {
if *ctx != context {
return;
}
for handler in handlers.borrow_mut().drain(..) {
window.disconnect(handler);
}
if let Some(done) = done.take() {
done(outcome.get());
}
}
});
handlers.borrow_mut().extend([data, end]);
Ok(())
}
}
#[cfg(windows)]
mod ole;
#[cfg(windows)]
pub use ole::start;
#[cfg(target_os = "macos")]
mod appkit;
#[cfg(target_os = "macos")]
pub use appkit::start;
/// The `CF_HDROP` file list: each path in UTF-16 with `/` as `\\`, NUL-terminated, and a
/// second NUL after the last.
#[cfg(any(windows, test))]
fn hdrop_file_list<P: IntoIterator<Item = u16>>(paths: impl IntoIterator<Item = P>) -> Vec<u16> {
let mut list = Vec::new();
for path in paths {
list.extend(path.into_iter().map(|unit| if unit == u16::from(b'/') { u16::from(b'\\') } else { unit }));
list.push(0);
}
list.push(0);
list
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accepts_existing_absolute_files_and_folders() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a b ü.txt");
std::fs::write(&file, "x").unwrap();
let paths = local_paths([file.clone(), dir.path().to_path_buf()]).unwrap();
assert_eq!(paths, vec![file, dir.path().to_path_buf()]);
}
#[test]
fn measures_max_path_in_utf16_units() {
let path = |len: usize| PathBuf::from(format!("C:/{}", "中".repeat(len - 3)));
assert!(fits_max_path(&path(259)));
assert!(!fits_max_path(&path(260)));
}
#[test]
fn lists_hdrop_files_double_nul_terminated() {
let list = hdrop_file_list(["C:/a b/ü.txt", r"\\nas\share\中"].map(str::encode_utf16));
let expected: Vec<u16> = "C:\\a b\\ü.txt\0\\\\nas\\share\\中\0\0".encode_utf16().collect();
assert_eq!(list, expected);
}
#[test]
fn refuses_an_empty_drag() {
assert_eq!(local_paths(Vec::<PathBuf>::new()).unwrap_err().kind(), io::ErrorKind::InvalidInput);
}
#[test]
fn refuses_relative_and_missing_paths() {
let dir = tempfile::tempdir().unwrap();
let file = dir.path().join("a.txt");
std::fs::write(&file, "x").unwrap();
// One path that is not local fails the whole drag: none of it is half-copied.
for bad in [PathBuf::from("a.txt"), dir.path().join("missing.txt")] {
assert_eq!(local_paths([file.clone(), bad]).unwrap_err().kind(), io::ErrorKind::NotFound);
}
}
}
+171
Переглянути файл
@@ -0,0 +1,171 @@
//! Windows: OLE `DoDragDrop` of a data object that serves the paths as `CF_HDROP`.
use super::{Outcome, hdrop_file_list};
use raw_window_handle::HasWindowHandle;
use std::io;
use std::os::windows::ffi::OsStrExt;
use std::path::PathBuf;
use windows::Win32::Foundation::{
DRAGDROP_S_CANCEL, DRAGDROP_S_DROP, DRAGDROP_S_USEDEFAULTCURSORS, DV_E_FORMATETC, E_NOTIMPL, GlobalFree, HGLOBAL,
OLE_E_ADVISENOTSUPPORTED, S_OK,
};
use windows::Win32::System::Com::{
DATADIR_GET, DVASPECT_CONTENT, FORMATETC, IAdviseSink, IDataObject, IDataObject_Impl, IEnumFORMATETC,
IEnumSTATDATA, STGMEDIUM, STGMEDIUM_0, TYMED_HGLOBAL,
};
use windows::Win32::System::Memory::{GHND, GlobalAlloc, GlobalLock, GlobalUnlock};
use windows::Win32::System::Ole::{
CF_HDROP, DROPEFFECT, DROPEFFECT_COPY, DROPEFFECT_NONE, DoDragDrop, IDropSource, IDropSource_Impl, OleInitialize,
OleUninitialize,
};
use windows::Win32::System::SystemServices::{MK_LBUTTON, MODIFIERKEYS_FLAGS};
use windows::Win32::UI::Shell::{DROPFILES, SHCreateDataObject, SHCreateStdEnumFmtEtc};
use windows::core::{BOOL, Error, HRESULT, Ref, Result, implement};
/// Drags `paths` (see [`super::local_paths`]) until the button is released, then calls
/// `done` and returns. `DoDragDrop` runs its own message loop, so the window keeps painting.
pub fn start<W: HasWindowHandle>(
_window: &W,
paths: Vec<PathBuf>,
done: impl FnOnce(Outcome) + 'static,
) -> io::Result<()> {
let files = hdrop_file_list(paths.iter().map(|path| path.as_os_str().encode_wide()));
// The window's event loop has initialised OLE on this thread already; this takes a
// reference that `OleUninitialize` gives back.
unsafe { OleInitialize(None) }.map_err(io::Error::other)?;
let outcome = drag(files);
unsafe { OleUninitialize() };
done(outcome.map_err(io::Error::other)?);
Ok(())
}
fn drag(files: Vec<u16>) -> Result<Outcome> {
// Formats other than `CF_HDROP` (the drag image, drop descriptions the shell sets on
// the source's data object) are kept by a plain shell data object.
let inner: IDataObject = unsafe { SHCreateDataObject(None, None, None::<&IDataObject>) }?;
let data: IDataObject = DataObject { files, inner }.into();
let source: IDropSource = DropSource.into();
let mut effect = DROPEFFECT_NONE;
match unsafe { DoDragDrop(&data, &source, DROPEFFECT_COPY, &mut effect) } {
DRAGDROP_S_DROP if effect != DROPEFFECT_NONE => Ok(Outcome::Dropped),
DRAGDROP_S_DROP | DRAGDROP_S_CANCEL => Ok(Outcome::Cancelled),
error => Err(Error::from_hresult(error)),
}
}
#[implement(IDropSource)]
struct DropSource;
impl IDropSource_Impl for DropSource_Impl {
fn QueryContinueDrag(&self, escape_pressed: BOOL, keys: MODIFIERKEYS_FLAGS) -> HRESULT {
if escape_pressed.as_bool() {
DRAGDROP_S_CANCEL
} else if keys & MK_LBUTTON == MODIFIERKEYS_FLAGS(0) {
DRAGDROP_S_DROP
} else {
S_OK
}
}
fn GiveFeedback(&self, _effect: DROPEFFECT) -> HRESULT {
DRAGDROP_S_USEDEFAULTCURSORS
}
}
#[implement(IDataObject)]
struct DataObject {
/// The `DROPFILES` file list ([`hdrop_file_list`]).
files: Vec<u16>,
inner: IDataObject,
}
const HDROP: FORMATETC = FORMATETC {
cfFormat: CF_HDROP.0,
ptd: std::ptr::null_mut(),
dwAspect: DVASPECT_CONTENT.0,
lindex: -1,
tymed: TYMED_HGLOBAL.0 as u32,
};
fn is_hdrop(format: *const FORMATETC) -> bool {
unsafe { format.as_ref() }.is_some_and(|format| {
format.cfFormat == HDROP.cfFormat && format.dwAspect == HDROP.dwAspect && format.tymed & HDROP.tymed != 0
})
}
impl DataObject {
/// A new `DROPFILES` block; the receiver frees it.
fn hdrop(&self) -> Result<HGLOBAL> {
let header = size_of::<DROPFILES>();
let size = header + std::mem::size_of_val(self.files.as_slice());
unsafe {
let handle = GlobalAlloc(GHND, size)?;
let block = GlobalLock(handle).cast::<u8>();
if block.is_null() {
let error = Error::from_thread();
let _ = GlobalFree(Some(handle));
return Err(error);
}
block.cast::<DROPFILES>().write_unaligned(DROPFILES {
pFiles: header as u32,
fWide: true.into(),
..Default::default()
});
std::ptr::copy_nonoverlapping(self.files.as_ptr().cast::<u8>(), block.add(header), size - header);
// Fails with no error once the lock count is back to zero, which it is.
let _ = GlobalUnlock(handle);
Ok(handle)
}
}
}
impl IDataObject_Impl for DataObject_Impl {
fn GetData(&self, format: *const FORMATETC) -> Result<STGMEDIUM> {
if !is_hdrop(format) {
return unsafe { self.inner.GetData(format) };
}
Ok(STGMEDIUM {
tymed: TYMED_HGLOBAL.0 as u32,
u: STGMEDIUM_0 { hGlobal: self.hdrop()? },
pUnkForRelease: std::mem::ManuallyDrop::new(None),
})
}
fn GetDataHere(&self, format: *const FORMATETC, medium: *mut STGMEDIUM) -> Result<()> {
if is_hdrop(format) {
return Err(DV_E_FORMATETC.into());
}
unsafe { self.inner.GetDataHere(format, medium) }
}
fn QueryGetData(&self, format: *const FORMATETC) -> HRESULT {
if is_hdrop(format) { S_OK } else { unsafe { self.inner.QueryGetData(format) } }
}
fn GetCanonicalFormatEtc(&self, format: *const FORMATETC, canonical: *mut FORMATETC) -> HRESULT {
unsafe { self.inner.GetCanonicalFormatEtc(format, canonical) }
}
fn SetData(&self, format: *const FORMATETC, medium: *const STGMEDIUM, release: BOOL) -> Result<()> {
unsafe { self.inner.SetData(format, medium, release.as_bool()) }
}
fn EnumFormatEtc(&self, direction: u32) -> Result<IEnumFORMATETC> {
if direction != DATADIR_GET.0 as u32 {
return Err(E_NOTIMPL.into());
}
unsafe { SHCreateStdEnumFmtEtc(&[HDROP]) }
}
fn DAdvise(&self, _format: *const FORMATETC, _advf: u32, _sink: Ref<IAdviseSink>) -> Result<u32> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
fn DUnadvise(&self, _connection: u32) -> Result<()> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
fn EnumDAdvise(&self) -> Result<IEnumSTATDATA> {
Err(OLE_E_ADVISENOTSUPPORTED.into())
}
}
+50 -4
Переглянути файл
@@ -5,10 +5,10 @@ use crate::Host;
use crate::agent_secrets::{AgentSecrets, Kept};
use ide_agent::registry::{AgentRegistry, RegistryPaths};
use ide_agent::{
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCommand, AgentContextUsage,
AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe, AgentPrompt, AgentProvider, AgentQueued, AgentTask,
CustomAgentInput, ExternalSession, McpExternalSource, McpImportSelection, McpProbeResult, McpScope, McpServer,
McpServerInput, McpTransport, NewAgentTask,
AcpImportOutcome, AgentAcceptOutcome, AgentChange, AgentChanges, AgentChangesView, AgentCliOffer,
AgentCliUpdateResult, AgentCommand, AgentContextUsage, AgentEntry, AgentEvent, AgentModelCatalog, AgentProbe,
AgentPrompt, AgentProvider, AgentQueued, AgentTask, CustomAgentInput, ExternalSession, McpExternalSource,
McpImportSelection, McpProbeResult, McpScope, McpServer, McpServerInput, McpTransport, NewAgentTask,
};
use ide_command::command;
use ide_core::error::ErrorKind;
@@ -359,6 +359,50 @@ pub async fn agent_rollback(host: &Host, window: &str, task: String, turns: u32)
host.project(window)?.agents.rollback(&task, turns).await
}
/// Checks the selected installation without modifying it.
#[command(trust = trusted)]
pub async fn agent_cli_update_check(
host: &Host,
window: &str,
provider: String,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
cli_update(host, window, provider, None, request).await
}
/// Installs the exact version offered if the selected installation still matches.
#[command(trust = trusted)]
pub async fn agent_cli_update(
host: &Host,
window: &str,
provider: String,
offer: AgentCliOffer,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
cli_update(host, window, provider, Some(offer), request).await
}
async fn cli_update(
host: &Host,
window: &str,
provider: String,
offer: Option<AgentCliOffer>,
request: RequestId,
) -> IdeResult<AgentCliUpdateResult> {
host.require_trust(window)?;
let project = host.project(window)?;
let installing = offer.as_ref().map(|_| Installing::begin(&provider)).transpose()?;
let cancel = host.begin_project_request(window, request);
let result = tokio::task::spawn_blocking(move || {
let _installing = installing;
project.agents.cli_update(&provider, offer.as_ref(), &cancel)
})
.await
.map_err(join_err);
host.end_request(request);
result?
}
/// What the agent reports about itself when it starts (no session: no MCP servers, hooks
/// or sign-in run). Remembered until `refresh`.
#[command(trust = trusted)]
@@ -1102,6 +1146,8 @@ ide_command::domain!(
agent_cancel,
agent_context_usage,
agent_changes,
agent_cli_update,
agent_cli_update_check,
agent_commands,
agent_create,
agent_delete,
+25 -4
Переглянути файл
@@ -1,6 +1,7 @@
//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files
//! (`@cucumber/cucumber`, `playwright-bdd`) and Java / Kotlin files (cucumber-jvm's
//! `@Given("…")` annotations and Java 8 lambdas) that could define steps, with their text. The UI
//! `@Given("…")` annotations and Java 8 lambdas) and Python files (behave and pytest-bdd's
//! `@given('…')` decorators) that could define steps, with their text. The UI
//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`),
//! so this side stays a cheap scan.
@@ -21,6 +22,8 @@ const MAX_FILE_BYTES: u64 = 2 << 20;
/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`).
const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("];
/** What a Python step decorator starts with (behave also takes the capitalized names). */
const PYTHON_STEP_CALLS: [&str; 8] = ["@given(", "@when(", "@then(", "@step(", "@Given(", "@When(", "@Then(", "@Step("];
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -38,10 +41,14 @@ fn is_feature(path: &Path) -> bool {
fn is_script(path: &Path) -> bool {
matches!(
path.extension().and_then(|e| e.to_str()),
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt")
Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts" | "java" | "kt" | "py")
)
}
fn is_python(path: &Path) -> bool {
path.extension().and_then(|e| e.to_str()) == Some("py")
}
/// The feature files and step definition files under `root`.
pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
let found: Mutex<Vec<StepSource>> = Mutex::new(Vec::new());
@@ -55,7 +62,8 @@ pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec<StepSource> {
return;
}
let Ok(text) = std::fs::read_to_string(path) else { return };
if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) {
let calls: &[&str] = if is_python(path) { &PYTHON_STEP_CALLS } else { &STEP_CALLS };
if !feature && !calls.iter().any(|call| text.contains(call)) {
return;
}
let Ok(mut found) = found.lock() else { return };
@@ -76,6 +84,7 @@ pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult<Vec<StepSource>>
let mut excludes = project.search_excludes();
// Cucumber's own sources (and every other package's) are not the project's steps.
excludes.push("node_modules".to_owned());
excludes.push("site-packages".to_owned());
let mut out = Vec::new();
for root in std::iter::once(project.root.clone()).chain(project.content_roots()) {
out.extend(sources_in(&root, &excludes));
@@ -104,11 +113,23 @@ mod tests {
std::fs::write(root.join("src/CartSteps.java"), "@Given(\"an empty cart\")\npublic void empty() {}").unwrap();
std::fs::write(root.join("src/App.java"), "class App {}").unwrap();
std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap();
std::fs::write(root.join("steps/cart_steps.py"), "@given('an empty cart')\ndef step_impl(context): pass")
.unwrap();
std::fs::write(root.join("src/util.py"), "def given(x): return x\nWhen = given('x')").unwrap();
std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap();
let files = sources_in(root, &["node_modules".to_owned()]);
let names: Vec<String> =
files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect();
assert_eq!(names, ["features/cart.feature", "src/CartSteps.java", "steps/bdd.mjs", "steps/cart.steps.ts"]);
assert_eq!(
names,
[
"features/cart.feature",
"src/CartSteps.java",
"steps/bdd.mjs",
"steps/cart.steps.ts",
"steps/cart_steps.py"
]
);
assert!(files[0].feature && !files[1].feature);
assert!(files[3].text.contains("an empty cart"));
}
+6
Переглянути файл
@@ -342,6 +342,11 @@ pub async fn debug_variables(host: &Host, session: DebugSessionId, reference: i6
host.debugger.variables(session, reference).await
}
#[command(trust = trusted)]
pub async fn debug_resolve_variable(host: &Host, session: DebugSessionId, variable: Variable) -> IdeResult<Variable> {
host.debugger.resolve_variable(session, variable).await
}
#[command(trust = trusted)]
pub async fn debug_evaluate(
host: &Host,
@@ -834,6 +839,7 @@ ide_command::domain!(
debug_listen_for_jvm,
debug_pause,
debug_redefine_classes,
debug_resolve_variable,
debug_restart_frame,
debug_resume,
debug_run_to,
+5 -2
Переглянути файл
@@ -13,6 +13,9 @@ const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
const SCHEMA: &str = "openidea-index-4";
/// redb's page cache, which otherwise grows to 1 GiB. Queries run on the in-memory snapshot;
/// the database is read once at startup and written incrementally.
const DB_CACHE_BYTES: usize = 64 * 1024 * 1024;
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
/// containing `gitdir: ...`).
@@ -389,7 +392,7 @@ impl Store {
fn open_db(&self) -> Result<Database> {
let file = self.snapshot.with_file_name("index.redb");
let db = match Database::create(&file) {
let db = match Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file) {
Ok(db) => db,
Err(redb::DatabaseError::DatabaseAlreadyOpen) => {
return Err(format!("{} is in use", file.display()));
@@ -398,7 +401,7 @@ impl Store {
tracing::warn!("index cache {} unreadable ({e}); rebuilding", file.display());
let _ = std::fs::remove_file(&file);
let _ = std::fs::remove_file(&self.snapshot);
Database::create(&file).map_err(err)?
Database::builder().set_cache_size(DB_CACHE_BYTES).create(&file).map_err(err)?
}
};
let valid = {
+2
Переглянути файл
@@ -472,6 +472,8 @@ impl Shared {
fn full_scan(&self, found: Option<Vec<Found>>, guard: SystemTime) {
self.scan(None, found, guard);
// Parsing every file churns through far more memory than the index keeps.
ide_core::memory::release_free_pages();
}
fn scan(&self, dirs: Option<&[PathBuf]>, prewalked: Option<Vec<Found>>, guard: SystemTime) -> Option<ScanCounts> {
+5
Переглянути файл
@@ -245,6 +245,11 @@ pub struct DebuggerConfig {
pub connect: Option<String>,
#[serde(default)]
pub install_hint: Option<String>,
/// The adapter's lazy values (DAP `presentationHint.lazy`) are renderings such as `toString()`,
/// safe to compute for every value shown: they are resolved before the UI sees them, as IDEA
/// shows `toString()` at once. Off (getters with side effects), a value resolves when opened.
#[serde(default)]
pub resolve_lazy_variables: bool,
/// Set on plugin languages: start exactly this approved program.
#[serde(skip)]
pub pinned: Option<ProgramPin>,
+44 -5
Переглянути файл
@@ -25,6 +25,17 @@ const PROGRESS_SWEEP: Duration = Duration::from_secs(15);
/// visible, but stops holding the server busy while the work behind it keeps running.
const PROGRESS_STALE: Duration = Duration::from_secs(180);
/// How long a cancelled progress task waits for its server to end it.
const CANCEL_GRACE: Duration = Duration::from_secs(5);
/// The key of progress token `token` in [`Server::progress`].
fn progress_key(token: &Value) -> String {
match token {
Value::String(s) => s.clone(),
other => other.to_string(),
}
}
/// Task message after [`PROGRESS_STALE`] of silence: keep the server's last message and
/// say how long nothing happened.
fn stalled_message(message: Option<&str>) -> String {
@@ -97,22 +108,50 @@ impl ClientHandler {
}
/// Cancelling task `task` asks this server instance to stop the work of progress `token`.
/// A server that never ends it (Pyright waiting on a workspace that never loads) would
/// leave the task "Cancelling…" for good: after [`CANCEL_GRACE`] the task ends here.
fn cancel_handle(&self, task: TaskId, token: &Value) -> ide_core::task::CancelHandle {
let (server, generation, token) = (self.server.clone(), self.generation, token.clone());
let (mgr, server, generation, token) = (self.mgr.clone(), self.server.clone(), self.generation, token.clone());
ide_core::task::on_cancel(task, move || {
if let Some(run) = server.initialized_gen(generation)
&& let Err(e) = run.peer.notify("window/workDoneProgress/cancel", json!({ "token": token }))
{
tracing::debug!("{}: cannot cancel progress: {e}", server.name);
}
let Some(runtime) = mgr.upgrade().map(|m| m.runtime.clone()) else { return };
runtime.spawn(async move {
tokio::time::sleep(CANCEL_GRACE).await;
let Some(mgr) = mgr.upgrade() else { return };
let key = progress_key(&token);
let ended = {
let mut progress = server.progress.lock();
if progress.get(&key).is_none_or(|p| p.task != task) {
return; // the server ended it, or the token began new work
}
progress.remove(&key)
};
if let Some(p) = ended {
tracing::info!("{}: progress '{key}' did not end after cancel; ending its task", server.name);
server.emit(
mgr.sink(),
IdeEvent::Task {
id: p.task,
title: p.title,
message: p.message,
fraction: None,
done: true,
cancellable: false,
},
);
server.refresh_busy_status(mgr.sink());
server.progress_ended();
}
});
})
}
fn progress(&self, mgr: &LspManager, params: Value) {
let token = match &params["token"] {
Value::String(s) => s.clone(),
other => other.to_string(),
};
let token = progress_key(&params["token"]);
let value = &params["value"];
let kind = value.get("kind").and_then(Value::as_str);
let message = value.get("message").and_then(Value::as_str).map(str::to_owned);
+8 -6
Переглянути файл
@@ -1049,12 +1049,14 @@ impl LspManager {
if let Err(e) = peer.notify("initialized", json!({})) {
tracing::warn!("{}: {e}", server.name);
}
// Servers that don't ask with `workspace/configuration` only learn settings this way.
let cfg = server.effective_config();
if cfg.settings.is_some()
&& let Err(e) =
peer.notify("workspace/didChangeConfiguration", json!({ "settings": handler::all_settings(&cfg) }))
{
// Sent even without settings: servers that don't ask with `workspace/configuration`
// only learn settings this way, and Pyright, given workspace folders, waits for it
// before asking and loading the workspace.
let mut settings = handler::all_settings(&server.effective_config());
if settings.is_null() {
settings = json!({});
}
if let Err(e) = peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {
tracing::debug!("{}: didChangeConfiguration: {e}", server.name);
}
+88 -4
Переглянути файл
@@ -2,7 +2,7 @@
use ide_core::event::{LspRefreshKind, ServerStatus};
use ide_core::{
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, TaskId, WorkspaceEdit,
};
use ide_jsonrpc::{Handler, NoopHandler, Peer};
use ide_language::{LanguageConfig, LanguageRegistry, LanguageServerConfig};
@@ -1324,6 +1324,36 @@ async fn initialize_and_incremental_sync() {
assert_eq!(infos[0].status, ServerStatus::Ready);
}
/// Pyright, told the client has workspace folders, asks for its configuration and loads the
/// workspace only after a `workspace/didChangeConfiguration`: every server gets one at startup.
#[tokio::test(flavor = "multi_thread")]
async fn every_server_hears_its_configuration_once_initialized() {
let cases = [
(None, None, json!({})),
(Some(json!({ "flag": true })), None, json!({ "flag": true })),
(
None,
Some(json!({ "python": { "pythonPath": "/venv/bin/python" } })),
json!({ "python": { "pythonPath": "/venv/bin/python" } }),
),
(Some(json!({ "flag": true })), Some(json!({ "other": 2 })), json!({ "flag": true, "other": 2 })),
];
for (init, settings, expected) in cases {
let h = harness_configured("mock", "mk", &[("pyright", incremental_caps())], |cfg| {
cfg.initialization_options = init.clone().map(|v| toml::Value::try_from(v).unwrap());
cfg.settings = settings.clone();
});
h.open("a.mk", "x");
h.wait_status("pyright", ServerStatus::Ready).await;
let s = h.launcher.state("pyright");
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
assert_eq!(s.notified("workspace/didChangeConfiguration"), vec![json!({ "settings": expected })]);
let order: Vec<String> = s.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
let at = |m: &str| order.iter().position(|n| n == m).unwrap();
assert!(at("initialized") < at("workspace/didChangeConfiguration"));
}
}
#[tokio::test(flavor = "multi_thread")]
async fn full_sync_and_desync_recovery() {
let h = harness(&[("full", json!({ "textDocumentSync": 1 })), ("inc", json!({ "textDocumentSync": 2 }))]);
@@ -2152,6 +2182,51 @@ async fn replacing_progress_keeps_cancellation_reports_and_indexing_on_the_new_t
);
}
/// A server that ignores `window/workDoneProgress/cancel` (Pyright waiting on a workspace
/// that never loads) does not keep the task "Cancelling…": it ends after a grace period,
/// once, and later reports on the token change nothing. A server that ends it in time ends it.
#[tokio::test(flavor = "multi_thread")]
async fn a_cancelled_progress_the_server_never_ends_ends_on_its_own() {
let h = harness(&[("mock", incremental_caps())]);
h.open("a.mk", "x");
h.wait_status("mock", ServerStatus::Ready).await;
let s = h.launcher.state("mock");
let peer = s.peer();
let begin = |token: &str, title: &str| json!({ "token": token, "value": { "kind": "begin", "title": title, "cancellable": true } });
let task_of = |title: &str| {
h.events.lock().iter().find_map(|e| match e {
IdeEvent::Task { id, title: t, done: false, .. } if t == title => Some(*id),
_ => None,
})
};
let ends = |task: TaskId| {
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Task { id, done: true, .. } if *id == task)).count()
};
peer.notify("$/progress", begin("ignored", "Finding references")).unwrap();
peer.notify("$/progress", begin("honoured", "Indexing")).unwrap();
eventually(|| task_of("Finding references").is_some() && task_of("Indexing").is_some()).await;
h.wait_status("mock", ServerStatus::Busy).await;
let (ignored, honoured) = (task_of("Finding references").unwrap(), task_of("Indexing").unwrap());
assert!(ide_core::task::cancel(ignored));
assert!(ide_core::task::cancel(honoured));
eventually(|| s.notified("window/workDoneProgress/cancel").len() == 2).await;
peer.notify("$/progress", json!({ "token": "honoured", "value": { "kind": "end" } })).unwrap();
eventually(|| ends(honoured) == 1).await;
assert_eq!(ends(ignored), 0, "the server still has its grace period");
eventually(|| ends(ignored) == 1).await;
h.wait_status("mock", ServerStatus::Ready).await;
// Late reports on the token reach no task.
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "report", "message": "late" } })).unwrap();
peer.notify("$/progress", json!({ "token": "ignored", "value": { "kind": "end" } })).unwrap();
peer.notify("$/progress", begin("after", "After")).unwrap();
eventually(|| task_of("After").is_some()).await;
assert_eq!(ends(ignored), 1);
assert_eq!(ends(honoured), 1);
assert!(!h.events.lock().iter().any(|e| matches!(e, IdeEvent::Task { message: Some(m), .. } if m == "late")));
}
#[tokio::test(flavor = "multi_thread")]
async fn cancelling_a_cancellable_progress_task_asks_the_server_to_stop() {
let h = harness(&[("mock", incremental_caps())]);
@@ -2650,7 +2725,16 @@ async fn configuration_answer_resyncs_open_documents_of_opted_in_servers() {
.await;
assert_eq!(s.notified("textDocument/didChange").len(), 2, "one re-sync per answer");
let methods: Vec<String> = extra.notifications.lock().iter().map(|(m, _)| m.clone()).collect();
assert_eq!(methods, ["initialized", "textDocument/didOpen", "textDocument/didChange", "textDocument/didSave"]);
assert_eq!(
methods,
[
"initialized",
"workspace/didChangeConfiguration",
"textDocument/didOpen",
"textDocument/didChange",
"textDocument/didSave"
]
);
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
}
@@ -2706,9 +2790,9 @@ async fn settings_changes_reach_servers_without_restarts() {
let s = h.launcher.state("mock");
*settings.lock() = Some(json!({ "nested": { "other": 2 } }));
h.mgr.reconfigure().await;
eventually(|| !s.notified("workspace/didChangeConfiguration").is_empty()).await;
eventually(|| s.notified("workspace/didChangeConfiguration").len() == 2).await;
assert_eq!(
s.notified("workspace/didChangeConfiguration")[0],
s.notified("workspace/didChangeConfiguration")[1],
json!({ "settings": { "flag": true, "nested": { "deep": 1, "other": 2 } } })
);
assert_eq!(s.launches.load(Ordering::SeqCst), 1);
+26 -7
Переглянути файл
@@ -462,35 +462,54 @@ fn main() {
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires ty on PATH"]
async fn ty_python_end_to_end() {
python_server_end_to_end("ty").await;
}
/// Pyright loads the workspace only after `workspace/didChangeConfiguration`.
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires pyright-langserver on PATH"]
async fn pyright_python_end_to_end() {
python_server_end_to_end("pyright").await;
}
#[tokio::test(flavor = "multi_thread")]
#[ignore = "requires basedpyright on PATH"]
async fn basedpyright_python_end_to_end() {
python_server_end_to_end("basedpyright").await;
}
/// Definition and diagnostics from `name` alone, in a project without configuration.
async fn python_server_end_to_end(name: &str) {
let dir = tempfile::tempdir().unwrap();
let root = dir.path().canonicalize().unwrap();
let path = root.join("example.py");
let source = "def greet(name: str) -> str:\n return name\n\nresult = greet('Ada')\nbad: int = 'wrong'\n";
std::fs::write(&path, source).unwrap();
let mut python = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("python")).unwrap();
python.language_servers.retain(|server| server.name == "ty");
python.language_servers.retain(|server| server.name == name);
assert_eq!(python.language_servers.len(), 1);
python.language_servers[0].fallback = false;
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![python]));
let doc = DocId::next();
mgr.did_open(doc, &path, &LanguageId::new("python"), 1, source);
retry("ty ready", Duration::from_secs(30), || {
let status = last_status(&events, "ty");
retry(&format!("{name} ready"), Duration::from_secs(30), || {
let status = last_status(&events, name);
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
panic!("ty failed: {msg:?}");
panic!("{name} failed: {msg:?}");
}
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
})
.await;
let defs = retry("ty definition", Duration::from_secs(30), || {
let defs = retry(&format!("{name} definition"), Duration::from_secs(30), || {
let mgr = mgr.clone();
async move { mgr.goto(doc, Pos::new(3, 10), GotoKind::Definition).await.ok().filter(|d| !d.is_empty()) }
})
.await;
assert_eq!(defs[0].path, path);
assert_eq!(defs[0].range.start.line, 0);
retry("ty diagnostics", Duration::from_secs(30), || {
retry(&format!("{name} diagnostics"), Duration::from_secs(30), || {
let found = events.lock().iter().any(
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == "ty" && !items.is_empty()),
|event| matches!(event, IdeEvent::Diagnostics { source, items, .. } if source == name && !items.is_empty()),
);
async move { found.then_some(()) }
})
+2 -2
Переглянути файл
@@ -1649,7 +1649,7 @@ pub fn jvm_inspect_bundle(data_dir: &Path) -> Option<PathBuf> {
install_bundle(
data_dir,
"jvm-inspect",
"1.1.0",
"1.1.1",
include_bytes!("../../../java/jvm-inspect/openidea-jvm-inspect.jar"),
)
}
@@ -1745,7 +1745,7 @@ mod usages_bundle_tests {
std::fs::write(dir.path().join(name), b"old").unwrap();
}
let jar = super::jvm_inspect_bundle(dir.path()).unwrap();
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.0.jar"));
assert_eq!(jar, dir.path().join("jvm-inspect-1.1.1.jar"));
assert_eq!(std::fs::read(&jar).unwrap(), include_bytes!("../../../java/jvm-inspect/openidea-jvm-inspect.jar"));
assert!(!dir.path().join("jvm-inspect-0.9.0.jar").exists());
assert_eq!(std::fs::read(dir.path().join("java-usages-1.7.0.jar")).unwrap(), b"old");
+121 -26
Переглянути файл
@@ -197,28 +197,62 @@ fn software_term(lower: &str) -> bool {
.is_some_and(|w| ["s", "x", "z", "ch", "sh"].iter().any(|e| w.ends_with(e)) && plural_of(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>> {
type Cache = HashMap<PathBuf, (Option<SystemTime>, Arc<HashSet<String>>)>;
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
let modified = std::fs::metadata(path).and_then(|m| m.modified()).ok();
let mut cache = CACHE.get_or_init(Default::default).lock();
if let Some((at, words)) = cache.get(path)
&& *at == modified
{
return words.clone();
}
let words: HashSet<String> = match std::fs::read_to_string(path) {
Ok(text) => parse_word_list(&text),
Err(e) => {
tracing::debug!("custom dictionary {}: {e}", path.display());
HashSet::new()
/// A custom dictionary: a word list, or a Hunspell dictionary with its affix rules.
enum CustomDictionary {
Words(HashSet<String>),
Hunspell(Box<spellbook::Dictionary>),
}
impl CustomDictionary {
/// Whether the lowercased `lower` is a word of it, in any case style.
fn contains(&self, lower: &str) -> bool {
match self {
Self::Words(words) => words.contains(lower),
Self::Hunspell(dict) => {
dict.check(lower) || dict.check(&capitalize(lower)) || dict.check(&lower.to_uppercase())
}
}
}
}
/// The `.aff` next to a Hunspell `.dic` (`de_DE.dic` → `de_DE.aff`), if there is one.
fn affix_file(path: &Path) -> Option<PathBuf> {
if !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("dic")) {
return None;
}
["aff", "AFF"].into_iter().map(|ext| path.with_extension(ext)).find(|aff| aff.is_file())
}
/// A custom dictionary file: a Hunspell `.dic` with the `.aff` beside it, with
/// its affix, compounding and case rules; otherwise a plain word list (a `.dic`
/// alone: leading count line and `/FLAGS` ignored). Cached by modification time.
fn dictionary_file(path: &Path) -> Arc<CustomDictionary> {
type Stamp = (Option<SystemTime>, Option<SystemTime>);
type Cache = HashMap<PathBuf, (Stamp, Arc<CustomDictionary>)>;
static CACHE: OnceLock<Mutex<Cache>> = OnceLock::new();
let modified = |p: &Path| std::fs::metadata(p).and_then(|m| m.modified()).ok();
let aff = affix_file(path);
let stamp = (modified(path), aff.as_deref().and_then(modified));
if let Some((at, dict)) = CACHE.get_or_init(Default::default).lock().get(path)
&& *at == stamp
{
return dict.clone();
}
let read = |p: &Path| {
std::fs::read_to_string(p).map_err(|e| tracing::debug!("custom dictionary {}: {e}", p.display())).ok()
};
let words = Arc::new(words);
cache.insert(path.to_path_buf(), (modified, words.clone()));
words
let text = read(path).unwrap_or_default();
let hunspell = aff.as_deref().and_then(read).and_then(|aff| {
spellbook::Dictionary::new(&aff, &text)
.map_err(|e| tracing::warn!("Hunspell dictionary {}: {e}", path.display()))
.ok()
});
let dict = Arc::new(match hunspell {
Some(dict) => CustomDictionary::Hunspell(Box::new(dict)),
None => CustomDictionary::Words(parse_word_list(&text)),
});
CACHE.get_or_init(Default::default).lock().insert(path.to_path_buf(), (stamp, dict.clone()));
dict
}
/// Lowercased words of a word list / Hunspell `.dic` text.
@@ -238,7 +272,7 @@ pub fn parse_word_list(text: &str) -> HashSet<String> {
#[derive(Default)]
pub struct Speller {
accepted: HashSet<String>,
custom: Vec<Arc<HashSet<String>>>,
custom: Vec<Arc<CustomDictionary>>,
}
impl Speller {
@@ -351,16 +385,31 @@ impl Speller {
&& !near_word(lower, |w| english().check(w))
}
/// Replacements for `word`, best first, in the word's case style.
/// Replacements for `word`, best first, in the word's case style: from the
/// English dictionary and the custom Hunspell dictionaries, the closest first.
pub fn suggest(&self, word: &str, limit: usize) -> Vec<String> {
let hunspell = self.custom.iter().filter_map(|d| match d.as_ref() {
CustomDictionary::Hunspell(dict) => Some(dict.as_ref()),
CustomDictionary::Words(_) => None,
});
let dicts: Vec<&spellbook::Dictionary> = std::iter::once(english()).chain(hunspell).collect();
let mut out = Vec::new();
english().suggest(word, &mut out);
if out.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
english().suggest(&word.to_lowercase(), &mut out);
out = out.into_iter().map(|s| capitalize(&s)).collect();
for dict in &dicts {
let mut found = Vec::new();
dict.suggest(word, &mut found);
if found.is_empty() && word.chars().next().is_some_and(char::is_uppercase) {
dict.suggest(&word.to_lowercase(), &mut found);
found = found.into_iter().map(|s| capitalize(&s)).collect();
}
out.extend(found);
}
let mut seen = HashSet::new();
out.retain(|s| s != word && seen.insert(s.clone()));
if dicts.len() > 1 {
// Stable: within a distance each dictionary keeps its own order, English first.
let lower = word.to_lowercase();
out.sort_by_key(|s| edit_distance(&lower, &s.to_lowercase()));
}
out.truncate(limit);
out
}
@@ -416,6 +465,22 @@ impl Speller {
}
}
/// Levenshtein distance in characters.
fn edit_distance(a: &str, b: &str) -> usize {
let b: Vec<char> = b.chars().collect();
let mut row: Vec<usize> = (0..=b.len()).collect();
for (i, ca) in a.chars().enumerate() {
let mut diagonal = row[0];
row[0] = i + 1;
for (j, cb) in b.iter().enumerate() {
let next = (row[j + 1] + 1).min(row[j] + 1).min(diagonal + usize::from(ca != *cb));
diagonal = row[j + 1];
row[j + 1] = next;
}
}
row[b.len()]
}
fn capitalize(s: &str) -> String {
let mut chars = s.chars();
chars.next().into_iter().flat_map(char::to_uppercase).chain(chars).collect()
@@ -736,6 +801,36 @@ mod tests {
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn hunspell_custom_dictionaries_use_their_affix_rules() {
let dir = std::env::temp_dir().join(format!("ide-spell-hunspell-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let dic = dir.join("de_TEST.dic");
std::fs::write(&dic, "3\nhaus/NZ\ntür/NZ\nschlüssel/Z\n").unwrap();
std::fs::write(
dir.join("de_TEST.aff"),
"SET UTF-8\nTRY esianrtolcdugmphbyfvkwzäöüß\nCOMPOUNDFLAG Z\nSFX N Y 1\nSFX N 0 en .\n",
)
.unwrap();
let s = Speller::new::<&str>([], std::slice::from_ref(&dic));
// Affix rules, compounds and case styles of the .aff, not just the listed stems.
for word in ["haus", "Haus", "hausen", "türen", "Haustür", "schlüsselhaus"] {
assert!(s.is_correct(word), "{word}");
}
assert!(!s.is_correct("hauz"));
assert!(!s.is_correct("schlüsselen"));
assert!(s.suggest("Hauss", 5).iter().any(|w| w == "Haus"), "{:?}", s.suggest("Hauss", 5));
// English still checks and suggests.
assert!(s.is_correct("message"));
assert!(s.suggest("mesage", 5).iter().any(|w| w == "message"));
// Without its .aff, a .dic is a word list.
std::fs::remove_file(dir.join("de_TEST.aff")).unwrap();
let words = Speller::new::<&str>([], std::slice::from_ref(&dic));
assert!(words.is_correct("haus"));
assert!(!words.is_correct("hausen"));
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn utf16_ranges() {
let s = Speller::default();
+8 -6
Переглянути файл
@@ -372,6 +372,8 @@ fn materialize_row(
if let Some((pos, total)) = position {
commit.log_position = Some(pos);
commit.log_total = Some(total);
let merge_time_ms = row.merge_time_secs as f64 * 1000.0;
commit.log_merge_time_ms = (merge_time_ms > commit.commit_time_ms).then_some(merge_time_ms);
}
if !summary_only {
commit.message = index.message(repo, row.id)?;
@@ -714,17 +716,16 @@ fn log_indexed_rows(
skip -= 1;
continue;
}
let parents: Vec<ObjectId> = if shallow.contains(&id) {
Vec::new()
} else if let Some((ps, _)) = visibility.index.nodes.get(&id) {
ps.clone()
let (parents, commit_time_secs) = if let Some((parents, time)) = visibility.index.nodes.get(&id) {
(parents.clone(), *time)
} else {
let record = visibility.index.get_with_table(&repo, id, visibility.table)?;
record
let parents = record
.parents
.iter()
.map(|p| ObjectId::from_hex(p.as_bytes()).map_err(gx))
.collect::<IdeResult<Vec<_>>>()?
.collect::<IdeResult<Vec<_>>>()?;
(parents, (record.commit_time_ms / 1000.0) as i64)
};
let shown_parents = if shallow.contains(&id) {
Vec::new()
@@ -743,6 +744,7 @@ fn log_indexed_rows(
graph_parents: shown_parents,
on_current_branch,
history_path: history_paths.get(&id).cloned(),
merge_time_secs: commit_time_secs,
});
if out.len() >= limit || stop_id == Some(id) {
break;
+3
Переглянути файл
@@ -125,6 +125,9 @@ pub struct Commit {
pub log_position: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub log_total: Option<u32>,
/// Newest committer time at or after this row if newer than the row's commit.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub log_merge_time_ms: Option<f64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub graph_boundary_parents: Vec<String>,
/// Reachability from HEAD, computed independently of the visible filters.
+19 -3
Переглянути файл
@@ -19,12 +19,16 @@ const MESSAGES: TableDefinition<&str, &str> = TableDefinition::new("messages-v1"
const MAX_MEMORY_COMMITS: usize = 4096;
const MAX_MEMORY_MESSAGES: usize = 1024;
const MAX_DIRTY_BATCH: usize = 16_384;
/// redb's page cache, which otherwise grows to 1 GiB per repository. Hot commits are already
/// kept in `memory`.
const DB_CACHE_BYTES: usize = 32 * 1024 * 1024;
pub(crate) struct IndexedRow {
pub id: ObjectId,
pub graph_parents: Vec<ObjectId>,
pub on_current_branch: bool,
pub history_path: Option<String>,
pub merge_time_secs: i64,
}
pub(crate) struct IndexedView {
@@ -32,8 +36,15 @@ pub(crate) struct IndexedView {
pub positions: HashMap<ObjectId, usize>,
}
impl IndexedView {
pub fn new(rows: Vec<IndexedRow>) -> Self {
let positions = rows.iter().enumerate().map(|(i, r)| (r.id, i)).collect();
pub fn new(mut rows: Vec<IndexedRow>) -> Self {
let mut positions = HashMap::with_capacity(rows.len());
let mut latest = i64::MIN;
// Compute priority across the whole log so it stays the same on every page.
for (i, row) in rows.iter_mut().enumerate().rev() {
latest = latest.max(row.merge_time_secs);
row.merge_time_secs = latest;
positions.insert(row.id, i);
}
Self { rows, positions }
}
}
@@ -269,7 +280,11 @@ impl LogIndex {
let path = dir.join("commits.redb");
let mut databases = DATABASES.get_or_init(Mutex::default).lock().unwrap_or_else(|p| p.into_inner());
self.db = databases.get(&path).and_then(Weak::upgrade).or_else(|| {
let db = Arc::new(std::fs::create_dir_all(dir).ok().and_then(|_| Database::create(&path).ok())?);
let db = Arc::new(
std::fs::create_dir_all(dir)
.ok()
.and_then(|_| Database::builder().set_cache_size(DB_CACHE_BYTES).create(&path).ok())?,
);
drop_stale_tables(&db);
databases.insert(path, Arc::downgrade(&db));
Some(db)
@@ -334,6 +349,7 @@ impl LogIndex {
history_path: None,
log_position: None,
log_total: None,
log_merge_time_ms: None,
graph_boundary_parents: Vec::new(),
refs: Vec::new(),
});
+17 -2
Переглянути файл
@@ -1155,16 +1155,31 @@ fn check_rev(rev: &str) -> IdeResult<&str> {
Ok(rev)
}
/// The short name of a full branch ref (`refs/heads/x`, `refs/remotes/origin/x`) when it
/// names that same branch: git writes the name it is given into the merge message and the
/// reflog. A name a tag shares stays a full ref, the case IDEA also passes in full.
fn unambiguous_branch_name<'a>(r: &Repo, rev: &'a str) -> &'a str {
let Some(short) = rev.strip_prefix("refs/heads/").or_else(|| rev.strip_prefix("refs/remotes/")) else {
return rev;
};
// An ambiguous name prints nothing (git reports it on stderr).
let full = cli::run_raw(r.root(), &["rev-parse", "--verify", "-q", "--symbolic-full-name", short], None);
match full {
Ok(out) if out.code == Some(0) && out.stdout_str().trim() == rev => short,
_ => rev,
}
}
/// Local changes are stashed and restored around the merge (IDEA's "save local changes").
pub(crate) fn merge(r: &Repo, branch: &str) -> IdeResult<()> {
let branch = check_rev(branch)?;
let branch = unambiguous_branch_name(r, check_rev(branch)?);
crate::preserve::around(r, "Local changes saved before merge", || {
run(r.root(), &["merge", "--no-edit", branch], None).map(|_| ())
})
}
pub(crate) fn rebase(r: &Repo, onto: &str) -> IdeResult<()> {
let onto = check_rev(onto)?;
let onto = unambiguous_branch_name(r, check_rev(onto)?);
crate::preserve::around(r, "Local changes saved before rebase", || {
run(r.root(), &["rebase", onto], None).map(|_| ())
})
+31
Переглянути файл
@@ -505,6 +505,37 @@ fn rebase_and_merge_onto_a_branch_named_like_a_tag_use_the_branch() {
assert_eq!(fx.head(), tip, "fast-forwarded to the branch, not the tag");
}
#[test]
fn merge_and_rebase_record_the_branch_name_git_would_show() {
let (fx, _bare) = Fixture::with_origin();
fx.git(&["switch", "-q", "-c", "topic"]);
fx.write("t.txt", "t\n");
fx.commit_all("topic");
fx.git(&["push", "-q", "origin", "topic"]);
fx.git(&["switch", "-q", "main"]);
fx.write("m.txt", "m\n");
fx.commit_all("main");
let repo = fx.repo();
let subject = || fx.git(&["log", "-1", "--format=%s"]);
repo.merge("refs/heads/topic").unwrap();
assert_eq!(subject(), "Merge branch 'topic'");
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
repo.merge("refs/remotes/origin/topic").unwrap();
assert_eq!(subject(), "Merge remote-tracking branch 'origin/topic'");
fx.git(&["reset", "-q", "--hard", "HEAD~1"]);
repo.rebase("refs/heads/topic").unwrap();
let reflog = fx.git(&["reflog", "--format=%gs"]);
assert!(reflog.contains("rebase (start): checkout topic"), "{reflog}");
fx.git(&["reset", "-q", "--hard", "ORIG_HEAD"]);
// A tag of the same name makes the short name ambiguous: the full ref stays.
fx.git(&["tag", "topic", "main~1"]);
repo.merge("refs/heads/topic").unwrap();
assert_eq!(subject(), "Merge branch 'refs/heads/topic'");
}
#[test]
fn interactive_rebase_edit_stops_for_amend() {
let (fx, ids) = linear();
+22
Переглянути файл
@@ -83,6 +83,28 @@ fn incoming_order_groups_the_merged_branch_before_the_main_parent() {
assert_eq!(out[1].parents, vec![h.c2.clone(), h.s1.clone()]);
}
#[test]
fn an_older_incoming_tip_uses_the_later_commit_time_when_merging_repo_pages() {
let tmp = tempfile::tempdir().unwrap();
let dir = tmp.path();
git(dir, &["init", "-q"], None);
let base = commit(dir, "base.txt", "base", 1000);
let recent = commit(dir, "recent.txt", "recent", 4000);
git(dir, &["checkout", "-qb", "incoming", &base], None);
let incoming = commit(dir, "incoming.txt", "incoming", 2000);
git(dir, &["checkout", "-q", "main"], None);
let repo = Repo::discover(dir).unwrap().unwrap();
let query = LogQuery { summary_only: true, order: LogOrder::Standard, limit: 1, ..Default::default() };
let first = repo.log(&query).unwrap();
assert_eq!(first[0].id, incoming);
assert_eq!(first[0].commit_time_ms, 2_000_000.0);
assert_eq!(first[0].log_merge_time_ms, Some(4_000_000.0));
let next = repo.log(&LogQuery { skip: 1, ..query }).unwrap();
assert_eq!(next[0].id, recent);
assert_eq!(next[0].log_merge_time_ms, None);
}
#[test]
fn no_merges_links_children_to_the_merge_parents() {
let h = history();
+1
Переглянути файл
@@ -86,6 +86,7 @@ Each crate's `lib.rs` opens with a module doc comment describing its contract; r
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ide-cli` | The `openidea` command: argument parsing, the request it sends to a running app over a local socket, installing it on `PATH`. |
| `ide-clipboard` | The OS clipboard's file list (Windows `CF_HDROP`, macOS `NSPasteboard` file URLs) for copying files between the Project view and the file manager. |
| `ide-drag-out` | OS file drags out of a window (GTK, OLE, AppKit), so files dragged from the Project view to another app are copied there. |
| `ide-fonts` | Installed font families for the font pickers, via CoreText, DirectWrite or fontconfig. |
| `src-tauri` (package `openidea`) | The desktop shell: `AppState`, Tauri commands, the event sink, windows, menus, the remote-development client, the `openidea-plugin` URL scheme for plugin web views. Glue only. |
+1 -1
Переглянути файл
@@ -125,7 +125,7 @@ Tasks are saved per project and survive restarts. When the agent supports resumi
**Settings › Tools › Agents** (also **More Agents…** in the agent picker) has two tabs:
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions.
- **Built-in**: for each built-in agent, whether its executable was found on `PATH`, a field to point at a **Custom executable**, **Environment variables** for the agent process (written as `NAME=value; OTHER=value`; the values are kept in the OS credential store) and how to sign in. Changes apply to new sessions. When the agent is a global npm install (such as Claude Code, Codex or Gemini CLI), **Check for updates** compares it with npm's latest stable release and **Update to…** updates that installation.
- **ACP Registry**: agents published in the [ACP Registry](https://agentclientprotocol.com). Search, **Install**, **Update** and **Remove**. Installed agents are kept in OpenIDEA's data directory; downloads are checked against the registry's SHA-256 when it provides one.
**Settings › Tools › Agents › Chat** chooses what the task header shows: **Context window usage**, **Time spent on the task**, **Usage limits** (when the agent reports them, such as Claude Code) and **Session cost**.
+4 -2
Переглянути файл
@@ -172,11 +172,13 @@ The export button offers **Export Data…** and quick copies: **Copy as CSV**, *
The built-in HTTP driver uses a named session by default (`use_http_session=true`). Route requests to one node or enable session affinity. If the session expires or another node reports code 372, OpenIDEA shows a reconnect error and never replays the statement.
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request; result-limit settings remain enabled.
For endpoints that route each request to a different node, add **Advanced** property `use_http_session` with value `false`. Each request omits `session_id`, `session_check` and `session_timeout`, and sends the configured database (or **Default schema**), time zone and Advanced settings again. **Read-only** sends `readonly=1` on every request.
Stateless statements must be independent: `USE`, standalone `SET`, temporary tables and other session state cannot carry over to later requests. Configure the database and settings on the data source. Startup scripts and explicit session properties (`session_id`, `session_check`, `session_timeout`) are rejected. SQL transactions and statement caching are unsupported in either mode.
Strict read-only servers that refuse per-request driver settings cannot use stateless mode: the connection fails without dropping read-only protection or limits. The strict read-only fallback requires proof in the same named HTTP session, including on subsequent requests; use one node or session affinity.
For strict read-only accounts behind a load balancer, set `use_http_session=false` and enable **Read-only**. If the initial connection check receives ClickHouse code 164 for a driver-managed result setting, OpenIDEA repeats the check without its result-limit and JSON number-format settings. Each request still sends `readonly=1`, and the grid still retains only the requested page. Configure server-side limits in the account's settings profile. With the server's default JSON settings, `NaN` and infinities may appear as `NULL`.
Use consistent account profiles across replicas. If the first node accepts the driver's result settings and a later node rejects them, OpenIDEA reports the error on that request. Connect again after aligning the profiles.
## Oracle
+1 -1
Переглянути файл
@@ -112,7 +112,7 @@ The debugger adds attach-only types such as **Remote JVM Debug**, **Go Remote**,
### Common fields
- **Run on**: the local machine, or an SSH host defined in **Settings › Build, Execution, Deployment › Run Targets**. Debugging is not available on run targets. See [SSH](/en/guide/remote/ssh).
- **Working directory**: relative to the project root; empty means the project root.
- **Working directory**: relative to the project root; empty means the project root. It may use the path macros `$PROJECT_DIR$`, `$ContentRoot$`, `$MODULE_DIR$`, `$MODULE_WORKING_DIR$` and `$USER_HOME$`, expanded when the configuration starts, so a shared configuration works on every machine.
- **Environment variables**: `VAR=value` pairs separated by `;`. The list button opens the **Environment Variables** dialog, where **Include system environment variables** can be turned off.
- **Debug adapter**: which debugger **Debug** uses for this configuration (for example `debugpy`, `js-debug`, `codelldb`, `delve`).
+1
Переглянути файл
@@ -86,6 +86,7 @@ Cargo workspace 由 `crates/*` 加 `src-tauri` 组成(见根目录 `Cargo.toml
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| `ide-cli` | `openidea` 命令:参数解析、通过本地 socket 发给运行中应用的请求、安装到 `PATH`。 |
| `ide-clipboard` | 操作系统剪贴板里的文件列表(Windows `CF_HDROP`、macOS `NSPasteboard` 文件 URL),用于 Project 视图与文件管理器之间复制文件。 |
| `ide-drag-out` | 从窗口发起操作系统文件拖放(GTK、OLE、AppKit),从 Project 视图拖到其他程序的文件由该程序复制。 |
| `ide-fonts` | 已安装的字体族,供字体选择器使用,分别通过 CoreText、DirectWrite 或 fontconfig 获取。 |
| `src-tauri`(包名 `openidea`) | 桌面外壳:`AppState`、Tauri 命令、事件 sink、窗口、菜单、远程开发客户端、插件 Web 视图用的 `openidea-plugin` URL scheme。只做胶水。 |
+1 -1
Переглянути файл
@@ -125,7 +125,7 @@ agent 运行过一个任务后,新任务会以它自动批准所有操作的
**设置 › 工具 › 智能体**(也可以在 agent 选择器中点 **更多 Agent…**)有两个标签页:
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。
- **内置**:每个内置 agent 的可执行文件是否在 `PATH` 中找到、指定 **自定义可执行文件** 的输入框、传给 agent 进程的 **环境变量**(格式为 `NAME=value; OTHER=value`;这些值保存在系统凭据存储中)以及登录方式。改动对新会话生效。如果 agent 是 npm 全局安装(例如 Claude Code、Codex、Gemini CLI),**检查更新** 会与 npm 的最新稳定版比较,点击 **更新至…** 即可更新这份安装。
- **ACP 注册表**:[ACP Registry](https://agentclientprotocol.com) 中发布的 agent,可以搜索、**安装**、**更新** 和 **移除**。安装的 agent 保存在 OpenIDEA 的数据目录中;注册表提供 SHA-256 时会校验下载内容。
**设置 › 工具 › 智能体 › 聊天** 决定任务标题栏显示哪些信息:**上下文窗口用量**、**任务耗时**、**用量限额**(agent 报告时,例如 Claude Code)和 **会话花费**。
+4 -2
Переглянути файл
@@ -171,11 +171,13 @@ SQL 补全基于已连接的架构:`FROM`/`JOIN` 后补全表(并根据外
内置 HTTP 驱动默认使用命名会话(`use_http_session=true`)。请求应路由到同一节点,或启用会话亲和性。如果会话过期或其他节点返回代码 372,OpenIDEA 会提示重新连接,且不会重放语句。
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`;结果行数限制设置也会保留。
如果端点把每个请求路由到不同节点,可在 **高级** 中添加属性 `use_http_session`,值设为 `false`。每个请求都省略 `session_id`、`session_check` 和 `session_timeout`,并重新发送配置的数据库(或 **默认架构**)、时区及高级设置。启用 **只读** 时,每个请求都发送 `readonly=1`。
无会话模式下,每条语句必须独立:`USE`、独立的 `SET`、临时表及其他会话状态无法延续到后续请求。请在数据源中配置数据库和设置。驱动会拒绝启动脚本以及显式会话属性(`session_id`、`session_check`、`session_timeout`)。两种模式均不支持 SQL 事务和语句缓存。
拒绝逐请求驱动设置的严格只读服务器无法使用无会话模式:连接会失败,不会移除只读保护或限制。严格只读回退必须在同一个命名 HTTP 会话中验证,后续请求也必须使用该会话;请使用单一节点或会话亲和性。
对于负载均衡器后的严格只读账户,请设置 `use_http_session=false` 并启用 **只读**。如果初次连接检查因驱动管理的结果设置收到 ClickHouse 错误码 164,OpenIDEA 会省略驱动的结果行数限制和 JSON 数字格式设置,再进行一次连接检查。每个请求仍会发送 `readonly=1`,结果表格仍只保留所请求的一页。请在账户的设置配置文件中配置服务端限制。使用服务器的默认 JSON 设置时,`NaN` 和无穷值可能显示为 `NULL`。
请在各副本上使用一致的账户设置配置文件。如果第一个节点接受驱动的结果设置,后续节点拒绝这些设置,OpenIDEA 会报告该请求的错误。调整配置文件使其一致后再连接。
## Oracle
+1 -1
Переглянути файл
@@ -108,7 +108,7 @@ description: "创建、编辑和启动运行配置,从装订区运行代码,
### 通用字段
- **运行于**:本地计算机,或在 **设置 › 构建、执行、部署 › 运行目标** 中添加的 SSH 主机。运行目标上不支持调试。参见 [SSH](/zh/guide/remote/ssh)。
- **工作目录**:相对于项目根目录,留空即项目根目录。
- **工作目录**:相对于项目根目录,留空即项目根目录。可以使用路径宏 `$PROJECT_DIR$`、`$ContentRoot$`、`$MODULE_DIR$`、`$MODULE_WORKING_DIR$` 和 `$USER_HOME$`,在配置启动时展开,因此共享的配置在每台机器上都能用。
- **环境变量**:`VAR=value` 形式,用 `;` 分隔。点旁边的列表按钮打开“环境变量”对话框,可以关闭 **包括系统环境变量**。
- **调试适配器**:按“调试”时这个配置使用哪个调试器(如 `debugpy`、`js-debug`、`codelldb`、`delve`)。
+88
Переглянути файл
@@ -0,0 +1,88 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openSaveActions(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("Optimize imports");
await settings.getByRole("treeitem", { name: "Actions on Save", exact: true }).click();
await search.clear();
return settings;
}
test("Actions on Save aligns each enabled action with its trigger in wide and narrow panes", async ({
workbench: page,
}) => {
const settings = await openSaveActions(page);
const table = settings.getByRole("table", { name: "Actions on Save", exact: true });
const action = table.getByRole("columnheader", { name: "Action", exact: true });
const heading = table.getByRole("columnheader", { name: "Activated on", exact: true });
const format = table.getByRole("row", { name: /Reformat code/ });
const imports = table.getByRole("row", { name: /Optimize imports/ });
const cleanup = table.getByRole("row", { name: /Run code cleanup/ });
const trigger = (action: typeof format) => action.getByRole("cell").nth(1);
await expect(table.getByRole("row")).toHaveCount(4);
await format.getByRole("checkbox").check();
await imports.getByRole("checkbox").press("Space");
await expect(trigger(format)).toHaveText("Save or Save All");
await expect(trigger(imports)).toHaveText("Save or Save All");
await expect(trigger(cleanup)).toBeEmpty();
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 740 });
await expect(heading).toBeInViewport({ ratio: 1 });
await expect(trigger(imports)).toBeInViewport({ ratio: 1 });
const column = (await heading.boundingBox())!;
expect((await action.boundingBox())!.width).toBeGreaterThan(column.width);
expect(
await trigger(imports).evaluate((cell) => {
const range = document.createRange();
range.selectNodeContents(cell.firstElementChild!);
return range.getClientRects().length;
}),
).toBe(1);
for (const row of [format, imports, cleanup]) {
const cell = (await trigger(row).boundingBox())!;
expect(Math.abs(column.x - cell.x)).toBeLessThan(1);
expect(Math.abs(column.width - cell.width)).toBeLessThan(1);
}
expect(await table.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
await expect(settings.getByRole("button", { name: "Editor › General", exact: true })).toBeInViewport();
}
await format.getByRole("checkbox").uncheck();
await expect(trigger(format)).toBeEmpty();
await expect(trigger(imports)).toHaveText("Save or Save All");
});
test("Actions on Save stages the same preferences as Editor General and honors Apply and Cancel", async ({
workbench: page,
}) => {
const settings = await openSaveActions(page);
const format = settings.getByRole("checkbox", { name: "Reformat code", exact: true });
const imports = settings.getByRole("checkbox", { name: "Optimize imports", exact: true });
const cleanup = settings.getByRole("checkbox", { name: "Run code cleanup", exact: true });
const apply = settings.getByRole("button", { name: "Apply", exact: true });
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
await format.check();
await imports.check();
await settings.getByRole("button", { name: "Editor › General", exact: true }).click();
await expect(settings.getByRole("checkbox", { name: "Reformat code on save", exact: true })).toBeChecked();
await settings.getByRole("button", { name: "Back", exact: true }).click();
await expect(format).toBeChecked();
await expect(imports).toBeChecked();
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openSaveActions(page);
await expect(format).toBeChecked();
await expect(imports).toBeChecked();
await cleanup.check();
await cancel.click();
await openSaveActions(page);
await expect(cleanup).not.toBeChecked();
await expect(format).toBeChecked();
await expect(imports).toBeChecked();
});
+85
Переглянути файл
@@ -0,0 +1,85 @@
import type { AgentEntry, AgentTask } from "../src/bindings";
import { expect, test } from "./fixtures";
const first: AgentTask = {
id: "context-first",
title: "First conversation",
provider: "codex",
status: "ready",
isolation: "local",
model: null,
cwd: "/dev/acme-api",
branch: null,
base: null,
baseCommit: null,
error: null,
createdMs: 0,
updatedMs: 0,
config: [],
commands: [],
usage: null,
queue: [],
};
const second: AgentTask = { ...first, id: "context-second", title: "Second conversation" };
for (const active of ["conversation", "file"] as const) {
test(`an agent context menu keeps the current ${active} open`, async ({ workbench: page }) => {
await page.getByRole("treeitem", { name: "README.md", exact: true }).dblclick();
await expect(page.getByRole("tab", { name: "README.md", exact: true })).toBeVisible();
await page.evaluate(
async ({ first, second }) => {
const storePath = "/src/features/agents/store.ts";
const ipcPath = "/src/platform/ipc.ts";
const contributionsPath = "/src/workbench/contributions.ts";
const store = await import(storePath);
const { commands } = await import(ipcPath);
const { toolWindowService } = await import(contributionsPath);
commands.agentChanges = async () => ({ status: "ok", data: [] });
const entries: AgentEntry[] = [{ type: "agent", text: "The active conversation stays here." }];
store.useAgents.setState({
loaded: true,
error: null,
providers: [],
tasks: new Map([
[first.id, first],
[second.id, second],
]),
entries: new Map([
[first.id, entries],
[second.id, []],
]),
composers: new Map([[first.id, { text: "Keep this unsent draft", files: [], images: [] }]]),
unread: new Set(),
docked: null,
homeOpen: false,
sessionLocation: "editor",
});
toolWindowService().show("agents", true);
store.openTask(first.id);
},
{ first, second },
);
const firstTab = page.getByRole("tab", { name: first.title, exact: true });
const fileTab = page.getByRole("tab", { name: "README.md", exact: true });
await expect(firstTab).toHaveAttribute("aria-selected", "true");
if (active === "file") await fileTab.click();
const current = active === "file" ? fileTab : firstTab;
const target = page.getByRole("tree", { name: "Agent tasks" }).getByText(second.title, { exact: true });
await target.click({ button: "right" });
await expect(page.getByRole("menuitem", { name: "Rename…", exact: true })).toBeVisible();
await expect(current).toHaveAttribute("aria-selected", "true");
await expect(page.getByRole("tab", { name: second.title, exact: true })).toHaveCount(0);
await page.keyboard.press("Escape");
await expect(current).toHaveAttribute("aria-selected", "true");
await expect
.poll(() =>
page.evaluate(async (id) => {
const storePath = "/src/features/agents/store.ts";
return (await import(storePath)).composerDraft(id).text;
}, first.id),
)
.toBe("Keep this unsent draft");
await target.click();
await expect(page.getByRole("tab", { name: second.title, exact: true })).toHaveAttribute("aria-selected", "true");
});
}
+80
Переглянути файл
@@ -0,0 +1,80 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openCompletionSettings(page: Page) {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
const search = dialog.getByRole("textbox", { name: "Search settings" });
await search.fill("First letter only");
await dialog.getByRole("treeitem", { name: "Code Completion", exact: true }).click();
await search.clear();
return dialog;
}
test("Code Completion puts both case-matching choices beside the checkbox and keeps them in view", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 1120, height: 740 });
const dialog = await openCompletionSettings(page);
const matchCase = dialog.getByRole("checkbox", { name: "Match case:", exact: true });
const choices = dialog.getByRole("radiogroup", { name: "Match case:", exact: true });
const first = choices.getByRole("radio", { name: "First letter only", exact: true });
const all = choices.getByRole("radio", { name: "All letters", exact: true });
await expect(first).toBeChecked();
await expect(all).not.toBeChecked();
const matchBox = (await matchCase.boundingBox())!;
const firstBox = (await first.boundingBox())!;
const allBox = (await all.boundingBox())!;
expect(Math.abs(matchBox.y - firstBox.y)).toBeLessThan(1);
expect(Math.abs(firstBox.y - allBox.y)).toBeLessThan(1);
expect(firstBox.x).toBeGreaterThan(matchBox.x + matchBox.width);
expect(allBox.x).toBeGreaterThan(firstBox.x + firstBox.width);
for (const width of [580, 520]) {
await page.setViewportSize({ width, height: 740 });
await expect(matchCase).toBeInViewport({ ratio: 1 });
await expect(first).toBeInViewport({ ratio: 1 });
await expect(all).toBeInViewport({ ratio: 1 });
await expect(dialog.getByText("All letters", { exact: true })).toBeInViewport({ ratio: 1 });
}
});
test("Code Completion preserves case and popup delay preferences across Apply and Cancel", async ({
workbench: page,
}) => {
const dialog = await openCompletionSettings(page);
const matchCase = dialog.getByRole("checkbox", { name: "Match case:", exact: true });
const first = dialog.getByRole("radio", { name: "First letter only", exact: true });
const all = dialog.getByRole("radio", { name: "All letters", exact: true });
await matchCase.uncheck();
await expect(first).toBeDisabled();
await expect(all).toBeDisabled();
await expect(first).toBeChecked();
await matchCase.check();
await first.press("ArrowRight");
await expect(all).toBeChecked();
const docs = dialog.getByRole("textbox", { name: "Show the documentation popup in", exact: true });
const params = dialog.getByRole("textbox", { name: "Show the parameter info popup in", exact: true });
await dialog.getByRole("checkbox", { name: "Show the documentation popup in", exact: true }).check();
await dialog.getByRole("checkbox", { name: "Show the parameter info popup in", exact: true }).check();
await docs.fill("750");
await params.fill("1250");
const apply = dialog.getByRole("button", { name: "Apply", exact: true });
const cancel = dialog.getByRole("button", { name: "Cancel", exact: true });
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openCompletionSettings(page);
await expect(all).toBeChecked();
await expect(docs).toHaveValue("750");
await expect(params).toHaveValue("1250");
await matchCase.uncheck();
await expect(all).toBeDisabled();
await expect(all).toBeChecked();
await cancel.click();
await openCompletionSettings(page);
await expect(matchCase).toBeChecked();
await expect(all).toBeChecked();
});
+71
Переглянути файл
@@ -0,0 +1,71 @@
import { expect, openFromTree, test } from "./fixtures";
test("code folding controls stay grouped in narrow settings", async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
const label = "Show code folding outline";
const outline = dialog.getByRole("checkbox", { name: label, exact: true });
const visibility = dialog.getByRole("button", { name: label, exact: true });
const defaults = dialog.getByRole("region", { name: "Fold by default:", exact: true });
await expect(visibility).toHaveText("On hover");
const wideOutline = (await outline.boundingBox())!;
expect((await visibility.boundingBox())!.x).toBeGreaterThan(wideOutline.x + wideOutline.width);
await page.setViewportSize({ width: 520, height: 760 });
await expect(visibility).toBeInViewport({ ratio: 0.98 });
const rows = await Promise.all(
["File header", "Imports", "Documentation comments"].map((name) =>
defaults.getByRole("checkbox", { name, exact: true }).boundingBox(),
),
);
expect(rows[0]!.x).toBe(rows[2]!.x);
expect(rows[0]!.y).toBeLessThan(rows[1]!.y);
expect(rows[1]!.y).toBeLessThan(rows[2]!.y);
await outline.uncheck();
await expect(dialog.getByRole("textbox", { name: label, exact: true })).toBeDisabled();
await expect(defaults.getByRole("checkbox", { name: "Imports", exact: true })).toBeEnabled();
});
test("folding visibility applies to an already open editor and keeps folded arrows visible", async ({
workbench: page,
}) => {
const editor = await openFromTree(page, "App.tsx");
const content = editor.locator(".cm-content");
await content.click();
await page.keyboard.press("Meta+a");
await page.keyboard.insertText("export function sum() {\n return 1 + 2;\n}\n");
const arrow = editor.locator(".cm-foldGutter .cm-openidea-foldOpen").first();
await expect(arrow).toHaveCSS("opacity", "0");
const openSettings = async () => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Code Folding");
await dialog.getByRole("treeitem", { name: "Code Folding", exact: true }).click();
return dialog;
};
const label = "Show code folding outline";
const settings = await openSettings();
await settings.getByRole("button", { name: label, exact: true }).click();
await page.getByRole("option", { name: "Always", exact: true }).click();
await settings.getByRole("button", { name: "OK", exact: true }).click();
await content.hover();
await expect(arrow).toHaveCSS("opacity", "1");
const reopened = await openSettings();
const control = reopened.getByRole("button", { name: label, exact: true });
await expect(control).toHaveText("Always");
await control.click();
await page.getByRole("option", { name: "On hover", exact: true }).click();
await reopened.getByRole("button", { name: "OK", exact: true }).click();
await content.hover();
await expect(arrow).toHaveCSS("opacity", "0");
await arrow.click();
await content.hover();
await expect(editor.locator(".cm-foldGutter .cm-openidea-foldClosed").first()).toHaveCSS("opacity", "1");
await expect(editor.locator(".cm-foldPlaceholder").first()).toBeVisible();
});
+17 -1
Переглянути файл
@@ -60,7 +60,21 @@ test("completion lists the server's items and inserts the chosen one", async ({
await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
await page.keyboard.press("End");
await page.keyboard.press("Enter");
await page.keyboard.type("order.");
await page.keyboard.type("order");
const firstPlacement = await page.evaluateHandle(() => {
const sample: { labelX?: number } = {};
const observer = new MutationObserver(() => {
const label = document.querySelector(
":is(.cm-tooltip-above, .cm-tooltip-below).cm-lsp-completion .cm-completionLabel",
);
if (!label) return;
sample.labelX = label.getBoundingClientRect().left;
observer.disconnect();
});
observer.observe(document.body, { subtree: true, attributes: true, attributeFilter: ["class"] });
return sample;
});
await page.keyboard.type(".");
await page.keyboard.press("Control+Space");
const popup = page.locator(".cm-tooltip-autocomplete");
await expect(popup.getByText("total", { exact: true })).toBeVisible();
@@ -83,6 +97,8 @@ test("completion lists the server's items and inserts the chosen one", async ({
});
const label = await method.locator(".cm-completionLabel").boundingBox();
// Subpixel rounding differs per platform/font; a mis-set inset is a whole icon column off.
const firstLabelX = await firstPlacement.evaluate((sample) => sample.labelX!);
expect(Math.abs(firstLabelX - wordStart)).toBeLessThanOrEqual(2);
expect(Math.abs(label!.x - wordStart)).toBeLessThanOrEqual(2);
const zoomedSize = await editor.locator(".cm-content").evaluate(async (content) => {
const viewModule = "/node_modules/.vite/deps/@codemirror_view.js";
+3 -2
Переглянути файл
@@ -2,7 +2,8 @@ import { expect, stubDesktop, test } from "./fixtures";
const amountName = "regionalSettlementAmountFromExternalProcessorBeforeRounding";
const routingName = "settlementRoutingReferenceForCrossBorderReconciliation";
const routingValue = "'APR-2026 / eu-west / batch-701 / settlement complete'";
const routingText = "APR-2026 / eu-west / batch-701 / settlement complete";
const routingValue = "'" + routingText + "'";
test("keeps values and their full-value action readable in a narrow debugger", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1220, height: 760 });
@@ -46,7 +47,7 @@ test("keeps values and their full-value action readable in a narrow debugger", a
await expect(show).toBeInViewport({ ratio: 1 });
await show.click();
const dialog = page.getByRole("dialog", { name: `Value of ${routingName}` });
await expect(dialog.getByText(routingValue, { exact: true })).toBeVisible();
await expect(dialog.getByText(routingText, { exact: true })).toBeVisible();
await page.keyboard.press("Escape");
await expect(dialog).toBeHidden();
+12
Переглянути файл
@@ -666,12 +666,24 @@ test("dragging the Markdown split divider resizes and reflows editor and preview
const box = (await handle.boundingBox())!;
const startX = box.x + box.width / 2;
const midY = box.y + box.height / 2;
const cursorAt = (x: number) =>
page.evaluate(({ x, y }) => getComputedStyle(document.elementFromPoint(x, y)!).cursor, { x, y: midY });
await page.mouse.move(startX + 40, midY);
await page.mouse.move(startX, midY);
expect(await cursorAt(startX)).toMatch(/resize$/);
await page.mouse.move(startX - 5, midY);
expect(await cursorAt(startX - 5)).not.toMatch(/resize$/);
await page.mouse.move(startX, midY);
await page.mouse.down();
await page.mouse.move(startX - 180, midY, { steps: 6 });
await expect(handle).toHaveAttribute("data-separator", "active");
const sourceX = (await editor.boundingBox())!.x + 60;
expect(await cursorAt(sourceX)).toMatch(/resize$/);
await page.mouse.up();
await page.mouse.move(sourceX, midY);
expect(await cursorAt(sourceX)).toBe("text");
await expect.poll(async () => (await editor.boundingBox())!.width).toBeLessThan(initialEditor - 150);
await expect.poll(async () => (await preview.boundingBox())!.width).toBeGreaterThan(initialPreview + 150);
+87
Переглянути файл
@@ -0,0 +1,87 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openGeneral(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("File patterns");
await settings.getByRole("treeitem", { name: "General", exact: true }).click();
await search.clear();
return settings;
}
test("Editor General fits the soft-wrap pattern field and stacks the scrolling choices", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 1120, height: 850 });
const settings = await openGeneral(page);
const softWraps = settings.getByRole("region", { name: "Soft Wraps", exact: true });
const wrap = softWraps.getByRole("checkbox", { name: "Soft-wrap files", exact: true });
const patterns = softWraps.getByRole("textbox", { name: "File patterns" });
const scrolling = settings.getByRole("region", { name: "Scrolling", exact: true });
const virtualSpace = settings.getByRole("region", { name: "Virtual Space", exact: true });
const caretPrompt = scrolling.getByText("When caret is moved", { exact: true });
const center = scrolling.getByRole("radio", { name: /keep caret line centered/ });
const minimize = scrolling.getByRole("radio", { name: /minimize editor scrolling/ });
await expect(patterns).toBeVisible();
const toggle = (await wrap.boundingBox())!;
const field = (await patterns.boundingBox())!;
expect(toggle.y).toBeGreaterThan(field.y);
expect(toggle.y + toggle.height).toBeLessThan(field.y + field.height);
expect(field.x).toBeGreaterThan(toggle.x + toggle.width);
expect(await patterns.getAttribute("aria-describedby")).toBeTruthy();
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 850 });
await patterns.scrollIntoViewIfNeeded();
await expect(patterns).toBeInViewport({ ratio: 0.99 });
const fieldBox = (await patterns.boundingBox())!;
const indent = softWraps.getByRole("checkbox", { name: "Use original line's indent for wrapped parts" });
expect((await indent.boundingBox())!.y).toBeGreaterThan(fieldBox.y + fieldBox.height);
expect(await scrolling.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
expect((await scrolling.boundingBox())!.y).toBeGreaterThan((await virtualSpace.boundingBox())!.y);
const first = (await center.boundingBox())!;
const second = (await minimize.boundingBox())!;
expect(first.x).toBeGreaterThan((await caretPrompt.boundingBox())!.x);
expect(second.y).toBeGreaterThan(first.y + first.height);
expect(Math.abs(first.x - second.x)).toBeLessThan(1);
}
});
test("Editor General keeps wheel and wrap dependencies and saves the selected values", async ({ workbench: page }) => {
const settings = await openGeneral(page);
const zoom = settings.getByRole("checkbox", { name: "Change font size with Ctrl/Command+Mouse Wheel" });
const active = settings.getByRole("radio", { name: "Active editor", exact: true });
const all = settings.getByRole("radio", { name: "All editors", exact: true });
const wrap = settings.getByRole("checkbox", { name: "Soft-wrap files", exact: true });
const patterns = settings.getByRole("textbox", { name: "File patterns", exact: true });
const indent = settings.getByRole("checkbox", { name: "Use original line's indent for wrapped parts" });
const apply = settings.getByRole("button", { name: "Apply", exact: true });
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
await zoom.uncheck();
await expect(active).toBeDisabled();
await expect(all).toBeDisabled();
await zoom.check();
await expect(active).toBeChecked();
await active.focus();
await page.keyboard.press("ArrowDown");
await expect(all).toBeChecked();
await wrap.uncheck();
await expect(patterns).toBeDisabled();
await expect(indent).toBeDisabled();
await wrap.check();
await expect(indent).toBeEnabled();
await patterns.fill("*.md; *.notes");
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openGeneral(page);
await expect(zoom).toBeChecked();
await expect(all).toBeChecked();
await expect(wrap).toBeChecked();
await expect(patterns).toHaveValue("*.md; *.notes");
});
+88
Переглянути файл
@@ -0,0 +1,88 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openFileColors(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("Use in project view");
await settings.getByRole("treeitem", { name: "File Colors", exact: true }).click();
await search.clear();
return settings;
}
test("File Colors fits its switches and keeps the toolbar and table headings in view", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1120, height: 760 });
const settings = await openFileColors(page);
const table = settings.getByRole("table", { name: "File colors", exact: true });
const scope = table.getByRole("columnheader", { name: "Scope", exact: true });
const color = table.getByRole("columnheader", { name: "Color", exact: true });
const toolbar = settings.getByRole("toolbar", { name: "File colors actions", exact: true });
const master = settings.getByRole("checkbox", { name: "Enable file colors", exact: true });
const project = settings.getByRole("checkbox", { name: "Use in project view", exact: true });
const hex = settings.getByRole("textbox", { name: "Custom colour hex", exact: true });
await expect(scope).toBeVisible();
expect(Math.abs((await master.boundingBox())!.y - (await project.boundingBox())!.y)).toBeLessThan(1);
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 760 });
await expect(project).toBeInViewport({ ratio: 1 });
await expect(color).toBeInViewport({ ratio: 1 });
await expect(hex).toBeInViewport({ ratio: 1 });
expect((await hex.boundingBox())!.width).toBeGreaterThan(70);
expect((await color.boundingBox())!.width).toBeGreaterThan(80);
const cell = table.getByRole("cell", { name: "Green", exact: true });
expect(Math.abs((await color.boundingBox())!.x - (await cell.boundingBox())!.x)).toBeLessThan(1);
}
const add = toolbar.getByRole("button", { name: "Add", exact: true });
for (let i = 0; i < 10; i++) await add.click();
const last = table.getByRole("row").last();
await expect(last.getByRole("button")).toHaveAttribute("aria-pressed", "true");
await expect(last).toBeInViewport({ ratio: 1 });
await expect(scope).toBeInViewport({ ratio: 1 });
await expect(toolbar).toBeInViewport({ ratio: 1 });
});
test("File Colors preserves ordered rules and placement settings across Apply and Cancel", async ({
workbench: page,
}) => {
const settings = await openFileColors(page);
const table = settings.getByRole("table", { name: "File colors", exact: true });
const tests = table.getByRole("button", { name: "Tests", exact: true });
const firstRule = table.getByRole("row").nth(1);
const toolbar = settings.getByRole("toolbar", { name: "File colors actions", exact: true });
const tabs = settings.getByRole("checkbox", { name: "Use in editor tabs", exact: true });
const master = settings.getByRole("checkbox", { name: "Enable file colors", exact: true });
const apply = settings.getByRole("button", { name: "Apply", exact: true });
const cancel = settings.getByRole("button", { name: "Cancel", exact: true });
await tabs.uncheck();
await master.uncheck();
await expect(tabs).toBeDisabled();
await master.check();
await expect(tabs).not.toBeChecked();
await expect(tabs).toBeEnabled();
await tests.press("Enter");
await expect(tests).toHaveAttribute("aria-pressed", "true");
await settings.getByRole("textbox", { name: "Custom colour hex", exact: true }).fill("#1258a5");
await toolbar.getByRole("button", { name: "Move Up", exact: true }).click();
await expect(firstRule.getByRole("button", { name: "Tests", exact: true })).toBeVisible();
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
await apply.click();
await expect(apply).toBeDisabled();
await cancel.click();
await openFileColors(page);
await expect(tabs).not.toBeChecked();
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
const remove = toolbar.getByRole("button", { name: "Remove", exact: true });
await remove.click();
await remove.click();
await expect(table.getByText("No file colors. Click + to add one.", { exact: true })).toBeVisible();
await expect(remove).toBeDisabled();
await cancel.click();
await openFileColors(page);
await expect(firstRule.getByRole("cell", { name: "#1258a5", exact: true })).toBeVisible();
});
+67
Переглянути файл
@@ -0,0 +1,67 @@
import { expect, test } from "./fixtures";
test.beforeEach(async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
await page.evaluate(async () => {
const path = "/src/features/settings/model/staging.ts";
(await import(/* @vite-ignore */ path)).selectPage("editor.fileTemplates");
});
});
test("file template fields and editors fit in narrow settings", async ({ workbench: page }) => {
await page.setViewportSize({ width: 520, height: 760 });
const tabs = page.getByRole("tablist", { name: "Template kinds" });
const name = page.getByRole("textbox", { name: "Template name" });
const extension = page.getByRole("textbox", { name: "Extension" });
const style = page.getByRole("button", { name: "File name style" });
const body = page.getByRole("textbox", { name: "Template body", exact: true });
await expect(body).toBeInViewport({ ratio: 0.98 });
expect((await body.boundingBox())!.width).toBeGreaterThan(150);
await expect(extension).toBeInViewport({ ratio: 0.98 });
await expect(style).toBeInViewport({ ratio: 0.98 });
expect((await extension.boundingBox())!.y).toBeGreaterThan((await name.boundingBox())!.y);
expect((await style.boundingBox())!.y).toBeGreaterThan((await extension.boundingBox())!.y);
await style.click();
await expect(page.getByRole("option", { name: "PascalCase" })).toBeVisible();
await page.keyboard.press("Escape");
for (const [tab, editorName] of [
["Includes", "Include body"],
["Code", "Code template body"],
]) {
await tabs.getByRole("tab", { name: tab, exact: true }).click();
await expect(page.getByRole("textbox", { name: editorName, exact: true })).toBeInViewport({ ratio: 0.98 });
}
});
test("file template tabs share a remembered, keyboard-adjustable divider", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1100, height: 760 });
const tabs = page.getByRole("tablist", { name: "Template kinds" });
const name = page.getByRole("textbox", { name: "Template name" });
const extension = page.getByRole("textbox", { name: "Extension" });
const divider = page.getByRole("separator", { name: "Resize file template panes" });
const width = async (listName: string) =>
(await page.getByRole("listbox", { name: listName, exact: true }).boundingBox())!.width;
await expect(divider).toBeVisible();
expect((await extension.boundingBox())!.y).toBe((await name.boundingBox())!.y);
const initial = await width("File templates");
await divider.press("ArrowRight");
await expect.poll(() => width("File templates")).toBeGreaterThan(initial + 10);
const resized = await width("File templates");
await tabs.getByRole("tab", { name: "Files", exact: true }).press("ArrowRight");
await expect(tabs.getByRole("tab", { name: "Includes", exact: true })).toBeFocused();
await expect.poll(() => width("Includes")).toBeCloseTo(resized, 0);
await page.getByRole("button", { name: "Add Include" }).click();
const include = page.getByRole("textbox", { name: "Include body" });
await include.fill("// Shared header");
await tabs.getByRole("tab", { name: "Code", exact: true }).click();
await expect.poll(() => width("Code templates")).toBeCloseTo(resized, 0);
await tabs.getByRole("tab", { name: "Includes", exact: true }).click();
await page.getByRole("option", { name: "New Include", exact: true }).click();
await expect(include).toHaveValue("// Shared header");
});
+93
Переглянути файл
@@ -0,0 +1,93 @@
import { expect, stubDesktop, test } from "./fixtures";
test.beforeEach(async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
});
test("inlay hint categories and the preview fit at both settings widths", async ({ workbench: page }) => {
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
await expect(preview).toBeVisible();
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
await page.setViewportSize({ width: 1100, height: 760 });
const wideList = (await categories.boundingBox())!;
const widePreview = (await preview.boundingBox())!;
expect(widePreview.x).toBeGreaterThan(wideList.x + wideList.width);
expect(widePreview.y).toBeLessThan(wideList.y + wideList.height);
await page.setViewportSize({ width: 520, height: 760 });
await categories.press("End");
await expect(categories.getByRole("option", { name: /^Other hints/ })).toHaveAttribute("aria-selected", "true");
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
const narrowList = (await categories.boundingBox())!;
const narrowPreview = (await preview.boundingBox())!;
expect(narrowPreview.y).toBeGreaterThan(narrowList.y + narrowList.height);
await expect(preview).toBeInViewport({ ratio: 0.98 });
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
});
test("the hint preview follows staged settings and saves the selected category", async ({ workbench: page }) => {
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
const search = dialog.getByRole("textbox", { name: "Search settings" });
const categories = dialog.getByRole("listbox", { name: "Inlay hint categories" });
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
const master = dialog.getByRole("checkbox", { name: "Show inlay hints", exact: true });
const parameters = dialog.getByRole("checkbox", { name: "Parameter names", exact: true });
const parameterHint = preview.getByText("width:", { exact: true });
await search.fill("Parameter names");
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
await expect(categories.getByRole("option", { name: "Parameter names", exact: true })).toHaveAttribute(
"aria-selected",
"true",
);
await expect(parameterHint).toBeVisible();
await master.uncheck();
await expect(parameters).toBeDisabled();
await expect(parameterHint).toHaveCount(0);
await expect(dialog.getByRole("checkbox", { name: "Show Code Vision", exact: true })).toBeEnabled();
await master.check();
await expect(parameterHint).toBeVisible();
await parameters.uncheck();
await expect(parameterHint).toHaveCount(0);
await categories.press("Home");
await expect(preview.getByText(": f64", { exact: true })).toBeVisible();
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
await page.keyboard.press("Meta+,");
await search.fill("Parameter names");
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
await expect(parameters).not.toBeChecked();
await expect(parameterHint).toHaveCount(0);
});
test("the hint preview respects the sample language's staged preference", async ({ workbench: page }) => {
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
await stubDesktop(page);
await page.evaluate(() => {
window.__ipc.handlers.languages = () => [
{ id: "go", name: "Go" },
{ id: "rust", name: "Rust" },
];
});
await page.keyboard.press("Meta+,");
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Inlay Hints");
await dialog.getByRole("treeitem", { name: "Inlay Hints", exact: true }).click();
const preview = dialog.getByRole("region", { name: "Inlay hint preview" });
const typeHint = preview.getByText(": f64", { exact: true });
await expect(typeHint).toBeVisible();
await dialog.getByRole("checkbox", { name: "Rust", exact: true }).uncheck();
await expect(typeHint).toHaveCount(0);
await dialog.getByRole("listbox", { name: "Inlay hint categories" }).press("End");
await expect(preview.getByText("= 300", { exact: true })).toBeVisible();
});
+17
Переглянути файл
@@ -133,3 +133,20 @@ test("rectangular drag remains configurable after removal and saves a middle mou
await expect(row).toContainText("Middle Click");
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
});
test("the action search also finds actions by typed shortcut text", async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
await settings.getByRole("treeitem", { name: "Keymap", exact: true }).click();
const search = settings.getByRole("textbox", { name: "Search actions", exact: true });
const actions = settings.getByRole("tree", { name: "Actions" });
const goToFile = actions.getByRole("treeitem", { name: /Go to File/ });
for (const query of ["cmd+shift+o", "Shift+Meta+O", "⇧⌘O"]) {
await search.fill(query);
await expect(goToFile).toBeVisible();
await expect(actions.getByRole("treeitem", { name: /Recent Files/ })).toHaveCount(0);
}
const shots = process.env.OPENIDEA_E2E_SHOTS;
if (shots) await settings.screenshot({ path: `${shots}/after.png`, animations: "disabled" });
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
});
+73
Переглянути файл
@@ -0,0 +1,73 @@
import { expect, test } from "./fixtures";
test.beforeEach(async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Notifications");
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
});
test("notification group controls stay inside narrow settings", async ({ workbench: page }) => {
await page.setViewportSize({ width: 520, height: 760 });
const groups = page.getByRole("region", { name: "Groups", exact: true });
const popup = groups.getByRole("button", { name: "System Messages popup type" });
await expect(popup).toBeInViewport({ ratio: 0.98 });
expect(await groups.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
const list = groups.getByRole("listbox", { name: "Notification groups" });
const controls = groups.getByRole("region", { name: "System Messages", exact: true });
const listBounds = (await list.boundingBox())!;
expect((await controls.boundingBox())!.y).toBeGreaterThanOrEqual(listBounds.y + listBounds.height);
await popup.click();
await expect(page.getByRole("option", { name: "Sticky balloon", exact: true })).toBeInViewport();
await page.keyboard.press("Escape");
await list.press("End");
const lastGroup = list.getByRole("option", { name: "Distraction Free Mode", exact: true });
await expect(lastGroup).toHaveAttribute("aria-selected", "true");
await expect(lastGroup).toBeInViewport({ ratio: 0.98 });
await list.press("Home");
await page.setViewportSize({ width: 1100, height: 760 });
const wideList = (await list.boundingBox())!;
const wideControls = (await controls.boundingBox())!;
expect(wideControls.x).toBeGreaterThan(wideList.x + wideList.width);
expect(wideControls.y).toBeLessThan(wideList.y + wideList.height);
});
test("notification groups follow settings search and keep edits per group", async ({ workbench: page }) => {
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
const search = dialog.getByRole("textbox", { name: "Search settings" });
const list = dialog.getByRole("listbox", { name: "Notification groups" });
const systemPopup = dialog.getByRole("button", { name: "System Messages popup type" });
const versionControlPopup = dialog.getByRole("button", { name: "Version Control popup type" });
const versionControlLog = dialog.getByRole("checkbox", { name: "Show Version Control in tool window" });
await list.press("ArrowDown");
await expect(list.getByRole("option", { name: "Language Servers" })).toHaveAttribute("aria-selected", "true");
await search.fill("Version Control");
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
await expect(list.getByRole("option", { name: "Version Control", exact: true })).toHaveAttribute(
"aria-selected",
"true",
);
await versionControlPopup.click();
await page.getByRole("option", { name: "No popup", exact: true }).click();
await versionControlLog.uncheck();
await list.press("Home");
await expect(systemPopup).toHaveText("Balloon");
await expect(dialog.getByRole("checkbox", { name: "Show System Messages in tool window" })).toBeChecked();
await list.getByRole("option", { name: "Version Control", exact: true }).click();
await expect(versionControlPopup).toHaveText("No popup");
await expect(versionControlLog).not.toBeChecked();
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
await page.keyboard.press("Meta+,");
await search.fill("Version Control");
await dialog.getByRole("treeitem", { name: "Notifications", exact: true }).click();
await expect(versionControlPopup).toHaveText("No popup");
await expect(versionControlLog).not.toBeChecked();
});
+80
Переглянути файл
@@ -0,0 +1,80 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openPostfixSettings(page: Page) {
await page.keyboard.press("Meta+,");
const settings = page.getByRole("dialog", { name: "Settings", exact: true });
const search = settings.getByRole("textbox", { name: "Search settings" });
await search.fill("Postfix Completion");
await settings.getByRole("treeitem", { name: "Postfix Completion", exact: true }).click();
await search.clear();
return settings;
}
test("Postfix Completion pairs the template list with a responsive code preview", async ({ workbench: page }) => {
await page.setViewportSize({ width: 1120, height: 760 });
const settings = await openPostfixSettings(page);
const list = settings.getByRole("list", { name: "Postfix templates", exact: true });
const preview = settings.getByRole("region", { name: "Template preview", exact: true });
const before = preview.locator("pre").first();
const after = preview.locator("pre").last();
await expect(before).toHaveText("expr.if");
await expect(after).toContainText("if (expr)");
const listBounds = (await list.boundingBox())!;
const widePreview = (await preview.boundingBox())!;
expect(widePreview.x).toBeGreaterThanOrEqual(listBounds.x + listBounds.width);
expect(widePreview.y).toBeLessThan(listBounds.y);
await list.getByRole("button", { name: ".if", exact: true }).press("ArrowDown");
const elseTemplate = list.getByRole("button", { name: ".else", exact: true });
await expect(elseTemplate).toBeFocused();
await expect(elseTemplate).toHaveAttribute("aria-pressed", "true");
await expect(before).toHaveText("expr.else");
await expect(after).toContainText("if (!expr)");
await page.setViewportSize({ width: 520, height: 760 });
await settings.getByRole("tab", { name: "Python", exact: true }).click();
await expect(before).toHaveText("expr.if");
await expect(after).toContainText("if expr:");
await after.scrollIntoViewIfNeeded();
await expect(after).toBeInViewport({ ratio: 0.99 });
const narrowList = (await list.boundingBox())!;
const narrowPreview = (await preview.boundingBox())!;
expect(narrowPreview.y).toBeGreaterThanOrEqual(narrowList.y + narrowList.height);
expect(Math.abs(narrowList.x - narrowPreview.x)).toBeLessThan(2);
expect(await preview.evaluate((el) => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
await settings.getByRole("tab", { name: "JavaScript / TypeScript", exact: true }).click();
await expect(elseTemplate).toHaveAttribute("aria-pressed", "true");
await expect(before).toHaveText("expr.else");
await settings.getByRole("tab", { name: "Java", exact: true }).click();
await list.getByRole("button", { name: ".var", exact: true }).click();
await expect(preview.getByText("Fallback expansion", { exact: true })).toBeVisible();
await expect(after).toContainText("var value = expr;");
});
test("Postfix Completion keeps template selection separate from enabled preferences", async ({ workbench: page }) => {
const settings = await openPostfixSettings(page);
const master = settings.getByRole("checkbox", { name: "Enable postfix completion", exact: true });
const expand = settings.getByRole("checkbox", { name: "Expand templates with Tab", exact: true });
const ifEnabled = settings.getByRole("checkbox", { name: "Enable .if", exact: true });
const preview = settings.getByRole("region", { name: "Template preview", exact: true });
const before = preview.locator("pre").first();
await settings.getByRole("button", { name: ".else", exact: true }).click();
await expect(ifEnabled).toBeChecked();
await ifEnabled.uncheck();
await expect(before).toHaveText("expr.if");
await master.uncheck();
await expect(expand).toBeDisabled();
await expect(ifEnabled).toBeDisabled();
await settings.getByRole("button", { name: ".else", exact: true }).click();
await expect(before).toHaveText("expr.else");
await master.check();
await expect(ifEnabled).not.toBeChecked();
await settings.getByRole("button", { name: "OK", exact: true }).click();
await openPostfixSettings(page);
await expect(ifEnabled).not.toBeChecked();
await expect(master).toBeChecked();
});
+2 -2
Переглянути файл
@@ -82,7 +82,7 @@ test("Quick Evaluate opens an object tree that fits the editor and returns focus
await expect(hint.getByRole("tree")).toHaveCount(0);
await expect(hint).toHaveText(/subtotal\s*=\s*42/);
expect(await ipcCalls(page, "debug_evaluate_in")).toEqual([
{ session: 91, frameId: 11, expression: "summary", context: "hover" },
{ session: 91, frameId: 11, expression: "subtotal", context: "hover" },
{ session: 91, frameId: 11, expression: "summary", context: "watch" },
{ session: 91, frameId: 11, expression: "subtotal", context: "watch" },
]);
});
+103
Переглянути файл
@@ -0,0 +1,103 @@
import type { EditorView } from "@codemirror/view";
import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
test("Safe Delete lays out the search option and makes View Usages the default in a narrow window", async ({
workbench: page,
}) => {
const editor = await openFromTree(page, "App.tsx");
await page.setViewportSize({ width: 425, height: 500 });
const content = editor.locator(".cm-content");
const symbol = "reconcileOutstandingSupplierAdjustmentsForTheMonthlySettlementArchive";
const source = [
`export function ${symbol}() {`,
" return 1;",
"}",
"",
`const debit = ${symbol}();`,
`const credit = ${symbol}();`,
].join("\n");
await content.evaluate(
(element, { source, symbol }) => {
const view = (element as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
view.dispatch({
changes: { from: 0, to: view.state.doc.length, insert: source },
selection: { anchor: source.indexOf(symbol) + 1 },
});
view.focus();
},
{ source, symbol },
);
await stubDesktop(page);
await page.evaluate(
({ source, symbol }) => {
const path = "/dev/acme-api/App.tsx";
const range = (line: number, col: number, end = col + symbol.length) => ({
start: { line, col },
end: { line, col: end },
});
const selection = range(0, "export function ".length);
const handlers = window.__ipc.handlers;
handlers.lsp_goto = () => [{ path, range: selection }];
handlers.doc_outline = () => [
{
name: symbol,
detail: null,
kind: "function",
range: { start: { line: 0, col: 0 }, end: { line: 2, col: 1 } },
selection_range: selection,
children: [],
},
];
handlers.languages = () => [];
handlers.lsp_references = () => ({
locations: [
{ path, range: range(4, "const debit = ".length) },
{ path, range: range(5, "const credit = ".length) },
],
incomplete: null,
});
handlers.fs_read_text = () => source;
},
{ source, symbol },
);
const openSafeDelete = () =>
page.evaluate(async () => {
const module = "/src/platform/actions.ts";
const { executeAction } = await import(/* @vite-ignore */ module);
void executeAction("refactor.safeDelete");
});
const usageSearches = async () => (await ipcCalls(page, "lsp_references")).filter((call) => call.projectWide);
await openSafeDelete();
const prompt = page.getByRole("dialog", { name: "Safe Delete", exact: true });
await expect(prompt.locator("[data-dialog-titlebar]")).toHaveText("Safe Delete");
const description = prompt.getByText(`Delete Function '${symbol}'?`);
const commentSearch = prompt.getByRole("checkbox", { name: "Search in comments and strings" });
await expect(commentSearch).toBeChecked();
const expectedLeft = (await description.boundingBox())!.x;
expect((await commentSearch.boundingBox())!.x).toBeCloseTo(expectedLeft, 0);
await expect(prompt.locator("[data-dialog-body]")).toContainText(symbol);
await page.keyboard.press("Escape");
await expect(prompt).toBeHidden();
await expect(content).toBeFocused();
expect(await usageSearches()).toHaveLength(0);
await openSafeDelete();
await commentSearch.uncheck();
await prompt.getByRole("button", { name: "OK", exact: true }).click();
const conflict = page.getByRole("dialog", { name: "Usages Detected", exact: true });
await expect(conflict.getByRole("heading", { name: "2 usages found" })).toBeVisible();
await expect(conflict.getByText(`Function '${symbol}' has 2 usages that are not safe to delete.`)).toBeVisible();
for (const button of ["View Usages", "Delete Anyway", "Cancel"]) {
await expect(conflict.getByRole("button", { name: button, exact: true })).toBeInViewport({ ratio: 1 });
}
expect(
await conflict.locator("[data-dialog-body]").evaluate((element) => element.scrollWidth - element.clientWidth),
).toBe(0);
await expect(conflict.getByRole("button", { name: "View Usages" })).toBeFocused();
await page.keyboard.press("Enter");
await expect(conflict).toBeHidden();
await expect(page.getByRole("region", { name: "Find Usages", exact: true })).toBeVisible();
await expect(content).toContainText("export function");
expect(await usageSearches()).toHaveLength(1);
});
+4 -3
Переглянути файл
@@ -184,6 +184,7 @@ test("Language Servers page installs a tool with progress (in-memory installer)"
test("font picker supports manual families and CJK fallback in browser development", async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings" });
const preview = dialog.getByRole("textbox", { name: "Font preview", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Typography Settings");
await dialog.getByRole("treeitem", { name: "Font", exact: true }).click();
const family = dialog.getByRole("combobox", { name: "Font", exact: true });
@@ -201,16 +202,16 @@ test("font picker supports manual families and CJK fallback in browser developme
await family.fill("Inter");
await family.press("Enter");
// Computed styles drop redundant quotes around single-token families ("Inter" -> Inter).
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
await expect(preview).toHaveCSS("font-family", /^Inter, "Inter Variable",/);
const fallback = dialog.getByRole("combobox", { name: "Fallback font", exact: true });
await family.fill("Maple Mono NF");
await family.press("Enter");
await fallback.fill("Inter");
await fallback.press("Enter");
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
await expect(preview).toHaveCSS("font-family", /Maple Mono NF.*Inter Variable/);
await fallback.fill("思源宋体");
await fallback.press("Enter");
await expect(dialog.getByLabel("Font preview")).toHaveCSS("font-family", /思源宋体/);
await expect(preview).toHaveCSS("font-family", /思源宋体/);
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
await expect(dialog).toBeHidden();
});
+46 -13
Переглянути файл
@@ -69,20 +69,53 @@ test("every color scheme page keeps its attribute tree visible", async ({ workbe
}
});
for (const id of ["editor.fileTemplates", "editor.liveTemplates"]) {
test(`${id} keeps its editor reachable beside the template list`, async ({ workbench: page }) => {
await page.keyboard.press("Meta+,");
await expect(page.getByRole("dialog", { name: "Settings", exact: true })).toBeVisible();
await page.evaluate(async (id) => {
const path = "/src/features/settings/model/staging.ts";
(await import(/* @vite-ignore */ path)).selectPage(id);
}, id);
await page.setViewportSize({ width: 520, height: 760 });
const editor = page.locator("[class*='split'] > [class*='editor']").first();
await expect(editor).toBeAttached();
expect((await editor.boundingBox())!.width).toBeGreaterThan(200);
test("Live Templates gives the editor the full settings pane width and keeps variable fields reachable", async ({
workbench: page,
}) => {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await expect(dialog).toBeVisible();
await page.evaluate(async () => {
const path = "/src/features/settings/model/staging.ts";
(await import(/* @vite-ignore */ path)).selectPage("editor.liveTemplates");
});
}
const list = dialog.getByRole("listbox", { name: "Live templates" });
const body = dialog.getByRole("textbox", { name: "Template text" });
await dialog.getByRole("button", { name: "Add Template" }).click();
await expect(body).toBeVisible();
const listBounds = (await list.boundingBox())!;
const bodyBounds = (await body.boundingBox())!;
expect(bodyBounds.y).toBeGreaterThan(listBounds.y + listBounds.height);
expect(bodyBounds.width).toBeGreaterThan(listBounds.width - 32);
const handle = dialog.getByRole("separator", { name: "Resize template panes" });
await expect(handle).toHaveAttribute("aria-orientation", "horizontal");
await handle.press("ArrowDown");
await expect.poll(async () => (await list.boundingBox())!.height).toBeGreaterThan(listBounds.height + 10);
await dialog.getByRole("textbox", { name: "Abbreviation" }).fill("settlement");
await dialog.getByRole("textbox", { name: "Filter templates" }).fill("settlement");
await expect(list.getByRole("option")).toHaveCount(1);
await expect(list.getByRole("option")).toHaveAttribute("aria-selected", "true");
await body.fill("record($SETTLEMENT_REFERENCE_IDENTIFIER$, $AMOUNT$)$END$");
await page.setViewportSize({ width: 520, height: 600 });
await body.scrollIntoViewIfNeeded();
await expect(body).toBeInViewport({ ratio: 0.98 });
const narrowList = (await list.boundingBox())!;
const narrowBody = (await body.boundingBox())!;
expect(narrowBody.x + narrowBody.width).toBeLessThanOrEqual(narrowList.x + narrowList.width);
const variables = dialog.getByRole("table");
const expression = variables.getByRole("textbox", { name: "SETTLEMENT_REFERENCE_IDENTIFIER expression" });
await expression.scrollIntoViewIfNeeded();
await expect(expression).toBeInViewport({ ratio: 1 });
await expression.fill("fileName()");
await expect(expression).toHaveValue("fileName()");
await expect(
variables.getByRole("checkbox", { name: "Skip SETTLEMENT_REFERENCE_IDENTIFIER if defined" }),
).toBeVisible();
expect(await variables.evaluate((element) => element.scrollWidth - element.clientWidth)).toBe(0);
});
test("Project Structure keeps every details pane usable in a compact window", async ({ workbench: page }) => {
await page.keyboard.press("Meta+;");
+67
Переглянути файл
@@ -0,0 +1,67 @@
import type { Page } from "@playwright/test";
import { expect, test } from "./fixtures";
async function openSmartKeys(page: Page) {
await page.keyboard.press("Meta+,");
const dialog = page.getByRole("dialog", { name: "Settings", exact: true });
await dialog.getByRole("textbox", { name: "Search settings" }).fill("Smart Keys");
await dialog.getByRole("treeitem", { name: "Smart Keys", exact: true }).click();
return dialog;
}
test("backspace and paste controls align below Enter options in Smart Keys", async ({ workbench: page }) => {
const dialog = await openSmartKeys(page);
const enter = dialog.getByRole("region", { name: "Enter", exact: true });
const unindent = dialog.getByRole("button", { name: /^Unindent(?: on Backspace)?$/ });
const paste = dialog.getByRole("button", { name: "Reformat on paste", exact: true });
const escape = dialog.getByRole("checkbox", { name: "Escape text on paste in string literals", exact: true });
for (const width of [1120, 520]) {
await page.setViewportSize({ width, height: 760 });
await expect(unindent).toBeInViewport({ ratio: 0.98 });
await expect(paste).toBeInViewport({ ratio: 0.98 });
const enterBox = (await enter.boundingBox())!;
const unindentBox = (await unindent.boundingBox())!;
const pasteBox = (await paste.boundingBox())!;
expect(unindentBox.y).toBeGreaterThan(enterBox.y + enterBox.height);
expect(pasteBox.y).toBeGreaterThanOrEqual(unindentBox.y + unindentBox.height);
expect(Math.abs(pasteBox.x - unindentBox.x)).toBeLessThan(1);
expect((await escape.boundingBox())!.y).toBeGreaterThanOrEqual(pasteBox.y + pasteBox.height);
}
await paste.click();
await expect(page.getByRole("option", { name: "Indent Each Line", exact: true })).toBeInViewport();
});
test("Smart Keys keeps backspace and paste preferences independent across Apply and Cancel", async ({
workbench: page,
}) => {
const setOption = async (label: string, option: string) => {
await page
.getByRole("dialog", { name: "Settings", exact: true })
.getByRole("button", { name: label, exact: true })
.click();
await page.getByRole("option", { name: option, exact: true }).click();
};
const dialog = await openSmartKeys(page);
await setOption("Unindent on Backspace", "To nearest indent position");
await setOption("Reformat on paste", "Indent Block");
await dialog.getByRole("button", { name: "Apply", exact: true }).click();
await expect(dialog.getByRole("button", { name: "Apply", exact: true })).toBeDisabled();
await dialog.getByRole("button", { name: "Cancel", exact: true }).click();
const reopened = await openSmartKeys(page);
await expect(reopened.getByRole("button", { name: "Unindent on Backspace", exact: true })).toHaveText(
"To nearest indent position",
);
await expect(reopened.getByRole("button", { name: "Reformat on paste", exact: true })).toHaveText("Indent Block");
await setOption("Reformat on paste", "None");
await reopened.getByRole("button", { name: "Cancel", exact: true }).click();
const final = await openSmartKeys(page);
await expect(final.getByRole("button", { name: "Unindent on Backspace", exact: true })).toHaveText(
"To nearest indent position",
);
await expect(final.getByRole("button", { name: "Reformat on paste", exact: true })).toHaveText("Indent Block");
});
+74
Переглянути файл
@@ -0,0 +1,74 @@
import type { EditorView } from "@codemirror/view";
import { expect, openFromTree, test } from "./fixtures";
test("Surround With keeps its title and keyboard-selected actions visible in a short window", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 680, height: 320 });
const editor = await openFromTree(page, "App.tsx");
const content = editor.locator(".cm-content");
const source = [
"const fee = 5;",
"",
"function settle(amount: number) {",
" const adjusted = amount - fee;",
" const receipt = adjusted.toString();",
" console.log(receipt);",
" return adjusted;",
"}",
].join("\n");
const selectedText = " console.log(receipt);";
await content.evaluate(
(node, { source, selectedText }) => {
const view = (node as HTMLElement & { cmTile: { view: EditorView } }).cmTile.view;
const start = source.indexOf(selectedText);
view.dispatch({
changes: { from: 0, to: view.state.doc.length, insert: source },
selection: { anchor: start, head: start + selectedText.length },
scrollIntoView: true,
});
view.focus();
},
{ source, selectedText },
);
const openSurround = () =>
page.evaluate(async () => {
const module = "/src/platform/actions.ts";
const { executeAction } = await import(/* @vite-ignore */ module);
await executeAction("code.surroundWith");
});
await openSurround();
const popup = page.getByRole("dialog", { name: "Surround With", exact: true });
const title = popup.getByText("Surround With", { exact: true });
const list = popup.getByRole("listbox");
await expect(title).toBeInViewport({ ratio: 1 });
await expect.poll(() => list.evaluate((node) => node.scrollHeight - node.clientHeight)).toBeGreaterThan(0);
await expect.poll(() => popup.evaluate((node) => node.scrollHeight - node.clientHeight)).toBe(0);
const first = list.getByRole("option", { name: /^1\.?\s+if$/ });
await expect(first).toHaveAttribute("aria-selected", "true");
const action = first.getByText("if", { exact: true });
const mnemonic = first.getByText(/^1\.?$/, { exact: true });
expect((await mnemonic.boundingBox())!.x + (await mnemonic.boundingBox())!.width).toBeLessThan(
(await action.boundingBox())!.x,
);
expect(await action.evaluate((node) => getComputedStyle(node).fontSize)).toBe("13px");
await page.keyboard.press("End");
const last = list.getByRole("option", { name: /!\(expr\)/ });
await expect(last).toHaveAttribute("aria-selected", "true");
await expect(last).toBeInViewport({ ratio: 1 });
await expect(title).toBeInViewport({ ratio: 1 });
await page.keyboard.press("Escape");
await expect(popup).toBeHidden();
await expect(content).toBeFocused();
await expect(content).toContainText("console.log(receipt);");
await openSurround();
await expect(first).toBeVisible();
await page.keyboard.press("1");
await expect(popup).toBeHidden();
await expect(content).toContainText(/if \([^)]*\) \{/);
await expect(content).toContainText("console.log(receipt);");
});
+1 -1
Переглянути файл
@@ -2,7 +2,7 @@ Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: OpenIDEA JVM inspect
Bundle-SymbolicName: ai.openidea.jvminspect;singleton:=true
Bundle-Version: 1.1.0
Bundle-Version: 1.1.1
Bundle-RequiredExecutionEnvironment: JavaSE-21
Require-Bundle: org.eclipse.jdt.ls.core,org.eclipse.core.runtime,
org.eclipse.equinox.common,org.eclipse.jdt.debug,org.eclipse.core.resources
+8 -1
Переглянути файл
@@ -123,6 +123,13 @@ ordinary `executeCommand` error.
invoke go on (ide-dap does that unseen while the trace runs).
The outcome is forced into the frame before it is pinned, so the pending return keeps it reachable;
should it be collected before that, the program gets the cancel exception and the trace fails.
- An exception the terminal threw (the cancel exception of `abort` included) ends the client's
`stepOut` in the program's catch. Nothing catching it, the thread would die with no stop left to
`collect` in, so before parking the bundle adds an uncaught-exception request on the thread,
suspending it: the step-out ends at that throw instead, as a java-debug `exception` stop, and a
resume lets the exception end the thread as it would have. Skipped when an enabled request of
java-debug's already reports uncaught throws of that type (one stop, not two). `collect` deletes it;
after `collect` a release no longer resumes the parked event, since that stop keeps the parked frames.
- `wait` returns as soon as the trace leaves `running`, or after `ms`, at most 30 000. While the
terminal runs it also checks every 500 ms whether the VM began to shut down
(`jdk.internal.misc.VM.initLevel`): `System.exit` in a lambda makes the VM wait forever to report
@@ -204,7 +211,7 @@ Java 21. The recorder is compiled by the `javac` on `PATH` with `--release 8`, s
run Java 8. Build twice and compare: two builds of the checked-in jar gave
```
22980a16bd8e303d67ed2e04d76d8974f2d3981120c26e6d9afa47ba361b1503 openidea-jvm-inspect.jar
4ab30723afe1254b991d9457ea66271109f397a17b238870572283aad73338ad openidea-jvm-inspect.jar
```
Change `Bundle-Version` whenever the jar changes: OSGi caches bundles by version.
Бінарний файл не відображається.
+64 -1
Переглянути файл
@@ -31,6 +31,8 @@ import com.sun.jdi.event.MethodExitEvent;
import com.sun.jdi.event.VMDeathEvent;
import com.sun.jdi.event.VMDisconnectEvent;
import com.sun.jdi.request.EventRequest;
import com.sun.jdi.request.EventRequestManager;
import com.sun.jdi.request.ExceptionRequest;
import com.sun.jdi.request.MethodEntryRequest;
import com.sun.jdi.request.MethodExitRequest;
import com.sun.jdi.request.StepRequest;
@@ -170,6 +172,10 @@ final class RealRunTrace {
private Value echoValue;
private EventSet parked;
private Method terminalMethod;
/** Stops the thread at a throw of the terminal's that nothing catches; see {@link #watchUncaught}. */
private volatile EventRequest uncaught;
/** {@code collect} ran, so the client's step-out ended in a stop of its own; see {@link #dispose}. */
private volatile boolean steppedOut;
private RealRunTrace(long id, VirtualMachine vm, ThreadReference thread, RealRunPlan plan, int budget, long generation) {
this.id = id;
@@ -514,6 +520,8 @@ final class RealRunTrace {
}
if (outcome instanceof ObjectReference object) keep(pinned(object));
restoreSilencers();
// Before the state moves: the client steps out as soon as it sees the trace parked.
if (kind.equals("threw")) watchUncaught((ObjectReference) outcome);
boolean hold;
synchronized (stateLock) {
terminalKind = kind;
@@ -532,10 +540,61 @@ final class RealRunTrace {
if (hold) {
parked = set;
terminalMethod = method;
} else {
deleteUncaught();
}
return hold;
}
/**
* Worker, before the trace parks on a terminal that threw. The client's step-out ends in the
* program's catch, but an exception nothing catches ends the thread, with no stop left to read the
* records in. This request stops the thread at that throw instead: java-debug reports every
* exception event as a stop. Not when an enabled request of java-debug's already stops there,
* since the throw would then be reported twice.
*/
private void watchUncaught(ObjectReference exception) {
try {
EventRequestManager manager = vm.eventRequestManager();
ReferenceType type = exception.referenceType();
for (ExceptionRequest r : manager.exceptionRequests()) {
if (r.isEnabled() && r.notifyUncaught() && r.getProperty(Silencer.OWN_PROPERTY) == null && covers(r.exception(), type)) {
return;
}
}
ExceptionRequest r = manager.createExceptionRequest(null, false, true);
r.addThreadFilter(thread);
r.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
r.putProperty(Silencer.OWN_PROPERTY, id);
r.enable();
uncaught = r;
} catch (VMDisconnectedException e) {
// nothing left to stop
} catch (RuntimeException e) {
errors.add("watching for an uncaught throw: " + e);
}
}
private static boolean covers(ReferenceType declared, ReferenceType type) {
for (ReferenceType t = type; t != null; t = t instanceof ClassType c ? c.superclass() : null) {
if (declared == null || t.equals(declared)) return true;
}
return false;
}
private void deleteUncaught() {
EventRequest r = uncaught;
if (r == null) return;
uncaught = null;
try {
vm.eventRequestManager().deleteEventRequest(r);
} catch (VMDisconnectedException e) {
// it went with the VM
} catch (RuntimeException e) {
errors.add("deleting the uncaught-throw request: " + e);
}
}
/**
* Worker, right before the terminal's invoke. JDWP holds an interrupt or stop of a thread that is
* handling an event until that event's handler exits, and an invoke runs inside the handler of the
@@ -758,9 +817,11 @@ final class RealRunTrace {
/** Worker: everything the trace holds, a parked thread the client never stepped out included. */
private void dispose() {
if (parked != null) {
if (stillParked()) resume(parked);
// A stop at an uncaught throw of the terminal's keeps the parked frames: resuming would end it behind java-debug.
if (!steppedOut && stillParked()) resume(parked);
parked = null;
}
deleteUncaught();
teardown();
for (ObjectReference o : pinned) {
try {
@@ -996,6 +1057,8 @@ final class RealRunTrace {
if (generation <= this.generation) {
throw new Failure("stale", "collect needs a stop after the trace's, not generation " + generation);
}
steppedOut = true;
deleteUncaught();
handles.begin(generation);
ToLongFunction<ObjectReference> handle = o -> {
long objectId = o.uniqueID();
+91
Переглянути файл
@@ -100,6 +100,9 @@ public class Real {
case "inl": inLambda(); break;
case "abort": abort(); break;
case "twice": abortAfterTrace(); break;
case "U": uncaught(true); break;
case "Ux": uncaught(false); break;
case "Ua": abortUncaught(); break;
case "exit": exit(); break;
case "mid": mid(); break;
case "fn": functionAndData(); break;
@@ -244,6 +247,23 @@ public class Real {
}
}
/** Keeps the VM alive once main has died of an exception. */
static void keeper() {
new Thread(() -> LockSupport.parkNanos(60_000_000_000L), "keeper").start();
}
static void uncaught(boolean keep) {
if (keep) keeper();
List<Integer> u = nums.stream().map(x -> 10 / (x - 4)).collect(Collectors.toList()); // @U
System.out.println("U " + u);
}
static void abortUncaught() {
keeper();
long never = Stream.iterate(1L, x -> x + 1).filter(x -> x < 0).count(); // @Ua
System.out.println("UA none " + never);
}
static void exit() {
List<Integer> e = nums.stream().filter(x -> { // @exit
if (x == 8) System.exit(3);
@@ -1025,6 +1045,77 @@ def real_run_abort_after_a_trace():
dbg.end()
def uncaught_stop(dbg, name, trace, exception):
"""After a terminal that threw what the program does not catch: the step-out ends in one stop at that
throw, the records can be read there, and Resume lets the exception end the thread. False when no
stop came."""
try:
stop = step_out(dbg, 15)
except (TimeoutError, AssertionError) as e:
check(f'{name}: the uncaught throw stops the traced thread', False, repr(e))
return False
check(f'{name}: the uncaught throw stops the traced thread', stop.get('reason') == 'exception', stop)
check(f'{name}: one stop for the throw', no_stop(dbg, 2))
c = ok(stream('collect', dbg, traceId=trace))
t = c['terminal']
check(f'{name}: the terminal threw {exception}', t['kind'] == 'threw' and t['exception'].get('typeName') == exception, t)
check(f'{name}: release keeps the stop', 'ok' in stream('release', dbg, traceId=trace) and top(dbg) is not None)
resume(dbg)
out = output_line(dbg, 'Exception in thread "main" ' + exception)
check(f'{name}: the exception ends the thread as without the trace', out is not None, ''.join(dbg.dap.output)[-300:])
check(f'{name}: no stop after Resume', no_stop(dbg, 2))
return c
@case
def real_run_uncaught_throw():
# `U` keeps the VM alive with another thread; `Ux` exits with main.
for name in ('U', 'Ux'):
dbg = real(name, 'U')
try:
trace, state, _ = run_until_parked(dbg, 'U', steps=(spec('map', 1),), step_kinds=('sync',))
check(f'{name}: parked after the lambda threw', state['state'] == 'parked', state)
c = uncaught_stop(dbg, name, trace, 'java.lang.ArithmeticException')
if c:
collected_ok(name, c, records=['0=5', '1=10', '0=3', '1=-10', '0=8', '1=2', '0=1', '1=-3', '0=4'])
finally:
dbg.end()
@case
def real_run_uncaught_throw_user_filter():
# java-debug's own uncaught-exception request is on: the throw must stop once, not once per request.
dbg = real('U')
try:
dbg.dap.request('setExceptionBreakpoints', {'filters': ['uncaught']})
trace, state, _ = run_until_parked(dbg, 'U', steps=(spec('map', 1),), step_kinds=('sync',))
check('U-filter: parked after the lambda threw', state['state'] == 'parked', state)
uncaught_stop(dbg, 'U-filter', trace, 'java.lang.ArithmeticException')
finally:
dbg.end()
@case
def real_run_uncaught_abort():
dbg = real('Ua')
try:
trace = ok(arm(dbg, at='Ua', root=spec('iterate', 2), steps=(spec('filter', 1),), terminal=spec('count'),
class_filters=('java.util.stream.*',), step_kinds=('sync',)))['traceId']
resume(dbg)
first = ok(stream('wait', dbg, traceId=trace, ms=500))
check('Ua: the endless terminal is running', first['state'] == 'running', first)
r = ok(stream('abort', dbg, traceId=trace, timeout=30))
check('Ua: interrupted or stopped', r.get('state') in ('interrupted', 'stopped'), r)
state = wait_until_done(dbg, trace, 20)
check('Ua: parked after the cancel', state['state'] == 'parked', state)
if state['state'] == 'parked':
c = uncaught_stop(dbg, 'Ua', trace, 'java.lang.RuntimeException')
if c:
check('Ua: the records up to the abort', len(c['records']) > 0, len(c['records']))
finally:
dbg.end()
def next_breakpoint_stops(dbg, name, what):
"""After a trace that ended without parking: the user's breakpoints are back on."""
try:
+1 -1
Переглянути файл
@@ -17,7 +17,7 @@ func main() {
[[language-servers]]
name = "gopls"
command = "gopls"
initialization-options = { semanticTokens = true, vulncheck = "Imports" }
initialization-options = { semanticTokens = true, vulncheck = "Imports", hints = { constantValues = true } }
root-markers = ["go.work", "go.mod"]
install-hint = "go install golang.org/x/tools/gopls@latest"
+2
Переглянути файл
@@ -26,6 +26,8 @@ adapter = "java-debug"
command = "com.microsoft.java.debug.plugin.jar"
transport = "tcp"
install-hint = "Install Microsoft java-debug (Settings › Languages & Frameworks › Language Servers › Java Debugger)"
# Its lazy values are toString() of objects whose class overrides it.
resolve-lazy-variables = true
[[language-servers]]
name = "jdtls"
+56
Переглянути файл
@@ -0,0 +1,56 @@
diff --git a/dist/index.cjs b/dist/index.cjs
index 4172cb0f2befc00da9ae09eb3486cae743403a97..ed3c542377fc6dff0195dd9116c16464fb615919 100644
--- a/dist/index.cjs
+++ b/dist/index.cjs
@@ -208,7 +208,9 @@ class Stack {
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
let mustMove = false;
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
- if (this.buffer[scan - 1] >= 0) {
+ // Reused skipped nodes after the end must be moved out too.
+ if (this.buffer[scan - 1] >= 0 ||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
mustMove = true;
break;
}
@@ -278,7 +280,11 @@ class Stack {
this.p.reused.push(value);
index++;
}
- let end = this.reducePos = this.pos = start + value.length;
+ // A reused skipped node (a comment) is not part of the node being
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
+ let end = this.pos = start + value.length;
+ if (!value.type.isSkipped)
+ this.reducePos = end;
this.pushState(next, start);
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
if (this.curContext)
diff --git a/dist/index.js b/dist/index.js
index 8fd3f87829c312b93ce022867fd17bf34da0dbc0..f67b16d2f46d683f12ddc81534efbf50925e7c65 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -206,7 +206,9 @@ class Stack {
if (index > 0 && (this.buffer[index - 4] != 0 /* Term.Err */ || this.buffer[index - 1] < 0)) {
let mustMove = false;
for (let scan = index; scan > 0 && this.buffer[scan - 2] > end; scan -= 4) {
- if (this.buffer[scan - 1] >= 0) {
+ // Reused skipped nodes after the end must be moved out too.
+ if (this.buffer[scan - 1] >= 0 ||
+ this.buffer[scan - 1] == -1 && this.p.reused[this.buffer[scan - 4]].type.isSkipped) {
mustMove = true;
break;
}
@@ -276,7 +278,11 @@ class Stack {
this.p.reused.push(value);
index++;
}
- let end = this.reducePos = this.pos = start + value.length;
+ // A reused skipped node (a comment) is not part of the node being
+ // reduced: like a shifted skipped token, it leaves reducePos alone.
+ let end = this.pos = start + value.length;
+ if (!value.type.isSkipped)
+ this.reducePos = end;
this.pushState(next, start);
this.buffer.push(index, start, end, -1 /* size == -1 means this is a reused value */);
if (this.curContext)
Створено
+27 -26
Переглянути файл
@@ -9,6 +9,7 @@ overrides:
patchedDependencies:
'@codemirror/view': 0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5
'@lezer/lr': 1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8
importers:
@@ -82,7 +83,7 @@ importers:
version: 1.2.5
'@lezer/lr':
specifier: ^1.4.11
version: 1.4.11
version: 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@plutojl/lang-julia':
specifier: ^1.2.0
version: 1.2.0
@@ -2408,7 +2409,7 @@ snapshots:
'@codemirror/language': 6.13.1
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
@@ -2467,7 +2468,7 @@ snapshots:
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
@@ -2480,7 +2481,7 @@ snapshots:
'@codemirror/language': 6.13.1
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
@@ -2491,7 +2492,7 @@ snapshots:
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
@@ -2539,7 +2540,7 @@ snapshots:
'@codemirror/state': 6.7.6
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
@@ -2548,14 +2549,14 @@ snapshots:
'@codemirror/language': 6.13.1
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
'@codemirror/language': 6.13.1
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@codemirror/[email protected]':
dependencies:
@@ -2573,7 +2574,7 @@ snapshots:
'@codemirror/state': 6.7.6
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/yaml': 1.0.4
'@codemirror/[email protected]':
@@ -2609,7 +2610,7 @@ snapshots:
'@codemirror/view': 6.43.14(patch_hash=0ee18e0fe711bd749ccc9f89f3566c74b5e08910f2892e166d207f286b0da0c5)
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
style-mod: 4.1.4
'@codemirror/[email protected]':
@@ -2745,24 +2746,24 @@ snapshots:
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
@@ -2772,27 +2773,27 @@ snapshots:
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
'@lezer/[email protected](patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)':
dependencies:
'@lezer/common': 1.5.3
@@ -2805,37 +2806,37 @@ snapshots:
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@lezer/[email protected]':
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@marijn/[email protected]': {}
@@ -3101,7 +3102,7 @@ snapshots:
dependencies:
'@lezer/common': 1.5.3
'@lezer/highlight': 1.2.5
'@lezer/lr': 1.4.11
'@lezer/lr': 1.4.11(patch_hash=1561ac9e9bbbc302f48ea274ae33602e598a7833edaadd7031559c893c7853b8)
'@replit/[email protected]': {}
+1
Переглянути файл
@@ -5,3 +5,4 @@ overrides:
mermaid>katex: ^0.18.2
patchedDependencies:
"@codemirror/view": patches/@codemirror__view.patch
"@lezer/lr": patches/@lezer__lr.patch
+1
Переглянути файл
@@ -41,6 +41,7 @@ ide-core.workspace = true
ide-cli.workspace = true
dunce.workspace = true
ide-clipboard.workspace = true
ide-drag-out.workspace = true
ide-fonts.workspace = true
ide-text.workspace = true
ide-vfs.workspace = true
+40 -2
Переглянути файл
@@ -1,7 +1,8 @@
//! Native window drag started from the web title bar.
//! Native drags started from the web UI: the window from its title bar, files out to other apps.
use ide_command::desktop_command;
use ide_core::{IdeError, IdeResult};
use std::path::PathBuf;
use tauri::WebviewWindow;
/// Starts dragging `window` while the primary mouse button is still down; returns whether a drag began.
@@ -20,4 +21,41 @@ pub fn window_start_drag(window: WebviewWindow) -> IdeResult<bool> {
Ok(true)
}
ide_command::desktop_domain!(window_start_drag);
/// Drags `paths` (local files and folders) out of `window` while the primary mouse button is
/// still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
/// with whether a target took the files.
#[desktop_command(trust = always)]
#[tauri::command]
#[specta::specta]
pub async fn window_drag_files(window: WebviewWindow, paths: Vec<PathBuf>) -> IdeResult<bool> {
let paths = ide_drag_out::local_paths(paths)?;
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
let (done_tx, done_rx) = tokio::sync::oneshot::channel();
let source = window.clone();
window
.run_on_main_thread(move || {
let done = move |outcome| {
let _ = done_tx.send(outcome);
};
// A tap WebKit delivered late: nothing is held, so the drag would never end.
#[cfg(target_os = "macos")]
if objc2_app_kit::NSEvent::pressedMouseButtons() & 1 == 0 {
let _ = started_tx.send(Ok(()));
return;
}
#[cfg(target_os = "linux")]
let started = source
.gtk_window()
.map_err(|error| std::io::Error::other(error.to_string()))
.and_then(|gtk_window| ide_drag_out::start(&gtk_window, paths, done));
#[cfg(any(windows, target_os = "macos"))]
let started = ide_drag_out::start(&source, paths, done);
let _ = started_tx.send(started);
})
.map_err(|error| IdeError::internal(format!("Cannot start a drag on the main thread: {error}")))?;
started_rx.await.map_err(|error| IdeError::internal(error.to_string()))??;
// Dropped without an outcome when the drag never began or its backend lost it.
Ok(matches!(done_rx.await, Ok(ide_drag_out::Outcome::Dropped)))
}
ide_command::desktop_domain!(window_start_drag, window_drag_files);
+64 -3
Переглянути файл
@@ -4,9 +4,15 @@
//! renderer, so that is done before the first web view is created. Turning the DMA-BUF
//! renderer off also avoids it, but then WebKit paints on the CPU and a tool window drag
//! stalls the UI for seconds; setting `WEBKIT_DISABLE_DMABUF_RENDERER=1` still does that.
//!
//! On Wayland, GTK's default input method goes through the compositor (text-input-v3).
//! With IBus behind it, a dead key waiting for its second key makes WebKit collapse every
//! new selection in the window to its caret (Select All, mouse drags, text fields) until a
//! composition completes. GTK's own IBus module does not, so IBus sessions use that.
const DISABLE_DMABUF: &str = "WEBKIT_DISABLE_DMABUF_RENDERER";
const DISABLE_EXPLICIT_SYNC: &str = "__NV_DISABLE_EXPLICIT_SYNC";
const IM_MODULE: &str = "GTK_IM_MODULE";
/// Run before other threads start (`set_var`).
#[cfg(target_os = "linux")]
@@ -16,6 +22,35 @@ pub fn configure() {
tracing::info!("Wayland with the NVIDIA driver: {DISABLE_EXPLICIT_SYNC}=1");
unsafe { std::env::set_var(DISABLE_EXPLICIT_SYNC, "1") };
}
if use_ibus_module(|k| std::env::var(k).ok(), gtk_ibus_module_installed) {
tracing::info!("Wayland with IBus: {IM_MODULE}=ibus");
unsafe { std::env::set_var(IM_MODULE, "ibus") };
}
}
/// GTK 3's IBus input method module (`ibus-gtk3`), wherever the distribution keeps it.
#[cfg(target_os = "linux")]
fn gtk_ibus_module_installed() -> bool {
const MODULE: &str = "gtk-3.0/3.0.0/immodules/im-ibus.so";
let lib_dirs = ["/usr/lib", "/usr/lib64", "/usr/local/lib"];
lib_dirs.iter().any(|dir| {
let dir = std::path::Path::new(dir);
dir.join(MODULE).exists()
|| std::fs::read_dir(dir)
.into_iter()
.flatten()
.flatten()
.any(|multiarch| multiarch.path().join(MODULE).exists())
})
}
/// A Wayland session whose input method is IBus, unless the user chose a GTK module.
fn use_ibus_module(var: impl Fn(&str) -> Option<String>, module_installed: impl FnOnce() -> bool) -> bool {
if var(IM_MODULE).is_some_and(|v| !v.is_empty()) || !gdk_wayland(&var) {
return false;
}
let ibus = var("XMODIFIERS").is_some_and(|v| v.split_whitespace().any(|m| m == "@im=ibus"));
ibus && module_installed()
}
/// Applies Appearance › Smooth scrolling to every new web view
@@ -46,11 +81,15 @@ fn disable_explicit_sync(var: impl Fn(&str) -> Option<String>, nvidia: bool) ->
if !nvidia || var(DISABLE_DMABUF).is_some() || var(DISABLE_EXPLICIT_SYNC).is_some() {
return false;
}
gdk_wayland(&var)
}
/// GDK will open a Wayland display (it tries the backends of `GDK_BACKEND` in order).
fn gdk_wayland(var: &impl Fn(&str) -> Option<String>) -> bool {
let wayland_display = var("WAYLAND_DISPLAY").is_some_and(|v| !v.is_empty());
// GDK tries the backends of `GDK_BACKEND` in order.
let gdk_wayland =
let backend =
var("GDK_BACKEND").is_none_or(|b| matches!(b.split(',').next().map(str::trim), Some("wayland" | "*" | "")));
wayland_display && gdk_wayland
wayland_display && backend
}
#[cfg(test)]
@@ -76,4 +115,26 @@ mod tests {
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_DMABUF, "1")], true));
assert!(!decide(&[("WAYLAND_DISPLAY", "wayland-0"), (DISABLE_EXPLICIT_SYNC, "0")], true));
}
fn decide_im(vars: &[(&str, &str)], installed: bool) -> bool {
use_ibus_module(|k| vars.iter().find(|(name, _)| *name == k).map(|(_, v)| v.to_string()), || installed)
}
#[test]
fn uses_the_ibus_module_on_wayland_with_ibus_only() {
let gnome = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus")];
assert!(decide_im(&gnome, true));
assert!(decide_im(&[gnome[0], gnome[1], (IM_MODULE, "")], true));
assert!(!decide_im(&gnome, false));
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=fcitx")], true));
assert!(!decide_im(&[("WAYLAND_DISPLAY", "wayland-0")], true));
assert!(!decide_im(&[("DISPLAY", ":0"), ("XMODIFIERS", "@im=ibus")], true));
assert!(!decide_im(&[gnome[0], gnome[1], ("GDK_BACKEND", "x11")], true));
}
#[test]
fn keeps_the_users_input_method_module() {
let vars = [("WAYLAND_DISPLAY", "wayland-0"), ("XMODIFIERS", "@im=ibus"), (IM_MODULE, "wayland")];
assert!(!decide_im(&vars, true));
}
}
+4
Переглянути файл
@@ -6,6 +6,8 @@ agent_archive always project_host bin
agent_base_text trusted project_host bindings async
agent_cancel always project_host bindings sync
agent_changes trusted project_host bindings async
agent_cli_update trusted project_host bindings async
agent_cli_update_check trusted project_host bindings async
agent_commands always project_host bindings async
agent_context_usage trusted project_host bindings async
agent_create trusted project_host bindings async
@@ -171,6 +173,7 @@ debug_jvm_memory_referrers trusted project_host bin
debug_listen_for_jvm trusted project_host bindings async
debug_pause trusted project_host bindings async
debug_redefine_classes trusted project_host bindings async
debug_resolve_variable trusted project_host bindings async
debug_restart_frame trusted project_host bindings async
debug_resume trusted project_host bindings async
debug_run_to trusted project_host bindings async
@@ -728,6 +731,7 @@ web_url always project_host bin
window_close_context always desktop bindings sync
window_complete_launch always desktop bindings sync
window_cycle always desktop bindings sync
window_drag_files always desktop bindings async
window_flash_taskbar always desktop bindings sync
window_group_cancel_close always desktop bindings sync
window_group_close always desktop bindings sync
+60 -5
Переглянути файл
@@ -33,6 +33,10 @@ export const commands = {
"group" |
/** What the last turn changed, against the checkout as that turn started. */
"lastTurn" | null) => typedError<AgentChange[], IdeError>(__TAURI_INVOKE("agent_changes", { task, view })),
/** Installs the exact version offered if the selected installation still matches. */
agentCliUpdate: (provider: string, offer: AgentCliOffer, request: RequestId) => typedError<AgentCliUpdateResult, IdeError>(__TAURI_INVOKE("agent_cli_update", { provider, offer, request })),
/** Checks the selected installation without modifying it. */
agentCliUpdateCheck: (provider: string, request: RequestId) => typedError<AgentCliUpdateResult, IdeError>(__TAURI_INVOKE("agent_cli_update_check", { provider, request })),
/**
* Slash commands to complete for `provider` in `task`'s directory, or in the project
* before a task exists (skills and custom commands on disk included).
@@ -369,9 +373,9 @@ export const commands = {
/** Completions for an expression typed in Evaluate (`line` / `column` 0-based, UTF-16). */
debugCompletions: (session: DebugSessionId, frameId: number | null, text: string, line: number, column: number) => typedError<DebugCompletion[], IdeError>(__TAURI_INVOKE("debug_completions", { session, frameId, text, line, column })),
debugDataBreakpointInfo: (session: DebugSessionId, container: number, name: string, frameId: number | null) => typedError<DataBreakpointInfo, IdeError>(__TAURI_INVOKE("debug_data_breakpoint_info", { session, container, name, frameId })),
debugEvaluate: (session: DebugSessionId, frameId: number | null, expression: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_evaluate", { session, frameId, expression })),
debugEvaluate: (session: DebugSessionId, frameId: number | null, expression: string) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_evaluate", { session, frameId, expression })),
/** Evaluate with an explicit DAP context: `repl`, `watch`, `hover` or `clipboard`. */
debugEvaluateIn: (session: DebugSessionId, frameId: number | null, expression: string, context: string | null) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_evaluate_in", { session, frameId, expression, context })),
debugEvaluateIn: (session: DebugSessionId, frameId: number | null, expression: string, context: string | null) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_evaluate_in", { session, frameId, expression, context })),
debugExceptionFilters: () => typedError<SessionExceptionFilters[], IdeError>(__TAURI_INVOKE("debug_exception_filters")),
/** Force Step Over: step over with every breakpoint suspended until the step ends. */
debugForceStepOver: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_force_step_over", { session, threadId })),
@@ -426,6 +430,7 @@ export const commands = {
debugPause: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_pause", { session, threadId })),
/** HotSwap (Reload Changed Classes) in a java-debug session. */
debugRedefineClasses: (session: DebugSessionId) => typedError<HotSwapResult, IdeError>(__TAURI_INVOKE("debug_redefine_classes", { session })),
debugResolveVariable: (session: DebugSessionId, variable: Variable_Deserialize) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_resolve_variable", { session, variable })),
/** Reset Frame (Drop Frame). */
debugRestartFrame: (session: DebugSessionId, frameId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_restart_frame", { session, frameId })),
debugResume: (session: DebugSessionId, threadId: number) => typedError<null, IdeError>(__TAURI_INVOKE("debug_resume", { session, threadId })),
@@ -441,7 +446,7 @@ export const commands = {
debugSetExceptionBreakpoints: (choices: { [key in string]: boolean }) => typedError<null, IdeError>(__TAURI_INVOKE("debug_set_exception_breakpoints", { choices })),
/** Method breakpoints (all files); states aligned with `breakpoints`. */
debugSetFunctionBreakpoints: (breakpoints: FunctionBreakpoint[]) => typedError<BreakpointState[], IdeError>(__TAURI_INVOKE("debug_set_function_breakpoints", { breakpoints })),
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
debugSetVariable: (session: DebugSessionId, container: number, name: string, evaluateName: string | null, frameId: number | null, value: string) => typedError<Variable_Serialize, IdeError>(__TAURI_INVOKE("debug_set_variable", { session, container, name, evaluateName, frameId, value })),
debugStackTrace: (session: DebugSessionId, threadId: number) => typedError<StackFrame[], IdeError>(__TAURI_INVOKE("debug_stack_trace", { session, threadId })),
/** Starts a session owned by this window: its events (and those of child sessions) go here only. */
debugStart: (config: LaunchConfig) => typedError<DebugSessionId, IdeError>(__TAURI_INVOKE("debug_start", { config })),
@@ -467,7 +472,7 @@ export const commands = {
{ kind: "finished" } | null, IdeError>(__TAURI_INVOKE("debug_stream_trace_abort", { session })),
debugThreads: (session: DebugSessionId) => typedError<ThreadInfo[], IdeError>(__TAURI_INVOKE("debug_threads", { session })),
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
debugVariables: (session: DebugSessionId, reference: number) => typedError<Variable[], IdeError>(__TAURI_INVOKE("debug_variables", { session, reference })),
debugVariables: (session: DebugSessionId, reference: number) => typedError<Variable_Serialize[], IdeError>(__TAURI_INVOKE("debug_variables", { session, reference })),
dependencyVersions: (doc: DocId, offset: number | null, request: RequestId) => typedError<DependencyVersions[], IdeError>(__TAURI_INVOKE("dependency_versions", { doc, offset, request })),
deployCompare: (path: IpcPath, server: string | null, request: RequestId) => typedError<SyncEntry[], IdeError>(__TAURI_INVOKE("deploy_compare", { path, server, request })),
deployCoverage: (paths: IpcPath[]) => typedError<DeploymentCoverage[], IdeError>(__TAURI_INVOKE("deploy_coverage", { paths })),
@@ -1935,6 +1940,12 @@ export const commands = {
windowCompleteLaunch: () => typedError<null, IdeError>(__TAURI_INVOKE("window_complete_launch")),
/** Focuses the next / previous window (⌘` / ⇧⌘`). */
windowCycle: (forward: boolean) => __TAURI_INVOKE<void>("window_cycle", { forward }),
/**
* Drags `paths` (local files and folders) out of `window` while the primary mouse button is
* still down, so the app they are dropped on copies them (#2867). Resolves when the drag ends,
* with whether a target took the files.
*/
windowDragFiles: (paths: string[]) => typedError<boolean, IdeError>(__TAURI_INVOKE("window_drag_files", { paths })),
/**
* Flash (`true`) or stop flashing (`false`) this window's taskbar button, like IDEA when a
* breakpoint is hit while the window is in the background (macOS bounces the dock icon,
@@ -2204,6 +2215,18 @@ export type AgentChangesView =
/** What the last turn changed, against the checkout as that turn started. */
"lastTurn";
export type AgentCliOffer = {
current: string,
latest: string,
prefix: string,
};
export type AgentCliUpdateResult = {
status: "available",
} & AgentCliOffer | {
status: "permission",
} & AgentCliOffer | ({ status: "current"; current: string }) & { code?: never } | ({ status: "channel"; current: string }) & { code?: never } | ({ status: "updated"; current: string }) & { code?: never } | ({ status: "unmanaged" }) & { code?: never; current?: never } | ({ status: "error"; code: string }) & { current?: never };
export type AgentCommand = {
/** Without the leading `/`. */
name: string,
@@ -2560,6 +2583,8 @@ export type AgentProvider = {
commandReadOnlyReason: AgentCommandReadOnlyReason | null,
/** Whether the command was found (on `PATH`). */
installed: boolean,
/** The built-in command can be owned by a global npm package. */
canCheckCliUpdate?: boolean,
/** Environment variables it starts with (from its agent file). */
env: { [key in string]: string },
/** Settings (models, modes…) the agent offered last time it ran; empty before its first session. */
@@ -3824,6 +3849,8 @@ export type Commit_Deserialize = {
historyPath?: string | null,
logPosition?: number | null,
logTotal?: number | null,
/** Newest committer time at or after this row if newer than the row's commit. */
logMergeTimeMs?: number | null,
graphBoundaryParents?: string[],
/** Reachability from HEAD, computed independently of the visible filters. */
onCurrentBranch?: boolean | null,
@@ -3853,6 +3880,8 @@ export type Commit_Serialize = {
historyPath?: string | null,
logPosition?: number | null,
logTotal?: number | null,
/** Newest committer time at or after this row if newer than the row's commit. */
logMergeTimeMs?: number | null,
graphBoundaryParents?: string[],
/** Reachability from HEAD, computed independently of the visible filters. */
onCurrentBranch?: boolean | null,
@@ -6282,9 +6311,12 @@ export type FoldRange = {
kind: FoldKind,
};
export type FoldingOutlineVisibility = "hover" | "always";
/** Editor › General › Code Folding. */
export type FoldingSettings = {
showOutline?: boolean,
outlineVisibility?: FoldingOutlineVisibility,
fileHeader?: boolean,
imports?: boolean,
docComments?: boolean,
@@ -12352,13 +12384,34 @@ export type UpdateStatus = {
checking: boolean,
};
export type Variable = {
export type Variable = Variable_Serialize | Variable_Deserialize;
export type Variable_Deserialize = {
name: string,
value: string,
typeName: string | null,
/** > 0 when expandable. */
variablesReference: number,
evaluateName: string | null,
/**
* `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
* `variables` returns for `variables_reference` holds the value and its children.
*/
lazy?: boolean,
};
export type Variable_Serialize = {
name: string,
value: string,
typeName: string | null,
/** > 0 when expandable. */
variablesReference: number,
evaluateName: string | null,
/**
* `value` is not computed yet (DAP `presentationHint.lazy`): the single variable that
* `variables` returns for `variables_reference` holds the value and its children.
*/
lazy?: boolean,
};
/** Version Control › Confirmation. */
@@ -12400,6 +12453,8 @@ export type VcsRoot = {
export type VcsSettings = {
/** Colour folders that contain changed files (project tree, tabs). */
showDirtyDirectories?: boolean,
/** Diffs the user opens show in an editor tab; off, in a separate window. */
diffAsEditorTab?: boolean,
/** Stop file history (Show History) after `history_limit` commits. */
limitHistory?: boolean,
historyLimit?: number,
+2 -12
Переглянути файл
@@ -68,6 +68,7 @@ import { cloneCaretAbove, cloneCaretBelow } from "./cm/verticalMotion";
import { pasteAsPlainText, pasteFromHistory, unwrapAtCaret } from "./extras";
import { cyclicExpandWord } from "./wordCompletion";
import { copyReferenceToClipboard, declaredName, qualifiedReference, referenceOffset } from "./copyReference";
import { selectedLineContext, selectedLines } from "./selectedLines";
import { declarationChain } from "./view/outline";
import { recordClipboard } from "./clipboardHistory";
import { useDocMeta, useOutline } from "./model/document";
@@ -589,15 +590,6 @@ function copyReference(reference: Promise<string>) {
}
}
/** The selected lines (1-based), leaving out the one a selection ends at the start of. */
function selectedLines(state: EditorState): { first: number; last: number } {
const { doc, selection } = state;
const { from, to } = selection.main;
const first = doc.lineAt(from).number;
const last = Math.max(first, doc.lineAt(to).number - (to > from && doc.lineAt(to).from === to ? 1 : 0));
return { first, last };
}
/** `path:12`, or `path:12-18` for a selection over several lines. */
function pathWithLines(state: EditorState, path: string): string {
const { first, last } = selectedLines(state);
@@ -606,11 +598,9 @@ function pathWithLines(state: EditorState, path: string): string {
function copyPathReferencePopup(view: EditorView, slot: EditorSlot) {
const path = slot.model.path;
const { first, last } = selectedLines(view.state);
const contributed = menuGroupItems("copyPath", {
paths: [path],
line: first - 1,
endLine: last > first ? last - 1 : undefined,
...selectedLineContext(view.state),
}).flatMap((item) =>
(item.kind ?? "item") === "item" && "run" in item && item.id && item.run && item.preview
? [
+10 -4
Переглянути файл
@@ -1,7 +1,7 @@
/**
* Folding: ranges from the backend (`doc_folding`, tree-sitter based) merged
* with CodeMirror's syntax folding (`foldNodeProp`) as fallback, IDEA-style
* chevrons in the gutter (open chevrons only on gutter hover).
* chevrons in the gutter (open chevrons can be shown only on hover).
*/
import {
EditorSelection,
@@ -23,6 +23,7 @@ import {
unfoldEffect,
} from "@codemirror/language";
import type { FoldRange } from "@/platform/ipc";
import type { FoldingOutlineVisibility } from "@/bindings";
import { enclosingCodeBlock } from "./caretCommands";
import { regionMarkerAt, regionNameAt } from "./regions";
@@ -432,9 +433,10 @@ export const expandRecursively = (view: EditorView) =>
view.state.selection.ranges.flatMap((r) => expandRecursivelyEffects(view.state, r.head)),
);
function chevron(open: boolean): HTMLElement {
function chevron(open: boolean, visibility: FoldingOutlineVisibility): HTMLElement {
const span = document.createElement("span");
span.className = open ? "cm-openidea-foldOpen" : "cm-openidea-foldClosed";
span.classList.toggle("cm-openidea-foldOnHover", open && visibility === "hover");
span.title = open ? "Collapse" : "Expand";
const ns = "http://www.w3.org/2000/svg";
const svg = document.createElementNS(ns, "svg");
@@ -477,10 +479,14 @@ export function foldChipWidth(el: HTMLElement): number {
return Math.round(chip.getBoundingClientRect().width);
}
export function foldingExtension(showOutline = true): Extension {
export function foldingExtension(showOutline = true, visibility: FoldingOutlineVisibility = "hover"): Extension {
return [
// The chevron column sits right of contributed icon gutters (IDEA new UI).
showOutline ? Prec.lowest(foldGutter({ markerDOM: chevron, foldingChanged: backendFoldingChanged })) : [],
showOutline
? Prec.lowest(
foldGutter({ markerDOM: (open) => chevron(open, visibility), foldingChanged: backendFoldingChanged }),
)
: [],
backendFolds,
backendFoldService,
codeFolding({
+27
Переглянути файл
@@ -0,0 +1,27 @@
import { describe, expect, it } from "vitest";
import { ensureSyntaxTree, syntaxTree } from "@codemirror/language";
import { javascript } from "@codemirror/lang-javascript";
import { EditorState } from "@codemirror/state";
/** Functions with long doc comments: re-parsing reuses a whole comment as one node. */
const source = Array.from(
{ length: 5 },
(_, i) =>
`/**\n${Array.from({ length: 40 }, (_, j) => ` * line ${j} of the comment on f${i}\n`).join("")} */\n` +
`export const f${i} = (a, b = {}) => {\n // body\n if (a) return b\n return a\n}\n\n`,
).join("");
describe("incremental parsing (#4468)", () => {
it("keeps a reused comment out of the declaration before it", () => {
let state = EditorState.create({ doc: source, extensions: [javascript()] });
ensureSyntaxTree(state, state.doc.length, 5000);
// Reindenting, as a formatter does.
const at = source.indexOf(" // body");
state = state.update({ changes: { from: at, to: at + 4, insert: " " } }).state;
const tree = ensureSyntaxTree(state, state.doc.length, 5000) ?? syntaxTree(state);
const fresh = javascript().language.parser.parse(state.doc.toString());
expect(tree.toString()).toBe(fresh.toString());
expect(tree.topNode.firstChild?.name).toBe("BlockComment");
expect(tree.topNode.firstChild?.from).toBe(0);
});
});
+2 -1
Переглянути файл
@@ -276,7 +276,8 @@ export function distractionFreeExtension(
}
export function foldingFor(settings: EditorSettings | undefined): Extension {
return foldingExtension(prefsOf(settings).folding.showOutline);
const { showOutline, outlineVisibility } = prefsOf(settings).folding;
return foldingExtension(showOutline, outlineVisibility);
}
export function caretFor(settings: EditorSettings | undefined): Extension {
+3 -3
Переглянути файл
@@ -303,9 +303,9 @@ export const openideaTheme = EditorView.theme({
cursor: "pointer",
transition: "opacity var(--dur-fast) var(--ease)",
},
".cm-foldGutter .cm-openidea-foldOpen": { opacity: "0", display: "inline-flex" },
".cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOpen": { opacity: "1" },
".cm-foldGutter .cm-openidea-foldOpen, .cm-foldGutter .cm-openidea-foldClosed": { display: "inline-flex" },
".cm-foldGutter .cm-openidea-foldOnHover": { opacity: "0" },
".cm-gutters:hover .cm-foldGutter .cm-openidea-foldOnHover": { opacity: "1" },
".cm-foldGutter .cm-gutterElement:hover": { color: "var(--fg-secondary)" },
".cm-foldPlaceholder": {
backgroundColor: "var(--editor-fold-chip)",
+4 -3
Переглянути файл
@@ -115,6 +115,7 @@ import { isClassFile } from "@/platform/classFiles";
import { isVirtualUri, virtualDocument } from "@/platform/virtualDocs";
import type { VirtualDocument } from "@/platform/ipc";
import type { Scheduler } from "./sync/DocSync";
import { selectedLineContext } from "./selectedLines";
export const fileKey = (path: string) => `file:${path}`;
export const fileInput = (path: string): EditorInput => ({ kind: "file", key: fileKey(path), path });
@@ -994,7 +995,7 @@ export class EditorController implements SlotHost {
] as MenuItem[])
: ([
{ kind: "separator" },
openInMenu(slot.model.path, view.state.doc.lineAt(view.state.selection.main.head).number - 1),
openInMenu(slot.model.path, selectedLineContext(view.state)),
{ kind: "separator" },
localHistoryMenu(slot.model.path),
gitMenu(slot.model.path),
@@ -2352,7 +2353,7 @@ export class EditorController implements SlotHost {
}
/** Open In › for a file: Project View, Finder / Explorer / Files, associated app, Terminal. */
function openInMenu(path: string, line?: number): MenuItem {
function openInMenu(path: string, lines?: { line: number; endLine?: number }): MenuItem {
return {
label: "Open In",
submenu: [
@@ -2372,7 +2373,7 @@ function openInMenu(path: string, line?: number): MenuItem {
: []),
{ kind: "action", action: "project.openInTerminal", arg: path, label: "Terminal" },
{ kind: "separator" },
...menuGroupItems("openIn", { paths: [path], line }),
...menuGroupItems("openIn", { paths: [path], ...lines }),
],
};
}
+30
Переглянути файл
@@ -239,6 +239,36 @@ describe("editor Copy Path/Reference chooser", () => {
]);
});
it("gives Open In contributions the selected lines", () => {
const contexts: MenuGroupContext[] = [];
disposers.push(
registerMenuGroup({
id: "test.openIn",
menus: ["openIn"],
items: (_menu, ctx) => {
contexts.push(ctx);
return [];
},
}),
);
const view = ctrl.activeSlot!.view!;
vi.spyOn(view, "posAtCoords").mockReturnValue(null);
// The caret; a selection from the second line back into the first; one ending at the start of the second.
for (const selection of [
{ anchor: documentText.indexOf("A {}") },
{ anchor: documentText.indexOf("A {}"), head: 0 },
{ anchor: 0, head: documentText.indexOf("class") },
]) {
view.dispatch({ selection });
ctrl.onContextMenu(ctrl.activeSlot!, new MouseEvent("contextmenu"));
}
expect(contexts.map(({ paths, line, endLine }) => [paths, line, endLine])).toEqual([
[[path], 1, undefined],
[[path], 0, 1],
[[path], 0, undefined],
]);
});
it("adds the chooser to Copy / Paste Special", () => {
vi.spyOn(ctrl.activeSlot!.view!, "posAtCoords").mockReturnValue(null);
ctrl.onContextMenu(ctrl.activeSlot!, new MouseEvent("contextmenu"));
+16
Переглянути файл
@@ -0,0 +1,16 @@
import type { EditorState } from "@codemirror/state";
/** The main selection's lines (1-based), leaving out the one a selection ends at the start of, as IDEA. */
export function selectedLines(state: EditorState): { first: number; last: number } {
const { doc, selection } = state;
const { from, to } = selection.main;
const first = doc.lineAt(from).number;
const last = Math.max(first, doc.lineAt(to).number - (to > from && doc.lineAt(to).from === to ? 1 : 0));
return { first, last };
}
/** The selected lines as a menu group's 0-based `line` / `endLine` (absent for a single line). */
export function selectedLineContext(state: EditorState): { line: number; endLine?: number } {
const { first, last } = selectedLines(state);
return { line: first - 1, endLine: last > first ? last - 1 : undefined };
}
+33
Переглянути файл
@@ -28,6 +28,7 @@ import {
import {
acceptCompletion,
closeCompletion,
completionStatus,
currentCompletions,
snippet,
startCompletion,
@@ -840,6 +841,38 @@ describe("completion footer", () => {
view = null;
});
it("formats partial results while the language server is still answering", async () => {
let finishReply = () => {};
const reply = new Promise((resolve) => {
finishReply = () => resolve({ isIncomplete: false, items: [] });
});
setInvokeRoute((cmd) => (cmd === "lsp_completion" ? reply : Promise.resolve(null)));
const source: CompletionSource = (ctx) => ({ from: ctx.pos, options: [{ label: "localSuggestion" }] });
view = new EditorView({
state: EditorState.create({
doc: "thing.",
selection: { anchor: 6 },
extensions: [
lspDoc.of({ doc: 902, path: "/p/Example.java", language: "java", uiMode: "Java", readOnly: false }),
completionExtension(),
EditorState.languageData.of(() => [{ openideaCompletion: source }]),
],
}),
parent: document.body,
});
try {
startCompletion(view);
await vi.waitFor(() => {
expect(completionStatus(view!.state)).toBe("pending");
expect(document.querySelector(".cm-tooltip-autocomplete > .cm-lsp-completion-footer")).not.toBeNull();
});
} finally {
closeCompletion(view);
setInvokeRoute(null);
finishReply();
}
});
it("stays below the list after CodeMirror rebuilds the options", async () => {
const source: CompletionSource = (ctx) => ({
from: ctx.pos,
+27 -15
Переглянути файл
@@ -25,7 +25,16 @@ import {
type CompletionSource,
} from "@codemirror/autocomplete";
import { EditorSelection, EditorState, Prec, StateEffect, StateField, type Text } from "@codemirror/state";
import { EditorView, ViewPlugin, getTooltip, keymap, showTooltip, type Rect, type ViewUpdate } from "@codemirror/view";
import {
EditorView,
ViewPlugin,
getTooltip,
keymap,
repositionTooltips,
showTooltip,
type Rect,
type ViewUpdate,
} from "@codemirror/view";
import {
call,
commands,
@@ -989,7 +998,14 @@ const completionPopup = ViewPlugin.fromClass(
class {
constructor(private view: EditorView) {}
update(u: ViewUpdate) {
if (completionStatus(u.state) !== "active") return;
// The lookup can show partial results while another source is still pending.
const popup = u.state
.facet(showTooltip)
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
if (!popup) return;
popup.offset ??= { x: -completionLabelOffset, y: 0 };
const t = popup.dom;
this.view.requestMeasure({
key: this,
read: () => {
@@ -1000,19 +1016,12 @@ const completionPopup = ViewPlugin.fromClass(
};
},
write: ({ width, fontSize }) => {
const popup = this.view.state
.facet(showTooltip)
.map((tooltip) => tooltip && getTooltip(this.view, tooltip))
.find((tooltip) => tooltip?.dom.classList.contains("cm-lsp-completion"));
if (!popup) return;
// Apply the label alignment inside CodeMirror's viewport clamp.
popup.offset = { x: -completionLabelOffset, y: 0 };
const t = popup.dom;
if (t.style.getPropertyValue("--cm-completion-max-width") !== width)
t.style.setProperty("--cm-completion-max-width", width);
if (!t.isConnected) return;
const widthChanged = t.style.getPropertyValue("--cm-completion-max-width") !== width;
if (widthChanged) t.style.setProperty("--cm-completion-max-width", width);
// The body-level tooltip does not inherit the editor's temporary font zoom.
if (t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize)
t.style.setProperty("--openidea-editor-font-size", fontSize);
const fontChanged = t.style.getPropertyValue("--openidea-editor-font-size") !== fontSize;
if (fontChanged) t.style.setProperty("--openidea-editor-font-size", fontSize);
let footer = t.querySelector<HTMLElement>(":scope > .cm-lsp-completion-footer");
if (!footer) {
footer = document.createElement("div");
@@ -1023,7 +1032,10 @@ const completionPopup = ViewPlugin.fromClass(
}
// CodeMirror appends a fresh list when the candidates change.
const list = t.querySelector(":scope > ul");
if (list && list.nextElementSibling !== footer) list.after(footer);
const footerMoved = list && list.nextElementSibling !== footer;
if (footerMoved) list.after(footer);
// CodeMirror has already measured the lookup. Reposition it before this frame paints.
if (widthChanged || fontChanged || footerMoved) repositionTooltips(this.view);
},
});
}
+2
Переглянути файл
@@ -30,6 +30,7 @@ describe("pending hints", () => {
vi.advanceTimersByTime(PENDING_HINT_DELAY_MS);
expect(hint()).toBe("Waiting…");
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBe("true");
expect(document.querySelector(".cm-lsp-hint .cm-lsp-hint-spinner svg")).not.toBeNull();
done();
expect(hint()).toBeNull();
});
@@ -37,6 +38,7 @@ describe("pending hints", () => {
it("marks only progress as pending", () => {
showHint(view, "Done");
expect(document.querySelector<HTMLElement>(".cm-lsp-hint")?.dataset.pending).toBeUndefined();
expect(document.querySelector(".cm-lsp-hint-spinner")).toBeNull();
});
it("puts what the hint answers in its data attributes", () => {
+2
Переглянути файл
@@ -7,6 +7,7 @@ import { StateEffect, StateField, type Extension } from "@codemirror/state";
import { EditorView, keymap, showTooltip, type Tooltip } from "@codemirror/view";
import { Prec } from "@codemirror/state";
import { txTemplate } from "@/platform/i18n";
import { spinnerNode } from "@/ui/iconNode";
interface Hint {
pos: number;
@@ -48,6 +49,7 @@ const hintField = StateField.define<Hint | null>({
Object.assign(dom.dataset, h.data);
if (typeof h.content === "string") {
dom.textContent = txTemplate(h.content);
if (h.pending) dom.prepend(spinnerNode(12, "cm-lsp-hint-spinner"));
return { dom };
}
const built = h.content();
+1
Переглянути файл
@@ -335,6 +335,7 @@ export const lspTheme = EditorView.theme({
boxShadow: "var(--shadow-popup)",
whiteSpace: "pre-wrap",
},
".cm-lsp-hint-spinner": { display: "inline-flex", verticalAlign: "-2px", marginRight: "var(--space-2)" },
// The hint is the tooltip element itself: beat the editor theme's `.cm-tooltip` width.
".cm-tooltip.cm-lsp-hint": { maxWidth: "min(480px, 100%)" },
".cm-lsp-hint-error": {
+16
Переглянути файл
@@ -0,0 +1,16 @@
.summary {
display: grid;
gap: var(--space-2);
}
.title {
margin: 0;
font-size: inherit;
font-weight: 600;
}
.detail {
margin: 0;
padding: var(--space-3);
border: 1px solid var(--border);
border-radius: var(--radius-control);
color: var(--fg-secondary);
}
+53
Переглянути файл
@@ -0,0 +1,53 @@
import type { Location } from "@/bindings";
import { tx } from "@/platform/i18n";
import { ask } from "@/workbench/messages";
import styles from "./SafeDeleteUsages.module.css";
type UsagesAnswer = "view" | "delete" | "cancel";
/** `subject`: "Function 'foo'", "File 'a.ts'", "3 files" (`plural`). */
export function usagesMessage(
subject: string,
usages: readonly Location[],
plural = false,
): { message: string; detail: string } {
const n = usages.length;
const files = new Set(usages.map((u) => u.path)).size;
const where = files > 1 ? tx` (in ${files} files)` : "";
let detail: string;
if (plural)
detail =
n === 1
? tx`${subject} have ${n} usage that is not safe to delete${where}.`
: tx`${subject} have ${n} usages that are not safe to delete${where}.`;
else
detail =
n === 1
? tx`${subject} has ${n} usage that is not safe to delete${where}.`
: tx`${subject} has ${n} usages that are not safe to delete${where}.`;
return { message: n === 1 ? tx`${n} usage found` : tx`${n} usages found`, detail };
}
export async function askUsagesDetected(
subject: string,
usages: readonly Location[],
plural = false,
): Promise<UsagesAnswer> {
const { message, detail } = usagesMessage(subject, usages, plural);
const { button } = await ask({
title: "Usages Detected",
presentation: "form",
width: 540,
body: (
<div className={styles.summary}>
<h2 className={styles.title}>{message}</h2>
<p className={styles.detail}>{detail}</p>
</div>
),
buttons: [
{ id: "view", label: "View Usages", primary: true },
{ id: "delete", label: "Delete Anyway" },
],
});
return button === "view" || button === "delete" ? button : "cancel";
}
+2 -1
Переглянути файл
@@ -1,5 +1,6 @@
export { refactorThis, runRefactoring, showNothingHere } from "./refactorThis";
export { askUsagesDetected, fileUsages, safeDelete, viewUsages } from "./safeDelete";
export { fileUsages, safeDelete, viewUsages } from "./safeDelete";
export { askUsagesDetected } from "./SafeDeleteUsages";
export { startHierarchyRefactoring } from "./hierarchy";
export { ChangeSignatureDialog } from "./ChangeSignatureDialog";
export { JAVA_REFACTORING_COMMAND, runJavaRefactoringCommand } from "./javaMove";
+11 -6
Переглянути файл
@@ -2,7 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { EditorState, Text } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
import { history, undo } from "@codemirror/commands";
import type { MessageRequest } from "@/workbench/messages";
import { render } from "@testing-library/react";
import type { ConfirmOptions, MessageRequest } from "@/workbench/messages";
import type { LocalSymbol, Location, Locals, OutlineItem, Pos, Range, StructuralRanges, SyntaxNode } from "@/bindings";
// --- backend fakes ---------------------------------------------------------
@@ -74,13 +75,12 @@ vi.mock("@tauri-apps/api/core", async (orig) => ({
let answer = "cancel";
const ask = vi.fn(async (_request: MessageRequest) => ({ button: answer, checked: false }));
let confirmAnswer: { checked: boolean } | null = { checked: false };
const confirmChecked = vi.fn(
async (_opts: { title: string; message: string; checkbox?: string; checked?: boolean }) => confirmAnswer,
);
const confirmChecked = vi.fn(async (_opts: ConfirmOptions) => confirmAnswer);
vi.mock("@/workbench/messages", () => ({ ask, confirmChecked }));
const { deletionRange, localDeclaration, outlineItemAt, safeDelete, fileUsages, usagesMessage, textOccurrences } =
const { deletionRange, localDeclaration, outlineItemAt, safeDelete, fileUsages, textOccurrences } =
await import("./safeDelete");
const { usagesMessage } = await import("./SafeDeleteUsages");
const { closePopup, useLspPopup } = await import("@/editor/lsp/popupStore");
const { lspDoc } = await import("@/editor/lsp/lsp");
@@ -294,7 +294,11 @@ describe("safeDelete in the editor", () => {
await safeDelete(v);
const request = ask.mock.calls[0]![0];
expect(request.title).toBe("Usages Detected");
expect(request.body).toBe("1 usage found\nFunction 'used' has 1 usage that is not safe to delete.");
expect(request.presentation).toBe("form");
const summary = render(request.body);
expect(summary.getByRole("heading", { name: "1 usage found" })).toBeInTheDocument();
expect(summary.getByText("Function 'used' has 1 usage that is not safe to delete.")).toBeInTheDocument();
summary.unmount();
expect(request.buttons.map((b) => b.label)).toEqual(["View Usages", "Delete Anyway"]);
return v;
};
@@ -314,6 +318,7 @@ describe("safeDelete in the editor", () => {
expect(confirmChecked).toHaveBeenCalledTimes(1);
const opts = confirmChecked.mock.calls[0]![0];
expect(opts.title).toBe("Safe Delete");
expect(opts.presentation).toBe("form");
expect(opts.message).toBe("Delete Function 'unused'?");
expect(opts.checkbox).toBe("Search in comments and strings");
expect(lspReferences).not.toHaveBeenCalled();
Loaded 100 of 205 files, more files were not shown because too many files have changed in this diff. Show more