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

...
Автор SHA1 Повідомлення Дата
l0ng-ai 18bdd908ca Merge remote-tracking branch 'origin/main' into fix/git-log-filter-layout 2026-11-19 20:55:14 +08:00
l0ng-ai af281341b1 fix(run): keep console actions visible in short panes (#4511)
Run session controls move above the console: Rerun, Stop, Clear All and configuration controls fit together in a short docked pane, the console gets the full width, and the toolbar wraps by action group in narrow panes. Sessions without lifecycle controls (services, debugger console) keep the vertical toolbar.
2026-11-19 20:55:10 +08:00
l0ng-ai 313a5f3a14 fix(search): give Find in Files previews and scope controls room (#4510)
Find in Files starts with a 33/67 results-to-preview split and remembers the user's split through the splitter's own storage, so a temporarily constrained window no longer overwrites it. Scope controls wrap below the tabs when they need more room.
2026-11-19 20:53:41 +08:00
l0ng-ai 18cd2ef63b fix(debugger): keep controls visible in narrow tool windows (#4507)
Debug controls and view tabs wrap onto separate rows as the tool window narrows, and the action buttons use the standard control size, so every action and view stays reachable in a side pane.
2026-11-19 20:51:55 +08:00
l0ng-ai 4fc55f7520 fix(editor): fit wrapped tabs inside narrow splits (#4505)
Wrapped editor tabs fit inside their own split: a tab never grows past the strip, long labels truncate before the close button, and editor tabs use the 8px inline inset from the spacing scale.
2026-11-19 20:51:03 +08:00
l0ng-ai 795413c366 fix(project-view): prioritize names over paths in narrow trees (#4498)
Project tree rows give file, folder and symbol names priority over secondary text: a long project name can use the row width while paths and details truncate (full text on hover). Row icon spacing uses the spacing token.
2026-11-19 20:49:22 +08:00
l0ng-ai dd3c9c7b0a fix(problems): keep diagnostics readable in narrow panes (#4495)
The Problems tool window moves navigation and severity filters into a vertical toolbar left of the diagnostic list. Long directories, counts and diagnostic sources truncate (full text on hover) so file names and messages stay readable in a narrow split; line numbers use tabular digits.
2026-11-19 20:48:31 +08:00
l0ng-ai 361ca01cc0 fix(todo): improve tool window layout and result typography (#4492)
The TODO tool window moves its actions into a vertical toolbar beside the results, so the scope tabs get the full width. Results use the standard text size with right-aligned line numbers (the full position stays in the tooltip), long directories truncate so file names and counts stay visible, and the list and preview start at equal width.
2026-11-19 20:47:25 +08:00
Mr0Bread 1b9c330613 fix(bench): require current operation postconditions (#4491)
UI benchmarks and Java evals now arm their observation before triggering an action and wait for that action's own postcondition (current file, text, caret, completion/navigation outcome, rename scope, fresh diagnostics publication) instead of accepting editor or result state left by an earlier step. Budgets and goldens are unchanged.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 20:45:53 +08:00
wangfeiтаhapput 2d7bb56a8d feat(workbench): open a project as a new tab of this window (#4508)
Adds a New Tab choice to the Open Project prompt: the project opens in its own window, which joins this window's group as a selected project tab (new window_group_join command; window_groups::join is no longer macOS-only, since select handles every platform). The prompt keeps its original text when Attach and New Tab aren't offered (remote projects).

Co-authored-by: happut <[email protected]>
2026-11-19 20:43:26 +08:00
Shohruh Ismoilovтаshohruh-genius 2c8a029939 fix(vcs): fit Git Log commits to the available width (#4517)
Git Log sized its table for the widest graph row plus the saved column widths, so in a narrow pane columns went out of view behind a horizontal scrollbar. The header and rows now fit the pane: the columns shrink, the subject keeps a minimum share, and graph lanes past the room left for the subject are cut off rather than squeezed.

Co-authored-by: shohruh-genius <[email protected]>
2026-11-19 20:37:19 +08:00
l0ng-ai 6e2c19846c test(maven): fix the Always update snapshots test on main (#4514)
always_update_snapshots_adds_dash_u_once (from #4484) turned the setting off and re-applied it to the already-applied configuration, expecting -U to be removed, which failed main's Rust checks on every platform. Maven settings are applied to the stored configuration at each launch, so the test now checks a stored configuration with the setting off.
2026-11-19 20:13:26 +08:00
l0ng-ai a4ee6110e8 fix(vcs): fit Git Log controls in narrow panes 2026-11-19 20:03:55 +08:00
l0ng-ai 6c2ae13387 fix(vcs): select the best-matching branch while filtering the branches popup (#4509)
Typing a filter in the branches popup selected the first selectable row, the Local group header, so Enter did not act on the branch it found. While filtering, the popup now selects the best match of the first kind that has one: a matching action, then local branches, remote ones and tags (for several repositories: repositories, common branches, then one repository's). A match at the start of the name's last segment or at a word start ranks higher.
2026-11-19 19:44:53 +08:00
Mr0Bread 34cb4ad5e0 fix(bench): preserve failed trials and bound cleanup (#4489)
Failed warmups and repetitions were dropped from benchmark summaries, a failed startup, build or cleanup could leave an earlier success report in place, and a hung renderer or child process could block a run. Every attempt now keeps its status, metrics and error so summaries have the complete denominator; failures replace stale reports; browser and child-process lifecycles are bounded with cleanup of owned resources; and each criterion execution gets its own artifact directory.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 19:38:34 +08:00
Mr0Bread d080ca28f8 fix(bench): require selected workloads and finite metrics (#4488)
Benchmark verdicts could pass with selected workloads or required metrics missing, empty or non-finite, and pnpm perf:rust could accept stale or partial criterion results. Selections and counts are now validated before any work starts, every selected workload must report finite values for its required metrics, and Rust results are collected only for the selected packages from fresh, well-formed criterion artifacts, against a list of the benchmarks each package owns.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 19:34:55 +08:00
Vadim LazukтаInf1mum 22a5e4c9e6 fix(maven): reuse an existing build configuration for Maven goal runs (#4503)
Running a lifecycle goal such as package from the Maven tool window always created a temporary '<project> [package]' configuration, even when a saved or detected configuration already ran the same goal. adoptTemporary only matched by id or main class. Maven and Gradle runs now also match a kept configuration with the same build tool, command, directory and exact arguments, which is then selected and run instead; a different flag set (for example -DskipTests) still gets its own temporary configuration.

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 19:29:44 +08:00
Vadim LazukтаInf1mum e93ac42489 fix(workbench): coalesce system toasts for external edit bursts (#4502)
Every balloon raised while OpenIDEA was in the background became its own OS toast, so an external agent editing many files produced a stream of toasts. The first toast still shows at once; balloons that follow within a 3-second quiet period become one toast naming the last balloon and how many more arrived, and a steady stream raises such a summary at most every 30 seconds. In-IDE balloons and the Notifications tool window keep every notification.

Closes #4466

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 19:28:02 +08:00
Vadim LazukтаInf1mum ae604b7933 fix(editor): keep target indentation when pasting onto a blank line (#4500)
Pasting onto a blank line in YAML placed the text at column 0, turning a nested key into a root key, even with Reformat on paste. @lezer/yaml has no indent strategy, so the indent engine reports 0 and the blank target line looked already correct. On a blank target line where the engine gives no indent (null or 0), the paste filter now uses the indentation of the nearest non-empty line above, in both reformat modes.

Closes #4474

Co-authored-by: Inf1mum <[email protected]>
2026-11-19 19:25:53 +08:00
Mr0Bread bd27eb5474 fix(agents): preserve effort for pending model switches (#4487)
In an existing chat, a model that only appeared after Refresh models could be selected but its effort levels stayed unavailable until a message was sent, because the refreshed catalog listed the model without the settings a session reports for it. Selecting such a model now discovers its settings without a prompt and keeps the model and chosen effort as a pending switch; the next message reloads the same session, applies the model and the effort, then sends. If either is rejected, the previous selection is restored and nothing is sent.

Co-authored-by: Mr0Bread <[email protected]>
2026-11-19 19:25:08 +08:00
wangfeiтаhapput 15fcf4f2c1 feat(workbench): custom colours for project tabs (#4481)
Right-clicking a project tab in a window group offers Change Project Color…: nine preset colours from the project badge palette, a custom colour and hex field, and Reset to Default. The colour is stored per project root, syncs across windows, and tints the tab, the title bar project badge and the project's badge in Recent Projects and the project popup. Without a choice the tab keeps its plain surface.

Co-authored-by: happut <[email protected]>
2026-11-19 19:20:38 +08:00
C3B6 65415a03bd fix(diff): preserve the selection when expanding unchanged lines (#4480)
Pressing and slightly moving the pointer on a diff viewer's unchanged-lines bar could start a text selection that covered the whole folded block once it expanded. The bar is now unselectable, so expanding keeps the caret and any existing selection.

Co-authored-by: 0xC3B6 <[email protected]>
2026-11-19 19:16:43 +08:00
l0ng-ai 58585e1064 feat(vcs): choose the agent, model and effort for Generate Commit Message (#4504)
Settings › Version Control › Commit › Commit Message Generation gets Agent, Model and Effort dropdowns (vcs.commit.agent / agentModel / agentEffort). Automatic keeps the agent of the latest task on its model; a chosen agent runs on the chosen model and thinking level when it offers them, independent of the chat's model. The lists come from the agent's model catalog.
2026-11-19 19:15:53 +08:00
l0ng-ai 0f355c286d fix(format): keep the caret when a language server replaces the whole file (#4497)
Vue's language server answers Reformat Code with one edit replacing the whole document, which moved the caret and the view to the top of the file. Multi-line LSP formatting edits are now reduced to one edit per changed region via Document::diff, which covers every server that formats this way.
2026-11-19 19:05:18 +08:00
l0ng-ai a0a51a63cb feat(vcs): open a push dialog file's diff in its own window (#4490)
Double-click or Enter on a file in the push dialog opens its diff in a separate diff window (Show Diff in New Window), as IDEA's push dialog does; closing it returns to the dialog. Before, the diff was only shown in a split inside the small modal dialog. Selecting a file still shows the diff in the dialog.
2026-11-19 18:28:32 +08:00
l0ng-ai b44393a989 feat(welcome): show project groups in the title bar's recent projects (#4485)
The title bar project popup's Recent Projects section now lists each Welcome-screen project group's name above its projects (collapsed groups included), then the ungrouped projects after a separator; a search stays a flat list. Before, recent projects were always flat, so similarly named projects were easy to mix up.
2026-11-19 18:23:12 +08:00
l0ng-ai eda632866a feat(maven): Always update snapshots setting (#4484)
Settings › Build Tools › Maven gets Always update snapshots (off by default, Global or This project). On, Maven runs, builds, goals and sync get -U and jdtls imports with java.maven.updateSnapshots, so newer SNAPSHOT dependencies are picked up from remote repositories. A configuration's own -U/--update-snapshots is kept; turning the setting off removes the -U it added.
2026-11-19 18:20:15 +08:00
HEOJUNFO 3eaaa71ae1 fix(http-client): keep a > inside an attribute value within its tag (#4470)
The HTTP Client's formatted XML/HTML response cut a tag at the first `>` even inside a quoted attribute value, splitting the value across lines, over-indenting what followed and, in HTML, dropping the space after the `>`. The tag pattern now skips "…" and '…' values; a tag with an unclosed quote still ends at the first `>`.

Co-authored-by: HEOJUNFO <[email protected]>
2026-11-19 17:58:48 +08:00
Mansur Akhmadiтаmansur-akhmadi 77503e5fee feat(run): Export Test Results to HTML or XML from the test results toolbar (#4413)
The test results toolbar and Find Action get Export Test Results…: a dialog with HTML or XML format, the output file (default "<working directory>/Test Results - <configuration>.html") and an option to open the HTML report in the browser. HTML is a self-contained report (summary, suites, per-test status, duration, output and location, no scripts); XML uses the <testrun> format with count, suite, test, output and expected/actual diff. An existing file is replaced only after confirmation. Both entry points are disabled while tests run and when there are no results.

Closes #4412

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 17:57:29 +08:00
l0ng-ai 8edab7b8e6 fix(vim): drop text an input method echoes after a key Vim handled (#4479)
Some macOS input methods (Doubao in its English mode) still insert a key's character after Vim handled and prevented its keydown, so Normal-mode j/k moved and typed, and i/a entered Insert mode and typed. Text input equal to the last keydown is dropped when Vim took that key outside Insert mode within 100 ms; any later keydown clears the record, so keys typed in the new Insert mode stay text.
2026-11-19 17:56:25 +08:00
l0ng-ai f8474fc2a2 feat(project-view): option to turn off horizontal scrolling (#4478)
The Project view's options menu gets Horizontal Scrolling under Appearance (on by default, as before). Turned off, long rows are clipped with an ellipsis instead of the whole tree scrolling sideways and cutting names on the left.
2026-11-19 17:56:15 +08:00
l0ng-ai 0558c1127c feat(terminal): option to use the application title as the tab name always (#4477)
Settings › Tools › Terminal gets "Use application title as tab name" (When command is running, the default; Always; Never). The title a program sets via OSC 0/2 named the tab only while a command ran, so a CLI agent's own title did not show when shell integration could not tell a command was running.
2026-11-19 17:55:24 +08:00
l0ng-ai e335e8bcf6 fix(languages): run a language server set to a .jar with java -jar (#4475)
A language server whose executable in Settings › Language Servers was a runnable jar (a locally built groovy-language-server-all.jar) was spawned as the program and never started. A .jar command now runs as java -jar <jar> <args>, on the project JDK's java when one is set, else java from PATH. Fixes #4403
2026-11-19 17:39:42 +08:00
Deng Liuтаdengliu 7e2e2e6cc9 feat(agents): colocate effort and context settings (#4382)
Effort moves into the model popup, next to context size and model settings, with the current effort shown on the model chip (Atlas · Gentle), as Codex and Copilot keep it in the model picker. Up to four levels use the segmented control, more (Codex has six) a dropdown row; the chip's effort/context detail stays visible in the narrow composer layout, where the model name truncates first.

Co-authored-by: dengliu <[email protected]>
2026-11-19 17:36:23 +08:00
Mamaev Igor de73495ab0 fix(vim): support the clipboard option and +=/-=/^= operators in .ideavimrc (#4318)
#4136 added the clipboard option with += only. The rc parser and engine now also take Vim's -= (remove an item / subtract) and ^= (prepend / multiply) for comma-list and number options, clipboard gets its cb alias, and the Vim guide documents the clipboard option.

Co-authored-by: pxc1984 <[email protected]>
2026-11-19 17:32:41 +08:00
l0ng-ai 6c848b9a43 fix(database): connect without TLS when a Prefer handshake fails (#4473)
With SSL mode Prefer, a MySQL/PostgreSQL server whose TLS handshake fails (e.g. TLS 1.0/1.1 only) failed with "received fatal alert: HandshakeFailure", since sqlx only skips TLS when the server doesn't offer it. Prefer now retries once without TLS after a failed handshake (sqlx::Error::Tls or an I/O error carrying a rustls error), as libpq's sslmode=prefer does; the pool keeps the plain options. Fixes #4447
2026-11-19 17:30:57 +08:00
l0ng-ai 4812adba97 fix(deps): update wasmtime to 49.0.6 for RUSTSEC-2026-0571/0572/0573 (#4472)
cargo deny reported three wasmtime advisories (RUSTSEC-2026-0571/0572/0573). wasmtime, wasmtime-wasi and their internal crates move from 49.0.5 to 49.0.6, the patch release with the fixes.
2026-11-19 17:28:27 +08:00
LU XIANGRUIтаwildcatDownstairs af938d0726 feat(structure): show the Flutter widget tree in the Structure view (#4433)
In Flutter projects the Structure view now shows the widget nesting inside build() (e.g. Scaffold > Column > Text 'Hello') from the Dart analysis server's dart/textDocument/publishFlutterOutline, following the Flutter plugin's former Outline window: letter badges (private widgets in pink), properties after the name, bold build methods, and Show Only Widgets in View Options. A new doc_flutter_outline command keeps doc_outline unchanged; the outline is cached per document and server and refreshed via LspRefresh. Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:25:21 +08:00
Moler1995 8562fadde2 fix(vim): render the command line in the editor font (#4419)
The Vim : command line and / ? prompts used codemirror-vim's inline font-family: monospace (Consolas under WebView2) instead of the editor font. The prompt panel now uses the editor's font variables, overrides the inline declaration on the wrapping span, and follows the ligatures toggle. Closes #4401

Co-authored-by: Moler1995 <[email protected]>
2026-11-19 17:24:01 +08:00
Muuтаmuutot a50813eb56 fix(editor): keep fold chip clicks working when inline blame refreshes the line (#4469)
Clicking a fold placeholder while the caret was on another line could do nothing: the mousedown started a selection that moved the caret, the inline blame refresh rebuilt the line's DOM, and the browser dropped the click on the detached chip. The chip now swallows its mousedown, so the caret stays put and the click always expands the fold.

Co-authored-by: muutot <[email protected]>
2026-11-19 17:23:54 +08:00
LU XIANGRUIтаwildcatDownstairs 282f1fd482 feat(run): import Flutter/Dart run configurations from JetBrains and VS Code (#4460)
Importing run configurations skipped every Flutter/Dart entry. JetBrains FlutterRunConfigurationType (filePath, additionalArgs, buildFlavor, envs) and VS Code dart launches (deviceId, flutterMode, toolArgs, args as --dart-entrypoint-args; plain Dart projects as dart run) now become Flutter configurations run from the owning pubspec.yaml's directory. An imported entry identical to an existing configuration is skipped with the new sameAs reason, and compounds point to the existing one.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:23:44 +08:00
LU XIANGRUIтаwildcatDownstairs 2129efd196 feat(debugger): add Flutter DevTools tool windows (#4422)
Flutter projects get four tool windows on the right, as in the Flutter plugin: Flutter Inspector (one tab per app started with Debug, selecting a widget jumps to its source), Flutter DevTools, Flutter Deep Links and Flutter DevTools Extensions. They embed one dart devtools --machine server per trusted project (stopped on close, trust revoke or quit); the VM Service URI comes from the Dart debug adapter's dart.debuggerUris. Links in embedded pages that open a new window go to the system browser. Icons from flutter-intellij (BSD-3-Clause, THIRD_PARTY_LICENSES.md). Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:23:30 +08:00
LU XIANGRUIтаwildcatDownstairs a4de18796b feat(run): add Flutter Hot Reload and Hot Restart buttons to the Run tool window (#4415)
Flutter apps started with Run had no hot reload control. Hot Reload and Hot Restart now follow Stop in the Run tool window for flutter run configurations in a hot-reload mode, sending r / R to flutter run's stdin (plain console and terminal emulation); disabled once the process ends. Refs #4096

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:23:12 +08:00
LU XIANGRUIтаwildcatDownstairs cbf09b8962 feat(vcs): update several selected branches at once from the Branches pane (#4457)
With several local branches selected in the Branches pane, Update Selected (context menu and toolbar) now fast-forwards each to its tracked branch and reports updated / up to date / diverged / no tracked branch / failed in one notification, as IDEA's Git.Update.Selected. The new vcs_update_branches fetches each remote once, uses merge --ff-only for the current branch and fetch . <tracked>:<branch> for others (refusing branches checked out in another worktree), and groups per repository. Branches common to several repositories also get Update in the multi-repo branch popup. Closes #4397

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:22:52 +08:00
jiejie1133таliufajie f9077a1f93 feat(vcs): open files from Commit groups with F4 (#4442)
Co-authored-by: liufajie <[email protected]>
2026-11-19 17:19:18 +08:00
LU XIANGRUIтаwildcatDownstairs 68d2370c8f fix(maven): apply offline mode to the Java language server's Maven import too (#4456)
Offline mode in the Maven tool window only added -o to sync's mvn; jdtls's m2e kept downloading. Each sync now records the offline mode (in the build cache, like profiles) and jdtls follows it via java.import.maven.offline.enabled, reconfigured when it changes; toggling offline reloads Maven. Offline sync keeps maven-dependency-plugin 3.8.1 when the local repository has it, and "No plugin found for prefix 'help'" now explains why and offers Open Maven Settings.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:07:13 +08:00
Mansur Akhmadiтаmansur-akhmadi d735a7b7ce fix(services): close a Docker connection's SSH tunnel on Disconnect and Remove (#4432)
Disconnect, Remove Connection and moving a connection to another SSH configuration left the Docker SSH tunnel and its SSH connection open until exit. The new docker_disconnect command closes the tunnel (Tunnel::close waits for the listener and forwarded connections) and then releases the SSH connection unless something else holds it; the UI waits for a snapshot in flight first, keeps it while another connected Docker connection uses the same configuration, and Connect waits for a close in progress. Closes #4431

Co-authored-by: mansur-akhmadi <[email protected]>
2026-11-19 17:06:31 +08:00
l0ng-ai 4ac0cbd908 fix(agents): run ! commands from the new task composer and complete them (#4443)
A ! line typed in the New Task composer went to the agent as a normal message. It now creates the task without starting a turn (NewAgentTask.idle) and runs the command there; the command and output go along with the first message. ! commands also complete earlier commands and paths under the task's folder (Tab accepts, Enter runs), and a command's output starts expanded.
2026-11-19 17:04:27 +08:00
Muuтаmuutot 142552741a perf(intentions): show the ⌥↵ list at once, not after the server answers (#4429)
⌥↵ opened the list only after the language server answered. It now opens after 100 ms with the rows found locally and a spinner ("Computing…" when empty), and fills in when the actions arrive; a faster answer paints once. The caret line's error quick fixes are requested in parallel with the caret's actions, a late answer doesn't reopen a dismissed list, and a stale answer after an edit is dropped.

Co-authored-by: muutot <[email protected]>
2026-11-19 17:04:09 +08:00
LU XIANGRUIтаwildcatDownstairs 685b458ad0 fix(web): keep Open in Browser for HTML files associated with another file type (#4462)
Associating .html/.htm/.xhtml/.shtml with another language (or overriding a file's type) removed Open in Browser and Open In › Browser, because they shared isHtmlPath with the preview. The browser entry points now also recognise pages by name, while the toolbar and Built-in Preview still follow File Types; .shtml is served as text/html.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:54 +08:00
LU XIANGRUIтаwildcatDownstairs 846794450a fix(agents): let Send to Agent reference files of non-primary workspace projects (#4459)
Send to Agent resolved paths against the primary project only, so files of other workspace projects were dropped silently. It now goes through referenceOf with the target composer's roots (the task's cwd/project, or the project picked on the New Task page), keeps folders as folder references, maps only the task's own project into a worktree, and shows the existing notice for paths outside every project. Closes #4438

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:44 +08:00
LU XIANGRUIтаwildcatDownstairs 5e78713188 fix(maven): give the Java language server's Maven import the same settings as mvn (#4455)
jdtls's Maven import (m2e) got different settings from the IDE's mvn: it ignored the Maven home's conf/settings.xml, lost ~/.m2/settings.xml's mirrors when only a local repository was configured, kept a settings.xml's own <localRepository> over the configured one, and dropped the configured repository from the profiles copy. m2e now gets the Maven home's global settings and user settings derived the same way mvn's are (m2e_user_settings), shared with the profiles copy.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:36 +08:00
LU XIANGRUIтаwildcatDownstairs 33c802c048 fix(vcs): keep the unsent commit message per project across restarts (#4454)
A half-written commit message was lost on restart: it lived only in useCommit's memory. The draft is now kept per project root in localStorage (debounced, flushed on blur/pagehide/project switch), cleared by a successful commit, and not overwritten by Amend's message or a message kept after commit. Closes #4423

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:03:20 +08:00
Qingтаqtvbwfn 1e75b7717b fix(run): run a Java class's main even when its file is named like a test (#4453)
Running the file context of a Test.java / XxxTest.kt that declares a main ran mvn test -Dtest=... instead of the program, because fileRole checked the test-name pattern before the content. A JVM file with a main is now a program first; a caret inside a @Test method still runs that test, and a test-named class without a main still runs its tests.

Co-authored-by: qtvbwfn <[email protected]>
2026-11-19 17:03:12 +08:00
Bin 28a464d3b7 fix(editor): show IDEA-style comment fold previews (#4451)
Folded block comments, Javadoc, line documentation and docstrings now show their opener, the first summary line, an ellipsis and the closer (/** Summary ...*/), as in IDEA. Backend folds of a comment now start at the comment itself, and the syntax-fold placeholder adapts when CodeMirror leaves /* and */ outside the range.

Co-authored-by: ffgenius <[email protected]>
2026-11-19 17:03:04 +08:00
LU XIANGRUIтаwildcatDownstairs 0b9048ce02 fix(build): start mvnw / gradlew without the execute bit through sh (#4444)
On macOS/Linux a mvnw / gradlew without the execute bit (committed from Windows, unpacked from a zip) failed with Permission denied in sync and runs. A #! script without the execute bit is now started as /bin/sh <script> in ide-build's process runner and ide-run's process start; the file mode is left alone and the console still shows ./mvnw. Other non-executable files are left to fail as before.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:02:49 +08:00
J 1996таjameingh 4567540b95 fix(vcs): retry an index git could not replace while it is open (#4418)
After a partial commit, aligning the real index with `git reset` could fail on Windows with "fatal: Could not write new index file." while the status scan still had .git/index open; only the index.lock conflict was retried, so the Changes view kept listing committed files as staged. That failure is now retried for reset, add and rm --cached (not switch or plain rm).

Co-authored-by: jameingh <[email protected]>
2026-11-19 17:02:42 +08:00
LU XIANGRUIтаwildcatDownstairs 3a0288111d fix(run): keep the Stop button red while a process is stopping (#4411)
While stopping, the title bar's Stop button switched to the warning background and the spinner took --fg-muted, so it read as a warning and the spinner was barely visible. It now keeps Stop's red background and the spinner uses --bg-elev.

Co-authored-by: wildcatDownstairs <[email protected]>
2026-11-19 17:02:33 +08:00
l0ng-ai a83fc0f3d1 fix(editor): keep line-end annotations past the code with wrapped-part indent (#4463)
With soft wrap and "Use original line's indent for wrapped parts", an indented
line carries a negative text-indent. Inline widgets inherited it, so the inline
blame (and other line-end hints drawn in a block box) started that many columns
to the left, over the code. Widgets now reset text-indent.
2026-11-19 15:49:10 +08:00
314 змінених файлів з 13871 додано та 1815 видалено

No files matched your search

Створено
+59 -59
Переглянути файл
@@ -1203,27 +1203,27 @@ dependencies = [
[[package]]
name = "cranelift-assembler-x64"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "249a61efca6a54425e027f5704a6f68a0232b4df527e05a3ef947d89dbdcb078"
checksum = "aecefa88696b62f833cc0c997d19c93246b0268e2aaf23e0e8692e527f6de088"
dependencies = [
"cranelift-assembler-x64-meta",
]
[[package]]
name = "cranelift-assembler-x64-meta"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5336a46e05db2d515440b1ce8a9363e7bc04b608c0f66cc98dddc5492a66fbf"
checksum = "1391a2546f5edf06a0ff5e9430d73c2713fd536aefec53200dc21846d1467f53"
dependencies = [
"cranelift-srcgen",
]
[[package]]
name = "cranelift-bforest"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01b3675b13214270fddbd257d5fbf4109be8b02d92fc636fe96e2829514a7235"
checksum = "9528915fbc2c950702329e08c6d72aaff8ece9b7ecdbd225742825c09a445227"
dependencies = [
"cranelift-entity",
"wasmtime-internal-core",
@@ -1231,9 +1231,9 @@ dependencies = [
[[package]]
name = "cranelift-bitset"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d7c1d67aa02b6e174bd2b165c113e94af9498fcc20e2892d0f4d5ab8c9618d09"
checksum = "9dd69a6db85c1bcff989809e0e0b3b06506425f32b545c46aeafda5fe7775d6a"
dependencies = [
"serde",
"serde_derive",
@@ -1242,9 +1242,9 @@ dependencies = [
[[package]]
name = "cranelift-codegen"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26fe6f3ec5344c32602c414e986dcbe699fa501a3e3e7b02f887d9d12b14ae42"
checksum = "24c2db6c26cd96393cf785c4b51b900738963cc7422aa0045416a7641ae2f6cd"
dependencies = [
"bumpalo",
"cranelift-assembler-x64",
@@ -1273,9 +1273,9 @@ dependencies = [
[[package]]
name = "cranelift-codegen-meta"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96c5e6323d458486d95781defdb5016a1176fc911d8bc8e64b696adbda6e9044"
checksum = "e284270142e7f1dcb73a992a62a8b3716b4062a65a52d8f2732c6ebf6f7f342f"
dependencies = [
"cranelift-assembler-x64-meta",
"cranelift-codegen-shared",
@@ -1286,24 +1286,24 @@ dependencies = [
[[package]]
name = "cranelift-codegen-shared"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1260aa93b0bd48e8e55c1c7fd9ff6a260f1a1bc46e1f0151a5055b124e5b15d"
checksum = "6595667b7d505cf85d5bdd014e6f57ad6128183238f8e372319d9384782472f5"
[[package]]
name = "cranelift-control"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50c179632a09850f81f1a1e9116cb09330c734a86689f3ee4c3f4ec81543acbd"
checksum = "f26ffdbfcd24c3833d730849e6d132af34a400a2b89b44446015c01eecbea21d"
dependencies = [
"arbitrary",
]
[[package]]
name = "cranelift-entity"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d8c071188cb1c3b1803e23ae415a8d5f58d741d3a4b26a79b83dd61921112eac"
checksum = "9ffb08ccd8a77fb31cdbbda2afa2333d8f85299b1bc0d1c194259ba66d160d74"
dependencies = [
"cranelift-bitset",
"serde",
@@ -1313,9 +1313,9 @@ dependencies = [
[[package]]
name = "cranelift-frontend"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2b85ba0a55d7685117b275fe6f36c819d438862e4223d28f0b97902460ff0ac"
checksum = "b447e4f2bb44b1188185a77f478e5a91b7723a40b3b58c3e2d5b26df2ed5a665"
dependencies = [
"cranelift-codegen",
"hashbrown 0.17.1",
@@ -1326,15 +1326,15 @@ dependencies = [
[[package]]
name = "cranelift-isle"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20ed364edcaed769da7b2709d540f8f7d0ff257749ba193f475e22dba6a0178b"
checksum = "2f0989e943f3a9d41989595826bba544df9fda64bcddd4df0c06fb2e26af3cb3"
[[package]]
name = "cranelift-native"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "418d98c3dce08f0d13526692bbd1888bff4c5f45207f5093d168b5a224fbc88c"
checksum = "5fa10df59e776c42dae5b6ba5216ba5321707a2136abd2219e615c54b234fc1b"
dependencies = [
"cranelift-codegen",
"libc",
@@ -1343,9 +1343,9 @@ dependencies = [
[[package]]
name = "cranelift-srcgen"
version = "0.136.5"
version = "0.136.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f016b9994e39cad68107f33fa5b8dcee8fb7e38332bde3f97690e5e8abe1b10"
checksum = "36508559c8839a8b6ee091f9deaa9cfe620a82f1abb5e358a0a0c65290583622"
[[package]]
name = "crc"
@@ -7403,9 +7403,9 @@ dependencies = [
[[package]]
name = "pulley-interpreter"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d74df9e20cba0f6dd07f01c3140535a6b23e40aecccfcacfb921621b41d0acb"
checksum = "335e459f9c7809af04768799880504d014d07e8e2fc6ae682fe2a105d8ced33f"
dependencies = [
"cranelift-bitset",
"log",
@@ -7415,9 +7415,9 @@ dependencies = [
[[package]]
name = "pulley-macros"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8415513bfa407c06de6f11dbe9437f2352e075a5520ff491a131166d3d90aed1"
checksum = "dd492ac929a6ca0357362d9fa0a09e31290feac5914550ccfb539b21f89c4b9e"
dependencies = [
"proc-macro2",
"quote",
@@ -9759,7 +9759,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"getrandom 0.3.4",
"once_cell",
"rustix",
"windows-sys 0.61.2",
@@ -11096,9 +11096,9 @@ dependencies = [
[[package]]
name = "wasmtime"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d45bf3b13781b9febb0eef42e1e145146c92ef891f345fd918e0e0fa1568c992"
checksum = "f32390bdc8d7cdb6259a1b855178bfed88226b4004b209fd48fb30e0deb01cd3"
dependencies = [
"addr2line",
"async-trait",
@@ -11138,9 +11138,9 @@ dependencies = [
[[package]]
name = "wasmtime-environ"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "833f00f3dc6128159284c5b71e211f24c97d45e052230a14f767fd830a6fb8b0"
checksum = "9c10f8ef1c9ee5e0f125c775fe56a4d07b8525db30a96e6358c61d93bd11dee4"
dependencies = [
"anyhow",
"cpp_demangle",
@@ -11169,9 +11169,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-macro"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d69c34412409072d2e8ec399101524c330e334ff313f77415e6984cc9c6a172"
checksum = "620c53182ebd26c9fff5b90dd53cf8ec3103c381403fd32f8d395da31a9e4a46"
dependencies = [
"anyhow",
"proc-macro2",
@@ -11184,15 +11184,15 @@ dependencies = [
[[package]]
name = "wasmtime-internal-component-util"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b168d39f2d6b896d89fe096afa4ccdd7a8e927b01469b590af84f02fca3126a1"
checksum = "011e31ca343d9ba0ec623153cd94131b6f03973ef1a0ab791161f642e4a16a93"
[[package]]
name = "wasmtime-internal-core"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ad86a65d12c6a9202584ceb658c9a20cf5b25c32eed61c9be5e5f863f88f0d9"
checksum = "ab15e50a060b746493e6e95ef3ce4e6e7ebfdd7cc336a7dff0f0277e01b447ef"
dependencies = [
"hashbrown 0.17.1",
"libm",
@@ -11201,9 +11201,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-cranelift"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a71f0fd1dd40e4e18d4a20cdba29ff8e0eb2c0f21b12c2eb5869e0fea789dd05"
checksum = "dc3d27440a83fba26dd2784a997e13d9acb3606a75fb127c324929b52221c5c5"
dependencies = [
"cranelift-codegen",
"cranelift-control",
@@ -11227,9 +11227,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-fiber"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa4dfa39e58735b24ce3d28bfc8c2b3041603cc8a941bb268395351beff90172"
checksum = "6e54b28d0d453ca8932e4504065ae66a78f01fcb22b1a2ee287128d732fa9d6f"
dependencies = [
"cc",
"libc",
@@ -11241,9 +11241,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-debug"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2eb98d4486c7b0163447d77dea06f3cc87e5e5ba5fc93613f8ec42e27ea181d"
checksum = "9293e75a3048b900f7b7c524702abca16d8a2332f970324eefc519f454cd5d69"
dependencies = [
"cc",
"wasmtime-internal-versioned-export-macros",
@@ -11251,9 +11251,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-jit-icache-coherence"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "852cae234735d79db6c58fe0d04b32f4078ad01fdb3fd6d488ac366132ba9785"
checksum = "b852e568831b913d410541bb37edc45a5002e472208fbdbaf844ed801dd4255f"
dependencies = [
"libc",
"wasmtime-internal-core",
@@ -11262,9 +11262,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-unwinder"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9289378c82b9db7e7cf933d6bb441ad968536ac48f3f38c55b7cf9d3e8d87e1"
checksum = "a1f7349c9834a542275ad757340079e6453fccb429efce581454d23f85af92c0"
dependencies = [
"cranelift-codegen",
"log",
@@ -11274,9 +11274,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-versioned-export-macros"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc5c60c732d99dbcc5d670b71ba6ccf2b015cd16fc828990eaad2c4b8805ebdb"
checksum = "30b3e0768a450d9dea3e16b83f2498f0b08db0e32bad695e35564eef017be3f1"
dependencies = [
"proc-macro2",
"quote",
@@ -11285,9 +11285,9 @@ dependencies = [
[[package]]
name = "wasmtime-internal-wit-bindgen"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c77e4fcc7cd22772578458c5e233df47190ebc9b8b65788797d99a02787c9000"
checksum = "b9d085c540b95d0ffebf98c266e6f152e1acf96a9f676f224a74307b9d422c15"
dependencies = [
"anyhow",
"bitflags 2.13.2",
@@ -11299,9 +11299,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "705b90d1fa1084cc73df656868948da77711b97f6b895d145a4949f86bcea674"
checksum = "17f8ce6b9e77539b5f52d440346f876a84c513ec1b07162845282f8652f7f7f9"
dependencies = [
"async-trait",
"bitflags 2.13.2",
@@ -11323,9 +11323,9 @@ dependencies = [
[[package]]
name = "wasmtime-wasi-io"
version = "49.0.5"
version = "49.0.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d2b6a255be488639f450b380e7e0923789f946de3463696cd30f2fe8a65cc3"
checksum = "da9f90eb7ce6edbead27dba3a58843398875defa73b8dce4bbc29d0ce3dc9b40"
dependencies = [
"async-trait",
"bytes",
+38
Переглянути файл
@@ -60,6 +60,44 @@ Their original copyright headers and Apache-2.0 licensing are retained.
At render time `src/ui/icons.tsx` may recolour monochrome icons to `currentColor`.
## Flutter plugin icons
These icons of [flutter-intellij](https://github.com/flutter/flutter-intellij) (commit `d02813ad5890`) are used
under the BSD 3-Clause License:
- `src/ui/expui/flutter/*.svg`: the DevTools tool window icons, copied unmodified from
`resources/icons/expui/`.
- `src/ui/expui/flutter/[email protected]` and `[email protected]`: the Flutter outline's widget
icons, `resources/icons/custom/[email protected]` and `[email protected]`, renamed, content unmodified.
```text
Copyright 2016 The Chromium Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
```
## JetBrains IntelliJ Platform VCS log graph algorithms
`crates/ide-vcs/src/bek.rs` and `src/features/vcs/graph.ts` adapt the Bek ordering,
+32
Переглянути файл
@@ -256,6 +256,38 @@ impl AgentCatalogs {
.cloned()
}
pub(super) async fn load_levels(
self: &Arc<Self>,
shared: &Arc<Shared>,
provider: &str,
model: &str,
) -> Result<Vec<AgentConfigOption>, String> {
if let Some(levels) = self.levels(shared, provider, model) {
return Ok(levels);
}
let unavailable = || "The agent did not report settings for the selected model".to_owned();
let spec = shared.spec(provider).ok_or_else(unavailable)?;
let (_, flight) = self.request(shared, spec, false, Some(model));
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
self.levels(shared, provider, model).ok_or_else(|| {
let state = self.state.lock();
state
.entries
.get(&Self::key(shared, provider))
.and_then(|entry| {
entry.model_failures.get(model).map(|failure| &failure.error).or(entry.error.as_ref())
})
.cloned()
.unwrap_or_else(unavailable)
})
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
+193 -25
Переглянути файл
@@ -323,6 +323,36 @@ async fn discovered_model_can_be_selected_while_the_session_is_not_running() {
switch_chat_model(ChatSwitch::Idle).await;
}
#[tokio::test]
async fn discovered_model_effort_is_discovered_persisted_and_applied_before_the_first_reply() {
switch_chat_model(ChatSwitch::Uncached).await;
}
#[tokio::test]
async fn discovered_model_with_no_effort_can_be_selected() {
switch_chat_model(ChatSwitch::NoEffort).await;
}
#[tokio::test]
async fn discovered_model_settings_failure_leaves_the_chat_unchanged() {
switch_chat_model(ChatSwitch::DiscoveryFails).await;
}
#[tokio::test]
async fn discovered_model_withdrawn_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortUnavailable).await;
}
#[tokio::test]
async fn discovered_model_rejected_effort_prevents_sending() {
switch_chat_model(ChatSwitch::EffortRejected).await;
}
#[tokio::test]
async fn discovered_model_lookup_does_not_overwrite_a_newer_selection() {
switch_chat_model(ChatSwitch::Superseded).await;
}
#[derive(Clone, Copy)]
enum ChatSwitch {
Live,
@@ -330,6 +360,12 @@ enum ChatSwitch {
ResumeFails,
Unavailable,
Idle,
Uncached,
NoEffort,
DiscoveryFails,
EffortUnavailable,
EffortRejected,
Superseded,
}
async fn switch_chat_model(scenario: ChatSwitch) {
@@ -376,7 +412,21 @@ async fn switch_chat_model(scenario: ChatSwitch) {
}
let before_entries = serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap();
let before_config = manager.task(&task.id).unwrap().state.lock().task.config.clone();
if matches!(scenario, ChatSwitch::Idle) {
let offline = matches!(scenario, ChatSwitch::Idle | ChatSwitch::Uncached | ChatSwitch::Superseded);
let missing_settings = matches!(
scenario,
ChatSwitch::Uncached | ChatSwitch::NoEffort | ChatSwitch::DiscoveryFails | ChatSwitch::Superseded
);
let no_effort = matches!(scenario, ChatSwitch::NoEffort);
let effort_error = match scenario {
ChatSwitch::EffortUnavailable => Some("no longer offers effort value thorough"),
ChatSwitch::EffortRejected => Some("effort rejected by the agent"),
_ => None,
};
let choose_effort = matches!(scenario, ChatSwitch::Uncached) || effort_error.is_some();
let (catalog_models, catalog_effort): (&[&str], &[&str]) =
if missing_settings { (&["old", "new"], &["low", "high"]) } else { (&["new", "old"], &["quick", "thorough"]) };
if offline {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
}
@@ -385,41 +435,122 @@ async fn switch_chat_model(scenario: ChatSwitch) {
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
let next = harness.next().await;
assert_eq!((next.launch, next.method.as_str()), (1, "session/new"));
next.reply.send(Ok(response(&["new", "old"], &["catalog-only"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new", "old"]);
next.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let catalog = completed(&mut events).await;
assert_eq!(model_values(&catalog), catalog_models);
if missing_settings {
assert!(!catalog.thought_levels.contains_key("new"));
}
assert_eq!(manager.task(&task.id).unwrap().state.lock().task.config, before_config);
let live = matches!(scenario, ChatSwitch::Live);
let offline = matches!(scenario, ChatSwitch::Idle);
let resumed_launch = if missing_settings { 3 } else { 2 };
let load_fails = matches!(scenario, ChatSwitch::ResumeFails);
let unavailable = matches!(scenario, ChatSwitch::Unavailable);
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
{
let switching = manager.set_config(&task.id, "model", "new".into());
tokio::pin!(switching);
if !offline {
let next = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((next.launch, next.method.as_str()), (0, "session/set_config_option"));
assert_eq!(next.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
if live {
next.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
} else {
next.reply.send(Err("not in this process's model list".into())).unwrap();
}
}
if missing_settings {
let discovery = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!((discovery.launch, discovery.method.as_str()), (2, "session/new"));
discovery.reply.send(Ok(response(catalog_models, catalog_effort))).unwrap();
let set = next_chat_request(&mut harness, switching.as_mut()).await;
assert_eq!(set.params, json!({"sessionId": "discovery-only", "configId": "model", "value": "new"}));
assert_eq!(set.method, "session/set_config_option");
assert!(
manager
.prompt(&task.id, AgentPrompt { text: "too early".into(), ..Default::default() }, false)
.await
.is_err()
);
if matches!(scenario, ChatSwitch::DiscoveryFails) {
set.reply.send(Err("Sign in required".into())).unwrap();
let error = switching.await.unwrap_err().to_string();
assert!(error.contains("Sign in required"), "{error}");
assert_eq!(manager.subscribe(Arc::new(|_| {})).remove(0).config, before_config);
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
if matches!(scenario, ChatSwitch::Superseded) {
manager.set_config(&task.id, "model", "old".into()).await.unwrap();
set.reply.send(Ok(response(&["new", "old"], &["quick", "thorough"]))).unwrap();
switching.await.unwrap();
let task = manager.subscribe(Arc::new(|_| {})).remove(0);
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("low"));
assert!(harness.pending.try_recv().is_err());
manager.shutdown();
return;
}
let levels: &[&str] = if no_effort { &[] } else { &["quick", "thorough"] };
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
}
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not reopen the chat or send: {request:?}"),
}
}
// A fallback selection settles without waiting for a new process.
tokio::select! {
result = &mut switching => result.unwrap(),
request = harness.next() => panic!("selection must not open another session: {request:?}"),
}
assert_eq!(serde_json::to_value(manager.entries(&task.id, None).unwrap()).unwrap(), before_entries);
if matches!(scenario, ChatSwitch::Uncached) {
let update = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let AgentEvent::Task { task: update } = events.recv().await.unwrap()
&& update.id == task.id
{
break update;
}
}
})
.await
.unwrap();
let effort = update.config.iter().find(|o| o.id == "effort").unwrap();
assert_eq!(effort.values.iter().map(|v| v.value.as_str()).collect::<Vec<_>>(), ["quick", "thorough"]);
}
let snapshot = |manager: &AgentManager| manager.subscribe(Arc::new(|_| {})).remove(0);
let current = snapshot(&manager);
assert_eq!(current.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("new"));
assert_eq!(current.model.as_deref(), Some(if live { "new" } else { "old" }));
let effort =
|task: &crate::AgentTask| task.config.iter().find(|o| o.id == "effort").and_then(|o| o.current.clone());
assert_eq!(
effort(&current).as_deref(),
if live {
Some("session-only")
} else if no_effort {
None
} else {
Some("quick")
},
"the new model's effort must be available before sending"
);
if choose_effort {
assert!(manager.set_config(&task.id, "effort", "high".into()).await.is_err());
manager.set_config(&task.id, "effort", "thorough".into()).await.unwrap();
assert_eq!(effort(&snapshot(&manager)).as_deref(), Some("thorough"));
if matches!(scenario, ChatSwitch::Uncached) {
manager.shutdown();
manager = make_manager(tmp.path(), Arc::default(), &harness);
let restored = snapshot(&manager);
assert_eq!(restored.id, task.id);
assert_eq!(effort(&restored).as_deref(), Some("thorough"));
}
}
manager.prompt(&task.id, AgentPrompt { text: "next".into(), ..Default::default() }, false).await.unwrap();
if !live {
let load = harness.next().await;
assert_eq!((load.launch, load.method.as_str()), (2, "session/load"));
assert_eq!((load.launch, load.method.as_str()), (resumed_launch, "session/load"));
assert_eq!(load.params["sessionId"], "saved-chat");
load.notifications
.send(json!({"jsonrpc": "2.0", "method": "session/update", "params": {
@@ -447,6 +578,7 @@ async fn switch_chat_model(scenario: ChatSwitch) {
let task = snapshot(&manager);
assert_eq!(task.model.as_deref(), Some("old"));
assert_eq!(task.config.iter().find(|o| o.id == "model").unwrap().current.as_deref(), Some("old"));
assert_eq!(effort(&task).as_deref(), Some("low"));
let expected = if load_fails { "cannot resume saved-chat" } else { "does not offer model new" };
assert!(task.error.as_deref().unwrap().contains(expected), "{:?}", task.error);
assert!(harness.pending.try_recv().is_err(), "must not send on the previous model or create a session");
@@ -472,24 +604,60 @@ async fn switch_chat_model(scenario: ChatSwitch) {
return;
}
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_config_option"));
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "model", "value": "new"}));
set.reply.send(Ok(response(&["new", "old"], &["session-only"]))).unwrap();
let levels: &[&str] = match scenario {
ChatSwitch::NoEffort => &[],
ChatSwitch::EffortUnavailable => &["session-only", "quick"],
_ if choose_effort => &["session-only", "thorough"],
_ => &["session-only"],
};
set.reply.send(Ok(response(&["new", "old"], levels))).unwrap();
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (2, "session/set_mode"));
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_mode"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "modeId": "ask"}));
set.reply.send(Ok(json!({}))).unwrap();
if choose_effort && !matches!(scenario, ChatSwitch::EffortUnavailable) {
let set = harness.next().await;
assert_eq!((set.launch, set.method.as_str()), (resumed_launch, "session/set_config_option"));
assert_eq!(set.params, json!({"sessionId": "saved-chat", "configId": "effort", "value": "thorough"}));
let reply = if effort_error.is_some() {
Err("effort rejected by the agent".into())
} else {
Ok(response(&["new", "old"], &["thorough", "session-only"]))
};
set.reply.send(reply).unwrap();
}
if let Some(expected) = effort_error {
wait_for_chat(&manager, &task.id, AgentStatus::Failed).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("old"));
assert_eq!(effort(&current).as_deref(), Some("low"));
assert!(current.error.as_deref().unwrap().contains(expected), "{:?}", current.error);
assert!(harness.pending.try_recv().is_err(), "must not send using a fallback effort");
manager.shutdown();
return;
}
}
let next = harness.next().await;
assert_eq!(
(next.launch, next.method.as_str(), &next.params["sessionId"]),
(if live { 0 } else { 2 }, "session/prompt", &json!("saved-chat"))
(if live { 0 } else { resumed_launch }, "session/prompt", &json!("saved-chat"))
);
next.reply.send(Ok(json!({"stopReason": "end_turn"}))).unwrap();
wait_for_chat(&manager, &task.id, AgentStatus::Ready).await;
let current = snapshot(&manager);
assert_eq!(current.model.as_deref(), Some("new"));
assert_eq!(current.config.iter().find(|o| o.id == "effort").unwrap().current.as_deref(), Some("session-only"));
assert_eq!(
effort(&current).as_deref(),
if choose_effort {
Some("thorough")
} else if no_effort {
None
} else {
Some("session-only")
}
);
assert_eq!(current.config.iter().find(|o| o.id == "mode").unwrap().current.as_deref(), Some("ask"));
manager.shutdown();
}
+316 -116
Переглянути файл
@@ -357,9 +357,11 @@ struct TaskFile {
/// Settings the user chose, re-applied to every new or reloaded session.
#[serde(default)]
wanted: Vec<AgentConfigChoice>,
/// Option id of a discovered model in `wanted` that still needs a same-session reload.
#[serde(default, skip_serializing_if = "Option::is_none")]
/// Pending model option id in task files saved before pending settings were stored separately.
#[serde(default, skip_serializing)]
pending_model: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pending_switch: Option<PendingModel>,
/// In the project's own checkout: files already changed when the task started.
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
before: BTreeMap<String, worktree::Stamp>,
@@ -384,6 +386,26 @@ struct TaskFile {
title_renamed: bool,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
struct PendingModel {
model: AgentConfigChoice,
candidate: Option<AgentConfigValue>,
options: Vec<AgentConfigOption>,
choices: Vec<AgentConfigChoice>,
}
impl PendingModel {
fn apply(&self, wanted: &mut Vec<AgentConfigChoice>, confirmed: &[AgentConfigOption]) {
wanted.retain(|choice| {
choice.id != self.model.id
&& !self.options.iter().any(|o| o.id == choice.id)
&& !confirmed.iter().any(|o| o.id == choice.id && config::is_per_model_option(o))
});
wanted.push(self.model.clone());
wanted.extend(self.choices.iter().cloned());
}
}
/// The changed files of a checkout, stamped.
type Snapshot = BTreeMap<String, worktree::Stamp>;
@@ -392,8 +414,9 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
pending_model: Option<String>,
pending_model: Option<PendingModel>,
model_choice: u64,
discovering_model: Option<u64>,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
@@ -415,23 +438,43 @@ struct TaskState {
}
impl TaskState {
fn pending_model(&self) -> Option<&AgentConfigChoice> {
let id = self.pending_model.as_deref()?;
self.wanted.iter().find(|c| c.id == id)
}
fn snapshot(&self) -> AgentTask {
let mut task = self.task.clone();
if let Some(choice) = self.pending_model()
&& let Some(model) = task.config.iter_mut().find(|o| o.id == choice.id)
if let Some(pending) = &self.pending_model
&& let Some(model) = task.config.iter_mut().find(|o| o.id == pending.model.id)
{
model.current = Some(choice.value.clone());
model.current = Some(pending.model.value.clone());
if let Some(candidate) = &pending.candidate
&& !model.values.iter().any(|v| v.value == candidate.value)
{
model.values.push(candidate.clone());
}
task.config.retain(|o| !config::is_per_model_option(o));
task.config.extend(pending.options.iter().cloned().map(|mut option| {
if let Some(choice) = pending.choices.iter().find(|choice| choice.id == option.id) {
option.current = Some(choice.value.clone());
}
option
}));
}
task
}
}
struct DiscoveringModel<'a> {
state: &'a Mutex<TaskState>,
generation: u64,
}
impl Drop for DiscoveringModel<'_> {
fn drop(&mut self) {
let mut s = self.state.lock();
if s.discovering_model == Some(self.generation) {
s.discovering_model = None;
}
}
}
/// A running agent and its session.
#[derive(Clone)]
struct Live {
@@ -796,6 +839,7 @@ impl AgentManager {
entries: Vec::new(),
wanted: Vec::new(),
pending_model: None,
pending_switch: None,
before: BTreeMap::new(),
saved: None,
touched: Some(BTreeSet::new()),
@@ -811,7 +855,8 @@ impl AgentManager {
Ok(task)
}
/// Creates the task (and its worktree) and sends `req.prompt` as its first message.
/// Creates the task (and its worktree) and sends `req.prompt` as its first message, unless
/// `req.idle`.
pub async fn create(&self, req: NewAgentTask) -> IdeResult<AgentTask> {
let spec = self
.shared
@@ -886,7 +931,7 @@ impl AgentManager {
title,
provider: spec.id.clone(),
model: model_of(&config),
status: AgentStatus::Starting,
status: if req.idle { AgentStatus::Ready } else { AgentStatus::Starting },
isolation: req.isolation,
cwd: IpcPath(cwd),
branch,
@@ -911,6 +956,7 @@ impl AgentManager {
entries: Vec::new(),
wanted: req.config,
pending_model: None,
pending_switch: None,
before,
saved,
touched: (req.isolation == Isolation::Local).then(BTreeSet::new),
@@ -920,11 +966,13 @@ impl AgentManager {
title_renamed: false,
};
let handle = Task::restore(file, self.shared.clone());
handle.state.lock().busy = true;
handle.state.lock().busy = !req.idle;
self.tasks.write().insert(task.id.clone(), handle.clone());
handle.emit_task();
handle.persist();
self.shared.runtime.spawn(async move { handle.run(prompt).await });
if !req.idle {
self.shared.runtime.spawn(async move { handle.run(prompt).await });
}
Ok(task)
}
@@ -946,6 +994,9 @@ impl AgentManager {
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if s.discovering_model.is_some() {
return Err(IdeError::unavailable("Model settings are still loading"));
}
if s.busy {
let item = AgentQueued { id: uuid::Uuid::new_v4().simple().to_string(), prompt };
if now {
@@ -1065,6 +1116,24 @@ impl AgentManager {
let task = self.task(id)?;
let (target, change) = {
let mut s = task.state.lock();
let busy = s.busy;
let archived = s.task.status == AgentStatus::Archived;
if let Some(pending) = &mut s.pending_model
&& let Some(target) = pending.options.iter().find(|o| o.id == option)
{
if archived || busy {
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
}
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
}
pending.choices.retain(|c| c.id != option);
pending.choices.push(AgentConfigChoice { id: option.to_owned(), value });
drop(s);
task.persist();
task.emit_task();
return Ok(());
}
let target = s
.task
.config
@@ -1072,6 +1141,9 @@ impl AgentManager {
.find(|o| o.id == option)
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if s.pending_model.is_some() && config::is_per_model_option(&target) {
return Err(IdeError::invalid("This setting is not available on the selected model"));
}
if !target.values.iter().any(|v| v.value == value) {
if target.category.as_deref() != Some("model") {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
@@ -1080,8 +1152,12 @@ impl AgentManager {
} else {
let switching_model = target.category.as_deref() == Some("model");
if switching_model {
if s.pending_model.is_some() && s.busy {
return Err(IdeError::invalid("The pending model settings cannot be changed now"));
}
s.model_choice += 1;
s.pending_model = None;
s.discovering_model = None;
}
let previous_levels = (switching_model && target.current.as_deref() != Some(value.as_str()))
.then(|| s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>());
@@ -1113,33 +1189,19 @@ impl AgentManager {
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
{
let provider = task.state.lock().task.provider.clone();
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
let mut error = None;
if levels.is_none()
&& let Some(spec) = self.shared.spec(&provider)
{
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
error = catalog.error;
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
}
let levels = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
// Another selection may have superseded this discovery while it was waiting.
if task.state.lock().model_choice != model_choice {
return Ok(());
}
let Some(levels) = levels else {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
));
let levels = match levels {
Ok(levels) => levels,
Err(error) => {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(error));
}
};
let mut s = task.state.lock();
if s.model_choice != model_choice {
@@ -1262,6 +1324,7 @@ impl AgentManager {
entries,
wanted: s.wanted.clone(),
pending_model: None,
pending_switch: None,
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -1307,6 +1370,8 @@ impl AgentManager {
};
s.session_id = None;
s.pending_model = None;
s.model_choice += 1;
s.discovering_model = None;
s.conversation = Conversation::default();
// The fresh session reports its own usage; nothing carries over.
s.task.usage = None;
@@ -1905,6 +1970,24 @@ impl Task {
let mut task = file.task;
config::add_client_options(&task.provider, &mut task.config);
let conversation = Conversation::restore(file.entries, file.subagents);
let mut wanted = file.wanted;
let pending_model = file.pending_switch.or_else(|| {
let id = file.pending_model?;
let index = wanted.iter().position(|choice| choice.id == id)?;
let model = wanted.remove(index);
if let Some(value) = task.model.clone() {
wanted.push(AgentConfigChoice { id, value });
}
let catalog = shared.paths.catalogs.cached(&shared, &task.provider);
let candidate = catalog
.config
.iter()
.find(|o| o.category.as_deref() == Some("model"))
.and_then(|o| o.values.iter().find(|v| v.value == model.value))
.cloned();
let options = catalog.thought_levels.get(&model.value).cloned().unwrap_or_default();
Some(PendingModel { model, candidate, options, choices: Vec::new() })
});
Arc::new(Self {
id: task.id.clone(),
shared,
@@ -1912,9 +1995,10 @@ impl Task {
task,
session_id: file.session_id,
conversation,
wanted: file.wanted,
pending_model: file.pending_model,
wanted,
pending_model,
model_choice: 0,
discovering_model: None,
before: Arc::new(file.before),
saved: file.saved,
touched: file.touched.map(Arc::new),
@@ -2108,7 +2192,8 @@ impl Task {
session_id: s.session_id.clone(),
entries: s.conversation.main.entries.clone(),
wanted: s.wanted.clone(),
pending_model: s.pending_model.clone(),
pending_model: None,
pending_switch: s.pending_model.clone(),
before: (*s.before).clone(),
saved: s.saved.clone(),
touched: s.touched.as_deref().cloned(),
@@ -2261,13 +2346,18 @@ impl Task {
let candidate = self.shared.paths.catalogs.fresh_model(&self.shared, &spec, &value).ok_or_else(|| {
IdeError::invalid(format!("{} has no value {value} in the current model catalog", target.name))
})?;
let model_choice = {
let selection = {
let mut s = self.state.lock();
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
s.model_choice += 1;
s.model_choice
s.discovering_model = Some(s.model_choice);
DiscoveringModel { state: &self.state, generation: s.model_choice }
};
let model_choice = selection.generation;
// A prompt starting during the switch must not grab the peer we're about to recycle.
let _connecting = self.connecting.lock().await;
let connecting = self.connecting.lock().await;
{
let s = self.state.lock();
if s.model_choice != model_choice {
@@ -2290,16 +2380,16 @@ impl Task {
Ok(None)
};
let accepted = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
let pending = match result {
Ok(Some(reply)) => {
let refused = match result {
Ok(Some(reply)) => {
let (config, model) = {
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut s.task.config, options);
} else if s.task.model.as_deref() != Some(value.as_str()) {
@@ -2318,36 +2408,66 @@ impl Task {
model.current = Some(value.clone());
s.task.model = Some(value.clone());
sync_usage_context_size(&mut s.task);
false
}
refused => {
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
true
}
};
s.wanted.retain(|c| c.id != target.id);
s.pending_model = pending.then(|| target.id.clone());
s.wanted.push(AgentConfigChoice { id: target.id, value });
(!pending).then(|| {
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
})
s.pending_model = None;
s.wanted.retain(|c| c.id != target.id);
s.wanted.push(AgentConfigChoice { id: target.id, value });
let model = s.task.model.clone().filter(|_| s.task.config.iter().any(config::is_per_model_option));
(s.task.config.clone(), model)
};
self.shared.remember(&provider, Some(&config), None, model.as_deref());
self.persist();
self.emit_task();
return Ok(());
}
refused => refused,
};
if let Some((config, model)) = accepted {
self.shared.remember(&provider, Some(&config), None, model.as_deref());
} else {
self.recycle_resumable_session();
{
let s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.session_id.is_none()
|| live.as_ref().is_some_and(|l| !l.resumable)
|| self.start_fresh.load(Ordering::Acquire)
{
return Err(IdeError::unavailable(
refused.err().unwrap_or_else(|| "The agent does not support resuming this session.".into()),
));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
}
// Catalog discovery never owns the chat session. Let a newer model choice supersede it.
drop(connecting);
let options = self.shared.paths.catalogs.load_levels(&self.shared, &provider, &value).await;
let _connecting = self.connecting.lock().await;
{
let mut s = self.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
if s.task.status == AgentStatus::Archived {
return Err(IdeError::invalid("the task is archived"));
}
if s.busy || !s.background_tasks.is_empty() || !self.permissions.lock().is_empty() {
return Err(IdeError::invalid("wait until the agent is done"));
}
let options = options.map_err(IdeError::unavailable)?;
let choices = s
.pending_model
.take()
.filter(|pending| pending.model.value == value)
.map(|pending| pending.choices)
.unwrap_or_default();
s.pending_model = Some(PendingModel {
model: AgentConfigChoice { id: target.id, value },
candidate: Some(candidate),
options,
choices,
});
}
self.recycle_resumable_session();
self.persist();
self.emit_task();
Ok(())
@@ -2609,10 +2729,9 @@ impl Task {
}
let (provider_id, cwd, saved, pending) = {
let s = self.state.lock();
let pending = s.pending_model().map(|choice| (choice.clone(), s.task.model.clone()));
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), pending)
(s.task.provider.clone(), s.task.cwd.0.clone(), s.session_id.clone(), s.pending_model.clone())
};
let pending_model = pending.as_ref().map(|(choice, _)| choice);
let pending_model = pending.as_ref();
let raw_spec = self.shared.spec(&provider_id).ok_or_else(|| format!("unknown agent {provider_id}"))?;
let can_fallback =
raw_spec.driver == provider::Driver::Copilot && !self.shared.uses_copilot_acp_fallback(&raw_spec);
@@ -2638,22 +2757,12 @@ impl Task {
let live = match opened {
Ok(live) => live,
Err(err) => {
if let Some((choice, previous)) = pending {
let mut s = self.state.lock();
if s.pending_model() == Some(&choice) {
s.pending_model = None;
s.wanted.retain(|c| c.id != choice.id);
if let Some(model) = s.task.config.iter_mut().find(|o| o.id == choice.id) {
model.current.clone_from(&previous);
}
s.task.model.clone_from(&previous);
if let Some(value) = previous {
s.wanted.push(AgentConfigChoice { id: choice.id, value });
}
drop(s);
self.persist();
self.emit_task();
}
let mut s = self.state.lock();
if pending.is_some() && s.pending_model == pending {
s.pending_model = None;
drop(s);
self.persist();
self.emit_task();
}
return Err(err.message);
}
@@ -2668,7 +2777,7 @@ impl Task {
spec: provider::ProviderSpec,
cwd: &Path,
saved: Option<String>,
pending_model: Option<&AgentConfigChoice>,
pending_model: Option<&PendingModel>,
) -> Result<Live, SessionOpenError> {
let launch_cwd = cwd.to_path_buf();
let mut spec = tokio::task::spawn_blocking(move || spec.resolve_for_launch(&launch_cwd))
@@ -2694,14 +2803,15 @@ impl Task {
}
});
// Speaks ACP v1 or v2, whichever the agent chooses; the task sees v1 either way.
let client = acp::Dialect::wrap(Arc::new(Client { task: Arc::downgrade(self) }));
let client = Client::new(self, saved.as_deref().filter(|_| pending_model.is_some()));
let handler = acp::Dialect::wrap(client.clone());
let raw_peer =
(self.shared.connector)(&spec, cwd, client.clone(), on_stderr).map_err(|e| SessionOpenError {
(self.shared.connector)(&spec, cwd, handler.clone(), on_stderr).map_err(|e| SessionOpenError {
message: format!("Couldn't start {} (`{}`): {e}", spec.name, spec.command),
allow_acp_fallback: !native::copilot::is_missing_binary_error(&e),
})?;
let mut stop_on_err = KillOnDrop(Some(raw_peer.clone()));
let peer = acp::Conn::new(raw_peer, client);
let peer = acp::Conn::new(raw_peer, handler);
let init = peer.initialize(&client_info()).await.map_err(|e| {
let is_auth = matches!(&e, RpcError::Server { code, message, .. } if acp::auth_required(*code, message));
@@ -2800,7 +2910,13 @@ impl Task {
// The session's settings, then the user's choices on top.
// A session that reports none keeps the last known ones, but what is set is unknown.
let reported = config::options_of(&result);
let mut reported = config::options_of(&result);
if let Some(update) = client.take_opening_config()
&& let Some(config) = update.get("configOptions")
&& reported.iter().all(|o| o.category.as_deref() != Some("model"))
{
config::merge_update(&mut reported, config);
}
let known = !reported.is_empty();
if known {
self.shared.remember(provider_id, Some(&reported), None, model_of(&reported).as_deref());
@@ -2808,19 +2924,33 @@ impl Task {
let (mut options, mut wanted) = {
let s = self.state.lock();
let options = if known { reported } else { s.task.config.clone() };
let wanted = s.wanted.clone();
let mut wanted = s.wanted.clone();
if let Some(pending) = pending_model {
pending.apply(&mut wanted, &s.task.config);
}
(options, wanted)
};
config::add_client_options(provider_id, &mut options);
// Changing model can replace the effort / context-tier choices; validate those only afterwards.
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
wanted.sort_by_key(|c| {
if let Some(pending) = pending_model {
if c == &pending.model {
return 0;
}
if pending.choices.contains(c) {
return 2;
}
}
match options.iter().find(|o| o.id == c.id) {
Some(o) if o.category.as_deref() == Some("model") => 0,
Some(o) if config::is_per_model_option(o) => 2,
_ => 1,
}
});
let mut model_options = known;
for choice in &wanted {
let pending = pending_model == Some(choice);
let pending = pending_model.is_some_and(|p| &p.model == choice);
let explicit = pending_model.is_some_and(|p| p.choices.contains(choice));
if pending
&& !options.iter().any(|o| {
o.id == choice.id
@@ -2833,6 +2963,19 @@ impl Task {
allow_acp_fallback: false,
});
}
if explicit
&& (!model_options
|| !options.iter().any(|o| {
o.id == choice.id
&& config::is_per_model_option(o)
&& o.values.iter().any(|v| v.value == choice.value)
}))
{
return Err(SessionOpenError {
message: format!("The selected model no longer offers {} value {}.", choice.id, choice.value),
allow_acp_fallback: false,
});
}
// An option the session doesn't offer yet is set once it does (`apply_late_choices`).
let Some(o) = options.iter().find(|o| o.id == choice.id).cloned() else { continue };
if o.id == config::CURSOR_APPROVAL {
@@ -2844,7 +2987,7 @@ impl Task {
if config::is_per_model_option(&o) && !model_options {
continue;
}
let already = known && o.current.as_deref() == Some(choice.value.as_str());
let already = (known || explicit) && o.current.as_deref() == Some(choice.value.as_str());
if already || !o.values.iter().any(|v| v.value == choice.value) {
continue;
}
@@ -2853,14 +2996,30 @@ impl Task {
params["sessionId"] = json!(session_id);
match peer.request::<_, Value>(method, params, None).await {
Ok(reply) => {
if pending && !config::accepts_model(&reply, &o.id, &choice.value) {
let observed = client.take_opening_config();
let report =
if reply.get("configOptions").is_some() { &reply } else { observed.as_ref().unwrap_or(&reply) };
if pending && !config::accepts_model(report, &o.id, &choice.value) {
return Err(SessionOpenError {
message: format!("The reloaded session did not switch to model {}.", choice.value),
allow_acp_fallback: false,
});
}
if let Some(fresh) = reply.get("configOptions") {
if let Some(fresh) = report.get("configOptions") {
config::merge_update(&mut options, fresh);
if explicit
&& !options.iter().any(|option| {
option.id == choice.id && option.current.as_deref() == Some(choice.value.as_str())
})
{
return Err(SessionOpenError {
message: format!(
"The selected model did not accept {} value {}.",
choice.id, choice.value
),
allow_acp_fallback: false,
});
}
model_options = true;
} else if o.category.as_deref() == Some("model") {
if o.current.as_deref() != Some(choice.value.as_str()) {
@@ -2872,7 +3031,7 @@ impl Task {
o.current = Some(choice.value.clone());
}
}
Err(e) if pending => {
Err(e) if pending || explicit => {
return Err(SessionOpenError { message: self.describe(e), allow_acp_fallback: false });
}
Err(e) => tracing::warn!("agent task {}: setting {} to {} failed: {e}", self.id, o.id, choice.value),
@@ -2882,6 +3041,16 @@ impl Task {
self.shared.remember(provider_id, Some(&options), None, model.as_deref());
{
let mut s = self.state.lock();
if let Some(pending) = pending_model {
if s.pending_model.as_ref() != Some(pending) {
return Err(SessionOpenError {
message: "The pending model settings changed while reopening the session.".into(),
allow_acp_fallback: false,
});
}
let TaskState { task, wanted, .. } = &mut *s;
pending.apply(wanted, &task.config);
}
s.task.model = model_of(&options).or(s.task.model.take());
s.task.config = options;
s.pending_model = None;
@@ -2891,6 +3060,7 @@ impl Task {
// The (re)started process runs nothing yet: whatever it reports next is all of it.
s.background_tasks = Vec::new();
s.task.background.clear();
*client.opening_config.lock() = None;
}
self.persist();
self.emit_task();
@@ -3358,6 +3528,28 @@ impl Task {
/// Answers the agent's requests on behalf of one task.
struct Client {
task: Weak<Task>,
opening_config: Mutex<Option<OpeningConfig>>,
}
/// Config replays belong to the candidate connection until its model and settings are confirmed.
struct OpeningConfig {
session: String,
options: Option<Value>,
}
impl Client {
fn new(task: &Arc<Task>, opening_session: Option<&str>) -> Arc<Self> {
Arc::new(Self {
task: Arc::downgrade(task),
opening_config: Mutex::new(
opening_session.map(|id| OpeningConfig { session: id.to_owned(), options: None }),
),
})
}
fn take_opening_config(&self) -> Option<Value> {
self.opening_config.lock().as_mut()?.options.take()
}
}
impl Handler for Client {
@@ -3374,6 +3566,14 @@ impl Handler for Client {
if method == "session/update"
&& let (Some(task), Some(update)) = (self.task.upgrade(), params.get("update"))
{
if update.get("sessionUpdate").and_then(Value::as_str) == Some("config_option_update")
&& let Some(opening) = self.opening_config.lock().as_mut()
{
if params.get("sessionId").and_then(Value::as_str) == Some(opening.session.as_str()) {
opening.options = Some(update.clone());
}
return;
}
task.on_update(params.get("sessionId").and_then(Value::as_str), update);
}
}
+4
Переглянути файл
@@ -633,6 +633,10 @@ pub struct NewAgentTask {
/// Per-session MCP server enable/disable overrides (`server_name` -> `enabled`).
#[serde(default)]
pub mcp_overrides: BTreeMap<String, bool>,
/// Creates the task without sending `prompt` (it only names the task): the composer's
/// `!` command runs in it first.
#[serde(default)]
pub idle: bool,
}
/// A file the task changed: against [`AgentTask::base_commit`], or against `HEAD` in the
+30 -1
Переглянути файл
@@ -1420,6 +1420,32 @@ async fn shell_commands_show_in_the_conversation_and_go_with_the_next_message()
assert_eq!(sent.pointer("/0/text").and_then(Value::as_str), Some("again"));
}
#[tokio::test(flavor = "multi_thread")]
async fn an_idle_task_starts_no_turn_until_its_first_message() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("! echo first"),
provider: "claude".into(),
isolation: Isolation::Local,
idle: true,
..Default::default()
})
.await
.unwrap();
assert_eq!((task.status, task.title.as_str()), (AgentStatus::Ready, "! echo first"));
mgr.run_shell(&task.id, "echo first", ide_core::CancellationToken::new()).await.unwrap();
assert!(agent.prompts.lock().is_empty(), "an idle task starts no turn");
mgr.prompt(&task.id, text("again"), false).await.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
let sent = agent.prompts.lock().last().cloned().unwrap();
assert!(sent.pointer("/0/text").and_then(Value::as_str).is_some_and(|t| t.contains("echo first")));
assert_eq!(sent.pointer("/1/text").and_then(Value::as_str), Some("again"));
}
#[tokio::test(flavor = "multi_thread")]
async fn send_now_interrupts_the_turn_when_steering_is_refused() {
let tmp = tempfile::tempdir().unwrap();
@@ -1909,7 +1935,7 @@ async fn startup_warnings_survive_replay_and_restart_without_failing_the_task()
let handle = mgr.task(&task.id).unwrap();
handle.replaying.store(true, Ordering::Release);
handle.turn_started.store(false, Ordering::Release);
let client = Client { task: Arc::downgrade(&handle) };
let client = Client::new(&handle, None);
client.on_notification(WARNING_NOTIFICATION, json!({"message": "Project MCP config is disabled until trusted."}));
client.on_notification(WARNING_NOTIFICATION, json!({"message": " "}));
client.on_notification(WARNING_NOTIFICATION, json!({}));
@@ -4377,6 +4403,7 @@ async fn per_session_mcp_overrides_filter_session_and_reload_when_idle() {
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::from([("slack".into(), false)]),
idle: false,
})
.await
.unwrap();
@@ -4504,6 +4531,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
})
.await
.unwrap();
@@ -4528,6 +4556,7 @@ async fn copilot_falls_back_to_acp_when_headless_probe_session_or_prompt_fails()
isolation: Isolation::Local,
base: None,
mcp_overrides: BTreeMap::new(),
idle: false,
})
.await
.unwrap();
+2 -1
Переглянути файл
@@ -25,7 +25,8 @@ pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradl
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_gradle_model, sync_maven,
SyncOptions, SyncProgress, maven_offline, maven_profiles, save_maven_offline, save_maven_profiles, sync_gradle,
sync_gradle_model, sync_maven,
};
use serde::{Deserialize, Serialize};
+7 -1
Переглянути файл
@@ -163,7 +163,13 @@ fn run_with_env_capture(
let encoding =
ide_core::output_encoding::fix(program, args, env, |k| std::env::var(k).ok(), "UTF-8", cfg!(windows));
let program = program_path(program, env, cwd);
let mut command = Command::new(&program);
let mut command = if ide_core::process::needs_sh(&program) {
let mut sh = Command::new("/bin/sh");
sh.arg(&program);
sh
} else {
Command::new(&program)
};
command.args(args).current_dir(cwd).envs(env).envs(encoding.env.iter().map(|(k, v)| (k, v))).stdin(Stdio::null());
command.stdout(Stdio::piped()).stderr(Stdio::piped());
// Its own group: `mvnw` / `gradlew` start the JVM as a child, and cancelling kills both.
+88 -17
Переглянути файл
@@ -86,15 +86,20 @@ const MAVEN_CACHE_VERSION: u32 = 1;
/// `dependency:tree` of a plugin version whose `-Dverbose` lists the occurrences Maven
/// omitted (conflicts, duplicates): verbose output was dropped in 3.0 and is back since 3.2.
/// Offline, the project's own plugin version is used instead, since this one may not be cached.
/// Offline, it is used only when an earlier sync downloaded it; otherwise the project's own
/// plugin version is, which may be cached instead.
const DEPENDENCY_TREE: &str = "org.apache.maven.plugins:maven-dependency-plugin:3.8.1:tree";
const DEPENDENCY_TREE_JAR: &str =
"org/apache/maven/plugins/maven-dependency-plugin/3.8.1/maven-dependency-plugin-3.8.1.jar";
/// The goals that read the effective POM into `effective` and the verbose dependency trees.
fn maven_sync_goals(effective: &Path, offline: bool) -> Vec<String> {
/// The goals that read the effective POM into `effective` and the verbose dependency trees;
/// `repo` is the local repository the build resolves from.
fn maven_sync_goals(effective: &Path, offline: bool, repo: Option<&Path>) -> Vec<String> {
let pinned = !offline || repo.is_some_and(|repo| repo.join(DEPENDENCY_TREE_JAR).is_file());
vec![
"help:effective-pom".into(),
format!("-Doutput={}", effective.to_string_lossy()),
if offline { "dependency:tree".into() } else { DEPENDENCY_TREE.into() },
if pinned { DEPENDENCY_TREE.into() } else { "dependency:tree".into() },
"-Dverbose".into(),
]
}
@@ -118,6 +123,7 @@ fn sync_maven_options(options: &[String]) -> Vec<String> {
}
const GRADLE_CACHE: &str = "gradle.json";
const MAVEN_PROFILES: &str = "maven-profiles.json";
const MAVEN_OFFLINE: &str = "maven-offline.json";
/// The Maven profiles (`-P` entries, `!id` deactivates) the project was last synced
/// with: what the IDE resolves it with besides `mvn` (the Java language server, Build Project).
@@ -127,12 +133,31 @@ pub fn maven_profiles(cache_dir: &Path) -> Vec<String> {
/// Records the profiles of a sync for [`maven_profiles`]; `true` when they changed.
pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<bool> {
if maven_profiles(cache_dir) == profiles {
save_if_changed(cache_dir, MAVEN_PROFILES, &profiles.to_vec())
}
/// Whether the project was last synced offline (`-o`): the Java language server then
/// resolves it offline too.
pub fn maven_offline(cache_dir: &Path) -> bool {
read_cache(cache_dir, MAVEN_OFFLINE).unwrap_or(false)
}
/// Records the offline mode of a sync for [`maven_offline`]; `true` when it changed.
pub fn save_maven_offline(cache_dir: &Path, offline: bool) -> IdeResult<bool> {
save_if_changed(cache_dir, MAVEN_OFFLINE, &offline)
}
fn save_if_changed<T: Serialize + DeserializeOwned + PartialEq + Default>(
dir: &Path,
name: &str,
value: &T,
) -> IdeResult<bool> {
if read_cache::<T>(dir, name).unwrap_or_default() == *value {
return Ok(false);
}
std::fs::create_dir_all(cache_dir)?;
let json = serde_json::to_vec(profiles).map_err(|e| IdeError::internal(e.to_string()))?;
std::fs::write(cache_dir.join(MAVEN_PROFILES), json)?;
std::fs::create_dir_all(dir)?;
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
std::fs::write(dir.join(name), json)?;
Ok(true)
}
@@ -382,7 +407,8 @@ pub fn sync_maven(
if !options.profiles.is_empty() {
args.push(format!("-P{}", options.profiles.join(",")));
}
args.extend(maven_sync_goals(&effective, options.offline));
let repo = local_repo.clone().or_else(maven::default_local_repo);
args.extend(maven_sync_goals(&effective, options.offline, repo.as_deref()));
progress(SyncProgress { message: format!("Reading {}", top.display_name), fraction: None });
let command = options.maven_command.as_deref().unwrap_or(&top.command);
let out = run(command, &args, &root.join(&top.dir), &options.env, cancel, |line| {
@@ -532,14 +558,18 @@ mod tests {
assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
assert!(loaded.gradle[1].sync_error.is_none());
assert_eq!(loaded.gradle[1].projects[0].tasks[0].name, "healthy");
let bad_wrapper = root.join("a/gradlew");
std::fs::write(&bad_wrapper, "#!/bin/sh\nexit 0\n").unwrap();
std::fs::set_permissions(&bad_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
models[0].command = bad_wrapper.to_string_lossy().into_owned();
// A wrapper without the execute bit (committed from Windows, unpacked from a zip)
// runs through `sh`, and its mode is left alone.
let plain_wrapper = root.join("a/gradlew");
std::fs::write(&plain_wrapper, "#!/bin/sh\nprintf '%s\\n' 'Build tasks' '-----------' 'plain - ok'\n").unwrap();
std::fs::set_permissions(&plain_wrapper, std::fs::Permissions::from_mode(0o644)).unwrap();
models[0].command = plain_wrapper.to_string_lossy().into_owned();
run(&models[0]).unwrap();
let loaded = crate::load_linked(root, &cache, None, &Default::default(), &settings);
assert!(loaded.gradle[0].sync_error.as_deref().unwrap().contains("cannot start"));
assert!(loaded.gradle[0].sync_error.is_none());
assert_eq!(loaded.gradle[0].projects[0].tasks[0].name, "plain");
assert!(loaded.gradle[1].sync_error.is_none());
assert_eq!(std::fs::metadata(&plain_wrapper).unwrap().permissions().mode() & 0o777, 0o644);
let blocked_cache = root.join("blocked-cache");
std::fs::write(&blocked_cache, "a file cannot contain sync caches").unwrap();
assert!(
@@ -908,12 +938,31 @@ mod tests {
}
#[test]
fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline() {
let online = maven_sync_goals(Path::new("e.xml"), false);
fn the_offline_mode_of_the_last_sync_is_kept_for_the_language_server() {
let tmp = tempfile::tempdir().unwrap();
let cache = tmp.path().join("cache");
assert!(!maven_offline(&cache), "never synced: online");
assert!(save_maven_offline(&cache, true).unwrap());
assert!(maven_offline(&cache));
assert!(!save_maven_offline(&cache, true).unwrap(), "unchanged");
assert!(save_maven_offline(&cache, false).unwrap());
assert!(!maven_offline(&cache));
assert!(!save_maven_offline(&tmp.path().join("other"), false).unwrap(), "online is the default");
}
#[test]
fn sync_reads_verbose_trees_with_a_pinned_plugin_unless_offline_without_it() {
let tmp = tempfile::tempdir().unwrap();
let online = maven_sync_goals(Path::new("e.xml"), false, None);
assert_eq!(online, ["help:effective-pom", "-Doutput=e.xml", DEPENDENCY_TREE, "-Dverbose"]);
let offline = maven_sync_goals(Path::new("e.xml"), true);
let offline = maven_sync_goals(Path::new("e.xml"), true, Some(tmp.path()));
assert_eq!(offline[2], "dependency:tree");
assert!(offline.contains(&"-Dverbose".to_owned()));
// Downloaded by an online sync: offline keeps using it, the project's version may be missing.
let jar = tmp.path().join(DEPENDENCY_TREE_JAR);
std::fs::create_dir_all(jar.parent().unwrap()).unwrap();
std::fs::write(&jar, "").unwrap();
assert_eq!(maven_sync_goals(Path::new("e.xml"), true, Some(tmp.path()))[2], DEPENDENCY_TREE);
}
#[test]
@@ -965,6 +1014,28 @@ mod tests {
assert!(sync_maven_options(&[]).is_empty());
}
#[cfg(unix)]
#[test]
fn maven_sync_runs_a_wrapper_without_the_execute_bit() {
use std::os::unix::fs::PermissionsExt;
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().join("p");
std::fs::create_dir_all(&root).unwrap();
std::fs::write(root.join("pom.xml"), "<project><groupId>g</groupId><artifactId>a</artifactId></project>")
.unwrap();
let mvnw = root.join("mvnw");
std::fs::write(&mvnw, "#!/bin/sh\nprintf '%s\\n' \"$@\" > mvnw-args\n").unwrap();
std::fs::set_permissions(&mvnw, std::fs::Permissions::from_mode(0o644)).unwrap();
let cache = tmp.path().join("cache");
sync_maven(&root, &cache, &SyncOptions::default(), &CancellationToken::new(), &|_| {}).unwrap();
let args = std::fs::read_to_string(root.join("mvnw-args")).unwrap();
assert!(args.contains("help:effective-pom"), "args: {args}");
let loaded = crate::load_linked(&root, &cache, None, &Default::default(), &Default::default());
let maven = loaded.maven.unwrap();
assert!(maven.synced_at.is_some() && maven.sync_error.is_none(), "{:?}", maven.sync_error);
assert_eq!(std::fs::metadata(&mvnw).unwrap().permissions().mode() & 0o777, 0o644);
}
#[cfg(unix)]
#[test]
fn maven_sync_runs_the_daemon_command_serially() {
+14
Переглянути файл
@@ -312,6 +312,8 @@ pub enum LspRefreshKind {
InlayHints,
SemanticTokens,
CodeLens,
/// The Dart server published a document's Flutter outline.
FlutterOutline,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -370,6 +372,18 @@ pub enum DebugEvent {
/// `flutter debug_adapter`'s `flutter.appStarted` event (launch and attach): the session is
/// a Flutter app that can take a hot reload now. The plain Dart adapter never sends it.
FlutterAppStarted,
/// The VM Service of a Flutter session's app, which DevTools connects to.
FlutterVmService {
uri: String,
/// The Flutter device the app runs on.
device: Option<String>,
},
/// Flutter's inspector selected a widget: its source, 0-based.
FlutterNavigate {
path: crate::IpcPath,
line: u32,
column: u32,
},
/// The session's capabilities changed after it started: fetch them again.
Capabilities,
/// The adapter's `invalidated` event: what it shows for `areas` (`all`, `stacks`, `threads`,
+21
Переглянути файл
@@ -807,6 +807,27 @@ pub fn find_executable_in(
.find_map(|dir| names.iter().map(|n| dir.join(n)).find(|p| p.is_file()))
}
/// Whether `program` is a script to start as `/bin/sh <program>`: on Unix, a `#!` script
/// without the execute bit — a `mvnw` / `gradlew` committed from Windows or unpacked from a
/// zip — which `exec` refuses with `EACCES`. The file's mode is left alone, as other IDEs do.
pub fn needs_sh(program: &std::path::Path) -> bool {
#[cfg(unix)]
{
use std::io::Read;
use std::os::unix::fs::PermissionsExt;
let mut magic = [0u8; 2];
program.is_absolute()
&& std::fs::metadata(program).is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 == 0)
&& std::fs::File::open(program).and_then(|mut f| f.read_exact(&mut magic)).is_ok()
&& &magic == b"#!"
}
#[cfg(not(unix))]
{
let _ = program;
false
}
}
/// [`find_executable_in`] for this platform (`PATHEXT` from the environment).
pub fn find_executable(name: &str, search: &OsStr) -> Option<std::path::PathBuf> {
let pathext = host_var_os("PATHEXT");
+3
Переглянути файл
@@ -1535,6 +1535,9 @@ pub struct MavenSettings {
/// project (jdtls `java.maven.downloadSources`). Off: sources are fetched on demand
/// from a library class's Download Sources banner.
pub download_sources: bool,
/// Always update snapshots (`-U`): Maven checks remote repositories for newer SNAPSHOT
/// dependencies on every sync, build and run, and jdtls on import (`java.maven.updateSnapshots`).
pub update_snapshots: bool,
}
impl MavenSettings {
+2
Переглянути файл
@@ -239,6 +239,8 @@ pub enum SymbolKind {
Event,
Operator,
Key,
/// A Flutter widget built in the code (Flutter outline only).
Widget,
Unknown,
}
+13
Переглянути файл
@@ -170,6 +170,12 @@ pub struct CommitSettings {
pub double_click_opens_diff: Option<bool>,
/// Team conventions for Generate Commit Message with Agent, added to its prompt.
pub agent_instructions: String,
/// The coding agent Generate Commit Message with Agent uses; empty follows the latest task's agent.
pub agent: String,
/// That agent's model for commit messages; empty keeps the model the agent would use.
pub agent_model: String,
/// That model's thinking level for commit messages; empty keeps the agent's.
pub agent_effort: String,
}
impl Default for CommitSettings {
@@ -192,6 +198,9 @@ impl Default for CommitSettings {
disabled_plugin_checks: Vec::new(),
double_click_opens_diff: None,
agent_instructions: String::new(),
agent: String::new(),
agent_model: String::new(),
agent_effort: String::new(),
}
}
}
@@ -448,6 +457,9 @@ pub struct TerminalSettings {
/// Shell command line; empty = the login shell.
pub shell_path: String,
pub tab_name: String,
/// Title a program sets (OSC 0/2) as the tab's name: `running` (while a command runs),
/// `always`, or `off`.
pub app_title_as_tab_name: String,
pub audible_bell: bool,
pub close_on_exit: bool,
pub mouse_reporting: bool,
@@ -483,6 +495,7 @@ impl Default for TerminalSettings {
env: BTreeMap::new(),
shell_path: String::new(),
tab_name: "Local".into(),
app_title_as_tab_name: "running".into(),
audible_bell: true,
close_on_exit: true,
mouse_reporting: true,
+16
Переглянути файл
@@ -420,6 +420,22 @@ fn add_flutter_device(arguments: &mut Value, device: Value) {
}
}
/// The source a `navigate` tool event points at (1-based there). A `package:` location comes
/// with the file the adapter resolved it to.
fn flutter_navigation(body: &Value) -> Option<ide_core::event::DebugEvent> {
if body.get("kind")?.as_str()? != "navigate" {
return None;
}
let data = body.get("data")?;
let uri = data.get("resolvedFileUri").or_else(|| data.get("fileUri"))?.as_str()?;
let position = |key| data.get(key)?.as_u64().map(|n| n.saturating_sub(1) as u32);
Some(ide_core::event::DebugEvent::FlutterNavigate {
path: kotlin_lsp::source_path(uri)?.into(),
line: position("line")?,
column: position("column").unwrap_or(0),
})
}
fn no_session(s: DebugSessionId) -> IdeError {
IdeError::not_found(format!("no debug session {}", s.0))
}
+18
Переглянути файл
@@ -99,6 +99,9 @@ pub(crate) struct Session {
pub js_overrides: tokio::sync::Mutex<Option<tokio::sync::watch::Sender<Vec<crate::JsResponseRule>>>>,
/// The file js-debug records the page's CPU profile into, while one is being recorded.
pub js_profile: parking_lot::Mutex<Option<std::path::PathBuf>>,
/// The device of the app `flutter debug_adapter` announced, once it did: the Dart adapter
/// sends the same `dart.*` events.
pub flutter_app: std::sync::OnceLock<Option<String>>,
pub jvm_inspector: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::JvmInspector>>>,
/// One inspector request per session at a time.
pub inspect_lock: tokio::sync::Mutex<()>,
@@ -274,6 +277,7 @@ impl Session {
launch_type: std::sync::OnceLock::new(),
js_overrides: tokio::sync::Mutex::new(None),
js_profile: parking_lot::Mutex::new(None),
flutter_app: std::sync::OnceLock::new(),
jvm_inspector: parking_lot::Mutex::new(None),
inspect_lock: tokio::sync::Mutex::default(),
ended: ide_core::CancellationToken::new(),
@@ -898,6 +902,20 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
"profileStarted" => {
*s.js_profile.lock() = str_("file").map(std::path::PathBuf::from);
}
// Sent before `dart.debuggerUris`, for `launch` and `attach` alike.
"flutter.appStart" => {
let _ = s.flutter_app.set(str_("deviceId"));
}
"dart.debuggerUris" => {
if let (Some(device), Some(uri)) = (s.flutter_app.get(), str_("vmServiceUri")) {
s.emit(DebugEvent::FlutterVmService { uri, device: device.clone() });
}
}
"dart.toolEvent" if s.flutter_app.get().is_some() => {
if let Some(event) = crate::flutter_navigation(&body) {
s.emit(event);
}
}
_ => tracing::trace!("dap: ignored event {event}"),
}
}
+35
Переглянути файл
@@ -572,6 +572,20 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
json!({"type": "event", "event": "hotcodereplace", "body": {"changeType": 3, "message": "Build completed"}})
);
}
"hotRestart" => {
ok!(msg, Value::Null);
let uris = json!({"vmServiceUri": "ws://127.0.0.1:1/t=/ws"});
let navigate =
|file: &str| json!({"kind": "navigate", "data": {"fileUri": file, "line": 3, "column": 5}});
// Not Flutter's yet: a plain Dart session sends these too.
send!(json!({"type": "event", "event": "dart.debuggerUris", "body": uris}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("file:///early.dart")}));
send!(json!({"type": "event", "event": "flutter.appStart", "body": {"deviceId": "d1"}}));
send!(json!({"type": "event", "event": "dart.debuggerUris", "body": uris}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": {"kind": "other", "data": {}}}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("package:a/a.dart")}));
send!(json!({"type": "event", "event": "dart.toolEvent", "body": navigate("file:///a%20b/main.dart")}));
}
"terminate" => {
ok!(msg, Value::Null);
send!(json!({"type": "event", "event": "terminated"}));
@@ -1906,6 +1920,27 @@ async fn hot_reload_sends_its_reason_and_reports_the_flutter_app() {
h.wait_event(|e| matches!(e, DebugEvent::FlutterAppStarted)).await;
}
#[tokio::test]
async fn flutter_events_need_a_flutter_app() {
let h = harness(Script::default());
let id = h.start(config()).await.unwrap();
h.manager.hot_restart(id).await.unwrap();
let navigate = h.wait_event(|e| matches!(e, DebugEvent::FlutterNavigate { .. })).await;
let DebugEvent::FlutterNavigate { path, line, column } = navigate else { unreachable!() };
assert_eq!((path.as_ref(), line, column), (Path::new("/a b/main.dart"), 2, 4));
let events = h.events.lock();
let count = |want: fn(&DebugEvent) -> bool| {
events.iter().filter(|e| matches!(e, IdeEvent::Debug { event, .. } if want(event))).count()
};
assert_eq!(
count(
|e| matches!(e, DebugEvent::FlutterVmService { uri, device } if uri == "ws://127.0.0.1:1/t=/ws" && device.as_deref() == Some("d1"))
),
1
);
assert_eq!(count(|e| matches!(e, DebugEvent::FlutterNavigate { .. })), 1);
}
#[tokio::test]
async fn hot_swap_only_for_java_debug() {
let h = harness(Script::default());
+45 -8
Переглянути файл
@@ -248,6 +248,17 @@ fn legacy_eof(e: &sqlx::Error) -> bool {
matches!(e, sqlx::Error::Protocol(msg) if msg.starts_with("OK_Packet too short"))
}
/// A TLS handshake that failed, e.g. with a server limited to TLS 1.0/1.1. SSL mode Prefer means
/// TLS when it works, else a plain connection, as libpq's `sslmode=prefer` and MySQL clients'
/// PREFERRED do; sqlx only goes plain when the server offers no TLS, so such errors are retried.
fn tls_failed(e: &sqlx::Error) -> bool {
match e {
sqlx::Error::Tls(_) => true,
sqlx::Error::Io(io) => io.get_ref().is_some_and(|inner| inner.is::<rustls::Error>()),
_ => false,
}
}
pub(crate) fn db_err(e: sqlx::Error) -> IdeError {
match &e {
sqlx::Error::Database(d) => {
@@ -832,9 +843,17 @@ impl Pool {
if let Some(n) = setup.statement_cache {
opts = opts.statement_cache_capacity(n);
}
let manager = PgManager { options: opts, init: init.clone(), timeout };
let mut manager = PgManager { options: opts, init: init.clone(), timeout };
// Open once directly so authentication failures retain their database error.
let first = manager.connect().await.map_err(db_err)?;
let first = match manager.connect().await {
Err(e) if source.ssl == DbSslMode::Prefer && tls_failed(&e) => {
tracing::info!("TLS handshake failed, connecting without TLS (SSL mode Prefer): {e}");
manager.options = manager.options.clone().ssl_mode(PgSslMode::Disable);
manager.connect().await
}
first => first,
}
.map_err(db_err)?;
let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
let _ = pool.add(first);
Ok(Pool::Postgres(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
@@ -883,14 +902,19 @@ impl Pool {
}
let mut manager = MysqlManager { options: opts, init: init.clone(), timeout };
// Open once directly so authentication failures retain their database error.
let first = match manager.connect().await {
Err(e) if legacy_eof(&e) => {
manager.options = manager.options.clone().deprecate_eof(false);
manager.connect().await
let mut first = manager.connect().await;
if source.ssl == DbSslMode::Prefer && first.as_ref().is_err_and(tls_failed) {
if let Err(e) = &first {
tracing::info!("TLS handshake failed, connecting without TLS (SSL mode Prefer): {e}");
}
first => first,
manager.options = manager.options.clone().ssl_mode(MySqlSslMode::Disabled);
first = manager.connect().await;
}
.map_err(db_err)?;
if first.as_ref().is_err_and(legacy_eof) {
manager.options = manager.options.clone().deprecate_eof(false);
first = manager.connect().await;
}
let first = first.map_err(db_err)?;
let pool = Bb8Pool::builder().max_size(MAX).connection_timeout(timeout).build_unchecked(manager);
let _ = pool.add(first);
Ok(Pool::Mysql(ServerPool { inner: pool, closed: AtomicBool::new(false) }))
@@ -1406,6 +1430,19 @@ mod tests {
use super::*;
use crate::source::{DbOptions, DbProperty};
#[test]
fn prefer_retries_without_tls_only_after_a_failed_handshake() {
use std::io;
// What a server limited to old TLS versions gives: rustls's alert inside the I/O error.
let alert = rustls::Error::AlertReceived(rustls::AlertDescription::HandshakeFailure);
assert!(tls_failed(&sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, alert))));
assert!(tls_failed(&sqlx::Error::Tls("bad config".into())));
// Unreachable servers, protocol errors and wrong passwords keep their error.
assert!(!tls_failed(&sqlx::Error::Io(io::ErrorKind::ConnectionRefused.into())));
assert!(!tls_failed(&sqlx::Error::Io(io::Error::new(io::ErrorKind::InvalidData, "eof"))));
assert!(!tls_failed(&sqlx::Error::Protocol("OK_Packet too short".into())));
}
fn sqlserver_debug(ssl: DbSslMode) -> String {
let mut config = tiberius::Config::new();
apply_sqlserver_ssl(&mut config, ssl);
+1 -1
Переглянути файл
@@ -1,6 +1,6 @@
[package]
name = "ide-flutter"
description = "Flutter devices, kept current by the `flutter daemon` protocol"
description = "Flutter devices from the `flutter daemon` protocol, and the project's DevTools server"
version.workspace = true
edition.workspace = true
license.workspace = true
+299
Переглянути файл
@@ -0,0 +1,299 @@
//! One `dart devtools` server per project window, started when first asked for. In `--machine`
//! mode it reports its port as a `server.started` line on stdout. A server that fails or exits
//! is not restarted on its own: the next request starts a new one.
use crate::{KILL_GRACE, OUTPUT_TAIL, keep_output, read_lines, spawn_watched};
use ide_core::process::{kill_tree, terminate_tree};
use ide_core::tool_path::{find_command, search_path_in};
use parking_lot::{Condvar, Mutex};
use serde_json::Value;
use std::collections::VecDeque;
use std::path::{Path, PathBuf};
use std::process::Child;
use std::sync::Arc;
use std::time::{Duration, Instant};
const START_TIMEOUT: Duration = Duration::from_secs(60);
/// The address embedded pages are allowed to come from, so never `localhost`.
const HOST: &str = "127.0.0.1";
const ARGS: [&str; 7] = ["devtools", "--machine", "--allow-embedding", "--host", HOST, "--port", "0"];
fn started_port(line: &str) -> Option<u16> {
let message: Value = serde_json::from_str(line.trim()).ok()?;
if message.get("event")?.as_str()? != "server.started" {
return None;
}
u16::try_from(message.get("params")?.get("port")?.as_u64()?).ok()
}
/// The `dart` of the SDK `flutter` belongs to, so that DevTools matches the debugged app.
fn dart_executable(root: &Path) -> Option<PathBuf> {
let path = search_path_in(root);
find_command("flutter", &path, root)
.and_then(|flutter| {
// On the search path `flutter` is often a link into the SDK.
let flutter = if cfg!(unix) { std::fs::canonicalize(&flutter).unwrap_or(flutter) } else { flutter };
let dart = flutter.with_file_name(if cfg!(windows) { "dart.bat" } else { "dart" });
dart.is_file().then_some(dart)
})
.or_else(|| find_command("dart", &path, root))
}
#[derive(Default)]
enum Status {
#[default]
Stopped,
Starting,
Ready(String),
Failed(String),
}
#[derive(Default)]
struct State {
/// Bumped by every start and stop: a reader of an older process no longer has a say.
generation: u64,
child: Option<Child>,
status: Status,
}
impl State {
fn shut_down(&mut self) {
self.generation += 1;
if let Some(mut child) = self.child.take() {
std::thread::spawn(move || terminate_tree(&mut child, KILL_GRACE));
}
}
}
struct Shared {
root: PathBuf,
/// Replaces the lookup on the search path (tests).
executable: Option<PathBuf>,
timeout: Duration,
state: Mutex<State>,
changed: Condvar,
}
impl Shared {
/// Applies `status` unless this process was replaced or stopped; false if it was.
fn set(&self, generation: u64, status: Status) -> bool {
let mut state = self.state.lock();
if state.generation != generation {
return false;
}
state.status = status;
self.changed.notify_all();
true
}
}
pub struct DevToolsServer(Arc<Shared>);
impl DevToolsServer {
pub fn new(root: PathBuf) -> Self {
Self::with_executable(root, None, START_TIMEOUT)
}
fn with_executable(root: PathBuf, executable: Option<PathBuf>, timeout: Duration) -> Self {
Self(Arc::new(Shared { root, executable, timeout, state: Mutex::default(), changed: Condvar::new() }))
}
/// The server's address, starting it if none runs. Blocks until it is known.
pub fn url(&self) -> Result<String, String> {
let shared = &self.0;
let deadline = Instant::now() + shared.timeout;
let mut state = shared.state.lock();
if matches!(state.status, Status::Stopped | Status::Failed(_)) {
state.generation += 1;
state.status = Status::Starting;
let (shared, generation) = (shared.clone(), state.generation);
std::thread::spawn(move || run(&shared, generation));
}
loop {
match &state.status {
Status::Ready(url) => return Ok(url.clone()),
Status::Failed(message) => return Err(message.clone()),
Status::Stopped => return Err("Flutter DevTools was stopped".into()),
Status::Starting => {}
}
if shared.changed.wait_until(&mut state, deadline).timed_out() {
state.shut_down();
let message = "Flutter DevTools did not start in time".to_owned();
state.status = Status::Failed(message.clone());
shared.changed.notify_all();
return Err(message);
}
}
}
/// Ends the server (project closed, or no longer trusted).
pub fn stop(&self) {
let mut state = self.0.state.lock();
state.shut_down();
state.status = Status::Stopped;
self.0.changed.notify_all();
}
/// Ends the server before returning, for a process about to exit.
pub fn kill(&self) {
let mut state = self.0.state.lock();
state.generation += 1;
state.status = Status::Stopped;
if let Some(mut child) = state.child.take() {
kill_tree(&mut child);
}
self.0.changed.notify_all();
}
}
/// One server's whole life, on its own thread.
fn run(shared: &Arc<Shared>, generation: u64) {
let fail = |message: String| {
shared.set(generation, Status::Failed(message));
};
let Some(executable) = shared.executable.clone().or_else(|| dart_executable(&shared.root)) else {
return fail("Dart SDK not found: install Flutter or add it to PATH".into());
};
let mut child = match spawn_watched(&executable, &ARGS, &shared.root) {
Ok(child) => child,
Err(e) => return fail(format!("could not run {}: {e}", executable.display())),
};
let (Some(stdout), Some(stderr)) = (child.stdout.take(), child.stderr.take()) else {
terminate_tree(&mut child, Duration::ZERO);
return fail("no output pipe".into());
};
{
let mut state = shared.state.lock();
if state.generation != generation {
drop(state);
terminate_tree(&mut child, KILL_GRACE);
return;
}
state.child = Some(child);
}
let tail = Arc::new(Mutex::new(VecDeque::with_capacity(OUTPUT_TAIL)));
let errors = {
let tail = tail.clone();
std::thread::spawn(move || {
read_lines(stderr, |line| {
keep_output(&tail, line);
true
});
})
};
read_lines(stdout, |line| match started_port(line) {
Some(port) => shared.set(generation, Status::Ready(format!("http://{HOST}:{port}"))),
None => {
keep_output(&tail, line);
true
}
});
let _ = errors.join();
let mut state = shared.state.lock();
if state.generation != generation {
return;
}
let child = state.child.take();
state.status = if matches!(state.status, Status::Ready(_)) {
Status::Stopped
} else {
let message = Vec::from(std::mem::take(&mut *tail.lock())).join("\n");
Status::Failed(if message.is_empty() { "dart devtools exited".into() } else { message })
};
shared.changed.notify_all();
drop(state);
if let Some(mut child) = child {
std::thread::spawn(move || terminate_tree(&mut child, Duration::ZERO));
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_server_started_gives_a_port() {
let line =
r#"{"event":"server.started","method":"server.started","params":{"host":"127.0.0.1","port":9100,"pid":1}}"#;
assert_eq!(started_port(line), Some(9100));
assert_eq!(started_port(r#"{"event":"server.dtdStarted","params":{"uri":"ws://x"}}"#), None);
assert_eq!(started_port("Serving DevTools"), None);
}
#[cfg(unix)]
mod process {
use super::*;
use std::os::unix::fs::PermissionsExt;
const STARTED: &str = r#"echo '{"event":"server.started","params":{"port":4242}}'"#;
fn server(dir: &Path, script: &str, timeout: Duration) -> DevToolsServer {
let path = dir.join("dart");
std::fs::write(&path, format!("#!/bin/sh\necho run >> runs\n{script}")).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
DevToolsServer::with_executable(dir.to_owned(), Some(path), timeout)
}
fn runs(dir: &Path) -> usize {
std::fs::read_to_string(dir.join("runs")).map_or(0, |s| s.lines().count())
}
fn wait_for(what: &str, done: impl Fn() -> bool) {
let deadline = Instant::now() + Duration::from_secs(10);
while !done() {
assert!(Instant::now() < deadline, "timed out waiting for {what}");
std::thread::sleep(Duration::from_millis(10));
}
}
#[test]
fn a_running_server_is_shared_and_stop_ends_it() {
let dir = tempfile::tempdir().unwrap();
let script = format!("echo \"$*\" > args\necho $$ > pid\n{STARTED}\nexec sleep 30");
let devtools = server(dir.path(), &script, Duration::from_secs(10));
assert_eq!(devtools.url().unwrap(), "http://127.0.0.1:4242");
assert_eq!(devtools.url().unwrap(), "http://127.0.0.1:4242");
assert_eq!(runs(dir.path()), 1);
let args = std::fs::read_to_string(dir.path().join("args")).unwrap();
assert_eq!(args.trim(), ARGS.join(" "));
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
devtools.stop();
let alive = || {
let mut probe = std::process::Command::new("kill");
probe.args(["-0", pid.trim()]).stderr(std::process::Stdio::null()).status().unwrap().success()
};
wait_for("the server to end", || !alive());
}
#[test]
fn a_failure_is_reported_and_only_a_new_request_retries() {
let dir = tempfile::tempdir().unwrap();
let devtools = server(dir.path(), "echo boom >&2\nexit 3", Duration::from_secs(10));
assert_eq!(devtools.url().unwrap_err(), "boom");
std::thread::sleep(Duration::from_millis(100));
assert_eq!(runs(dir.path()), 1);
assert_eq!(devtools.url().unwrap_err(), "boom");
assert_eq!(runs(dir.path()), 2);
}
#[test]
fn a_server_that_exits_is_not_restarted_until_asked() {
let dir = tempfile::tempdir().unwrap();
let devtools = server(dir.path(), STARTED, Duration::from_secs(10));
devtools.url().unwrap();
wait_for("the exit to be noticed", || matches!(devtools.0.state.lock().status, Status::Stopped));
assert_eq!(runs(dir.path()), 1);
devtools.url().unwrap();
assert_eq!(runs(dir.path()), 2);
}
#[test]
fn a_server_that_never_reports_times_out() {
let dir = tempfile::tempdir().unwrap();
let devtools = server(dir.path(), "exec sleep 30", Duration::from_millis(200));
assert_eq!(devtools.url().unwrap_err(), "Flutter DevTools did not start in time");
}
}
}
+17 -11
Переглянути файл
@@ -8,6 +8,10 @@
//! a watcher in its process group ends the group once the IDE is gone, even after a crash. A
//! daemon that fails stays failed until the user restarts it.
mod devtools;
pub use devtools::DevToolsServer;
use ide_android::AndroidDevice;
use ide_core::event::{FlutterDaemonStatus, FlutterDevice, FlutterDeviceList};
use ide_core::process::{kill_tree, own_group, prepare, terminate_tree};
@@ -227,26 +231,28 @@ fn refresh_adb(shared: &Arc<Shared>, generation: u64) {
});
}
/// `flutter daemon`, ended with its whole process group when process `parent` is gone.
/// A tool that does not end with its stdin, ended with its whole process group when process
/// `parent` is gone.
#[cfg(unix)]
fn daemon_command(executable: &Path, parent: u32) -> Command {
fn watched_command(executable: &Path, args: &[&str], parent: u32) -> Command {
const WATCHED: &str = r#"(while kill -0 "$1" 2>/dev/null; do sleep 5; done; kill -KILL 0) </dev/null >/dev/null 2>&1 &
exec "$2" daemon"#;
shift
exec "$@""#;
let mut cmd = Command::new("/bin/sh");
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable);
cmd.args(["-c", WATCHED, "sh"]).arg(parent.to_string()).arg(executable).args(args);
cmd
}
// No watcher on Windows, so a crashed IDE leaves the daemon; a Job Object would cover it.
// No watcher on Windows, so a crashed IDE leaves the tool; a Job Object would cover it.
#[cfg(not(unix))]
fn daemon_command(executable: &Path, _parent: u32) -> Command {
fn watched_command(executable: &Path, args: &[&str], _parent: u32) -> Command {
let mut cmd = Command::new(executable);
cmd.arg("daemon");
cmd.args(args);
cmd
}
fn spawn_daemon(executable: &Path, root: &Path) -> std::io::Result<Child> {
let mut cmd = daemon_command(executable, std::process::id());
fn spawn_watched(executable: &Path, args: &[&str], root: &Path) -> std::io::Result<Child> {
let mut cmd = watched_command(executable, args, std::process::id());
cmd.current_dir(root).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
prepare(own_group(&mut cmd));
cmd.spawn()
@@ -299,7 +305,7 @@ fn run(shared: &Arc<Shared>, generation: u64) {
let Some(executable) = executable else {
return finish(shared, generation, FlutterDaemonStatus::NotInstalled);
};
let mut child = match spawn_daemon(&executable, &shared.root) {
let mut child = match spawn_watched(&executable, &["daemon"], &shared.root) {
Ok(child) => child,
Err(e) => {
let message = format!("could not run {}: {e}", executable.display());
@@ -530,7 +536,7 @@ cat > /dev/null
std::fs::write(&flutter, "#!/bin/sh\necho $$ > pid\nexec sleep 60\n").unwrap();
std::fs::set_permissions(&flutter, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut ide = Command::new("sleep").arg("60").spawn().unwrap();
let mut cmd = daemon_command(&flutter, ide.id());
let mut cmd = watched_command(&flutter, &["daemon"], ide.id());
cmd.current_dir(dir.path()).stdin(Stdio::piped());
let mut daemon = own_group(&mut cmd).spawn().unwrap();
wait_for("the daemon", || dir.path().join("pid").is_file());
+47 -1
Переглянути файл
@@ -119,6 +119,29 @@ fn php_cs_fixer_edits(
.collect())
}
/// Some language servers (Vue's, for one) answer Reformat Code with one edit replacing the
/// whole file; applied as is, it moves the caret and the view to the top of the file. The same
/// result as one edit per changed region keeps them where they were.
fn minimal_edits(text: &str, edits: Vec<TextEdit>) -> Vec<TextEdit> {
if !edits.iter().any(|e| e.range.end.line > e.range.start.line) {
return edits;
}
let original = ide_text::Document::new(text);
let mut formatted = original.clone();
if formatted.apply_edits(&edits).is_err() {
return edits;
}
original
.diff(&formatted.text())
.changes
.into_iter()
.map(|c| TextEdit {
range: Range::new(original.offset_to_pos(c.from), original.offset_to_pos(c.to)),
new_text: c.insert,
})
.collect()
}
pub async fn format(
host: &Host,
window: &str,
@@ -292,7 +315,11 @@ async fn provider_edits(
if options.on_save && !settings.editor.format_on_save {
return Ok(None);
}
return project.lsp.format(doc, range, options).await.map(Some);
let edits = project.lsp.format(doc, range, options).await?;
let text = snap.text;
return tokio::task::spawn_blocking(move || Some(minimal_edits(&text, edits)))
.await
.map_err(|e| IdeError::internal(e.to_string()));
};
let tool_settings = settings.languages.formatter(selected);
if options.on_save && !tool_settings.run_on_save {
@@ -523,6 +550,25 @@ mod tests {
const ALIGN: PhpAlignment = PhpAlignment { key_value_pairs: true, assignments: true };
#[test]
fn a_whole_file_edit_becomes_one_edit_per_changed_region() {
let text = "a\n b\nc\nd\n e\n";
let formatted = "a\nb\nc\nd\ne\n";
let whole = vec![TextEdit { range: Range::new(Pos::new(0, 0), Pos::new(5, 0)), new_text: formatted.into() }];
let edits = minimal_edits(text, whole);
assert_eq!(
edits,
[
TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() },
TextEdit { range: Range::new(Pos::new(4, 0), Pos::new(4, 2)), new_text: String::new() },
]
);
assert_eq!(after(text, &edits), formatted);
// Single-line edits are already minimal and pass through.
let small = vec![TextEdit { range: Range::new(Pos::new(1, 0), Pos::new(1, 2)), new_text: String::new() }];
assert_eq!(minimal_edits(text, small.clone()), small);
}
#[test]
fn php_alignment_is_off_unless_the_php_code_style_turns_it_on() {
let php = LanguageId::new("php");
+3
Переглянути файл
@@ -344,6 +344,7 @@ impl Host {
project.documents.clear_workspace_edit_history();
project.agents.shutdown();
project.flutter.stop();
project.devtools.stop();
project.notebooks.stop_admission();
// What the closing window started goes with it — the builds and searches it
// asked for, its runs, its shells and its debug sessions — and its language
@@ -464,6 +465,7 @@ impl Host {
self.terminals.kill_all();
for project in self.projects() {
project.flutter.kill();
project.devtools.kill();
}
}
@@ -487,6 +489,7 @@ impl Host {
for project in &projects {
project.files_events_active.store(false, std::sync::atomic::Ordering::Release);
project.flutter.kill();
project.devtools.kill();
}
for project in &projects {
project.plugin_diagnostics.close();
+9 -4
Переглянути файл
@@ -245,6 +245,7 @@ pub async fn build_sync(
return Err(IdeError::not_found("Build project is no longer linked"));
}
let mut profiles_changed = false;
let mut offline_changed = false;
for scope in selected {
if token.is_cancelled() {
return Err(IdeError::cancelled());
@@ -260,6 +261,10 @@ pub async fn build_sync(
p.sink.emit(IdeEvent::ProjectRootsChanged { root: p.root.clone().into() });
}
profiles_changed |= changed;
offline_changed |= ide_build::save_maven_offline(cache, offline).unwrap_or_else(|e| {
tracing::warn!("Maven offline mode not saved: {e}");
false
});
}
let env = current
.maven
@@ -306,12 +311,12 @@ pub async fn build_sync(
let scopes = workspace::scopes(&p, &config)?;
let model = workspace::load_scopes(&p.root, &scopes);
let updates = workspace::update_files(&p.root, &scopes, &model, tool);
Ok::<_, IdeError>((model, profiles_changed, updates))
Ok::<_, IdeError>((model, profiles_changed, offline_changed, updates))
})
.await
.map_err(join_err);
host.end_request(request);
let (model, profiles_changed, updates) = result??;
let (model, profiles_changed, offline_changed, updates) = result??;
if completion_token.is_cancelled() {
return Err(IdeError::cancelled());
}
@@ -336,8 +341,8 @@ pub async fn build_sync(
let lsp = project.lsp.clone();
let documents = project.documents.clone();
tokio::spawn(async move {
if profiles_changed {
// jdtls takes the profiles from its Maven settings (see `ide_sdk::maven_profiles`).
if profiles_changed || offline_changed {
// jdtls takes the profiles and offline mode from its Maven settings (see `ide_sdk::maven_profiles`).
lsp.reconfigure().await;
}
let first = updates.first().cloned();
+8
Переглянути файл
@@ -127,6 +127,13 @@ pub async fn doc_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec
.await
}
/// Structure view of a Flutter file: its declarations with the widgets they build. `None`
/// when the Dart server published no widgets for it; `doc_outline` then applies.
#[command(trust = always)]
pub async fn doc_flutter_outline(host: &Host, window: &str, doc: DocId) -> IdeResult<Option<Vec<OutlineItem>>> {
Ok(host.project(window)?.lsp.flutter_outline(doc))
}
#[command(trust = always)]
pub async fn doc_folding(host: &Host, window: &str, doc: DocId) -> IdeResult<Vec<FoldRange>> {
let project = host.project(window)?;
@@ -227,6 +234,7 @@ pub async fn history_content(host: &Host, window: &str, id: String) -> IdeResult
ide_command::domain!(
doc_commands:
doc_flutter_outline,
doc_folding,
doc_highlights,
doc_language,
+19 -8
Переглянути файл
@@ -6,14 +6,13 @@ use ide_core::{IdeError, IdeResult};
use ide_docker::DockerEndpoint;
use ide_ssh::Tunnel;
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
/// What each tunnelled connection runs on the SSH host, as the Docker CLI's `ssh://` does.
const DIAL: &str = "docker system dial-stdio";
/// Open tunnels of [`DockerEndpoint::Ssh`] connections, by SSH configuration id.
#[derive(Default)]
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Arc<Tunnel>>>);
pub struct DockerTunnels(tokio::sync::Mutex<HashMap<String, Tunnel>>);
/// `endpoint` as docker can use it: an SSH configuration becomes the local end of a tunnel to its
/// host's daemon (opened on first use, reopened when the SSH connection dropped).
@@ -21,8 +20,8 @@ pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerE
let DockerEndpoint::Ssh { config } = endpoint else { return Ok(endpoint) };
let id = config.trim().to_owned();
let mut tunnels = host.docker_tunnels.0.lock().await;
let tunnel = match tunnels.get(&id).filter(|t| !t.is_closed()) {
Some(t) => t.clone(),
let port = match tunnels.get(&id).filter(|t| !t.is_closed()) {
Some(t) => t.port(),
None => {
let session = host.ssh.session(&id).await?;
// Fail with the reason here: a missing docker only shows as a dropped connection later.
@@ -35,12 +34,24 @@ pub async fn resolve(host: &Host, endpoint: DockerEndpoint) -> IdeResult<DockerE
if why.is_empty() { String::new() } else { format!(": {why}") }
)));
}
let t = Arc::new(Tunnel::command(session, DIAL).await?);
tunnels.insert(id, t.clone());
t
let t = Tunnel::command(session, DIAL).await?;
let port = t.port();
tunnels.insert(id, t);
port
}
};
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{}", tunnel.port()), tls_cert_dir: None })
Ok(DockerEndpoint::Tcp { host: format!("tcp://127.0.0.1:{port}"), tls_cert_dir: None })
}
/// Closes what [`resolve`] opened for `endpoint`: an SSH configuration's tunnel, and then its SSH
/// connection unless something else (a terminal, a transfer) holds it. The next [`resolve`] opens
/// them again; other endpoints keep nothing open.
pub async fn disconnect(host: &Host, endpoint: &DockerEndpoint) {
let DockerEndpoint::Ssh { config } = endpoint else { return };
let id = config.trim();
let Some(tunnel) = host.docker_tunnels.0.lock().await.remove(id) else { return };
tunnel.close().await;
host.ssh.release(id);
}
/// Environment for a Docker run configuration's command line: selects `endpoint`'s
+13 -2
Переглянути файл
@@ -2,8 +2,8 @@
//! adapter run too, so a remote project lists the devices of its remote machine.
use crate::Host;
use ide_command::command;
use ide_core::IdeResult;
use ide_core::event::FlutterDeviceList;
use ide_core::{IdeError, IdeResult};
/// The project's Flutter devices, starting its `flutter daemon` on first use. Changes arrive as
/// `IdeEvent::FlutterDevices`.
@@ -25,4 +25,15 @@ pub fn flutter_daemon_restart(host: &Host, window: &str) -> IdeResult<FlutterDev
Ok(host.project(window)?.flutter.restart())
}
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart);
/// The address of the project's DevTools server, started on first use. A server that failed or
/// exited is only started again by the next request.
#[command(trust = trusted)]
pub async fn flutter_devtools_url(host: &Host, window: &str) -> IdeResult<String> {
let project = host.project(window)?;
tokio::task::spawn_blocking(move || project.devtools.url())
.await
.map_err(|e| IdeError::internal(e.to_string()))?
.map_err(IdeError::unavailable)
}
ide_command::domain!(flutter: flutter_devices, flutter_devices_refresh, flutter_daemon_restart, flutter_devtools_url);
+27 -5
Переглянути файл
@@ -214,10 +214,6 @@ pub enum RemoteOp {
tag: String,
remote: String,
},
/// Fast-forwards local `branch` (not checked out) to its upstream.
UpdateBranch {
branch: String,
},
/// Pull dialog: `branches` of `remote` (none = the configured merge branch).
PullFrom {
remote: String,
@@ -947,7 +943,6 @@ pub async fn vcs_remote(
&cancel,
&out,
),
RemoteOp::UpdateBranch { branch } => r.update_branch(&branch, &cancel, &out),
RemoteOp::PushTag { tag, remote } => r.push_tag(&tag, &remote, &cancel, &out),
RemoteOp::DeleteRemoteTag { tag, remote } => r.delete_remote_tag(&tag, &remote, &cancel, &out),
RemoteOp::PullFrom { remote, branches, rebase, options } => {
@@ -961,6 +956,32 @@ pub async fn vcs_remote(
result
}
/// Branches › Update Selected: fast-forwards local `branches` to their upstreams, one
/// fetch per remote; the result says what happened to each. Cancellable.
#[command(trust = trusted)]
pub async fn vcs_update_branches(
host: &Host,
window: &str,
repo: Option<PathBuf>,
request: RequestId,
branches: Vec<String>,
on_output: Channel<String>,
) -> IdeResult<Vec<BranchUpdate>> {
host.require_trust(window)?;
let project = host.project(window)?;
let cancel = host.begin_request(request);
let result = tokio::task::spawn_blocking(move || {
let out = |line: String| {
let _ = on_output.send(line);
};
project.with_repo_recorded(repo.as_deref(), Some("Git pull"), |r| r.update_branches(&branches, &cancel, &out))
})
.await
.map_err(|e| ide_core::IdeError::internal(e.to_string()))?;
host.end_request(request);
result
}
/// The user's side is `ours` (sides swapped during a rebase, as in IDEA).
#[command(trust = always)]
pub async fn vcs_conflict_versions(host: &Host, window: &str, path: PathBuf) -> IdeResult<ide_vcs::MergeVersions> {
@@ -1630,6 +1651,7 @@ ide_command::domain!(
vcs_rebase,
vcs_rebase_with,
vcs_remote,
vcs_update_branches,
vcs_remotes,
vcs_remove_worktree,
vcs_rename_branch,
+5
Переглянути файл
@@ -63,6 +63,8 @@ pub struct Project {
pub notebooks: Arc<crate::notebook::NotebookService>,
/// Flutter's devices; its daemon starts when the UI first asks for them.
pub(crate) flutter: ide_flutter::FlutterDaemon,
/// Flutter DevTools; its server starts when the UI first asks for it.
pub(crate) devtools: ide_flutter::DevToolsServer,
pub(crate) kotlin_bridge: Option<Arc<crate::kotlin_bridge::KotlinBridge>>,
pub(crate) phpstan: Option<Arc<crate::phpstan::Phpstan>>,
pub(crate) watcher: Arc<Watcher>,
@@ -202,6 +204,7 @@ impl Host {
};
let profiles = ide_build::maven_profiles(&cache);
ide_sdk::maven_profiles::configure_jdtls(cfg, root, &effective, &profiles, &cache);
ide_sdk::maven_profiles::configure_offline(cfg, ide_build::maven_offline(&cache));
}
ide_sdk::java::cap_java_home(cfg, &ide_sdk::java::installed_jdks());
if cfg.name == "jdtls" {
@@ -604,6 +607,7 @@ impl Host {
plugin_diagnostics,
trusted,
flutter: ide_flutter::FlutterDaemon::new(root.clone(), sink.clone()),
devtools: ide_flutter::DevToolsServer::new(root.clone()),
root,
sink,
languages,
@@ -817,6 +821,7 @@ impl Host {
plugin_diagnostics,
trusted: Arc::new(AtomicBool::new(false)),
flutter: ide_flutter::FlutterDaemon::new(dir.clone(), sink.clone()),
devtools: ide_flutter::DevToolsServer::new(dir.clone()),
sink,
languages,
settings,
+1
Переглянути файл
@@ -283,6 +283,7 @@ impl crate::Host {
self.environment.direnv_closed(&project.root);
project.agents.shutdown();
project.flutter.stop();
project.devtools.stop();
self.processes.kill_project(&project.root);
project.notebooks.restrict().await;
let windows: Vec<_> = self
+69 -8
Переглянути файл
@@ -1,7 +1,10 @@
use ide_core::remote_settings::{SshAuth, SshConfiguration};
use ide_core::{IdeEvent, SharedSink};
use ide_docker::DockerEndpoint;
use ide_host::ops::docker;
use ide_host::{Host, HostConfig};
use ide_ssh::{SshFiles, SshManager};
use std::path::Path;
use std::sync::{Arc, Mutex, mpsc};
use std::time::Duration;
@@ -16,14 +19,12 @@ fn read_until(rx: &mpsc::Receiver<String>, needle: &str) -> String {
all
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn ssh_session_opens_a_shell_with_the_saved_password() {
let tmp = tempfile::tempdir().unwrap();
let port =
ide_ssh::testing::sshd(tmp.path().join("server"), Arc::new(|cmd| panic!("unexpected exec: {cmd}"))).await;
/// A host whose SSH configuration `box` reaches an in-process server answering `exec`.
async fn host_with_ssh_box(tmp: &Path, exec: ide_ssh::testing::ExecFn) -> (Arc<Host>, mpsc::Receiver<IdeEvent>) {
let port = ide_ssh::testing::sshd(tmp.join("server"), exec).await;
let ssh = Arc::new(SshManager::with_files(
tmp.path().join("secrets.json"),
SshFiles { known_hosts: tmp.path().join("known_hosts"), config: None },
tmp.join("secrets.json"),
SshFiles { known_hosts: tmp.join("known_hosts"), config: None },
));
ssh.set_configs(vec![SshConfiguration {
id: "box".into(),
@@ -44,7 +45,7 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
let sink: SharedSink = Arc::new(move |e: IdeEvent| {
let _ = events_tx.lock().unwrap().send(e);
});
let base = tmp.path().join("app");
let base = tmp.join("app");
let mut host = Arc::new(Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
@@ -58,6 +59,14 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
}));
Arc::get_mut(&mut host).unwrap().ssh = ssh;
(host, events)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn ssh_session_opens_a_shell_with_the_saved_password() {
let tmp = tempfile::tempdir().unwrap();
let (host, events) = host_with_ssh_box(tmp.path(), Arc::new(|cmd| panic!("unexpected exec: {cmd}"))).await;
let (tx, output) = mpsc::channel();
let tx = Mutex::new(tx);
let info = ide_host::ops::term::spawn_ssh(
@@ -100,3 +109,55 @@ async fn ssh_session_opens_a_shell_with_the_saved_password() {
assert_eq!(code, None);
host.shutdown().await;
}
/// Reads what a connection to the local end of a Docker tunnel gets back.
async fn dial(port: u16) -> std::io::Result<String> {
use tokio::io::AsyncReadExt;
let mut socket = tokio::net::TcpStream::connect(("127.0.0.1", port)).await?;
let mut out = String::new();
socket.read_to_string(&mut out).await?;
Ok(out)
}
fn tunnel_port(endpoint: &DockerEndpoint) -> u16 {
let DockerEndpoint::Tcp { host, .. } = endpoint else { panic!("not a tunnel: {endpoint:?}") };
host.rsplit(':').next().unwrap().parse().unwrap()
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn disconnecting_a_docker_connection_closes_its_tunnel_and_unused_ssh_session() {
let tmp = tempfile::tempdir().unwrap();
let (host, _events) = host_with_ssh_box(
tmp.path(),
Arc::new(|cmd| match cmd {
"docker version --format {{.Client.Version}}" => ("27.0.3\n".into(), 0),
"docker system dial-stdio" => ("daemon".into(), 0),
other => panic!("unexpected exec: {other}"),
}),
)
.await;
let ssh = DockerEndpoint::Ssh { config: "box".into() };
let port = tunnel_port(&docker::resolve(&host, ssh.clone()).await.unwrap());
assert_eq!(dial(port).await.unwrap(), "daemon");
assert_eq!(host.ssh.connected(), ["box"]);
docker::disconnect(&host, &ssh).await;
assert!(dial(port).await.is_err(), "the tunnel stopped listening");
assert!(host.ssh.connected().is_empty(), "nothing else used the SSH connection");
// Connecting again opens a new tunnel; a terminal on the same host keeps the session open.
let port = tunnel_port(&docker::resolve(&host, ssh.clone()).await.unwrap());
assert_eq!(dial(port).await.unwrap(), "daemon");
let terminal = host.ssh.session("box").await.unwrap();
docker::disconnect(&host, &ssh).await;
assert!(dial(port).await.is_err());
assert_eq!(host.ssh.connected(), ["box"]);
assert!(!terminal.is_closed());
// Nothing to close: a second disconnect and other endpoints are no-ops.
docker::disconnect(&host, &ssh).await;
docker::disconnect(&host, &DockerEndpoint::Default).await;
assert_eq!(host.ssh.connected(), ["box"]);
host.shutdown().await;
}
+196
Переглянути файл
@@ -0,0 +1,196 @@
//! The Dart analysis server's Flutter outline (`dart/textDocument/publishFlutterOutline`):
//! a file's declarations with the widgets built inside them, in source order.
use crate::convert::Conv;
use ide_core::{OutlineItem, SymbolKind};
use lsp_types as lsp;
use serde::Deserialize;
use std::path::Path;
#[derive(Deserialize)]
pub(crate) struct Params {
pub uri: String,
pub outline: Node,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct Node {
kind: String,
label: Option<String>,
class_name: Option<String>,
variable_name: Option<String>,
attributes: Option<Vec<Attribute>>,
dart_element: Option<Element>,
range: lsp::Range,
children: Option<Vec<Node>>,
}
#[derive(Deserialize)]
struct Attribute {
name: String,
label: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Element {
name: String,
kind: String,
range: Option<lsp::Range>,
parameters: Option<String>,
type_parameters: Option<String>,
return_type: Option<String>,
}
/// The items below the compilation unit; `None` when no widget is built in the file, whose
/// structure is then the ordinary one.
pub(crate) fn items(conv: &Conv, path: &Path, root: Node) -> Option<Vec<OutlineItem>> {
let children = root.children?;
children.iter().any(has_widget).then(|| children.into_iter().map(|n| item(conv, path, n)).collect())
}
fn has_widget(node: &Node) -> bool {
node.dart_element.is_none() || node.children.iter().flatten().any(has_widget)
}
fn item(conv: &Conv, path: &Path, node: Node) -> OutlineItem {
let range = conv.range(path, node.range);
let detail = widget_detail(&node);
let children = node.children.unwrap_or_default().into_iter().map(|n| item(conv, path, n)).collect();
let (name, detail, kind, selection_range) = match node.dart_element {
Some(e) => (
format!("{}{}{}", e.name, e.type_parameters.unwrap_or_default(), e.parameters.unwrap_or_default()),
e.return_type.filter(|t| !t.is_empty()).map(|t| format!("→ {t}")),
element_kind(&e.kind),
e.range.map_or(range, |r| conv.range(path, r)),
),
None => (node.class_name.or(node.label).unwrap_or(node.kind), detail, SymbolKind::Widget, range),
};
OutlineItem { name, detail, kind, range, selection_range, children, visibility: None }
}
/// What follows a widget's class, as the Flutter plugin's outline shows it: the variable holding
/// it, a generic node's expression, then its attributes (`Text 'Hi'`, `Icon icon: add, size: 24`).
fn widget_detail(node: &Node) -> Option<String> {
let mut parts: Vec<String> = node.variable_name.iter().cloned().collect();
if node.kind == "GENERIC" {
parts.extend(node.label.iter().cloned());
}
match node.attributes.as_deref().unwrap_or_default() {
[only] if matches!(only.name.as_str(), "text" | "icon") => parts.push(only.label.clone()),
attributes if !attributes.is_empty() => parts.push(
attributes
.iter()
.map(|a| if a.name == "data" { a.label.clone() } else { format!("{}: {}", a.name, a.label) })
.collect::<Vec<_>>()
.join(", "),
),
_ => {}
}
(!parts.is_empty()).then(|| parts.join(" "))
}
fn element_kind(kind: &str) -> SymbolKind {
match kind {
"CLASS" | "CLASS_TYPE_ALIAS" | "EXTENSION" | "EXTENSION_TYPE" => SymbolKind::Class,
"MIXIN" => SymbolKind::Interface,
"ENUM" => SymbolKind::Enum,
"ENUM_CONSTANT" => SymbolKind::EnumMember,
"CONSTRUCTOR" => SymbolKind::Constructor,
"METHOD" => SymbolKind::Method,
"FUNCTION" => SymbolKind::Function,
"FIELD" => SymbolKind::Field,
"GETTER" | "SETTER" => SymbolKind::Property,
"TOP_LEVEL_VARIABLE" => SymbolKind::Variable,
"FUNCTION_TYPE_ALIAS" | "TYPE_ALIAS" => SymbolKind::TypeAlias,
_ => SymbolKind::Unknown,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::text::{DocText, Encoding};
use ide_core::{Pos, Range};
use serde_json::{Value, json};
use std::sync::Arc;
fn range(line: u32, from: u32, to: u32) -> Value {
json!({ "start": { "line": line, "character": from }, "end": { "line": line, "character": to } })
}
fn element(kind: &str, name: &str, extra: Value, children: Value) -> Value {
let mut e = json!({ "kind": kind, "name": name, "range": range(1, 9, 14) });
e.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
json!({ "kind": "DART_ELEMENT", "dartElement": e, "range": range(0, 0, 40), "codeRange": range(0, 0, 40), "children": children })
}
fn widget(kind: &str, class: &str, extra: Value) -> Value {
let mut w = json!({ "kind": kind, "className": class, "range": range(3, 4, 12), "codeRange": range(3, 4, 12) });
w.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
w
}
fn convert(conv: &Conv, children: Value) -> Option<Vec<OutlineItem>> {
let root: Node = serde_json::from_value(element("COMPILATION_UNIT", "<unit>", json!({}), children)).unwrap();
items(conv, Path::new("/p/a.dart"), root)
}
fn utf16() -> Conv<'static> {
Conv::new(Encoding::Utf16, |_: &Path| None)
}
#[test]
fn declarations_keep_their_widgets_in_source_order() {
let outline = json!([element(
"METHOD",
"build",
json!({ "parameters": "(BuildContext context)", "returnType": "Widget" }),
json!([widget("NEW_INSTANCE", "Scaffold", json!({})), widget("NEW_INSTANCE", "Align", json!({}))]),
)]);
let items = convert(&utf16(), outline).unwrap();
let build = &items[0];
assert_eq!(build.name, "build(BuildContext context)");
assert_eq!(build.detail.as_deref(), Some("→ Widget"));
assert_eq!(build.kind, SymbolKind::Method);
assert_eq!(build.selection_range, Range::new(Pos::new(1, 9), Pos::new(1, 14)));
let names: Vec<_> = build.children.iter().map(|c| c.name.as_str()).collect();
assert_eq!(names, ["Scaffold", "Align"]);
assert_eq!(build.children[0].kind, SymbolKind::Widget);
assert_eq!(build.children[0].selection_range, build.children[0].range);
}
#[test]
fn widget_details_read_like_the_flutter_plugin() {
let attr = |name: &str, label: &str| json!({ "name": name, "label": label });
let detail = |w: Value| convert(&utf16(), json!([w])).unwrap().remove(0).detail;
let w = widget("NEW_INSTANCE", "Text", json!({ "attributes": [attr("data", "'Hi'")] }));
assert_eq!(detail(w).as_deref(), Some("'Hi'"));
let w = widget("NEW_INSTANCE", "Icon", json!({ "attributes": [attr("icon", "Icons.add")] }));
assert_eq!(detail(w).as_deref(), Some("Icons.add"));
let w =
widget("NEW_INSTANCE", "Icon", json!({ "attributes": [attr("icon", "Icons.add"), attr("size", "24")] }));
assert_eq!(detail(w).as_deref(), Some("icon: Icons.add, size: 24"));
assert_eq!(detail(widget("VARIABLE", "Text", json!({ "variableName": "title" }))).as_deref(), Some("title"));
assert_eq!(detail(widget("GENERIC", "Widget", json!({ "label": "_footer()" }))).as_deref(), Some("_footer()"));
assert_eq!(detail(widget("NEW_INSTANCE", "Column", json!({}))), None);
}
#[test]
fn a_file_without_widgets_has_no_flutter_outline() {
let plain =
json!([element("CLASS", "Plain", json!({}), json!([element("METHOD", "run", json!({}), json!([]))]))]);
assert!(convert(&utf16(), plain).is_none());
assert!(convert(&utf16(), json!([])).is_none());
}
#[test]
fn positions_become_utf16_columns() {
let text = Arc::new(DocText::new("\n\n\n🙂🙂 Text('x')\n"));
let conv = Conv::new(Encoding::Utf8, move |_: &Path| Some(text.clone()));
let w = json!({ "kind": "NEW_INSTANCE", "className": "Text", "range": range(3, 9, 13), "codeRange": range(3, 9, 13) });
let item = convert(&conv, json!([w])).unwrap().remove(0);
assert_eq!(item.range, Range::new(Pos::new(3, 5), Pos::new(3, 9)));
}
}
+19
Переглянути файл
@@ -355,6 +355,24 @@ impl ClientHandler {
mgr.emit_diagnostics(&self.server, path, shown, self.encoding());
}
fn publish_flutter_outline(&self, mgr: &LspManager, params: Value) {
let params: crate::flutter_outline::Params = match serde_json::from_value(params) {
Ok(p) => p,
Err(e) => {
tracing::debug!("{}: bad publishFlutterOutline: {e}", self.server.name);
return;
}
};
let Some(path) = uri_to_path(&params.uri) else { return };
if !self.server.is_live(self.generation) {
return;
}
let items = crate::flutter_outline::items(&mgr.conv(self.encoding()), &path, params.outline);
if mgr.set_flutter_outline(&path, &self.server, self.generation, items) {
mgr.sink().emit(IdeEvent::LspRefresh { server: self.server.id, kind: LspRefreshKind::FlutterOutline });
}
}
/// Once per unresolved plugin, whether m2e marked a `pom.xml` or only logged it.
fn build_plan_failure(&self, mgr: &LspManager, (plugin, body): (String, String)) {
if mgr.first_message(&self.server.name, &format!("build plan: {plugin}")) {
@@ -562,6 +580,7 @@ impl Handler for ClientHandler {
}
}
"textDocument/publishDiagnostics" => self.publish_diagnostics(&mgr, params),
"dart/textDocument/publishFlutterOutline" => self.publish_flutter_outline(&mgr, params),
"window/showMessage" => self.show_message(&mgr, &params),
"window/logMessage" => {
let text = params.get("message").and_then(Value::as_str).unwrap_or_default();
+38
Переглянути файл
@@ -15,6 +15,7 @@ mod convert;
mod external_project;
mod file_ops;
mod file_watch;
mod flutter_outline;
mod go_mod;
mod go_scope;
mod handler;
@@ -131,6 +132,15 @@ struct DocState {
notebook: Option<PathBuf>,
/// When the servers last got new text (open or change): diagnostics published before are stale.
changed: std::time::Instant,
flutter_outline: Option<FlutterOutline>,
}
/// The widget tree last published for a document, valid while that server instance runs.
/// ponytail: positions lag edits until the server's next publish, which follows each analysis.
struct FlutterOutline {
server: ide_core::ServerId,
generation: u64,
items: Vec<OutlineItem>,
}
impl DocState {
@@ -1268,6 +1278,7 @@ impl LspManager {
compose_detected,
notebook: None,
changed: std::time::Instant::now(),
flutter_outline: None,
};
let compose_added = {
let mut docs = self.docs.lock();
@@ -2406,6 +2417,33 @@ impl LspManager {
out.finish(None)
}
/// The document's widget tree, when its running Dart server published one.
pub fn flutter_outline(&self, doc: DocId) -> Option<Vec<OutlineItem>> {
let docs = self.docs.lock();
let d = docs.get(&doc)?;
let outline = d.flutter_outline.as_ref()?;
d.servers
.iter()
.any(|a| a.server.id == outline.server && a.server.is_live(outline.generation))
.then(|| outline.items.clone())
}
/// Records a published outline; whether what the open documents of `path` show changed.
fn set_flutter_outline(
&self,
path: &Path,
server: &Server,
generation: u64,
items: Option<Vec<OutlineItem>>,
) -> bool {
let mut changed = false;
for d in self.docs.lock().values_mut().filter(|d| d.path == path) {
changed |= d.flutter_outline.is_some() || items.is_some();
d.flutter_outline = items.clone().map(|items| FlutterOutline { server: server.id, generation, items });
}
changed
}
pub async fn workspace_symbols(&self, query: &str, cancel: CancellationToken) -> IdeResult<Vec<WorkspaceSymbol>> {
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
let targets = self.ready_targets(&servers, |c| c.has("workspaceSymbolProvider")).await;
+1
Переглянути файл
@@ -236,6 +236,7 @@ impl LspManager {
compose_detected: false,
notebook: Some(path.to_owned()),
changed: std::time::Instant::now(),
flutter_outline: None,
},
);
state.cells.push((cell.id.clone(), doc));
+60 -1
Переглянути файл
@@ -1,6 +1,6 @@
//! Protocol tests against in-memory mock language servers.
use ide_core::event::ServerStatus;
use ide_core::event::{LspRefreshKind, ServerStatus};
use ide_core::{
CancellationToken, DocId, FileEdit, IdeEvent, LanguageId, Pos, Range, ServerId, Severity, WorkspaceEdit,
};
@@ -1459,6 +1459,65 @@ async fn unsupported_feature_names_the_running_servers_that_lack_it() {
assert_eq!(e.message, "plain, other doesn't support type hierarchy");
}
#[tokio::test(flavor = "multi_thread")]
async fn flutter_outline_follows_the_document_and_the_server_instance() {
let h = harness(&[("mock", incremental_caps())]);
let (doc, path) = h.open("a.mk", "Text('x')\n");
h.wait_status("mock", ServerStatus::Ready).await;
let refreshes = || {
h.events
.lock()
.iter()
.filter(|e| matches!(e, IdeEvent::LspRefresh { kind: LspRefreshKind::FlutterOutline, .. }))
.count()
};
let at = json!({"start":{"line":0,"character":0},"end":{"line":0,"character":9}});
let unit = |children: Value| {
json!({ "uri": uri_of(&path), "outline": {
"kind": "DART_ELEMENT", "range": at, "codeRange": at,
"dartElement": { "kind": "COMPILATION_UNIT", "name": "<unit>" },
"children": children,
}})
};
let widgets = json!([{ "kind": "NEW_INSTANCE", "className": "Text", "range": at, "codeRange": at }]);
let peer = h.launcher.state("mock").peer();
assert!(h.mgr.flutter_outline(doc).is_none());
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets.clone())).unwrap();
eventually(|| refreshes() == 1).await;
assert_eq!(h.mgr.flutter_outline(doc).unwrap()[0].name, "Text");
// The widgets are gone from the file: the ordinary structure applies again.
peer.notify("dart/textDocument/publishFlutterOutline", unit(json!([]))).unwrap();
eventually(|| refreshes() == 2).await;
assert!(h.mgr.flutter_outline(doc).is_none());
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets.clone())).unwrap();
eventually(|| refreshes() == 3).await;
// Reopening starts without the closed document's tree.
h.mgr.did_close(doc);
assert!(h.mgr.flutter_outline(doc).is_none());
let (reopened, _) = h.open("a.mk", "Text('x')\n");
assert!(h.mgr.flutter_outline(reopened).is_none());
peer.notify("dart/textDocument/publishFlutterOutline", unit(widgets)).unwrap();
eventually(|| refreshes() == 4).await;
assert!(h.mgr.flutter_outline(reopened).is_some());
// A restarted server has analysed nothing yet.
let server = h
.events
.lock()
.iter()
.find_map(|e| match e {
IdeEvent::LanguageServer { server, name, .. } if name == "mock" => Some(*server),
_ => None,
})
.unwrap();
h.mgr.restart(server).await.unwrap();
assert!(h.mgr.flutter_outline(reopened).is_none());
}
#[tokio::test(flavor = "multi_thread")]
async fn diagnostics_become_events_and_feed_code_actions() {
let h = harness(&[("mock", incremental_caps())]);
+31 -3
Переглянути файл
@@ -4,15 +4,15 @@
//! than one place is taken from the first, in that order.
//!
//! Python, Django server, Django tests, pytest, npm, Jest, Vitest, Node.js, Shell Script,
//! Application, JAR Application, Spring Boot, Go Application / Go Test and compound configurations become the
//! Application, JAR Application, Spring Boot, Go Application / Go Test, Flutter and compound configurations become the
//! matching kinds; other types are skipped with their type.
//! `$PROJECT_DIR$` (and `$MODULE_DIR$`, `$MODULE_WORKING_DIR$`, `$ContentRoot$`,
//! `$ProjectFileDir$`, all the project directory here) and `$USER_HOME$` are replaced; another
//! path variable skips the configuration.
use super::{
Entry, Found, SkipReason, command_name, config, env_var, normalize, path_from, project_python, relative_to,
working_dir,
Entry, Found, SkipReason, command_name, config, dart_package, env_var, flutter_run, normalize, path_from,
project_python, relative_to, working_dir,
};
use crate::RunConfig;
use ide_core::IdeResult;
@@ -168,6 +168,7 @@ const JAR_APPLICATION: &str = "JarApplication";
const SPRING_BOOT: &str = "SpringBootApplicationConfigurationType";
const GO_APPLICATION: &str = "GoApplicationRunConfiguration";
const GO_TEST: &str = "GoTestRunConfiguration";
const FLUTTER: &str = "FlutterRunConfigurationType";
type Res<T> = Result<T, SkipReason>;
@@ -349,6 +350,7 @@ impl Cx<'_> {
SPRING_BOOT => self.java_app(name, c, true, &mut ignored)?,
GO_APPLICATION => self.go_config(name, c, false, &mut ignored)?,
GO_TEST => self.go_config(name, c, true, &mut ignored)?,
FLUTTER => self.flutter(name, c, &mut ignored)?,
COMPOUND => {
members = c.children_named("toRun").filter_map(|t| t.attr("name")).map(str::to_owned).collect();
config(name, "compound", String::new(), Vec::new(), None)
@@ -437,6 +439,32 @@ impl Cx<'_> {
Ok(rc)
}
/// The Flutter plugin's configuration (its `SdkFields`): `flutter run` in the entry's package,
/// `additionalArgs` then `--flavor=<buildFlavor>` after the entry, as the plugin passes them.
fn flutter(&self, name: &str, c: &El, ignored: &mut Vec<String>) -> Res<RunConfig> {
let Some(entry) = self.path(c.option("filePath"))? else {
return Err(SkipReason::NothingToRun);
};
let entry = normalize(&self.root.join(entry));
let Some((package, _)) = dart_package(self.root, &entry) else {
return Err(SkipReason::MissingFile { file: "pubspec.yaml".into() });
};
let mut extra = self.words(c.option("additionalArgs"))?;
extra.extend(self.text(c.option("buildFlavor"))?.map(|f| format!("--flavor={f}")));
let mut rc = flutter_run(name, self.root, &package, &entry, extra);
// `<option name="envs"><map><entry key=… value=…/></map></option>`.
let envs = c.children_named("option").filter(|o| o.attr("name") == Some("envs"));
for e in envs.flat_map(|o| o.children.iter()).flat_map(|m| m.children_named("entry")) {
if let Some(key) = e.attr("key").filter(|k| !k.is_empty()) {
rc.env.insert(key.to_owned(), e.attr("value").unwrap_or_default().to_owned());
}
}
if self.text(c.option("attachArgs"))?.is_some() {
ignored.push("attachArgs".into());
}
Ok(rc)
}
// ------------------------------------------------------------- Python
/// The interpreter (`SDK_HOME` when the configuration doesn't use the module's), its
+41
Переглянути файл
@@ -73,6 +73,8 @@ pub struct SkippedRunConfig {
pub enum SkipReason {
/// A configuration with this name already exists.
NameTaken,
/// An existing configuration (a detected one, say) runs the same command.
SameAs { existing: String },
/// The configuration type has no equivalent here: a VS Code debugger (`cppdbg`), a JetBrains type (`Application`).
UnsupportedType {
#[serde(rename = "type")]
@@ -174,6 +176,13 @@ pub(crate) fn finish(source: RunImportSource, entries: Vec<Entry>, existing: &[R
compounds.push((i, e.name, found));
}
Ok(mut found) => {
// ponytail: only against the project's configurations; entries of one file may differ in ignored keys.
if let Some(same) = existing.iter().find(|c| same_run(c, &found.config)) {
// A compound naming it starts the one there is.
by_name.insert(e.name.clone(), same.id.clone());
skipped.push((i, skip(e.name, SkipReason::SameAs { existing: same.name.clone() })));
continue;
}
found.config.id = unique_id(&e.name, &mut ids);
by_name.insert(e.name.clone(), found.config.id.clone());
imported.push((i, ImportedRunConfig { config: found.config, ignored: found.ignored }));
@@ -205,8 +214,40 @@ pub(crate) fn finish(source: RunImportSource, entries: Vec<Entry>, existing: &[R
}
}
/// `a` and `b` start the same process (`flutter run -t lib/main.dart` detected and imported as `main.dart`).
fn same_run(a: &RunConfig, b: &RunConfig) -> bool {
a.kind == b.kind
&& a.command == b.command
&& a.args == b.args
&& a.cwd == b.cwd
&& a.is_test == b.is_test
&& a.debug_adapter == b.debug_adapter
&& a.env == b.env
&& a.extras.params == b.extras.params
&& a.extras.env_files == b.extras.env_files
}
// ------------------------------------------------------------- shared by the sources
/// The Dart package `file` belongs to (the closest directory with a `pubspec.yaml`, inside the
/// project) and whether it is a Flutter app.
pub(crate) fn dart_package(root: &Path, file: &Path) -> Option<(PathBuf, bool)> {
let dir =
file.ancestors().skip(1).take_while(|d| d.starts_with(root)).find(|d| d.join("pubspec.yaml").is_file())?;
let flutter = std::fs::read_to_string(dir.join("pubspec.yaml")).is_ok_and(|p| p.contains("sdk: flutter"));
Some((dir.to_path_buf(), flutter))
}
/// `flutter run -t <entry>` in `package` (absolute), as detection writes it; `extra` after the entry.
pub(crate) fn flutter_run(name: &str, root: &Path, package: &Path, entry: &Path, extra: Vec<String>) -> RunConfig {
let entry = relative_to(entry, package).unwrap_or_else(|| entry.to_string_lossy().into_owned());
let mut args = vec!["run".to_owned(), "-t".to_owned(), entry];
args.extend(extra);
let mut c = config(name, "flutter", "flutter".into(), args, Some("dart"));
c.cwd = working_dir(root, &package.to_string_lossy()).1.map(Into::into);
c
}
/// The variable `name` of `env`; Windows names ignore case (`${env:PATH}` finds `Path`).
pub(crate) fn env_var(env: &BTreeMap<String, String>, name: &str, windows: bool) -> Option<String> {
match env.get(name) {
+45 -4
Переглянути файл
@@ -8,8 +8,8 @@
//! `${input:…}`, `${command:…}`) is skipped.
use super::{
Entry, Found, SkipReason, command_name, config, env_var, normalize, path_from, project_python, split_args,
working_dir,
Entry, Found, SkipReason, command_name, config, dart_package, env_var, flutter_run, normalize, path_from,
project_python, split_args, working_dir,
};
use crate::RunConfig;
use ide_core::{IdeError, IdeResult};
@@ -48,6 +48,7 @@ const NODE_LAUNCH: &[&str] = &["program", "args", "runtimeExecutable", "runtimeA
const NODE_ATTACH: &[&str] = &["address", "port", "localRoot", "remoteRoot"];
const NODE_TERMINAL: &[&str] = &["command"];
const BROWSER_LAUNCH: &[&str] = &["url", "webRoot"];
const DART_LAUNCH: &[&str] = &["program", "args", "toolArgs", "deviceId", "flutterMode"];
const COMPOUND: &[&str] = &["configurations"];
const PACKAGE_MANAGERS: &[&str] = &["npm", "pnpm", "yarn", "bun"];
@@ -226,9 +227,10 @@ impl Cx<'_> {
("chrome" | "pwa-chrome" | "msedge" | "pwa-msedge", "launch") => {
(self.browser_launch(name, obj, ty)?, BROWSER_LAUNCH)
}
("dart", "launch") => (self.dart_launch(name, obj)?, DART_LAUNCH),
(
"debugpy" | "python" | "node" | "pwa-node" | "node-terminal" | "chrome" | "pwa-chrome" | "msedge"
| "pwa-msedge",
| "pwa-msedge" | "dart",
other,
) => {
return Err(SkipReason::UnsupportedRequest { request: other.to_owned() });
@@ -236,7 +238,9 @@ impl Cx<'_> {
(other, _) => return Err(SkipReason::UnsupportedType { type_: other.to_owned() }),
};
if request == "launch" {
config.cwd = self.cwd(obj)?.1.map(Into::into);
if config.cwd.is_none() {
config.cwd = self.cwd(obj)?.1.map(Into::into);
}
self.environment(obj, &mut config)?;
}
let mut ignored: Vec<String> = obj
@@ -366,6 +370,43 @@ impl Cx<'_> {
Ok(c)
}
/// Dart Code's launch: `flutter run` in a Flutter app's package, as the Flutter debug adapter
/// starts it (`args` go to the app), else `dart run`.
fn dart_launch(&self, name: &str, obj: &Map<String, Value>) -> Res<RunConfig> {
let (dir, _) = self.cwd(obj)?;
let program = self.string(obj, "program")?;
// Relative to `cwd`, or to the workspace folder as Dart Code resolves it.
let file = |p: &str| {
let base = [&dir, self.root].into_iter().find(|b| b.join(p).is_file()).unwrap_or(&dir);
normalize(&base.join(p))
};
let entry = file(program.as_deref().unwrap_or("lib/main.dart"));
let tool_args = self.words(obj, "toolArgs")?;
let args = self.words(obj, "args")?;
match dart_package(self.root, &entry) {
Some((package, true)) => {
let mut extra = Vec::new();
if let Some(device) = self.string(obj, "deviceId")? {
extra.extend(["-d".to_owned(), device]);
}
if let Some(mode @ ("profile" | "release")) = self.string(obj, "flutterMode")?.as_deref() {
extra.push(format!("--{mode}"));
}
extra.extend(tool_args);
extra.extend(args.into_iter().flat_map(|a| ["--dart-entrypoint-args".to_owned(), a]));
Ok(flutter_run(name, self.root, &package, &entry, extra))
}
_ if program.is_none() => Err(SkipReason::NothingToRun),
_ => {
let mut words = vec!["run".to_owned()];
words.extend(tool_args);
words.push(self.path_from(entry.to_string_lossy().into_owned(), &dir));
words.extend(args.into_iter().map(|a| self.path_from(a, &dir)));
Ok(config(name, "dart", "dart".into(), words, Some("dart")))
}
}
}
/// `localRoot` (relative to the project root, empty for the root itself) and `remoteRoot`.
fn roots(&self, obj: &Map<String, Value>, c: &mut RunConfig) -> Res<()> {
if let Some(local) = self.string(obj, "localRoot")? {
+42
Переглянути файл
@@ -229,6 +229,15 @@ fn match_console_encoding(
fix.notice
}
/// A script without the execute bit as `/bin/sh <script>` (see [`ide_core::process::needs_sh`]).
/// Applied last, so the encoding and Java fixes above still see the script itself.
fn sh_for_unexecutable(inv: &mut Invocation) {
if !inv.shell && ide_core::process::needs_sh(&inv.program) {
let script = std::mem::replace(&mut inv.program, "/bin/sh".into());
inv.args.insert(0, script.to_string_lossy().into_owned());
}
}
/// A launch's pathing jar / argfile, deleted when dropped (the process exited, or never started).
struct TempFile(Option<PathBuf>);
@@ -382,6 +391,7 @@ impl ProcessManager {
let notice =
if extras.emulate_terminal { None } else { match_console_encoding(&mut inv, &mut env, config, options) };
let temp = shorten_java(&mut inv, config, &cwd)?;
sh_for_unexecutable(&mut inv);
if extras.emulate_terminal && followup.is_some() {
return Err(IdeError::invalid("Go build and run requires the output console"));
}
@@ -1397,6 +1407,38 @@ fn input_writer(
mod tests {
use super::*;
#[cfg(unix)]
#[test]
fn scripts_without_the_execute_bit_run_through_sh() {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let script = dir.path().join("gradlew");
std::fs::write(&script, "#!/bin/sh\n").unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o644)).unwrap();
let inv = || Invocation {
program: script.clone(),
args: vec!["build".into()],
raw_args: false,
shell: false,
display: "./gradlew build".into(),
};
let mut plain = inv();
sh_for_unexecutable(&mut plain);
assert_eq!(plain.program, PathBuf::from("/bin/sh"));
assert_eq!(plain.args, [script.to_string_lossy().as_ref(), "build"]);
assert_eq!(plain.display, "./gradlew build");
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut executable = inv();
sh_for_unexecutable(&mut executable);
assert_eq!(executable.program, script);
// Not a `#!` script (a binary that lost its mode): left to fail as it is.
std::fs::write(&script, b"\x7fELF").unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o644)).unwrap();
let mut binary = inv();
sh_for_unexecutable(&mut binary);
assert_eq!(binary.program, script);
}
#[test]
fn shell_lines_use_cmd_verbatim_on_windows() {
let line = r#"(if not exist "C:\T\openidea-run" mkdir "C:\T\openidea-run") && "C:\Program Files\rustc.exe" -o "C:\T\openidea-run\hi.exe" hi.rs"#;
+64
Переглянути файл
@@ -1150,3 +1150,67 @@ fn imports_go_application_and_test_configurations() {
assert_eq!(test.extras.params["pattern"], "TestLogin");
assert_eq!(test.extras.params["module"], "pkg");
}
// What `flutter create` writes to `.idea/runConfigurations/main_dart.xml`; the Flutter plugin's
// `SdkFields` serializes `filePath`, `additionalArgs`, `buildFlavor`, `attachArgs` and `envs` as options:
// https://github.com/flutter/flutter-intellij/blob/main/src/io/flutter/run/SdkFields.java
const FLUTTER_MAIN: &str = r#"<configuration default="false" name="NAME" type="FlutterRunConfigurationType" factoryName="Flutter">
<option name="filePath" value="$PROJECT_DIR$/lib/main.dart" />
<method v="2" />
</configuration>"#;
const PUBSPEC_FLUTTER: &str = "name: my_app\ndependencies:\n flutter:\n sdk: flutter\n";
#[test]
fn flutter_main_dart_from_flutter_create_is_the_detected_configuration() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
write(root, "pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "lib/main.dart", "void main() {}\n");
write(root, ".idea/runConfigurations/main_dart.xml", &run_file("main.dart", FLUTTER_MAIN));
let alone = import_from(root, &[]);
let c = get(&alone, "main.dart");
assert_eq!((c.kind.as_str(), c.command.as_str()), ("flutter", "flutter"));
assert_eq!(c.args, s(&["run", "-t", "lib/main.dart"]));
assert_eq!((cwd(c), c.debug_adapter.as_deref()), (None, Some("dart")));
// Next to the detected `flutter run`, the same run is not listed twice.
let r = import_from(root, &ide_run::detect(root));
assert!(r.imported.is_empty(), "{r:#?}");
assert_eq!(reason(&r, "main.dart"), &SkipReason::SameAs { existing: "flutter run".into() });
}
#[test]
fn flutter_flavors_entry_points_arguments_and_envs() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
write(root, "app/pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "app/lib/main_dev.dart", "void main() {}\n");
let dev = r#"<configuration name="Dev" type="FlutterRunConfigurationType" factoryName="Flutter">
<option name="additionalArgs" value="--dart-define=API=&quot;https://dev.example&quot; --verbose" />
<option name="attachArgs" value="--debug-port 9000" />
<option name="buildFlavor" value="dev" />
<option name="envs"><map><entry key="FLUTTER_LOG" value="1" /></map></option>
<option name="filePath" value="$PROJECT_DIR$/app/lib/main_dev.dart" />
<method v="2" />
</configuration>
<configuration name="Gone" type="FlutterRunConfigurationType" factoryName="Flutter">
<option name="filePath" value="$PROJECT_DIR$/elsewhere/main.dart" />
</configuration>
<configuration name="No entry" type="FlutterRunConfigurationType" factoryName="Flutter" />"#;
write(root, ".idea/workspace.xml", &workspace(dev));
let r = import_from(root, &ide_run::detect(root));
let c = get(&r, "Dev");
assert_eq!(c.kind, "flutter");
assert_eq!(
c.args,
s(&["run", "-t", "lib/main_dev.dart", "--dart-define=API=https://dev.example", "--verbose", "--flavor=dev"])
);
assert_eq!(cwd(c), Some(PathBuf::from("app")));
assert_eq!(c.env, BTreeMap::from([("FLUTTER_LOG".into(), "1".into())]));
assert_eq!(ignored(&r, "Dev"), ["attachArgs"]);
assert_eq!(reason(&r, "Gone"), &SkipReason::MissingFile { file: "pubspec.yaml".into() });
assert_eq!(reason(&r, "No entry"), &SkipReason::NothingToRun);
}
+105
Переглянути файл
@@ -555,3 +555,108 @@ fn existing_names_match_without_surrounding_spaces() {
let r = import_from(dir.path(), &[existing]);
assert_eq!(reason(&r, "Django"), &SkipReason::NameTaken);
}
const PUBSPEC_FLUTTER: &str = "name: my_app\ndependencies:\n flutter:\n sdk: flutter\n";
fn write(root: &Path, rel: &str, text: &str) {
let path = root.join(rel);
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, text).unwrap();
}
// The configurations Dart Code adds to a Flutter app's launch.json.
const FLUTTER: &str = r#"{
"version": "0.2.0",
"configurations": [
{ "name": "my_app", "request": "launch", "type": "dart" },
{ "name": "my_app (profile mode)", "request": "launch", "type": "dart", "flutterMode": "profile" },
{ "name": "my_app (release mode)", "request": "launch", "type": "dart", "flutterMode": "release" },
{ "name": "Attach", "request": "attach", "type": "dart" }
],
"compounds": [{ "name": "Both", "configurations": ["my_app", "my_app (profile mode)"] }]
}"#;
#[test]
fn flutter_launches_from_dart_code_next_to_the_detected_configuration() {
let dir = project(FLUTTER);
let root = dir.path();
write(root, "pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "lib/main.dart", "void main() {}\n");
let r = import_from(root, &ide_run::detect(root));
assert_eq!(reason(&r, "my_app"), &SkipReason::SameAs { existing: "flutter run".into() });
for (name, mode) in [("my_app (profile mode)", "--profile"), ("my_app (release mode)", "--release")] {
let c = get(&r, name);
assert_eq!(
(c.kind.as_str(), c.command.as_str(), c.debug_adapter.as_deref()),
("flutter", "flutter", Some("dart"))
);
assert_eq!(c.args, s(&["run", "-t", "lib/main.dart", mode]));
assert_eq!(cwd(c), None);
}
assert_eq!(reason(&r, "Attach"), &SkipReason::UnsupportedRequest { request: "attach".into() });
// A compound naming the left-out entry starts the detected configuration.
assert_eq!(
get(&r, "Both").extras.compound,
["flutter:run".to_owned(), get(&r, "my_app (profile mode)").id.clone()]
);
}
#[test]
fn flutter_entry_device_tool_and_app_arguments_in_a_subfolder() {
let dir = project(
r#"{ "configurations": [
{ "name": "Dev", "request": "launch", "type": "dart", "cwd": "${workspaceFolder}/app",
"program": "lib/main_dev.dart", "deviceId": "chrome", "args": ["--seed", "1"],
"toolArgs": ["--flavor", "dev", "--dart-define=ENV=dev"], "vmAdditionalArgs": ["--x"] },
{ "name": "From the root", "request": "launch", "type": "dart", "program": "app/lib/main_dev.dart" }
] }"#,
);
let root = dir.path();
write(root, "app/pubspec.yaml", PUBSPEC_FLUTTER);
write(root, "app/lib/main_dev.dart", "void main() {}\n");
let r = import_from(root, &[]);
let c = get(&r, "Dev");
assert_eq!(
c.args,
s(&[
"run",
"-t",
"lib/main_dev.dart",
"-d",
"chrome",
"--flavor",
"dev",
"--dart-define=ENV=dev",
"--dart-entrypoint-args",
"--seed",
"--dart-entrypoint-args",
"1",
])
);
assert_eq!(cwd(c), Some(PathBuf::from("app")));
assert_eq!(ignored(&r, "Dev"), ["vmAdditionalArgs"]);
// A program path from the workspace folder runs in its package too.
let c = get(&r, "From the root");
assert_eq!((c.args.clone(), cwd(c)), (s(&["run", "-t", "lib/main_dev.dart"]), Some(PathBuf::from("app"))));
}
#[test]
fn dart_programs_outside_flutter_run_with_dart() {
let dir = project(
r#"{ "configurations": [
{ "name": "Server", "request": "launch", "type": "dart", "program": "bin/server.dart",
"args": ["--port", "8080"], "toolArgs": ["--enable-asserts"] },
{ "name": "Server (absolute)", "request": "launch", "type": "dart", "program": "${workspaceFolder}/bin/server.dart" },
{ "name": "Nothing", "request": "launch", "type": "dart" }
] }"#,
);
let root = dir.path();
write(root, "pubspec.yaml", "name: server\n");
write(root, "bin/server.dart", "void main() {}\n");
let r = import_from(root, &[]);
let c = get(&r, "Server");
assert_eq!((c.kind.as_str(), c.command.as_str(), c.debug_adapter.as_deref()), ("dart", "dart", Some("dart")));
assert_eq!(c.args, s(&["run", "--enable-asserts", "bin/server.dart", "--port", "8080"]));
assert_eq!(get(&r, "Server (absolute)").args, s(&["run", "bin/server.dart"]));
assert_eq!(reason(&r, "Nothing"), &SkipReason::NothingToRun);
}
+107 -40
Переглянути файл
@@ -537,18 +537,21 @@ pub fn configure_gradle_runtime(cfg: &mut LanguageServerConfig, root: &Path, bui
merge(cfg.settings.get_or_insert_with(|| json!({})), json!({"java": {"import": {"gradle": gradle}}}));
}
/// Settings › Build Tools › Maven › Automatically download sources → jdtls
/// `java.maven.downloadSources`.
/// Settings › Build Tools › Maven › Automatically download sources and Always update
/// snapshots → jdtls `java.maven.downloadSources` / `java.maven.updateSnapshots`.
pub fn configure_maven_sources(cfg: &mut LanguageServerConfig, s: &Settings) {
if cfg.name != "jdtls" {
return;
}
let download = s.languages.java.maven.download_sources;
merge(cfg.settings.get_or_insert_with(|| json!({})), json!({"java": {"maven": {"downloadSources": download}}}));
let m = &s.languages.java.maven;
merge(
cfg.settings.get_or_insert_with(|| json!({})),
json!({"java": {"maven": {"downloadSources": m.download_sources, "updateSnapshots": m.update_snapshots}}}),
);
}
/// Maven options from settings, placed before the goals: `-s <settings.xml>`,
/// `-t <toolchains.xml>`, `-Dmaven.repo.local=<dir>`, `-T <count>` and `-P <profiles>`.
/// `-t <toolchains.xml>`, `-Dmaven.repo.local=<dir>`, `-T <count>`, `-P <profiles>` and `-U`.
pub fn maven_options(root: &Path, s: &Settings) -> Vec<String> {
let m = &s.languages.java.maven;
let mut out = Vec::new();
@@ -567,6 +570,9 @@ pub fn maven_options(root: &Path, s: &Settings) -> Vec<String> {
if let Some(profiles) = non_empty(&m.active_profiles) {
out.extend(["-P".to_owned(), profiles.to_owned()]);
}
if m.update_snapshots {
out.push("-U".to_owned());
}
out
}
@@ -680,17 +686,50 @@ fn xml_escape(text: &str) -> String {
text.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
}
/// Inserts `<localRepository>` right after the `<settings>` open tag.
fn inject_local_repository(settings_xml: &str, repo: &str) -> Option<String> {
let start = settings_xml.find("<settings")?;
let end = settings_xml[start..].find('>')? + start;
let mut out = String::with_capacity(settings_xml.len() + repo.len() + 40);
out.push_str(&settings_xml[..=end]);
out.push_str("<localRepository>");
out.push_str(&xml_escape(repo));
out.push_str("</localRepository>");
out.push_str(&settings_xml[end + 1..]);
Some(out)
/// `settings_xml` with `<localRepository>` set to `repo`: an existing one is replaced, else
/// one goes right after the `<settings>` open tag. `None` without a `<settings>` element.
pub(crate) fn with_local_repository(settings_xml: &str, repo: &str) -> Option<String> {
use crate::maven_profiles::{find_tag, mask_comments};
let masked = mask_comments(settings_xml);
let element = format!("<localRepository>{}</localRepository>", xml_escape(repo));
if let Some(start) = find_tag(&masked, "<localRepository", 0) {
let open_end = start + masked[start..].find('>')?;
let end = if masked[..open_end].ends_with('/') {
open_end + 1
} else {
let close = open_end + masked[open_end..].find("</localRepository")?;
close + masked[close..].find('>')? + 1
};
return Some(format!("{}{element}{}", &settings_xml[..start], &settings_xml[end..]));
}
let start = find_tag(&masked, "<settings", 0)?;
let end = start + masked[start..].find('>')?;
if masked[..end].ends_with('/') {
return None;
}
Some(format!("{}{element}{}", &settings_xml[..=end], &settings_xml[end + 1..]))
}
/// The user settings m2e (the JDTLS Maven import) reads, as a file and its text: the
/// configured `settings.xml`, else `~/.m2/settings.xml`, with the configured local
/// repository as its `<localRepository>`. m2e reads mirrors, servers and the local
/// repository from this file only, never from `-Dmaven.repo.local`, which is how the IDE's
/// own `mvn` runs get the configured repository (#1739). The file is `None` when there is none.
pub(crate) fn m2e_user_settings(root: &Path, s: &Settings, home: &Path) -> (Option<PathBuf>, String) {
let m = &s.languages.java.maven;
let file = setting_path(root, &m.user_settings)
.or_else(|| Some(home.join(".m2").join("settings.xml")).filter(|f| f.is_file()));
let text = file
.as_ref()
.and_then(|f| std::fs::read_to_string(f).ok())
.unwrap_or_else(|| "<settings>\n</settings>\n".into());
match setting_path(root, &m.local_repository) {
Some(repo) => {
let merged = with_local_repository(&text, &repo.to_string_lossy());
(file, merged.unwrap_or(text))
}
None => (file, text),
}
}
fn write_m2e_settings(root: &Path, text: &str) -> Option<PathBuf> {
@@ -705,32 +744,36 @@ fn write_m2e_settings(root: &Path, text: &str) -> Option<PathBuf> {
Some(file)
}
/// The user settings file m2e (the JDTLS Maven import) should read: the
/// configured `settings.xml` when it already declares `<localRepository>`,
/// else a derived copy under `<root>/.openidea/` with the configured local
/// repository injected. m2e resolves the local repository from the settings
/// XML, not from `-Dmaven.repo.local`, so without this the import downloads
/// into `~/.m2/repository` even when the IDE's own `mvn` runs honor the
/// configured path (#1739). `None` = m2e's default applies.
/// The user settings file m2e should read (see [`m2e_user_settings`]): the configured
/// `settings.xml` as it is when no local repository is configured or it already names that
/// one, else a derived copy under `<root>/.openidea/`. `None` = m2e's default applies.
pub fn maven_user_settings_for_m2e(root: &Path, s: &Settings) -> Option<PathBuf> {
maven_user_settings_for_m2e_in(root, s, &crate::home_dir().unwrap_or_default())
}
pub(crate) fn maven_user_settings_for_m2e_in(root: &Path, s: &Settings, home: &Path) -> Option<PathBuf> {
let m = &s.languages.java.maven;
if let Some(file) = setting_path(root, &m.user_settings) {
let text = std::fs::read_to_string(&file).ok()?;
if crate::java::xml_value(&crate::lombok::strip_xml_comments(&text), "localRepository").is_some() {
return Some(file);
}
if let Some(repo) = setting_path(root, &m.local_repository) {
let merged = inject_local_repository(&text, &repo.to_string_lossy())?;
if let Some(derived) = write_m2e_settings(root, &merged) {
return Some(derived);
}
}
return Some(file);
let configured = setting_path(root, &m.user_settings);
setting_path(root, &m.local_repository)?;
let (file, text) = m2e_user_settings(root, s, home);
if file.as_ref().and_then(|f| std::fs::read_to_string(f).ok()).is_some_and(|original| original == text) {
return file;
}
let repo = setting_path(root, &m.local_repository)?;
let minimal =
format!("<settings><localRepository>{}</localRepository></settings>", xml_escape(&repo.to_string_lossy()));
write_m2e_settings(root, &minimal)
write_m2e_settings(root, &text).or(configured)
}
/// `conf/settings.xml` of the Maven installation the IDE's `mvn` runs use (Settings ›
/// Maven home, a version manager's pin, else `mvn` on `PATH`; none with a project wrapper):
/// `mvn` reads its mirrors and repositories as global settings, m2e only when told to.
pub fn maven_global_settings(root: &Path, s: &Settings) -> Option<PathBuf> {
let mvn = match maven_command(root, s) {
Some(mvn) => mvn,
None if root.join("mvnw").is_file() || root.join("mvnw.cmd").is_file() => return None,
None => crate::exec::which("mvn")?,
};
let mvn = dunce::canonicalize(&mvn).unwrap_or(mvn);
let file = mvn.parent()?.parent()?.join("conf").join("settings.xml");
file.is_file().then_some(file)
}
/// TypeScript `lib` directory for the selected version; `None` = the server's bundled one.
@@ -1070,6 +1113,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
}
cfg.command = custom.to_string_lossy().into_owned();
}
// `java -jar` servers run on the project JDK when there is one, like JAR Application runs.
if cfg.command == "java"
&& let Some(java) =
project_jdk(root, s).map(|jdk| crate::java::java_executable(&jdk.home)).filter(|j| j.is_file())
{
cfg.command = java.to_string_lossy().into_owned();
}
let name = cfg.name.clone();
let name = name.as_str();
@@ -1230,6 +1280,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root
json!({ "settings": { "java": { "configuration": { "maven": { "userSettings": file } } } } }),
);
}
if let Some(file) = maven_global_settings(root, s) {
let file = file.to_string_lossy();
merge_init_options(
cfg,
json!({ "settings": { "java": { "configuration": { "maven": { "globalSettings": file } } } } }),
);
}
// The JVM system property is still forwarded for JVM-level consumers,
// but it is the settings file above that m2e honors. A
// `-Dmaven.repo.local` the user put in their own jdtls VM options wins.
@@ -1491,6 +1548,12 @@ pub fn server_launch_overrides(cfg: &mut LanguageServerConfig, s: &Settings) {
if let Some(args) = &ls.args {
cfg.args = args.clone();
}
// A server shipped as a runnable jar (groovy-language-server-all.jar) runs on `java -jar`;
// `configure_server` then picks the project JDK's `java`.
if Path::new(&cfg.command).extension().is_some_and(|e| e.eq_ignore_ascii_case("jar")) {
let jar = std::mem::replace(&mut cfg.command, "java".to_owned());
cfg.args.splice(0..0, ["-jar".to_owned(), jar]);
}
}
/// Environment, features, `initializationOptions` and `workspace/configuration`
@@ -1590,6 +1653,9 @@ fn maven_option_flag(arg: &str) -> Option<&'static str> {
return Some(short);
}
}
if arg == "-U" || arg == "--update-snapshots" {
return Some("-U");
}
arg.starts_with("-Dmaven.repo.local=").then_some("-Dmaven.repo.local")
}
@@ -2409,8 +2475,9 @@ mod maven_linkage_tests {
Some(json!({"java": {"maven": {"downloadSources": false, "updateSnapshots": false}}}))
);
settings.languages.java.maven.download_sources = true;
settings.languages.java.maven.update_snapshots = true;
configure_maven_sources(&mut cfg, &settings);
assert_eq!(cfg.settings.unwrap()["java"]["maven"]["downloadSources"], json!(true));
assert_eq!(cfg.settings.unwrap()["java"]["maven"], json!({"downloadSources": true, "updateSnapshots": true}));
let mut other = custom_server("kotlin", &LanguageServerSettings::default());
configure_maven_sources(&mut other, &settings);
+46 -9
Переглянути файл
@@ -3,7 +3,6 @@
//! user `settings.xml`. The profiles chosen in the Maven tool window are therefore
//! passed as a copy of the user's settings with those profiles activated.
use crate::apply::setting_path;
use ide_core::settings::Settings;
use ide_language::LanguageServerConfig;
use serde_json::{Value, json};
@@ -32,13 +31,24 @@ pub fn configure_jdtls(cfg: &mut LanguageServerConfig, root: &Path, s: &Settings
}
}
/// The user's settings (Settings › Maven, else `~/.m2/settings.xml`) with `active`
/// added to `<activeProfiles>`. Named after its content: m2e reloads a settings file
/// only when the configured path changes.
/// The Maven tool window's offline mode of the last sync, for jdtls (m2e) too: without it the
/// import keeps downloading from the repositories while `mvn` runs with `-o`.
pub fn configure_offline(cfg: &mut LanguageServerConfig, offline: bool) {
if cfg.name != "jdtls" {
return;
}
let layer = json!({ "java": { "import": { "maven": { "offline": { "enabled": offline } } } } });
match &mut cfg.settings {
Some(settings) => merge(settings, layer),
None => cfg.settings = Some(layer),
}
}
/// The user settings m2e reads (Settings › Maven, else `~/.m2/settings.xml`, with the
/// configured local repository) with `active` added to `<activeProfiles>`. Named after its
/// content: m2e reloads a settings file only when the configured path changes.
fn write_settings(root: &Path, s: &Settings, active: &[&str], dir: &Path) -> Option<PathBuf> {
let user = setting_path(root, &s.languages.java.maven.user_settings)
.or_else(|| crate::home_dir().map(|h| h.join(".m2").join("settings.xml")));
let base = user.and_then(|f| std::fs::read_to_string(f).ok()).unwrap_or_else(|| "<settings>\n</settings>\n".into());
let (_, base) = crate::apply::m2e_user_settings(root, s, &crate::home_dir().unwrap_or_default());
let Some(text) = with_active_profiles(&base, active) else {
tracing::warn!("Maven profiles not passed to jdtls: the user settings.xml has no <settings> element");
return None;
@@ -91,7 +101,7 @@ pub fn with_active_profiles(text: &str, ids: &[&str]) -> Option<String> {
}
/// Start of the element `open` (`<name`), not a longer name sharing its prefix.
fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {
pub(crate) fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {
let mut at = from;
while let Some(i) = masked[at..].find(open) {
let start = at + i;
@@ -105,7 +115,7 @@ fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {
}
/// `text` with comments and CDATA blanked out, byte offsets unchanged.
fn mask_comments(text: &str) -> String {
pub(crate) fn mask_comments(text: &str) -> String {
let mut out = text.as_bytes().to_vec();
let mut at = 0;
while at < text.len() {
@@ -216,6 +226,24 @@ mod tests {
assert!(text.contains("<activeProfile>c</activeProfile>"));
}
#[test]
fn jdtls_imports_offline_when_the_last_sync_was_offline() {
let offline = |cfg: &LanguageServerConfig| {
cfg.settings.as_ref().and_then(|s| s.pointer("/java/import/maven/offline/enabled")).cloned()
};
for value in [true, false] {
let mut cfg = jdtls();
cfg.settings = Some(json!({ "java": { "import": { "maven": { "enabled": true } } } }));
configure_offline(&mut cfg, value);
assert_eq!(offline(&cfg), Some(json!(value)), "explicit, so turning it off reaches a running server");
assert_eq!(cfg.settings.as_ref().unwrap().pointer("/java/import/maven/enabled"), Some(&json!(true)));
}
let mut other: LanguageServerConfig =
serde_json::from_value(json!({ "name": "kotlin-lsp", "command": "kotlin-lsp" })).unwrap();
configure_offline(&mut other, true);
assert_eq!(other.settings, None);
}
#[test]
fn jdtls_imports_with_the_synced_profiles() {
let tmp = tempfile::tempdir().unwrap();
@@ -255,6 +283,15 @@ mod tests {
}
assert!(!Path::new(&second).exists());
// The local repository of Settings › Maven stays in the copy (#1739).
s.languages.java.maven.local_repository = tmp.path().join("configured").to_string_lossy().into_owned();
let mut cfg = jdtls();
configure_jdtls(&mut cfg, tmp.path(), &s, &profiles(&["native"]), &dir);
let text = std::fs::read_to_string(user_settings(&cfg).unwrap()).unwrap();
let expected =
format!("<localRepository>{}</localRepository>", tmp.path().join("configured").to_string_lossy());
assert!(text.contains(&expected) && !text.contains("/repo<"), "{text}");
let mut other_server: LanguageServerConfig =
serde_json::from_value(json!({ "name": "kotlin-lsp", "command": "kotlin-lsp" })).unwrap();
configure_jdtls(&mut other_server, tmp.path(), &s, &profiles(&["native"]), &dir);
+130 -2
Переглянути файл
@@ -409,18 +409,96 @@ fn jdtls_m2e_gets_effective_settings_with_local_repository() {
assert!(text.contains("<mirror><id>m</id></mirror>"));
assert!(text.contains(&format!("<localRepository>{}</localRepository>", repo.to_string_lossy())));
// User settings already declaring `<localRepository>`: passed through untouched.
std::fs::write(&settings, "<settings><localRepository>/user/repo</localRepository></settings>").unwrap();
// User settings already naming the configured repository: passed through untouched.
let own = format!("<settings><localRepository>{}</localRepository></settings>", repo.to_string_lossy());
std::fs::write(&settings, &own).unwrap();
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
assert_eq!(user_settings(&cfg), Some(settings.clone()));
// Another repository: the configured one wins, as `-Dmaven.repo.local` does for `mvn`.
std::fs::write(&settings, "<settings>\n <localRepository>/user/repo</localRepository><mirrors/></settings>")
.unwrap();
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
assert_eq!(user_settings(&cfg), Some(derived.clone()));
let text = std::fs::read_to_string(&derived).unwrap();
assert!(text.contains("<mirrors/>") && !text.contains("/user/repo"), "{text}");
assert_eq!(text.matches("<localRepository>").count(), 1, "{text}");
// Settings user settings unset: the configured repository has no settings file
// replacing `~/.m2/settings.xml` without its mirrors.
let home = tmp.path().join("home");
std::fs::create_dir_all(home.join(".m2")).unwrap();
std::fs::write(
home.join(".m2/settings.xml"),
"<settings><mirrors><mirror><id>corp</id></mirror></mirrors></settings>",
)
.unwrap();
let mut only_repo = Settings::default();
only_repo.languages.java.maven.local_repository = repo.to_string_lossy().into_owned();
let file = crate::apply::maven_user_settings_for_m2e_in(tmp.path(), &only_repo, &home).unwrap();
let text = std::fs::read_to_string(file).unwrap();
assert!(text.contains("<mirror><id>corp</id></mirror>"), "{text}");
assert!(text.contains(&format!("<localRepository>{}</localRepository>", repo.to_string_lossy())));
// Neither a local repository nor user settings: `~/.m2/settings.xml` is m2e's own default.
assert_eq!(crate::apply::maven_user_settings_for_m2e_in(tmp.path(), &Settings::default(), &home), None);
// Neither configured: no userSettings at all.
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
assert_eq!(user_settings(&cfg), None);
}
#[test]
fn local_repository_goes_into_every_shape_of_settings_xml() {
use crate::apply::with_local_repository;
let element = "<localRepository>/r&amp;d</localRepository>";
for (text, expected) in [
("<settings>\n</settings>", format!("<settings>{element}\n</settings>")),
("<settings><localRepository>/old</localRepository></settings>", format!("<settings>{element}</settings>")),
("<settings><localRepository /></settings>", format!("<settings>{element}</settings>")),
(
"<settings xmlns=\"x\"><!-- <localRepository>/c</localRepository> --></settings>",
format!("<settings xmlns=\"x\">{element}<!-- <localRepository>/c</localRepository> --></settings>"),
),
(
"<?xml version=\"1.0\"?>\n<!-- <settings> --><settings>\n <localRepository>\n /old\n </localRepository>\n</settings>",
format!("<?xml version=\"1.0\"?>\n<!-- <settings> --><settings>\n {element}\n</settings>"),
),
] {
assert_eq!(with_local_repository(text, "/r&d").as_deref(), Some(expected.as_str()), "{text}");
}
assert_eq!(with_local_repository("<settings/>", "/r"), None);
}
#[test]
fn jdtls_m2e_reads_the_global_settings_of_the_maven_home() {
fn global_settings(cfg: &LanguageServerConfig) -> Option<String> {
let opts = serde_json::to_value(cfg.initialization_options.clone()?).ok()?;
opts.pointer("/settings/java/configuration/maven/globalSettings")?.as_str().map(Into::into)
}
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("apache-maven-3.9.9");
let mvn = home.join("bin").join(if cfg!(windows) { "mvn.cmd" } else { "mvn" });
std::fs::create_dir_all(mvn.parent().unwrap()).unwrap();
std::fs::write(&mvn, "").unwrap();
let mut s = Settings::default();
s.languages.java.maven.home = home.to_string_lossy().into_owned();
let configured = |s: &Settings| {
let mut cfg = server("jdtls");
configure_server(&mut cfg, tmp.path(), tmp.path(), s);
global_settings(&cfg)
};
// No `conf/settings.xml`: nothing to pass.
assert_eq!(configured(&s), None);
let conf = home.join("conf").join("settings.xml");
std::fs::create_dir_all(conf.parent().unwrap()).unwrap();
std::fs::write(&conf, "<settings><mirrors/></settings>").unwrap();
let expected = dunce::canonicalize(&conf).unwrap();
assert_eq!(configured(&s).map(std::path::PathBuf::from), Some(expected));
}
#[test]
fn rust_analyzer_check_command_and_toolchain() {
if cfg!(windows) {
@@ -809,6 +887,28 @@ fn maven_options_carry_active_profiles_into_the_command_line() {
assert_eq!(configured[0].args, ["-P", "prod", "package"]);
}
#[test]
fn always_update_snapshots_adds_dash_u_once() {
let tmp = tempfile::tempdir().unwrap();
let mut s = Settings::default();
s.languages.java.maven.update_snapshots = true;
assert_eq!(maven_options(tmp.path(), &s), ["-U"]);
let mut configs = vec![run("maven", "./mvnw", &["package"])];
for _ in 0..2 {
apply_to_run_configs(&mut configs, tmp.path(), &s);
assert_eq!(configs[0].args, ["-U", "package"]);
}
let mut own = vec![run("maven", "./mvnw", &["--update-snapshots", "package"])];
apply_to_run_configs(&mut own, tmp.path(), &s);
assert_eq!(own[0].args, ["--update-snapshots", "package"]);
// Settings apply to the stored configuration at each launch, so turning it off drops -U.
s.languages.java.maven.update_snapshots = false;
let mut stored = vec![run("maven", "./mvnw", &["package"])];
apply_to_run_configs(&mut stored, tmp.path(), &s);
assert_eq!(stored[0].args, ["package"]);
}
#[test]
fn maven_profile_and_toolchain_overrides_accept_every_option_form() {
let tmp = tempfile::tempdir().unwrap();
@@ -1194,6 +1294,34 @@ fn language_server_settings_disable_add_and_override() {
assert_eq!(parsed.code_action_kinds, Some(vec!["refactor".to_string()]));
}
#[test]
fn a_server_path_to_a_jar_runs_with_java_jar() {
use crate::apply::server_launch_overrides;
use ide_core::settings::LanguageServerSettings;
let mut s = Settings::default();
let jar = "/opt/groovy/build/libs/groovy-language-server-all.JAR";
s.language_servers.insert(
"groovy-language-server".into(),
LanguageServerSettings { command: jar.into(), args: Some(vec!["--verbose".into()]), ..Default::default() },
);
let mut groovy = server("groovy-language-server");
server_launch_overrides(&mut groovy, &s);
assert_eq!(groovy.command, "java");
assert_eq!(groovy.args, ["-jar", jar, "--verbose"]);
// A project JDK is the one that runs it.
let tmp = tempfile::tempdir().unwrap();
let home = tmp.path().join("jdk");
let java = crate::java::java_executable(&home);
std::fs::create_dir_all(java.parent().unwrap()).unwrap();
std::fs::write(&java, "").unwrap();
std::fs::write(home.join("release"), "JAVA_VERSION=\"21.0.2\"\n").unwrap();
s.languages.java.jdk = home.to_string_lossy().into_owned();
configure_server(&mut groovy, tmp.path(), tmp.path(), &s);
assert!(groovy.command.ends_with(&*Path::new("jdk").join(java.strip_prefix(&home).unwrap()).to_string_lossy()));
assert!(Path::new(&groovy.command).is_file(), "{}", groovy.command);
}
#[test]
fn ruff_configuration_directory_resolves_files_and_validates_pyproject() {
let tmp = tempfile::tempdir().unwrap();
+11
Переглянути файл
@@ -190,6 +190,17 @@ impl SshManager {
self.sessions.lock().remove(id);
}
/// Closes the shared session of configuration `id` when nothing but this manager holds it
/// right now (no terminal, tunnel or transfer in progress); returns whether it did.
pub fn release(&self, id: &str) -> bool {
let mut sessions = self.sessions.lock();
let unused = sessions.get(id).is_some_and(|s| Arc::strong_count(s) == 1);
if unused {
sessions.remove(id);
}
unused
}
/// Ids of the configurations with an open session.
pub fn connected(&self) -> Vec<String> {
self.sessions.lock().iter().filter(|(_, s)| !s.is_closed()).map(|(k, _)| k.clone()).collect()
+23 -8
Переглянути файл
@@ -6,6 +6,7 @@ use crate::session::Session;
use ide_core::{IdeError, IdeResult, error::ErrorKind};
use std::sync::Arc;
use tokio::net::TcpListener;
use tokio::sync::Notify;
use tokio::task::JoinHandle;
/// An open tunnel; dropping it stops forwarding (the session stays open while
@@ -14,6 +15,7 @@ pub struct Tunnel {
port: u16,
session: Arc<Session>,
accept: JoinHandle<()>,
stop: Arc<Notify>,
}
impl Tunnel {
@@ -40,19 +42,21 @@ impl Tunnel {
},
None => TcpListener::bind(("127.0.0.1", 0)).await?,
};
let local = listener.local_addr()?.port();
let target = Target::Tcp(host.to_owned(), port);
let accept = tokio::spawn(forward(listener, session.clone(), target));
Ok(Tunnel { port: local, session, accept })
Self::spawn(listener, session, Target::Tcp(host.to_owned(), port))
}
/// Listens on a free local port; each connection runs `command` on the SSH host and talks
/// to its stdin / stdout (`docker system dial-stdio`, as the Docker CLI's `ssh://` does).
pub async fn command(session: Arc<Session>, command: &str) -> IdeResult<Tunnel> {
let listener = TcpListener::bind(("127.0.0.1", 0)).await?;
let local = listener.local_addr()?.port();
let accept = tokio::spawn(forward(listener, session.clone(), Target::Command(command.to_owned())));
Ok(Tunnel { port: local, session, accept })
Self::spawn(listener, session, Target::Command(command.to_owned()))
}
fn spawn(listener: TcpListener, session: Arc<Session>, target: Target) -> IdeResult<Tunnel> {
let port = listener.local_addr()?.port();
let stop = Arc::new(Notify::new());
let accept = tokio::spawn(forward(listener, session.clone(), target, stop.clone()));
Ok(Tunnel { port, session, accept, stop })
}
/// The local port to connect to instead of the target.
@@ -63,6 +67,13 @@ impl Tunnel {
pub fn is_closed(&self) -> bool {
self.session.is_closed()
}
/// Stops forwarding like dropping it does, but returns only once the listener and every
/// forwarded connection are gone, so the session is no longer held by this tunnel.
pub async fn close(mut self) {
self.stop.notify_one();
let _ = (&mut self.accept).await;
}
}
impl Drop for Tunnel {
@@ -77,12 +88,16 @@ enum Target {
Command(String),
}
async fn forward(listener: TcpListener, session: Arc<Session>, target: Target) {
async fn forward(listener: TcpListener, session: Arc<Session>, target: Target, stop: Arc<Notify>) {
let target = Arc::new(target);
let mut connections = tokio::task::JoinSet::new();
loop {
let accepted = tokio::select! {
Some(_) = connections.join_next(), if !connections.is_empty() => continue,
() = stop.notified() => {
connections.shutdown().await;
return;
}
accepted = listener.accept() => accepted,
};
let Ok((mut socket, _)) = accepted else { return };
+30
Переглянути файл
@@ -272,6 +272,36 @@ async fn dropping_a_tunnel_closes_active_connections() {
assert!(!session.is_closed());
}
#[tokio::test]
async fn closing_a_tunnel_lets_go_of_the_session_and_its_connections() {
let env = env().await;
let session = Arc::new(env.connect_trusted(&env.target(SshAuth::Password), Some("secret")).await.ok().unwrap());
let tunnel = Tunnel::listen(session.clone(), "127.0.0.1", env.echo_port).await.unwrap();
let port = tunnel.port();
let mut socket = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
socket.write_all(b"ping").await.unwrap();
let mut reply = [0; 4];
socket.read_exact(&mut reply).await.unwrap();
assert!(Arc::strong_count(&session) > 2, "the tunnel and its connection hold the session");
tunnel.close().await;
// Nothing is left behind to wait for: only this test holds the session now.
assert_eq!(Arc::strong_count(&session), 1);
let mut byte = [0];
assert_eq!(socket.read(&mut byte).await.unwrap(), 0);
assert!(TcpStream::connect(("127.0.0.1", port)).await.is_err());
assert!(!session.is_closed());
}
#[tokio::test]
async fn closing_an_idle_tunnel_returns_at_once() {
let env = env().await;
let session = Arc::new(env.connect_trusted(&env.target(SshAuth::Password), Some("secret")).await.ok().unwrap());
let tunnel = Tunnel::command(session.clone(), "docker system dial-stdio").await.unwrap();
tokio::time::timeout(std::time::Duration::from_secs(5), tunnel.close()).await.unwrap();
assert_eq!(Arc::strong_count(&session), 1);
}
#[tokio::test]
async fn key_pair_authentication_with_and_without_passphrase() {
let env = env().await;
+61 -14
Переглянути файл
@@ -306,7 +306,7 @@ pub(crate) fn run_raw_env(
env: &[(&str, &std::ffi::OsStr)],
) -> IdeResult<Output> {
let first = run_raw_env_once(root, args, stdin, env)?;
if !retryable_index_lock(args, &first) {
if !retryable_index_conflict(args, &first) {
return Ok(first);
}
let deadline = Instant::now() + Duration::from_secs(2);
@@ -320,13 +320,17 @@ pub(crate) fn run_raw_env(
return Ok(first);
}
let out = run_raw_env_once(root, args, stdin, env)?;
if !retryable_index_lock(args, &out) {
if !retryable_index_conflict(args, &out) {
return Ok(out);
}
}
}
fn retryable_index_lock(args: &[&str], out: &Output) -> bool {
/// git reporting that it could not replace `.git/index`: on Windows the file cannot be
/// renamed over while another process still has it open, which is no `index.lock` conflict.
const INDEX_WRITE_BLOCKED: &str = "fatal: Could not write new index file.";
fn retryable_index_conflict(args: &[&str], out: &Output) -> bool {
// These builtins take the index lock before changing the index, worktree or refs.
// switch folds post-checkout hook failures to exit 1, unlike checkout/restore
// path operations, whose hooks can return 128 after files have already changed.
@@ -345,11 +349,24 @@ fn retryable_index_lock(args: &[&str], out: &Output) -> bool {
return false;
}
let stderr = String::from_utf8_lossy(&out.stderr);
let Some(path) = stderr.lines().next().and_then(|line| line.strip_prefix("fatal: Unable to create '")) else {
return false;
};
path.strip_suffix("': File exists.")
.is_some_and(|path| path.ends_with("/index.lock") || path.ends_with("\\index.lock"))
let Some(first) = stderr.lines().next() else { return false };
if let Some(path) = first.strip_prefix("fatal: Unable to create '") {
return path
.strip_suffix("': File exists.")
.is_some_and(|path| path.ends_with("/index.lock") || path.ends_with("\\index.lock"));
}
// `.git/index` keeps its previous entries when the new file could not replace it, so
// rerunning is safe for the builtins that take the lock before changing anything.
// switch may already have updated the worktree by then, and `rm` without `--cached`
// has deleted the files before it writes the index.
if first == INDEX_WRITE_BLOCKED {
return match *sub {
"switch" => false,
"rm" => options.contains(&"--cached"),
_ => true,
};
}
false
}
fn run_raw_env_once(
@@ -977,15 +994,15 @@ mod index_lock_tests {
code: Some(128),
};
for args in [&["switch", "other"][..], &["--literal-pathspecs", "add", "-A", "--"], &["rm"], &["reset"]] {
assert!(retryable_index_lock(args, &out));
assert!(retryable_index_conflict(args, &out));
}
for sub in ["merge", "rebase", "stash", "commit", "update-index", "checkout", "restore", "pull", "status"] {
assert!(!retryable_index_lock(&[sub], &out));
assert!(!retryable_index_conflict(&[sub], &out));
}
assert!(!retryable_index_lock(&["add", "--patch"], &out));
assert!(!retryable_index_lock(&["reset", "--soft"], &out));
assert!(!retryable_index_conflict(&["add", "--patch"], &out));
assert!(!retryable_index_conflict(&["reset", "--soft"], &out));
out.code = Some(1); // switch's post-checkout hook can fail after the switch succeeded.
assert!(!retryable_index_lock(&["switch"], &out));
assert!(!retryable_index_conflict(&["switch"], &out));
out.code = Some(128);
for message in [
"fatal: Unable to create '/repo/.git/HEAD.lock': File exists.",
@@ -994,7 +1011,37 @@ mod index_lock_tests {
"warning: partial work\nfatal: Unable to create '/repo/.git/index.lock': File exists.",
] {
out.stderr = message.as_bytes().to_vec();
assert!(!retryable_index_lock(&["switch"], &out));
assert!(!retryable_index_conflict(&["switch"], &out));
}
}
#[test]
fn retries_an_index_the_worktree_scan_keeps_open_on_windows() {
// Windows cannot rename over `.git/index` while the IDE's own status scan has it
// open: git then reports a write failure instead of an index.lock conflict.
let mut out = Output { stdout: Vec::new(), stderr: INDEX_WRITE_BLOCKED.as_bytes().to_vec(), code: Some(128) };
for args in [
&["--literal-pathspecs", "reset", "-q", "HEAD", "--", "a.md"][..],
&["--literal-pathspecs", "add", "-A", "--"],
&["--literal-pathspecs", "rm", "--cached", "-r", "-q", "--ignore-unmatch", "--"],
] {
assert!(retryable_index_conflict(args, &out), "{args:?}");
}
// The worktree may already be updated by switch, and `rm` deletes its files before
// it writes the index, so neither is repeated.
out.code = Some(128);
for args in [&["switch", "other"][..], &["rm"]] {
assert!(!retryable_index_conflict(args, &out), "{args:?}");
}
for sub in ["commit", "merge", "rebase", "update-index", "restore"] {
assert!(!retryable_index_conflict(&[sub], &out));
}
// The same failure with output on stdout is not this message alone; and a
// different exit code is not git's fatal.
out.stdout = b"partial".to_vec();
assert!(!retryable_index_conflict(&["reset"], &out));
out.stdout.clear();
out.code = Some(1);
assert!(!retryable_index_conflict(&["reset"], &out));
}
}
+30 -4
Переглянути файл
@@ -259,6 +259,27 @@ pub struct Branch {
pub commit: String,
}
/// What Update Selected did to one local branch.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum BranchUpdateStatus {
Updated,
UpToDate,
/// Diverged from its upstream: left as it is.
NotFastForward,
NoUpstream,
Failed,
}
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct BranchUpdate {
pub branch: String,
pub status: BranchUpdateStatus,
/// Why it failed.
pub message: Option<String>,
}
/// Commit Options (IDEA's commit options popup).
#[derive(Clone, Debug, Default, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -1458,11 +1479,16 @@ impl Repo {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::reset_to_upstream(self, cancel, on_output)
}
/// Fast-forwards a local branch that is not checked out to its upstream (Branches ›
/// Update). Fails when the branch has diverged.
pub fn update_branch(&self, branch: &str, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {
/// Branches › Update Selected: fetches each remote once and fast-forwards every
/// branch to its upstream, reporting the branches it could not update.
pub fn update_branches(
&self,
branches: &[String],
cancel: &CancellationToken,
on_output: &dyn Fn(String),
) -> IdeResult<Vec<BranchUpdate>> {
let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
write::update_branch(self, branch, cancel, on_output)
write::update_branches(self, branches, cancel, on_output)
}
// ---- in-progress operations, history rewriting, tags ----
+73 -11
Переглянути файл
@@ -5,10 +5,11 @@ use crate::cli::{self, run};
use crate::repo::{gx, resolve};
use crate::text_encoding::{decode, encode, has_bom, is_binary};
use crate::{
BlameLine, CheckoutMode, CheckoutOptions, CheckoutOutcome, CommitOptions, DeletedBranch, DivergedLocal,
PushBranchOptions, Repo,
BlameLine, BranchUpdate, BranchUpdateStatus, CheckoutMode, CheckoutOptions, CheckoutOutcome, CommitOptions,
DeletedBranch, DivergedLocal, PushBranchOptions, Repo,
};
use gix::bstr::{BStr, ByteSlice};
use ide_core::error::ErrorKind;
use ide_core::{CancellationToken, IdeError, IdeResult};
use std::path::{Path, PathBuf};
@@ -1392,18 +1393,79 @@ pub(crate) fn push_branch(
cli::run_streaming(r.root(), &argv, cancel, on_output)
}
/// Fast-forwards local `branch` (not checked out) to its upstream, fetching it first.
pub(crate) fn update_branch(
/// Update Selected (IDEA's Git.Update.Selected): fetches the remote of each branch once,
/// then fast-forwards the branch to its tracked branch: the checked-out one with
/// `merge --ff-only`, the others with a local fetch, which refuses branches checked out
/// in another worktree. Diverged branches are left alone.
pub(crate) fn update_branches(
r: &Repo,
branch: &str,
branches: &[String],
cancel: &CancellationToken,
on_output: &dyn Fn(String),
) -> IdeResult<()> {
check_local_branch(r, branch)?;
let (remote, name) =
branch_upstream(r, branch).ok_or_else(|| IdeError::invalid(format!("'{branch}' has no tracked branch")))?;
let refspec = format!("refs/heads/{name}:refs/heads/{branch}");
cli::run_streaming(r.root(), &["fetch", "--progress", &remote, &refspec], cancel, on_output)
) -> IdeResult<Vec<BranchUpdate>> {
let head =
run(r.root(), &["symbolic-ref", "-q", "--short", "HEAD"], None).ok().map(|o| o.stdout_str().trim().to_string());
let mut fetched: Vec<(String, Result<(), String>)> = Vec::new();
let mut out = Vec::with_capacity(branches.len());
for branch in branches {
check_local_branch(r, branch)?;
let result = |status, message| BranchUpdate { branch: branch.clone(), status, message };
let Some((remote, _)) = branch_upstream(r, branch) else {
out.push(result(BranchUpdateStatus::NoUpstream, None));
continue;
};
let fetch = match fetched.iter().find(|(name, _)| *name == remote) {
Some((_, done)) => done.clone(),
None => {
let done = match cli::run_streaming(r.root(), &["fetch", "--progress", &remote], cancel, on_output) {
Err(e) if e.kind == ErrorKind::Cancelled => return Err(e),
done => done.map_err(|e| e.message),
};
fetched.push((remote, done.clone()));
done
}
};
let (status, message) = match fetch {
Err(message) => (BranchUpdateStatus::Failed, Some(message)),
Ok(()) => fast_forward(r, branch, head.as_deref() == Some(branch.as_str()), cancel, on_output)?,
};
out.push(result(status, message));
}
Ok(out)
}
fn fast_forward(
r: &Repo,
branch: &str,
current: bool,
cancel: &CancellationToken,
on_output: &dyn Fn(String),
) -> IdeResult<(BranchUpdateStatus, Option<String>)> {
let rev = |args: &[&str]| run(r.root(), args, None).ok().map(|o| o.stdout_str().trim().to_string());
let ancestor = |a: &str, b: &str| {
cli::run_raw(r.root(), &["merge-base", "--is-ancestor", a, b], None).is_ok_and(|o| o.code == Some(0))
};
let local = format!("refs/heads/{branch}");
let tracked =
rev(&["rev-parse", "--symbolic-full-name", &format!("{branch}@{{upstream}}")]).filter(|t| !t.is_empty());
let target = tracked.as_deref().and_then(|t| rev(&["rev-parse", "-q", "--verify", &format!("{t}^{{commit}}")]));
let (Some(tracked), Some(target), Some(tip)) = (tracked, target, rev(&["rev-parse", "-q", "--verify", &local]))
else {
return Ok((BranchUpdateStatus::Failed, Some(format!("the tracked branch of '{branch}' was not found"))));
};
if tip == target || ancestor(&target, &tip) {
return Ok((BranchUpdateStatus::UpToDate, None));
}
if !ancestor(&tip, &target) {
return Ok((BranchUpdateStatus::NotFastForward, None));
}
let refspec = format!("{tracked}:{local}");
let args: &[&str] = if current { &["merge", "--ff-only", &tracked] } else { &["fetch", ".", &refspec] };
match cli::run_streaming(r.root(), args, cancel, on_output) {
Ok(()) => Ok((BranchUpdateStatus::Updated, None)),
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
Err(e) => Ok((BranchUpdateStatus::Failed, Some(e.message))),
}
}
/// Update Project › Reset to the Remote Branch: fetches the current branch's tracked
+94 -12
Переглянути файл
@@ -560,7 +560,7 @@ fn push_branch_and_up_to_revision() {
}
#[test]
fn update_branch_fast_forwards_a_branch_not_checked_out() {
fn update_branches_fast_forwards_each_selected_branch() {
let fx = Fixture::new();
let bare = fx._tmp.path().join("origin.git");
git_in(fx._tmp.path(), &["init", "-q", "--bare", bare.to_str().unwrap()]);
@@ -568,22 +568,104 @@ fn update_branch_fast_forwards_a_branch_not_checked_out() {
fx.commit_all("one");
fx.git(&["remote", "add", "origin", bare.to_str().unwrap()]);
fx.git(&["push", "-q", "-u", "origin", "main"]);
fx.git(&["checkout", "-q", "-b", "work"]);
// Someone else advances origin/main.
for b in ["behind", "diverged", "ahead", "same", "elsewhere"] {
fx.git(&["push", "-q", "origin", &format!("main:{b}")]);
fx.git(&["branch", "-q", "--track", b, &format!("origin/{b}")]);
}
fx.git(&["branch", "-q", "local-only"]);
// Someone else advances main, behind, diverged and elsewhere on the remote.
let other = fx._tmp.path().join("other");
git_in(fx._tmp.path(), &["clone", "-q", bare.to_str().unwrap(), other.to_str().unwrap()]);
std::fs::write(other.join("a.txt"), "2\n").unwrap();
git_in(&other, &["-c", "user.name=O", "-c", "user.email=o@x", "commit", "-q", "-am", "two"]);
git_in(&other, &["push", "-q", "origin", "main"]);
let tip = git_in(&other, &["rev-parse", "HEAD"]);
let mut tips = std::collections::HashMap::new();
for b in ["main", "behind", "diverged", "elsewhere"] {
git_in(&other, &["checkout", "-q", b]);
std::fs::write(other.join("a.txt"), format!("{b}\n")).unwrap();
git_in(&other, &["-c", "user.name=O", "-c", "user.email=o@x", "commit", "-q", "-am", b]);
git_in(&other, &["push", "-q", "origin", b]);
tips.insert(b, git_in(&other, &["rev-parse", "HEAD"]));
}
// Local commits: `diverged` can't be fast-forwarded, `ahead` has nothing to take.
for b in ["diverged", "ahead"] {
fx.git(&["checkout", "-q", b]);
fx.write("b.txt", b);
fx.commit_all(b);
}
fx.git(&["checkout", "-q", "main"]);
// A branch checked out in another worktree is refused rather than moved under it.
let wt = fx._tmp.path().join("wt");
fx.git(&["worktree", "add", "-q", wt.to_str().unwrap(), "elsewhere"]);
let ahead = fx.git(&["rev-parse", "ahead"]);
let repo = fx.repo();
let (cancel, out) = quiet();
repo.update_branch("main", &cancel, &out).unwrap();
assert_eq!(fx.git(&["rev-parse", "main"]), tip);
assert_eq!(fx.git(&["rev-parse", "origin/main"]), tip);
// The checked-out branch and branches without upstream are refused.
assert!(repo.update_branch("work", &cancel, &out).is_err());
let names = ["main", "behind", "diverged", "ahead", "same", "local-only", "elsewhere"].map(String::from);
let result = repo.update_branches(&names, &cancel, &out).unwrap();
let status: Vec<_> = result.iter().map(|u| (u.branch.as_str(), u.status)).collect();
use BranchUpdateStatus::*;
assert_eq!(
status,
[
("main", Updated),
("behind", Updated),
("diverged", NotFastForward),
("ahead", UpToDate),
("same", UpToDate),
("local-only", NoUpstream),
("elsewhere", Failed),
]
);
assert!(result[6].message.as_deref().is_some_and(|m| m.contains("checked out")), "{:?}", result[6].message);
// The checked-out branch is fast-forwarded with its working tree.
assert_eq!(fx.git(&["rev-parse", "main"]), tips["main"]);
assert_eq!(fx.read("a.txt"), "main\n");
assert_eq!(fx.git(&["rev-parse", "behind"]), tips["behind"]);
assert_eq!(fx.git(&["rev-parse", "origin/diverged"]), tips["diverged"]);
assert_ne!(fx.git(&["rev-parse", "diverged"]), tips["diverged"]);
assert_eq!(fx.git(&["rev-parse", "ahead"]), ahead);
assert_ne!(fx.git(&["rev-parse", "elsewhere"]), tips["elsewhere"]);
assert!(repo.update_branches(&["origin/main".into()], &cancel, &out).is_err());
}
#[test]
fn update_branches_fetches_each_remote_once_and_reports_its_failure() {
let fx = Fixture::new();
let bare = fx._tmp.path().join("origin.git");
git_in(fx._tmp.path(), &["init", "-q", "--bare", bare.to_str().unwrap()]);
fx.write("a.txt", "1\n");
fx.commit_all("one");
fx.git(&["remote", "add", "origin", bare.to_str().unwrap()]);
fx.git(&["remote", "add", "gone", fx._tmp.path().join("missing.git").to_str().unwrap()]);
fx.git(&["push", "-q", "-u", "origin", "main", "main:a", "main:b"]);
for b in ["a", "b"] {
fx.git(&["branch", "-q", "--track", b, &format!("origin/{b}")]);
}
fx.git(&["branch", "-q", "c"]);
fx.git(&["config", "branch.c.remote", "gone"]);
fx.git(&["config", "branch.c.merge", "refs/heads/c"]);
// Counts the fetches from origin.
#[cfg(unix)]
let counter = {
use std::os::unix::fs::PermissionsExt;
let counter = fx._tmp.path().join("fetches");
let script = fx._tmp.path().join("upload-pack.sh");
std::fs::write(&script, format!("#!/bin/sh\necho >> '{}'\nexec git-upload-pack \"$@\"\n", counter.display()))
.unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
fx.git(&["config", "remote.origin.uploadpack", script.to_str().unwrap()]);
counter
};
let repo = fx.repo();
let (cancel, out) = quiet();
let names = ["a", "b", "c"].map(String::from);
let result = repo.update_branches(&names, &cancel, &out).unwrap();
let status: Vec<_> = result.iter().map(|u| u.status).collect();
use BranchUpdateStatus::*;
assert_eq!(status, [UpToDate, UpToDate, Failed]);
assert!(result[2].message.is_some());
#[cfg(unix)]
assert_eq!(std::fs::read_to_string(counter).unwrap().lines().count(), 1);
}
/// `"` and tabs are illegal in Windows file names, and only they make Git quote a path.
+6 -1
Переглянути файл
@@ -366,7 +366,7 @@ const HTML: &str = "text/html; charset=utf-8";
fn content_type(path: &Path) -> &'static str {
let ext = path.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();
match ext.as_str() {
"html" | "htm" | "xhtml" => HTML,
"html" | "htm" | "xhtml" | "shtml" => HTML,
"css" => "text/css; charset=utf-8",
"js" | "mjs" | "cjs" => "text/javascript; charset=utf-8",
"json" | "map" | "webmanifest" => "application/json; charset=utf-8",
@@ -415,6 +415,11 @@ mod tests {
out
}
#[test]
fn shtml_files_are_html_by_name() {
assert_eq!(content_type(Path::new("page.SHTML")), HTML);
}
#[tokio::test]
async fn a_page_is_html_whatever_its_name() {
let dir = tempfile::tempdir().unwrap();
+3
Переглянути файл
@@ -847,6 +847,9 @@ mod tests {
"disabledPluginChecks": [],
"doubleClickOpensDiff": null,
"agentInstructions": "",
"agent": "",
"agentModel": "",
"agentEffort": "",
})
);
}
+34 -2
Переглянути файл
@@ -29,7 +29,13 @@ pnpm perf -- --only typing --profile --unminified # CPU profile and top functi
Other options: `--warmup <n>` (default 1), `--headed`, `--no-build` (reuse the last build), `--channel <browser>` (default `chromium`, or `OPENIDEA_PERF_CHANNEL`), `--fail-on-regression`.
Scenarios (`perf/scenarios.ts`): `typing`, `typingLarge`, `typingAngular`, `completion`, `consoleOutput`, `terminalTui`, `keyRepeat`, `scroll`, `gitLog`, `gitLogScrollbar`, `resizePanels`, `startup`, `tabs`, `agentTabs`, `popups`, `toolWindows`, `projectTree`, `leaks`. Bundle size (`bundle.initialJsKb`, `bundle.initialCssKb`) is checked on every run.
`--runs` must be a positive integer, `--warmup` a nonnegative integer, and `--cpu` a finite number of at least 1. Empty or unknown `--only` entries fail before building or launching a browser. Every declared selected scenario must return exactly one result; missing budgeted metrics and nonfinite metrics fail even when CPU throttling disables timing-budget enforcement. Unminified profiling builds intentionally omit bundle-size checks.
Every attempted repetition, including warmups, is retained in `target/perf/report.json` with status, metrics and failure reason. Markdown shows valid/planned and attempted counts. Missing or nonfinite repetitions are not filtered out of medians; invalid warmups also fail the scenario. Build, browser and cleanup failures replace the previous report with a fresh failure.
UI builds and individual trials have five-minute wall-clock deadlines independent of renderer animation frames. Browser startup is bounded to 30 seconds; context/HTTP cleanup to five seconds, with bounded forced browser termination. The owned Playwright browser server adds a local WebSocket command hop; in-page timing clocks are unchanged.
Scenarios (`perf/scenarios.ts`): `typing`, `typingLarge`, `typingAngular`, `completion`, `consoleOutput`, `terminalTui`, `keyRepeat`, `scroll`, `gitLog`, `gitLogScrollbar`, `resizePanels`, `startup`, `tabs`, `agentTabs`, `popups`, `toolWindows`, `projectTree`, `leaks`. Bundle size (`bundle.initialJsKb`, `bundle.initialCssKb`) is checked except with `--unminified`.
Latencies are measured from input to the start of the first frame that shows the result, so about 16.7 ms means "next frame".
@@ -42,9 +48,17 @@ Latencies are measured from input to the start of the first frame that shows the
A scenario in `perf/scenarios.ts` has an `id`, a `title` and a `run(h)` that drives the page through the harness (`perf/lib/harness.ts`: open files, set the cursor, type and measure, read editor state) and returns metrics. Add a budget for each metric you want enforced as `"<scenario>.<metric>"` in `budgets.json`.
### Current-operation checks
An already-visible result is not evidence that the measured action worked. Interaction waits require a current input and the requested state transition; file opening checks the active full path, typing checks the resulting text/caret and key-sample count, and scroll/completion navigation checks its destination.
Code-intelligence evals also wait for successful action completion. Rename correctness uses the current matching request only: multi-file previews validate proposed edits, while applied local renames validate the edited document. Incomplete answers are degraded results. Clean-file diagnostics require a fresh backend publication for that document, including an explicitly empty publication; a quiet empty UI alone cannot pass.
Diagnostics acknowledgements match the path, backend source and local opening token. Backend publications carry no document version, so a delayed same-path publication after reopening cannot be distinguished from a newly computed one.
## Backend: `pnpm perf:rust`
`perf/rust.ts` runs `cargo bench` for `ide-text`, `ide-language`, `ide-index`, `ide-search` and `ide-host`, reads the Criterion results from `target/criterion`, and checks each bench's mean (in µs).
`perf/rust.ts` runs `cargo bench` for `ide-text`, `ide-language`, `ide-index`, `ide-search`, `ide-host` and `ide-heap`, reads the Criterion results, and checks each bench's mean (in µs).
```sh
pnpm perf:rust # run the benches, then check
@@ -62,6 +76,22 @@ The benches live in `crates/<crate>/benches/`:
| `search_5k/…` | `ide-search` | literal, regex and dense-match search over 5k files |
| `plugins/…` | `ide-host` | loading 50 plugins, cold activation, syntax highlights of a 2k-line file |
Expected IDs and package ownership are declared independently of collected artifacts in `perf/lib/rust.ts`. A selected package must produce every expected ID, including observe-only measurements. `--package` scopes both collection and required budgets, also with `--no-run`; unknown packages fail before Cargo starts.
Six IDs are observe-only (required finite measurements, without an absolute budget): `syntax_2mb/outline_uncached`, `syntax_2mb/folding_uncached`, `index_100k/find_files/zzzz`, `index_100k/find_symbols/renderView`, `startup_20k/reopen_wait_idle`, and `search_excluded_subtrees/5k_dependencies`. New IDs need an explicit budget or observe-only classification.
Normal runs write isolated `<Criterion root>/runs/run-*/criterion` artifacts, a `run.json` manifest and Cargo logs. `CRITERION_HOME` and `CARGO_TARGET_DIR` are passed consistently to Cargo. Both artifact files must fall within the recorded run window; future timestamps fail. `--no-run` inspects the newest recorded run covering the selected packages, retaining original artifact dates and any recorded failure; pre-manifest output is explicitly labelled legacy inspection, not current execution.
Cargo has a 60-minute deadline including cold compilation (`PERF_RUST_TIMEOUT_MS` overrides milliseconds), followed by bounded process-tree termination. Cargo, artifact and manifest failures write fresh `report-rust.json` and Markdown with partial evidence.
## Code intelligence: `pnpm eval`
Use `pnpm eval --list` for scenario IDs and supported conditions. `--only` accepts comma-separated IDs or dot-prefix groups; every entry must match executable work. `--condition` accepts only `warm` or `cold`, and a selection incompatible with that condition is rejected before building or launching. Repetition counts follow the UI runner's integer requirements.
The selected scenario/condition plan defines the required outcomes independently of collected results. Missing, duplicate or unexpected outcomes fail; an empty workload cannot pass. Required timing and correctness metrics must be present and finite, rather than silently skipped by the judge.
Raw attempts, warmups, results and partial timeout timings remain in `target/eval/report.json`; invalid trials cannot disappear into an otherwise valid median. Startup/build failures also produce a fresh failing report. Session startup, fixture setup and each trial have five-minute wall-clock bounds; renderer measurements additionally have a Node deadline one second beyond their configured timeout. Server initialization is limited to 30 seconds, individual stdio requests to five minutes, release compilation to 60 minutes. Cleanup errors fail the run.
## Budgets and baselines
[`perf/budgets.json`](https://github.com/l0ng-ai/openidea/blob/main/perf/budgets.json) holds upper bounds (lower is better):
@@ -92,4 +122,6 @@ python perf/compare/bench.py ~/src/some-project --runs 5 --wipe-caches # cold
Each run launches the app on the project, waits until it is ready (the process tree's CPU stays low after the window and the log markers appear), idles, closes it, and records time to window and to ready, peak and idle memory summed over every process the app started (webview, language servers, JVMs), CPU time, exit time and cache size. Apps run interleaved after warmup runs; output goes to `results/<time>-<project>/` (`report.md`, `results.json`).
Reports retain failed trials and warmups, display per-cell valid/attempted counts, and distinguish unsupported metrics from missing required values. Startup timeouts, crashes, forced shutdowns and interruptions fail the command. Quit/cache commands have explicit deadlines; cleanup runs even after observation failures. See the comparison README for the unchanged CPU-settled readiness proxy and daemon exclusions.
Use release builds only; the script refuses to run while another instance of the same executable is running. See [`perf/compare/README.md`](https://github.com/l0ng-ai/openidea/blob/main/perf/compare/README.md) for fair-run rules and platform notes.
+1 -1
Переглянути файл
@@ -78,7 +78,7 @@ The task tab shows the conversation: your messages, the agent's replies, its rea
On your own messages you can **Edit** (the messages after it are replaced; files already changed stay as they are) or **Retract Message**. On replies you can **Copy Markdown**, **Quote Reply**, **Regenerate Response** and **Branch Conversation from Here**, which starts a new task from that point.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending until your next message reopens the same session. If the session can't be reopened or doesn't accept the model, OpenIDEA restores the previous selection and reports the error without sending the message.
In an existing chat, open **Model › Refresh models** to discover newly available models without sending a message or changing the selection. If the agent can't switch in place, the choice stays pending. You can choose an effort level as soon as the provider reports the new model's options. On your next message, OpenIDEA reopens the same session and applies the model and any effort you selected before sending. If the session can't be reopened or rejects either choice, OpenIDEA restores the previous selection and reports the error without sending the message.
**Focus Agent Input** defaults to `⌘L` on macOS and `Ctrl+L` on Windows / Linux in every built-in keymap. When focus is inside your writable task conversation, in either an editor tab or the tool window, it returns focus to the message input without changing your draft, caret position or selection—even when pressed repeatedly. It does not send a message or jump through message history.
+2 -2
Переглянути файл
@@ -170,8 +170,8 @@ Each launch opens a tab in the **Run** tool window (bottom). The toolbar has **R
Two actions in Find Action (also linked from the dialog) import existing configurations:
- **Import Run Configurations from .vscode/launch.json**: Python and Node.js launches and attaches, plus compounds. Fixed variables such as `${workspaceFolder}` and `${env:NAME}` are replaced; entries that use `${file}`, `${input:…}` or `${command:…}` are skipped.
- **Import Run Configurations from JetBrains (.run, .idea)**: reads `.run/*.run.xml`, `.idea/runConfigurations/*.xml` and `.idea/workspace.xml`. Python, Django, pytest, npm, Jest, Vitest, Node.js, Shell Script, Application, JAR Application, Spring Boot, Go and compound configurations are converted; other types are skipped.
- **Import Run Configurations from .vscode/launch.json**: Python and Node.js launches and attaches, Dart launches (Flutter apps as Flutter configurations), plus compounds. Fixed variables such as `${workspaceFolder}` and `${env:NAME}` are replaced; entries that use `${file}`, `${input:…}` or `${command:…}` are skipped.
- **Import Run Configurations from JetBrains (.run, .idea)**: reads `.run/*.run.xml`, `.idea/runConfigurations/*.xml` and `.idea/workspace.xml`. Python, Django, pytest, npm, Jest, Vitest, Node.js, Shell Script, Application, JAR Application, Spring Boot, Go, Flutter and compound configurations are converted; other types are skipped. An entry that runs the same command as an existing configuration, such as the detected `flutter run`, is skipped.
A notification says how many were imported and why others were left out.
+1 -1
Переглянути файл
@@ -177,7 +177,7 @@ The **Log** tab of the Git tool window shows the commit graph.
- **Go to Hash/Branch/Tag** (`⌘F` / `Ctrl+F` in the log).
- **Graph Options**: sort by date, topologically or incoming first; first parent only; no merges.
- **View Options**: reference display, details pane, and columns (**Author**, **Date**, **Hash**, **Signature**, **GitHub Commit Checks**).
- The branches pane on the left filters the log by branch and has branch actions.
- The branches pane on the left filters the log by branch and has branch actions. Select several local branches and choose **Update Selected** to fast-forward each to its tracked branch, fetching each remote once; one notification lists the branches that were updated and those that could not be fast-forwarded or have no tracked branch.
- The details pane shows the changed files, the commit message, who committed it, which branches contain it and its signature.
Right-click a commit for **Copy Revision Number** (`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`), **Create Patch…**, **Cherry-Pick**, **Checkout Revision**, **Browse Repository at Revision**, **Compare with Local**, **Reset Current Branch to Here…**, **Revert Commit**, **Undo Commit…**, **New Branch…**, **New Tag…**, **View in Browser** and more. With two commits selected, **Compare Versions** diffs them.
+9 -7
Переглянути файл
@@ -37,13 +37,15 @@ After editing the file, run **Reload .ideavimrc** (from the status bar widget or
Supported lines:
| Line | Notes |
| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `map`, `noremap` and their `n`, `v`, `x`, `i`, `o` variants (`nnoremap`, `vmap`…) | `<silent>`, `<unique>`, `<nowait>`, `<buffer>`, `<expr>` and `<script>` flags are accepted and ignored. Key names such as `<esc>` and `<CR>` are case-insensitive. |
| `let mapleader = "…"` | Also `g:mapleader`. `"\<Space>"` and `" "` both mean Space. The default leader is `\`. |
| `set …` | Only the options codemirror-vim implements: `textwidth` (`tw`), `pcre`, `insertModeEscKeysTimeout` and `langmap` (`lmap`). Other options are reported as ignored. |
| `source <file>` | Reads another file by the same rules. `~` is your home directory. |
| `" comment` | Ignored. |
| Line | Notes |
| --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `map`, `noremap` and their `n`, `v`, `x`, `i`, `o` variants (`nnoremap`, `vmap`…) | `<silent>`, `<unique>`, `<nowait>`, `<buffer>`, `<expr>` and `<script>` flags are accepted and ignored. Key names such as `<esc>` and `<CR>` are case-insensitive. |
| `let mapleader = "…"` | Also `g:mapleader`. `"\<Space>"` and `" "` both mean Space. The default leader is `\`. |
| `set …` | `textwidth` (`tw`), `pcre`, `insertModeEscKeysTimeout`, `langmap` (`lmap`) and `clipboard` (`cb`). `+=`, `-=` and `^=` work as in Vim. Other options are reported as ignored. |
| `source <file>` | Reads another file by the same rules. `~` is your home directory. |
| `" comment` | Ignored. |
`set clipboard+=unnamedplus` (or `unnamed`) also copies yanks, deletes and changes without a register to the system clipboard. The `"+` register always reads and writes the system clipboard.
Anything else (functions, `if`, `autocmd`, plugin commands) is reported as ignored and never executed.
+34 -2
Переглянути файл
@@ -29,7 +29,13 @@ pnpm perf -- --only typing --profile --unminified # CPU profile 和耗时最
其他选项:`--warmup <n>`(默认 1)、`--headed`、`--no-build`(复用上次构建)、`--channel <browser>`(默认 `chromium`,或 `OPENIDEA_PERF_CHANNEL`)、`--fail-on-regression`。
场景(`perf/scenarios.ts`):`typing`、`typingLarge`、`typingAngular`、`completion`、`consoleOutput`、`terminalTui`、`keyRepeat`、`scroll`、`gitLog`、`gitLogScrollbar`、`resizePanels`、`startup`、`tabs`、`agentTabs`、`popups`、`toolWindows`、`projectTree`、`leaks`。每次运行都会检查包体积(`bundle.initialJsKb`、`bundle.initialCssKb`)。
`--runs` 必须为正整数,`--warmup` 为非负整数,`--cpu` 为不小于 1 的有限数值。`--only` 中的空项或未知场景会在构建或启动浏览器前报错。每个选中场景必须恰好返回一份结果;预算指标缺失或指标非有限值都会失败,即使 CPU 降速关闭了耗时预算检查。未压缩的性能分析构建不检查包体积。
`target/perf/report.json` 保留每次尝试(包括预热)的状态、指标和失败原因,Markdown 显示有效/计划次数及实际尝试次数。缺失或非有限值不会从中位数中被过滤,预热无效也会导致场景失败。构建、浏览器和清理失败都会用新的失败报告替换旧报告。
UI 构建和每次尝试都有独立于渲染器动画帧的五分钟墙钟期限。浏览器启动限时 30 秒,上下文及 HTTP 清理限时五秒,必要时有界强制终止浏览器。独立管理的 Playwright 浏览器服务增加一次本地 WebSocket 命令跳转,页面内计时基准不变。
场景(`perf/scenarios.ts`):`typing`、`typingLarge`、`typingAngular`、`completion`、`consoleOutput`、`terminalTui`、`keyRepeat`、`scroll`、`gitLog`、`gitLogScrollbar`、`resizePanels`、`startup`、`tabs`、`agentTabs`、`popups`、`toolWindows`、`projectTree`、`leaks`。除 `--unminified` 外,每次运行都会检查包体积(`bundle.initialJsKb`、`bundle.initialCssKb`)。
延迟是从输入到显示结果的第一帧开始的时间,因此约 16.7 ms 就表示“下一帧”。
@@ -42,9 +48,17 @@ pnpm perf -- --only typing --profile --unminified # CPU profile 和耗时最
`perf/scenarios.ts` 中的场景包含 `id`、`title` 和 `run(h)`:通过 harness(`perf/lib/harness.ts`:打开文件、设置光标、输入并测量、读取编辑器状态)驱动页面并返回指标。需要强制检查的指标,在 `budgets.json` 中以 `"<scenario>.<metric>"` 加上预算。
### 当前操作的正确性检查
已显示的结果不能证明被测操作成功。交互等待必须观察到当前输入及目标状态变化;打开文件会核对活动编辑器的完整路径,输入会核对最终文本、光标和按键样本数,滚动及补全导航会核对目标位置。
代码智能 eval 也会等待动作成功结束。重命名只使用当前匹配请求的结果:跨文件预览验证拟议的修改,已应用的局部重命名验证实际文档。不完整的答复按降级结果处理。干净文件的诊断必须收到针对该文档的新后端发布,包括明确的空发布;仅有安静且为空的 UI 不能通过。
诊断确认匹配路径、后端来源和本地打开令牌。后端发布不携带文档版本,因此重新打开后延迟到达的同路径发布,无法与新计算的发布区分。
## 后端:`pnpm perf:rust`
`perf/rust.ts` 对 `ide-text`、`ide-language`、`ide-index`、`ide-search` 和 `ide-host` 运行 `cargo bench`,从 `target/criterion` 读取 Criterion 结果,检查每个基准的平均值(µs)。
`perf/rust.ts` 对 `ide-text`、`ide-language`、`ide-index`、`ide-search`、`ide-host` 和 `ide-heap` 运行 `cargo bench`,读取 Criterion 结果,检查每个基准的平均值(µs)。
```sh
pnpm perf:rust # 跑基准并检查
@@ -62,6 +76,22 @@ pnpm perf:rust -- --package ide-text --save-baseline
| `search_5k/…` | `ide-search` | 在 5 千个文件中做字面量、正则和密集匹配搜索 |
| `plugins/…` | `ide-host` | 加载 50 个插件、冷激活、2 千行文件的语法高亮 |
预期 ID 及其所属包在 `perf/lib/rust.ts` 中独立于收集到的产物声明。选中的包必须提供全部预期 ID,包括仅观察的指标。`--package` 同时限定收集范围和必需预算,使用 `--no-run` 时也如此;未知包会在启动 Cargo 前报错。
六个 ID 仅观察(必须提供有限测量值,但没有绝对预算):`syntax_2mb/outline_uncached`、`syntax_2mb/folding_uncached`、`index_100k/find_files/zzzz`、`index_100k/find_symbols/renderView`、`startup_20k/reopen_wait_idle`、`search_excluded_subtrees/5k_dependencies`。新增 ID 必须明确设置预算或归类为仅观察。
正常执行将产物隔离到 `<Criterion 根目录>/runs/run-*/criterion`,并保留 `run.json` 清单和 Cargo 日志。`CRITERION_HOME`、`CARGO_TARGET_DIR` 与 Cargo 保持一致。两个产物文件都必须处于记录的运行时间窗口内,未来时间戳会失败。`--no-run` 检查覆盖所选包的最新记录,保留原始产物时间及已有失败;清单引入前的产物明确标为旧产物检查,而非本次执行。
Cargo 包括冷编译在内默认限时 60 分钟(`PERF_RUST_TIMEOUT_MS` 可按毫秒覆盖),随后有界终止所属进程树。Cargo、产物和清单失败都会输出新的 `report-rust.json` 和 Markdown,并保留部分证据。
## 代码智能:`pnpm eval`
用 `pnpm eval --list` 查看场景 ID 及支持的条件。`--only` 接受逗号分隔的 ID 或点号前缀分组;每项都必须匹配可执行的工作。`--condition` 只接受 `warm` 或 `cold`,与该条件不兼容的选择会在构建或启动前被拒绝。重复次数遵循 UI 运行器的整数要求。
选中的场景/条件计划独立于收集结果定义必需的输出。缺失、重复或非预期输出都会失败,空工作集不能通过。必需的耗时和正确性指标必须存在且为有限数值,判定器不再静默跳过它们。
`target/eval/report.json` 保留原始尝试、预热、结果及超时前的部分计时,无效尝试不能消失在看似有效的中位数中。启动或构建失败也会生成新的失败报告。会话启动、夹具准备和每次尝试均限时五分钟;渲染器测量另有 Node 期限,比场景配置超时多一秒。服务初始化限时 30 秒,单个 stdio 请求限时五分钟,release 编译限时 60 分钟。清理错误会导致整次运行失败。
## 预算与基线
[`perf/budgets.json`](https://github.com/l0ng-ai/openidea/blob/main/perf/budgets.json) 保存上限(越低越好):
@@ -92,4 +122,6 @@ python perf/compare/bench.py ~/src/some-project --runs 5 --wipe-caches # 冷
每次运行都会用该应用打开项目,等待就绪(窗口出现、日志标记出现后,进程树的 CPU 保持在低位),空闲一段时间后关闭,并记录:到窗口出现和到就绪的时间、应用启动的所有进程(webview、语言服务器、JVM)合计的峰值与空闲内存、CPU 时间、退出耗时和缓存大小。各应用在预热后交替运行,结果输出到 `results/<time>-<project>/`(`report.md`、`results.json`)。
报告保留失败尝试和预热,逐单元格显示有效/尝试次数,并区分不支持的指标与缺失的必需指标。启动超时、崩溃、强制关闭和中断都会使命令失败。退出及清缓存命令有明确期限,观察失败后仍会清理。CPU 平静就绪代理和守护进程排除策略保持不变,详见对比工具 README。
只使用 release 构建;同一可执行文件已有实例在运行时脚本会拒绝执行。公平测量的规则和各平台说明见 [`perf/compare/README.md`](https://github.com/l0ng-ai/openidea/blob/main/perf/compare/README.md)。
+1 -1
Переглянути файл
@@ -78,7 +78,7 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
在你自己的消息上可以 **编辑**(其后的消息会被替换,已经改动的文件保持不变)或 **撤回消息**。在回复上可以 **复制 Markdown**、**引用回复**、**重新生成回复**,以及 **从此处创建分支对话**,从这一点开始一个新任务。
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会在下一条消息重新打开原会话时才应用。如果无法恢复会话,或原会话不接受所选模型,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会保持待应用状态。提供商返回新模型支持的思考强度后,你就可以选择强度。发送下一条消息时,OpenIDEA 会先恢复原会话并应用所选模型和思考强度,再发送消息。如果无法恢复会话,或原会话不接受其中任何一项,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
所有内置按键映射中,**聚焦 Agent 输入框** 的默认快捷键都是 macOS 上的 `⌘L`、Windows / Linux 上的 `Ctrl+L`。焦点位于你自己的可输入任务对话中时,无论对话显示在编辑器标签页还是工具窗口中,它都会将焦点移回消息输入框,保留草稿、光标位置和选区;重复按下也不会改变这些内容。它不会发送消息,也不会跳转消息历史。
+2 -2
Переглянути файл
@@ -166,8 +166,8 @@ Maven 模块在 **自动** 和 **构建(Make)** 时由 jdtls(ECJ)构建
“查找操作”里有两个导入操作(对话框里也有入口):
- **从 .vscode/launch.json 导入运行配置**:导入 Python 和 Node.js 的 launch / attach 配置以及 compounds。`${workspaceFolder}`、`${env:NAME}` 这类含义固定的变量会被替换;用到 `${file}`、`${input:…}`、`${command:…}` 的条目会被跳过。
- **从 JetBrains 导入运行配置(.run、.idea)**:读取 `.run/*.run.xml`、`.idea/runConfigurations/*.xml` 和 `.idea/workspace.xml`。Python、Django、pytest、npm、Jest、Vitest、Node.js、Shell Script、Application、JAR Application、Spring Boot、Go 和复合配置会被转换,其他类型跳过。
- **从 .vscode/launch.json 导入运行配置**:导入 Python 和 Node.js 的 launch / attach 配置、Dart 的 launch 配置(Flutter 应用导入为 Flutter 配置)以及 compounds。`${workspaceFolder}`、`${env:NAME}` 这类含义固定的变量会被替换;用到 `${file}`、`${input:…}`、`${command:…}` 的条目会被跳过。
- **从 JetBrains 导入运行配置(.run、.idea)**:读取 `.run/*.run.xml`、`.idea/runConfigurations/*.xml` 和 `.idea/workspace.xml`。Python、Django、pytest、npm、Jest、Vitest、Node.js、Shell Script、Application、JAR Application、Spring Boot、Go、Flutter 和复合配置会被转换,其他类型跳过。和已有配置(例如自动检测出的 `flutter run`)命令相同的条目会被跳过。
导入完成后会有通知告诉你导入了多少、哪些被跳过以及原因。
+1 -1
Переглянути файл
@@ -175,7 +175,7 @@ Git 工具窗口的 **日志** 标签页显示提交图。
- **转到哈希/分支/标签**(在日志中按 `⌘F` / `Ctrl+F`)。
- **图形选项**:按日期、拓扑或传入优先排序;仅第一父提交;不显示合并提交。
- **视图选项**:引用显示方式、详情面板,以及列(**作者**、**日期**、**哈希**、**签名**、**GitHub 提交检查**)。
- 左侧的分支面板可以按分支过滤日志,并提供分支操作。
- 左侧的分支面板可以按分支过滤日志,并提供分支操作。选中多个本地分支后选择 **Update Selected**,会把每个分支快进到它的跟踪分支,每个远程只 fetch 一次;结果汇总在一条通知里,列出已更新的分支,以及因不能快进或没有跟踪分支而未更新的分支。
- 详情面板显示变更文件、提交消息、提交者、包含该提交的分支以及签名。
右键提交可以选择 **复制修订号**(`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`)、**创建补丁…**、**拣选**、**签出修订**、**浏览此修订版本的仓库**、**与本地比较**、**将当前分支重置到此处…**、**还原提交**、**撤消提交…**、**新建分支…**、**新建标签…**、**在浏览器中查看** 等。选中两个提交时,**比较版本** 会比较它们。
+9 -7
Переглянути файл
@@ -37,13 +37,15 @@ Vim 模式开启时(如果上次是开启状态,启动时也会),OpenIDE
支持的写法:
| 写法 | 说明 |
| ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `map`、`noremap` 以及它们的 `n`、`v`、`x`、`i`、`o` 变体(`nnoremap`、`vmap`…) | `<silent>`、`<unique>`、`<nowait>`、`<buffer>`、`<expr>`、`<script>` 标志可以写,但会被忽略。`<esc>`、`<CR>` 等键名不区分大小写。 |
| `let mapleader = "…"` | 也可以写 `g:mapleader`。`"\<Space>"` 和 `" "` 都表示空格。默认 leader 是 `\`。 |
| `set …` | 只支持 codemirror-vim 实现的选项:`textwidth`(`tw`)、`pcre`、`insertModeEscKeysTimeout` 和 `langmap`(`lmap`)。其他选项会被标记为已忽略。 |
| `source <file>` | 按同样的规则读取另一个文件,`~` 表示主目录。 |
| `" 注释` | 忽略。 |
| 写法 | 说明 |
| ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `map`、`noremap` 以及它们的 `n`、`v`、`x`、`i`、`o` 变体(`nnoremap`、`vmap`…) | `<silent>`、`<unique>`、`<nowait>`、`<buffer>`、`<expr>`、`<script>` 标志可以写,但会被忽略。`<esc>`、`<CR>` 等键名不区分大小写。 |
| `let mapleader = "…"` | 也可以写 `g:mapleader`。`"\<Space>"` 和 `" "` 都表示空格。默认 leader 是 `\`。 |
| `set …` | `textwidth`(`tw`)、`pcre`、`insertModeEscKeysTimeout`、`langmap`(`lmap`)和 `clipboard`(`cb`)。`+=`、`-=`、`^=` 与 Vim 相同。其他选项会被标记为已忽略。 |
| `source <file>` | 按同样的规则读取另一个文件,`~` 表示主目录。 |
| `" 注释` | 忽略。 |
`set clipboard+=unnamedplus`(或 `unnamed`)让不指定寄存器的复制、删除和修改也写入系统剪贴板。`"+` 寄存器始终读写系统剪贴板。
其他内容(函数、`if`、`autocmd`、插件命令等)都会被标记为已忽略,不会执行。
+64 -17
Переглянути файл
@@ -108,15 +108,23 @@ async function seed(
surface: "new" | "task" = "task",
model = "atlas",
status: AgentTask["status"] = "ready",
catalogOnly = false,
) {
await stubDesktop(page);
await page.evaluate(
async ({ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId }) => {
async ({ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId, catalogOnly }) => {
// In-memory sample tasks belong to Vite's browser realm. Static Node imports create a different store and cannot seed the workbench.
const storePath = "/src/features/agents/store.ts";
const store = await import(storePath);
const initialCatalog = {
...provider,
config: provider.config.map((entry) => ({
...entry,
values: entry.values.filter((value) => value.value !== "swift"),
})),
};
const configFor = (model: string) => [
{ ...provider.config[0]!, current: model },
{ ...(catalogOnly && model !== "swift" ? initialCatalog : provider).config[0]!, current: model },
...(provider.thoughtLevels?.[model] ?? []),
];
const tasks = new Map(
@@ -150,10 +158,10 @@ async function seed(
channel = onEvent;
return [...tasks.values()];
};
handlers.agent_providers = () => [provider];
handlers.agent_refresh_models = () => ({
handlers.agent_providers = () => [catalogOnly ? initialCatalog : provider];
handlers.agent_refresh_models = ({ force }) => ({
provider: provider.id,
config: provider.config,
config: (catalogOnly && !force ? initialCatalog : provider).config,
thoughtLevels: provider.thoughtLevels,
refreshing: false,
refreshedAtMs: Date.now(),
@@ -170,9 +178,15 @@ async function seed(
handlers.vcs_branches = () => [];
handlers.agent_set_config = async ({ task: id, option, value }) => {
const previous = tasks.get(String(id))!;
const pendingModel = catalogOnly && option === modelId && value === "swift";
if (pendingModel) {
const { promise, resolve } = Promise.withResolvers<void>();
document.addEventListener("test:chat-model-settings-ready", () => resolve(), { once: true });
await promise;
}
const updated =
option === modelId
? { ...previous, model: String(value), config: configFor(String(value)) }
? { ...previous, model: pendingModel ? previous.model : String(value), config: configFor(String(value)) }
: {
...previous,
config: previous.config.map((entry) =>
@@ -204,7 +218,7 @@ async function seed(
if (surface === "new") store.openHome();
else store.openTask(firstTask.id);
},
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId },
{ placement, surface, provider, firstTask, secondTask, subagent, model, status, modelId, catalogOnly },
);
await expect(box(page)).toBeVisible();
await page.evaluate(() => document.fonts.ready);
@@ -219,11 +233,12 @@ function history(page: Page) {
function modelButton(page: Page) {
return page.getByRole("button", { name: "Model", exact: true }).filter({ visible: true });
}
function effortButton(page: Page) {
return page.getByRole("button", { name: "Reasoning", exact: true }).filter({ visible: true });
/** The effort is shown on the model button, after the model's name. */
function effortLabel(page: Page) {
return modelButton(page).locator("[class*='modelDetail']");
}
async function expectEffort(page: Page, name: string) {
await expect(effortButton(page)).toHaveText(name);
await expect(effortLabel(page)).toHaveText(name);
}
async function selected(box: Locator) {
return box.evaluate((element) => {
@@ -364,8 +379,8 @@ test("Settings and effort popup exclude the agent shortcut", async ({ workbench:
await expect(search).toBeFocused();
await expect(search).toHaveValue("keymap");
await settings.getByRole("button", { name: "Cancel", exact: true }).click();
await effortButton(page).click();
const popup = page.getByRole("listbox", { name: "Reasoning", exact: true });
await modelButton(page).click();
const popup = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
await expect(popup).toBeVisible();
await page.keyboard.press("Alt+t");
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
@@ -584,14 +599,16 @@ test("New Task discovers uncached model effort before the first prompt", async (
.poll(async () => (await ipcCalls(page, "agent_refresh_models")).filter((call) => call.model === "swift"))
.toEqual([{ provider: provider.id, force: false, model: "swift" }]);
await expect(page.getByRole("status").filter({ hasText: "Loading model settings…" })).toBeVisible();
await expect(effortButton(page)).toHaveCount(0);
await expect(effortLabel(page)).toHaveCount(0);
await page.screenshot({ path: testInfo.outputPath("model-settings-loading.png") });
await page.evaluate(() => document.dispatchEvent(new Event("test:model-settings-ready")));
await expectEffort(page, "Quick");
await effortButton(page).click();
await expect(page.getByRole("option", { name: "Quick", exact: true })).toBeVisible();
await expect(page.getByRole("option", { name: "Thorough", exact: true })).toBeVisible();
await expect(page.getByRole("option", { name: "Gentle", exact: true })).toHaveCount(0);
await modelButton(page).click();
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
await expect(efforts.getByRole("radio", { name: "Quick", exact: true })).toBeVisible();
await expect(efforts.getByRole("radio", { name: "Thorough", exact: true })).toBeVisible();
await expect(efforts.getByRole("radio", { name: "Gentle", exact: true })).toHaveCount(0);
await page.keyboard.press("Escape");
await expect(box(page)).toHaveText("Keep this first task unsent");
await expectNoSubmission(page);
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
@@ -599,3 +616,33 @@ test("New Task discovers uncached model effort before the first prompt", async (
await page.screenshot({ path: testInfo.outputPath("uncached-model-effort.png") });
}
});
test("an existing chat can choose effort for a refreshed model before sending", async ({ workbench: page }) => {
await seed(page, "editor", "task", "atlas", "ready", true);
await box(page).fill(draft);
await expectEffort(page, "Gentle");
await modelButton(page).click();
const swiftModel = page.getByRole("option", { name: /^Swift\b/ });
await expect(swiftModel).toHaveCount(0);
await page.getByRole("button", { name: "Refresh models", exact: true }).click();
await swiftModel.click();
const loading = page.getByRole("status").filter({ hasText: "Loading model settings…" });
const send = page.getByRole("button", { name: "Send", exact: true });
await expect(loading).toBeVisible();
await expect(send).toBeDisabled();
await expect(modelButton(page)).toHaveAttribute("title", /^Model: Atlas\b/);
await page.evaluate(() => document.dispatchEvent(new Event("test:chat-model-settings-ready")));
await expect(loading).toHaveCount(0);
await expect(modelButton(page)).toHaveAttribute("title", /^Model: Swift\b/);
await expectEffort(page, "Quick");
await modelButton(page).click();
const efforts = page.getByRole("radiogroup", { name: "Effort Level", exact: true });
await expect(efforts.getByRole("radio", { name: "Gentle", exact: true })).toHaveCount(0);
await efforts.getByRole("radio", { name: "Thorough", exact: true }).click();
await page.keyboard.press("Escape");
await expectEffort(page, "Thorough");
await expect(send).toBeEnabled();
await expect(box(page)).toHaveText(draft);
await expectNoSubmission(page);
});
+61
Переглянути файл
@@ -479,6 +479,67 @@ test("diagnostics underline the range and ⌥⏎ applies the preferred quick fix
expect(applied).toMatchObject({ action: { title: "Import 'com.acme.orders.model.Order'" } });
});
test("⌥⏎ opens the list before a slow server answers, then fills it", async ({ workbench: page }) => {
const editor = await openSample(page);
await page.evaluate(
({ file, bad }) => {
const action = {
title: "Import 'com.acme.orders.model.Order'",
kind: "quickfix",
isPreferred: true,
disabledReason: null,
edit: {
files: [
{
kind: "edit",
path: file,
edits: [
{
range: { start: { line: 4, col: 0 }, end: { line: 4, col: 0 } },
new_text: "import com.acme.orders.model.Order\n",
},
],
},
],
},
command: null,
data: null,
server: "kotlin",
};
// The server's answer is held until the test releases it, so "the popup is up while the
// server is still thinking" is a fact and not a race against a timer.
window.__releaseActions = null;
window.__ipc.handlers.lsp_code_actions = () =>
new Promise((resolve) => {
window.__releaseActions = () => resolve([action]);
});
window.__ipc.handlers.lsp_execute_code_action = () => [];
window.__ipc.emit({
type: "diagnostics",
path: file,
source: "kotlin",
items: [
{ range: bad, severity: "error", message: "Unresolved reference: Order", source: "kotlin", code: null },
],
});
},
{ file: FILE, bad: range(20, 19, 24) },
);
await caretAt(editor, page, "val order: Order", "Order ");
const popup = page.getByTestId("list-popup");
await page.keyboard.press("Alt+Enter");
await expect(popup).toBeVisible();
await expect(popup).toHaveAttribute("aria-busy", "true");
expect(await ipcCalls(page, "lsp_code_actions")).toHaveLength(1);
// Only now does the server answer.
await page.evaluate(() => window.__releaseActions?.());
const fix = page.getByRole("option", { name: /Import 'com\.acme\.orders\.model\.Order'/ });
await expect(fix).toBeVisible();
await expect(popup).not.toHaveAttribute("aria-busy", "true");
await fix.click();
await expect.poll(() => ipcCalls(page, "lsp_execute_code_action")).toHaveLength(1);
});
test("lazy plugin actions resolve only when invoked, never for their intention preview", async ({
workbench: page,
}) => {
+36
Переглянути файл
@@ -0,0 +1,36 @@
import { expect, openFromTree, test } from "./fixtures";
for (const { name, source, expected } of [
{
name: "multiline documentation comment",
source: "/**\n * Creates a visitor record.\n * More detail.\n */\nexport const visitor = 1;",
expected: "/** Creates a visitor record. ...*/",
},
{
name: "inline documentation header",
source: "/** Returns the visitor name.\n * More detail.\n */\nexport const visitor = 1;",
expected: "/**...*/",
},
{
name: "ordinary block comment",
source:
"/*\n * Ordinary block comment for comparison.\n * It is not a documentation comment.\n */\nexport const visitor = 1;",
expected: "/* Ordinary block comment for comparison. ...*/",
},
]) {
test(`folds a JavaScript ${name} like IDEA`, async ({ workbench: page }, testInfo) => {
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(source);
await expect(editor.locator(".cm-line").first()).toHaveText(source.split("\n")[0]!);
await editor.locator(".cm-foldGutter .cm-openidea-foldOpen").first().click();
await expect(editor.locator(".cm-line").first()).toHaveText(expected);
await page.screenshot({ path: testInfo.outputPath("folded.png"), animations: "disabled" });
await editor.locator(".cm-foldPlaceholder").first().click();
await expect(editor.locator(".cm-line").first()).toHaveText(source.split("\n")[0]!);
});
}
+1 -1
Переглянути файл
@@ -30,7 +30,7 @@ for (const kind of ["run", "debug", "services-run", "services-debug", "stacktrac
component = SessionPanel;
props = {
session: run.useRun.getState().sessions.find((s: { id: string }) => s.id === id),
...(kind === "services-run" ? { onRerun: null, onDebug: null } : {}),
showLifecycle: kind === "run",
};
} else if (kind === "debug" || kind === "services-debug") {
const statePath = "/src/features/debugger/state.ts";
+27
Переглянути файл
@@ -0,0 +1,27 @@
import { expect, test } from "./fixtures";
test("keeps debug actions and views accessible when the Debug window is docked at the side", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 900, height: 760 });
await page.evaluate(async () => {
const debugModule = "/src/features/debugger/state.ts";
const layoutModule = "/src/workbench/toolwindows/store.ts";
const servicesModule = "/src/workbench/contributions.ts";
const { adoptSession } = await import(/* @vite-ignore */ debugModule);
const { moveToolWindow, setToolWindowSize } = await import(/* @vite-ignore */ layoutModule);
const { toolWindowService } = await import(/* @vite-ignore */ servicesModule);
adoptSession(91, { name: "Checkout service", adapter: "java-debug", status: "starting" });
moveToolWindow("debug", "right");
setToolWindowSize("right", 300);
toolWindowService().show("debug", true);
});
const pane = page.getByRole("region", { name: "Debug", exact: true });
const toolbar = pane.getByRole("toolbar", { name: "Debugger actions" });
const views = pane.getByRole("tablist", { name: "Debug views" });
await expect(toolbar.getByRole("button", { name: "More", exact: true })).toBeInViewport();
await expect(views.getByRole("tab", { name: "Console", exact: true })).toBeInViewport();
await views.getByRole("tab", { name: "Memory", exact: true }).click();
await expect(views.getByRole("tab", { name: "Memory", exact: true })).toHaveAttribute("aria-selected", "true");
});
+39
Переглянути файл
@@ -0,0 +1,39 @@
import { expect, openFromTree, test } from "./fixtures";
test("fits a long wrapped tab and its close button inside a narrow editor group", async ({ workbench: page }) => {
const filename = "QuarterlyReconciliationAndCheckoutAllocation.test.ts";
await page.setViewportSize({ width: 720, height: 760 });
await openFromTree(page, "README.md");
await page.evaluate(async (filename) => {
const projectModule = "/src/platform/project.ts";
const projectFilesModule = "/src/features/project-tree/fs.ts";
const editorModule = "/src/editor/core/controller.ts";
const { useProject } = await import(/* @vite-ignore */ projectModule);
const { projectFs } = await import(/* @vite-ignore */ projectFilesModule);
const { editorController, useTabs } = await import(/* @vite-ignore */ editorModule);
const { project, settings } = useProject.getState();
useProject.setState({
settings: {
...settings,
editor: { ...settings?.editor, tabs: { ...settings?.editor?.tabs, multipleRows: true } },
},
});
const path = `${project.root}/${filename}`;
await projectFs(project.root).createFile(path);
await editorController().openFilesIn([path], useTabs.getState().activePane, "right");
}, filename);
const tab = page.getByRole("tab", { name: filename, exact: true });
await expect(tab).toHaveAttribute("aria-selected", "true");
await expect
.poll(() =>
tab.evaluate((element) => {
const close = element.parentElement?.querySelector("[data-tab-close]");
const strip = element.closest('[role="tablist"]');
return !!close && !!strip && close.getBoundingClientRect().right <= strip.getBoundingClientRect().right;
}),
)
.toBe(true);
await tab.locator("..").getByRole("button", { name: "Close Tab", exact: true }).click();
await expect(tab).toBeHidden();
});
+2
Переглянути файл
@@ -39,6 +39,8 @@ export interface IpcStub {
declare global {
interface Window {
__ipc: IpcStub;
/** Releases a stubbed answer a test holds back on purpose (see the ⌥⏎ popup test). */
__releaseActions?: (() => void) | null;
}
}
+41
Переглянути файл
@@ -76,6 +76,47 @@ test.beforeEach(async ({ workbench: page }) => {
});
});
test("fits a wide graph and saved columns without horizontal scrolling", async ({ workbench: page }) => {
await page.evaluate(async () => {
const module = "/src/features/vcs/logOptions.ts";
const { useLogOptions } = await import(/* @vite-ignore */ module);
useLogOptions.setState({
showColumnHeaders: true,
showHash: true,
showSignature: true,
columnWidths: { author: 400, date: 240 },
});
});
const list = page.getByRole("listbox", { name: "Commits" });
await expect(list.getByRole("separator", { name: "Resize Date column" })).toBeVisible();
for (const width of [1400, 620, 400]) {
await page.setViewportSize({ width, height: 900 });
await expect
.poll(() =>
list.evaluate((element) => {
const header = [...element.querySelectorAll("[data-log-column]")];
const row = [...element.querySelector('[role="option"]')!.children];
const right = element.getBoundingClientRect().right;
return {
fits: element.scrollWidth === element.clientWidth,
aligned: header.every((cell, i) => {
const heading = cell.getBoundingClientRect();
const data = row[i]!.getBoundingClientRect();
return heading.width > 0 && heading.right <= right && Math.abs(heading.right - data.right) < 1;
}),
};
}),
)
.toEqual({ fits: true, aligned: true });
}
await list.hover();
await page.mouse.wheel(450, 450);
await expect.poll(() => list.evaluate((element) => element.scrollTop)).toBeGreaterThan(0);
expect(await list.evaluate((element) => element.scrollLeft)).toBe(0);
});
test("keeps a wide Git graph filled during scrollbar drags and its edges interactive afterwards", async ({
workbench: page,
}) => {
+27
Переглянути файл
@@ -94,3 +94,30 @@ test("a second click on a Git Log toolbar button closes its popup", async ({ wor
await expect(row).toBeHidden();
}
});
test("Git Log keeps filters and actions inside the commit pane at the minimum window width", async ({
workbench: page,
}) => {
await page.setViewportSize({ width: 400, height: 500 });
const toolbar = page.getByRole("toolbar", { name: "Log filters" });
const clippedButtons = () =>
toolbar.evaluate((el) => {
const bar = el.getBoundingClientRect();
return Array.from(el.querySelectorAll("button"))
.filter((button) => {
if (getComputedStyle(button).visibility === "hidden") return false;
const box = button.getBoundingClientRect();
return box.width > 0 && (box.right > bar.right + 1 || box.bottom > bar.bottom + 1);
})
.map((button) => button.getAttribute("aria-label"));
});
await expect.poll(clippedButtons).toEqual([]);
const search = toolbar.getByRole("textbox", { name: "Filter by message" });
await expect(search).toBeVisible();
expect((await search.boundingBox())!.width).toBeGreaterThan(12);
await toolbar.getByRole("button", { name: "View Options" }).click();
await expect(page.getByRole("menuitemcheckbox", { name: "Tag Names" })).toBeVisible();
await page.keyboard.press("Escape");
await toolbar.getByRole("button", { name: "More Filters" }).click();
await expect(page.getByRole("menuitem", { name: "Paths" })).toBeVisible();
});
+34
Переглянути файл
@@ -0,0 +1,34 @@
import { expect, test } from "./fixtures";
test("keeps diagnostic text and file counts visible in a narrow Problems pane", async ({ workbench: page }) => {
await page.setViewportSize({ width: 720, height: 760 });
await page.evaluate(async () => {
const projectModule = "/src/platform/project.ts";
const problemsModule = "/src/features/code-insight/problemsStore.ts";
const { useProject } = await import(/* @vite-ignore */ projectModule);
const { applyDiagnosticsEvent } = await import(/* @vite-ignore */ problemsModule);
const root = useProject.getState().project.root;
const path = `${root}/src/features/checkout/shared/services/with-a-long-directory-name/for-order-processing/orders.ts`;
const source = "typescript-eslint-application-rules-with-a-very-long-source-label";
applyDiagnosticsEvent(path, source, [
{
range: { start: { line: 2, col: 2 }, end: { line: 2, col: 9 } },
severity: "error",
source,
message: "Invalid order total",
},
]);
});
await page.getByRole("button", { name: "Problems", exact: true }).click();
const pane = page.locator('[data-toolwindow="problems"]');
await pane.getByRole("tab", { name: /Project Errors/ }).click();
await expect(pane.getByRole("toolbar", { name: "Problems actions" })).toHaveAttribute("aria-orientation", "vertical");
const tree = pane.getByRole("tree", { name: "Problems" });
const count = tree.getByText("1 error", { exact: true });
const message = tree.getByText("Invalid order total", { exact: true });
await expect(count).toBeVisible();
await expect(message).toBeVisible();
await expect.poll(() => message.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
await expect.poll(() => tree.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
});
+19
Переглянути файл
@@ -0,0 +1,19 @@
import { expect, test } from "./fixtures";
test("gives the project name room before its path in a narrow tree", async ({ workbench: page }) => {
await page.evaluate(async () => {
const storeModule = "/src/features/project-tree/store.ts";
const { useProjectTree } = await import(/* @vite-ignore */ storeModule);
useProjectTree.setState({ name: "checkout-order-processing" });
});
const pane = page.getByRole("region", { name: "Project", exact: true });
await pane.getByRole("button", { name: "Options", exact: true }).click();
await page.getByRole("menuitemcheckbox", { name: "Horizontal Scrolling" }).click();
const tree = pane.getByRole("tree", { name: "Project" });
const name = tree.getByText("checkout-order-processing", { exact: true });
await expect(name).toBeVisible();
await expect.poll(() => name.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
await expect.poll(() => tree.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
});
+33
Переглянути файл
@@ -81,6 +81,39 @@ test("⌘F2 stops a running process", async ({ workbench: page }) => {
await expect(run.getByRole("tab", { name: "dev" })).toHaveAttribute("data-tooltip", /exit code 143$/);
});
test("a short Run pane has room for the full toolbar above the output", async ({ workbench: page }) => {
await page.setViewportSize({ width: 400, height: 500 });
const output = "Watching for changes…";
await stubRun(page, [{ kind: "stdout", text: `${output}\n` }], null);
await page.keyboard.press("Control+r");
const run = page.getByRole("region", { name: "Run", exact: true });
await expect(run.getByText(output)).toBeVisible();
await page.evaluate(async () => {
const path = "/src/workbench/toolwindows/store.ts";
const { setToolWindowSize } = await import(/* @vite-ignore */ path);
setToolWindowSize("bottom", 160);
});
const toolbar = run.getByRole("toolbar", { name: "Run actions" });
const clipped = await toolbar.evaluate((el) => {
const bar = el.getBoundingClientRect();
return Array.from(el.querySelectorAll("button")).flatMap((button) => {
const box = button.getBoundingClientRect();
return box.left < bar.left - 1 || box.right > bar.right + 1 || box.bottom > bar.bottom + 1
? [button.getAttribute("aria-label")]
: [];
});
});
expect(clipped).toEqual([]);
await expect(toolbar).toHaveAttribute("aria-orientation", "horizontal");
const toolbarBox = (await toolbar.boundingBox())!;
const consoleBox = (await run.getByRole("log").boundingBox())!;
expect(consoleBox.y).toBeGreaterThanOrEqual(toolbarBox.y + toolbarBox.height - 1);
await toolbar.getByRole("button", { name: "Clear All" }).click();
await expect(run.getByText(output)).toBeHidden();
await toolbar.getByRole("button", { name: "Stop" }).click();
await expect.poll(() => ipcCalls(page, "run_stop")).toEqual([{ id: RUN_ID }]);
});
test("Go reruns keep each package's exact failures and the original configuration", async ({ workbench: page }) => {
await stubDesktop(page);
await page.evaluate(async () => {
+68 -29
Переглянути файл
@@ -13,6 +13,32 @@ async function run(page: Page, id: string) {
}, id);
}
async function stubFindMatches(page: Page) {
await stubDesktop(page);
await page.evaluate(() => {
window.__ipc.handlers.search_validate = () => null;
window.__ipc.handlers.search_start = (args) => {
const send = (event: unknown) => window.__ipc.send(args.onEvent, event);
const text = "base=http://localhost:8080";
setTimeout(() => {
for (let i = 0; i < 12; i++) {
const relPath = `config/endpoint-${i}.txt`;
const matches = [{ line: 0, text, ranges: [[5, text.length]], textOffset: 0 }];
send({
type: "file",
file: { path: `/dev/acme-api/${relPath}`, relPath, matches },
});
}
send({
type: "done",
summary: { files: 12, matches: 12, limitHit: false, cancelled: false, elapsedMs: 4 },
});
}, 20);
return null;
};
});
}
async function expectControlsFit(page: Page) {
const dialog = page.getByRole("dialog");
await expect(dialog).toBeVisible();
@@ -42,35 +68,7 @@ test.describe("search popups at the minimum window width", () => {
for (const id of ["find.inPath", "find.replaceInPath"]) {
test(`${id} keeps its title, count and buttons visible`, async ({ workbench: page }) => {
await stubDesktop(page);
await page.evaluate(() => {
window.__ipc.handlers.search_validate = () => null;
window.__ipc.handlers.search_start = (args) => {
const send = (event: unknown) => window.__ipc.send(args.onEvent, event);
const text = "base=http://localhost:8080";
setTimeout(() => {
for (let i = 0; i < 12; i++) {
const relPath = `config/endpoint-${i}.txt`;
const matches = [{ line: 0, text, ranges: [[5, text.length]], textOffset: 0 }];
send({
type: "file",
file: { path: `/dev/acme-api/${relPath}`, relPath, matches },
});
}
send({
type: "done",
summary: {
files: 12,
matches: 12,
limitHit: false,
cancelled: false,
elapsedMs: 4,
},
});
}, 20);
return null;
};
});
await stubFindMatches(page);
await run(page, id);
await page.getByRole("dialog").getByPlaceholder("Search").fill("http://localhost:8080");
await expect(page.getByRole("dialog").locator("header [aria-live]")).toContainText(/match/);
@@ -95,6 +93,19 @@ test.describe("search popups at the minimum window width", () => {
});
}
test("directory scope gives the path field room at the minimum width", async ({ workbench: page }) => {
await stubDesktop(page);
await run(page, "find.inPath");
const dialog = page.getByRole("dialog", { name: "Find in Files" });
await dialog.getByRole("tab", { name: "Directory", exact: true }).click();
const input = dialog.getByRole("textbox", { name: "Directory", exact: true });
await expect(input).toBeVisible();
const { width } = (await input.boundingBox())!;
expect(width).toBeGreaterThan(200);
await expectControlsFit(page);
await dialog.getByRole("button", { name: /Browse/ }).click({ trial: true });
});
for (const id of [
"navigate.searchEverywhere",
"navigate.searchText",
@@ -111,3 +122,31 @@ test.describe("search popups at the minimum window width", () => {
});
}
});
test("Find in Files prioritizes the preview and remembers an adjusted split", async ({ workbench: page }) => {
await stubFindMatches(page);
await run(page, "find.inPath");
const dialog = page.getByRole("dialog", { name: "Find in Files" });
await dialog.getByPlaceholder("Search").fill("http://localhost:8080");
const results = dialog.locator("[data-panel][id=results]");
const preview = dialog.locator("[data-panel][id=preview]");
const handle = dialog.getByTestId("find-popup-split").getByRole("separator");
const resultsShare = async () => {
const resultHeight = (await results.boundingBox())!.height;
const previewHeight = (await preview.boundingBox())!.height;
return resultHeight / (resultHeight + previewHeight);
};
await expect(handle).toBeAttached();
await expect.poll(resultsShare).toBeCloseTo(0.33, 2);
await handle.press("ArrowUp");
await expect.poll(resultsShare).toBeLessThan(0.31);
const adjusted = await resultsShare();
await page.setViewportSize({ width: 400, height: 500 });
await expect.poll(resultsShare).toBeGreaterThan(adjusted + 0.02);
await dialog.getByPlaceholder("Search").press("Escape");
await expect(dialog).toBeHidden();
await page.setViewportSize({ width: 1400, height: 900 });
await run(page, "find.inPath");
await expect(handle).toBeAttached();
await expect.poll(resultsShare).toBeCloseTo(adjusted, 2);
});
+37
Переглянути файл
@@ -0,0 +1,37 @@
import { expect, test } from "./fixtures";
test("keeps the file count visible beside a long directory in the TODO pane", async ({ workbench: page }) => {
await page.setViewportSize({ width: 900, height: 760 });
await page.evaluate(async () => {
const projectModule = "/src/platform/project.ts";
const todoModule = "/src/features/todo/store.ts";
const { useProject } = await import(/* @vite-ignore */ projectModule);
const { useTodos } = await import(/* @vite-ignore */ todoModule);
const directory = "src/features/checkout/shared/services/with-a-long-directory-name/for-order-processing";
const path = `${useProject.getState().project.root}/${directory}/orders.ts`;
useTodos.setState({
scannedOnce: true,
error: null,
scanned: new Map([[path, [{ path, line: 8, col: 3, keyword: "TODO", text: "TODO: validate orders" }]]]),
});
});
await page.getByRole("button", { name: "TODO" }).click();
const pane = page.locator('[data-toolwindow="todo"]');
const toolbar = pane.getByRole("toolbar", { name: "TODO actions" });
await expect(toolbar).toHaveAttribute("aria-orientation", "vertical");
const tree = pane.getByRole("tree", { name: "TODO items" });
const fileName = tree.getByText("orders.ts", { exact: true });
await expect(fileName).toBeVisible();
await expect.poll(() => fileName.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true);
const count = tree.getByText("1 item", { exact: true });
await expect(count).toBeVisible();
await expect
.poll(() =>
count.evaluate(
(element) =>
element.getBoundingClientRect().right <= element.closest('[role="tree"]')!.getBoundingClientRect().right,
),
)
.toBe(true);
});
+107
Переглянути файл
@@ -0,0 +1,107 @@
import type { Page } from "@playwright/test";
import { expect, stubDesktop, test } from "./fixtures";
const FILE = "/dev/acme-api/command-line.txt";
async function openEditor(page: Page) {
const editor = page.locator(".cm-editor").first();
await expect(editor).toHaveAttribute("data-openidea-vim", "true");
await editor.locator(".cm-content").click();
return editor;
}
/** Computed type of one element: `null` when it is not in the DOM. */
function fontOf(page: Page, selector: string) {
return page.evaluate((sel) => {
const el = document.querySelector(sel);
if (!el) return null;
const style = getComputedStyle(el);
return {
family: style.fontFamily,
size: style.fontSize,
ligatures: style.fontVariantLigatures,
};
}, selector);
}
test.beforeEach(async ({ page }) => {
test.setTimeout(180_000);
await page.addInitScript(() =>
localStorage.setItem("openidea.vim.v1", JSON.stringify({ enabled: true, handlers: {} })),
);
await page.goto("/");
await expect(page.getByRole("tree", { name: "Project" })).toBeVisible();
await stubDesktop(page);
await page.evaluate(async (path) => {
const backendPath = "/src/editor/core/backend.ts";
const contributionsPath = "/src/workbench/contributions.ts";
const { docBackend } = await import(backendPath);
const { editorService } = await import(contributionsPath);
docBackend().files.set(path, "alpha\nbravo\ncharlie\n");
await editorService().openFile(path);
}, FILE);
await openEditor(page);
});
test("the command line renders in the editor's font", async ({ page }) => {
await page.keyboard.press(":");
await expect(page.locator(".cm-vim-panel input")).toBeVisible();
await page.keyboard.type("echo hello");
const prompt = await fontOf(page, ".cm-vim-panel input");
// The package puts the prefix in a span with an inline `font-family: monospace`.
const prefix = await fontOf(page, ".cm-vim-panel span");
const body = await fontOf(page, ".cm-scroller");
expect(prompt).not.toBeNull();
expect(prefix).not.toBeNull();
expect(body).not.toBeNull();
expect(prompt!.family).toBe(body!.family);
expect(prompt!.size).toBe(body!.size);
expect(prefix!.family).toBe(prompt!.family);
expect(prefix!.size).toBe(prompt!.size);
// The browser's generic monospace (Consolas under WebView2) is what we are moving away from.
expect(prompt!.family).not.toBe("monospace");
expect(prompt!.ligatures).toBe("none");
await page.keyboard.press("Escape");
});
test("the search prompt shares the command line's font", async ({ page }) => {
await page.keyboard.press("/");
await expect(page.locator(".cm-vim-panel input")).toBeVisible();
await page.keyboard.type("alpha");
const prompt = await fontOf(page, ".cm-vim-panel input");
const body = await fontOf(page, ".cm-scroller");
expect(prompt).not.toBeNull();
expect(body).not.toBeNull();
expect(prompt!.family).toBe(body!.family);
expect(prompt!.size).toBe(body!.size);
await page.keyboard.press("Escape");
});
test("the command line follows the editor's font variables", async ({ page }) => {
// What Editor › Font and the zoom field write on the editor root.
await page.evaluate(() => {
const editor = document.querySelector<HTMLElement>(".cm-editor")!;
editor.style.setProperty("--openidea-editor-font", '"Sentinel Mono"');
editor.style.setProperty("--openidea-editor-font-size", "21px");
});
await page.keyboard.press(":");
await expect(page.locator(".cm-vim-panel input")).toBeVisible();
await page.keyboard.type("echo");
const prompt = await fontOf(page, ".cm-vim-panel input");
const body = await fontOf(page, ".cm-scroller");
expect(prompt).not.toBeNull();
expect(body).not.toBeNull();
expect(prompt!.family).toContain("Sentinel Mono");
expect(prompt!.size).toBe("21px");
expect(prompt!.family).toBe(body!.family);
expect(prompt!.size).toBe(body!.size);
await page.keyboard.press("Escape");
});
+69 -36
Переглянути файл
@@ -7,6 +7,8 @@ import { join } from "node:path";
import { track } from "../lib/measure.ts";
import { normalizePath, type EvalScenario, type Measured } from "../lib/scenario.ts";
import type { Session } from "../lib/session.ts";
import { renameFinished, renameResult, type RenameStep } from "../lib/renameObservation.ts";
import type { Renamed } from "../../src/bindings.ts";
const SRC = "src/main/java/com/example/orders";
const TEST = "src/test/java/com/example/orders";
@@ -17,7 +19,7 @@ const LONG_TIMEOUT = 60_000;
interface ProbeWindow {
__openideaPerf: {
editorState(): { path: string; head: number; line: number; word: string } | null;
editorState(): { doc: number; path: string; head: number; line: number; col: number; word: string } | null;
editorText(): string | null;
setCursor(offset: number): void;
insertAfter(after: string, text: string): number;
@@ -25,6 +27,8 @@ interface ProbeWindow {
completionPending(): boolean;
diagnostics(): Array<{ line: number; severity: string; message: string }>;
lineAtY(y: number): number;
openFileForDiagnostics(path: string, source: string): Promise<number>;
diagnosticsPublished(generation: number): boolean;
};
}
@@ -373,10 +377,21 @@ function diagnosticsOnOpen(project: string, id: string, title: string, file: str
async setup() {},
async step(s): Promise<Measured> {
const timing = await track(s.page, {
openFile: join(s.root, file),
arg: null,
first: () => !!document.querySelector(".cm-content .cm-line"),
done: () => true,
run: async (arg) => {
const w = window as unknown as ProbeWindow;
arg.generation = await w.__openideaPerf.openFileForDiagnostics(arg.path, "jdtls");
},
arg: { path: join(s.root, file), generation: 0 },
first: (arg) => {
const w = window as unknown as ProbeWindow;
return (
w.__openideaPerf.diagnosticsPublished(arg.generation) && !!document.querySelector(".cm-content .cm-line")
);
},
done: (arg) => {
const w = window as unknown as ProbeWindow;
return w.__openideaPerf.diagnosticsPublished(arg.generation);
},
signature: problems,
settleMs: 3000,
timeoutMs: TIMEOUT,
@@ -514,12 +529,19 @@ function quickDoc(project: string, id: string, title: string, at: Place): EvalSc
};
}
interface RenameAnswer {
edit: { files: Array<{ path?: string; edits?: Array<{ range: { start: { line: number } }; new_text: string }> }> };
}
/** Rename in place to `newName`, then ↵: every edit it makes (a preview is left unapplied). */
function rename(project: string, id: string, title: string, at: Place, newName: string): EvalScenario {
function rename(
project: string,
id: string,
title: string,
at: Place,
newName: string,
mode: RenameStep["mode"],
): EvalScenario {
const prepared = new WeakMap<
Session,
{ doc: number; path: string; pos: { line: number; col: number }; original: string }
>();
return {
id,
title,
@@ -528,23 +550,39 @@ function rename(project: string, id: string, title: string, at: Place, newName:
conditions: ["warm"],
async setup(s) {
await reach(s, at);
const before = await s.page.evaluate(() => {
const w = window as unknown as ProbeWindow;
const state = w.__openideaPerf.editorState();
const original = w.__openideaPerf.editorText();
if (!state || original === null) throw new Error("no active editor before rename");
return { doc: state.doc, path: state.path, pos: { line: state.line, col: state.col }, original };
});
prepared.set(s, before);
await s.keepText();
await s.runAction("refactor.rename");
await s.page.waitForSelector(".cm-lsp-inplace-primary", { timeout: TIMEOUT });
await s.page.keyboard.type(newName);
},
async step(s): Promise<Measured> {
const answered = (newName: string) => {
if (document.querySelector('[data-testid="refactor-preview"]')) return true;
if (document.querySelector(".cm-lsp-hint:not([data-pending]):not(.cm-lsp-inplace-hint)")) return true;
return (
!document.querySelector(".cm-lsp-inplace") &&
!!(window as unknown as ProbeWindow).__openideaPerf.editorText()?.includes(newName)
);
const before = prepared.get(s);
if (!before) throw new Error("rename was not prepared");
const scope = s.renameObservations.begin({ doc: before.doc, pos: before.pos, newName });
const arg: RenameStep = {
scope,
root: s.root,
path: before.path,
original: before.original,
oldName: at.word,
newName,
mode,
answer: null,
};
const timing = await track(s.page, {
run: () =>
document.querySelector(".cm-content")?.dispatchEvent(
run: async (arg) => {
const w = window as unknown as { __openideaEvalRenameAnswer(scope: number): Promise<Renamed> };
const content = document.querySelector(".cm-content");
if (!content) throw new Error("no editor for rename");
content.dispatchEvent(
new KeyboardEvent("keydown", {
key: "Enter",
code: "Enter",
@@ -552,25 +590,17 @@ function rename(project: string, id: string, title: string, at: Place, newName:
bubbles: true,
cancelable: true,
}),
),
arg: newName,
first: answered,
done: answered,
);
arg.answer = await w.__openideaEvalRenameAnswer(arg.scope);
},
arg,
first: renameFinished,
done: renameFinished,
timeoutMs: TIMEOUT,
});
// The preview only counts per file: where the name lands is in the answer it shows. A server
// may merge nearby occurrences into one edit, so every line of its new text counts.
const answer = s.lastAnswer.get("lsp_rename") as RenameAnswer | undefined;
const changes = (answer?.edit.files ?? []).flatMap((f) =>
(f.edits ?? []).flatMap((e) =>
e.new_text
.split("\n")
.flatMap((l, i) =>
l.includes(newName) ? [`${normalizePath(s.root, f.path!)}:${e.range.start.line + i + 1}`] : [],
),
),
);
return { timing, results: { changes } };
const answer = s.renameObservations.completed(scope) as Renamed | null;
if (!answer) throw new Error("rename did not receive a current successful response");
return { timing, ...renameResult(s.root, answer, newName) };
},
};
}
@@ -748,6 +778,7 @@ export const JAVA_SCENARIOS: EvalScenario[] = [
"Rename: method used across files",
{ file: `${SRC}/Order.java`, line: "public long totalCents() {", word: "totalCents" },
"orderTotalCents",
"preview",
),
rename(
APP,
@@ -755,6 +786,7 @@ export const JAVA_SCENARIOS: EvalScenario[] = [
"Rename: local variable",
{ file: BOOK, line: "Order order = new Order(customer, product, quantity, unitPriceCents);", word: "order" },
"placedOrder",
"applied",
),
declaration(
@@ -837,5 +869,6 @@ export const JAVA_SCENARIOS: EvalScenario[] = [
"Rename: entity method used across controllers and tests",
{ file: `${PET}/owner/Owner.java`, line: "public void addVisit(Integer petId, Visit visit) {", word: "addVisit" },
"recordVisit",
"preview",
),
];
+29
Переглянути файл
@@ -0,0 +1,29 @@
import { spawnSync } from "node:child_process";
import { resolve } from "node:path";
import { describe, expect, test } from "vitest";
const runner = resolve(import.meta.dirname, "../run.ts");
describe("eval CLI preflight (no app builds)", () => {
test.each([
[["--condition", "hot"], /--condition must be warm or cold/],
[["--only", "java.app,unknown"], /no scenario matches unknown/],
[["--only", "java.app,"], /empty selector/],
[["--only", "java.app.usages", "--condition", "cold"], /no compatible scenario/],
[["--runs", "0"], /--runs/],
[["--runs", "Infinity"], /--runs/],
[["--runs", "1.5"], /--runs/],
[["--warmup", "NaN"], /--warmup/],
[["--warmup=-1"], /--warmup/],
] as const)("rejects %j before build/start", (args, message) => {
const result = spawnSync(process.execPath, [runner, ...args], {
encoding: "utf8",
timeout: 15_000,
env: { ...process.env, PATH: "", OPENIDEA_SERVER: "/nonexistent/eval-preflight-server" },
});
expect(result.error).toBeUndefined();
expect(result.status).not.toBe(0);
expect(result.stderr).toMatch(message);
expect(result.stdout).not.toContain("Building openidea-server");
});
});
+91
Переглянути файл
@@ -0,0 +1,91 @@
import { describe, expect, test } from "vitest";
import { RenameObservations } from "./commandObservation.ts";
const target = { doc: 7, pos: { line: 2, col: 8 }, newName: "renamed" };
const answer = { edit: { files: [] }, incomplete: null };
function deferred() {
let resolve!: (value: unknown) => void;
// The harness TypeScript project targets ES2023.
const promise = new Promise<unknown>((done) => {
resolve = done;
});
return { promise, resolve };
}
describe("rename command observations", () => {
test("consumes only a matching command in the current operation", async () => {
const capture = new RenameObservations();
const scope = capture.begin(target);
await capture.invoke("lsp_rename", { ...target, doc: 8, request: 1 }, async () => answer);
await capture.invoke("lsp_rename", { ...target, newName: "other", request: 2 }, async () => answer);
await capture.invoke("lsp_rename", { ...target, pos: { line: 3, col: 8 }, request: 3 }, async () => answer);
expect(capture.completed(scope)).toBeNull();
await capture.invoke("lsp_rename", { ...target, request: 4 }, async () => answer);
expect(await capture.wait(scope)).toEqual(answer);
});
test("reset and failure cannot supply a preceding success", async () => {
const capture = new RenameObservations();
const previous = capture.begin(target);
await capture.invoke("lsp_rename", { ...target, request: 1 }, async () => answer);
capture.reset();
expect(capture.completed(previous)).toBeNull();
await expect(capture.wait(previous)).rejects.toThrow("operation expired");
const current = capture.begin(target);
const waiting = capture.wait(current);
const rejected = expect(waiting).rejects.toThrow("rename failed");
await expect(
capture.invoke("lsp_rename", { ...target, request: 2 }, async () => {
throw new Error("rename failed");
}),
).rejects.toThrow("rename failed");
await rejected;
expect(capture.completed(current)).toBeNull();
});
test("a failed retry clears a success in the same operation", async () => {
const capture = new RenameObservations();
const scope = capture.begin(target);
await capture.invoke("lsp_rename", { ...target, request: 1 }, async () => answer);
expect(capture.completed(scope)).toEqual(answer);
await expect(
capture.invoke("lsp_rename", { ...target, request: 2 }, async () => {
throw new Error("retry failed");
}),
).rejects.toThrow("retry failed");
expect(capture.completed(scope)).toBeNull();
await expect(capture.wait(scope)).rejects.toThrow("retry failed");
});
test("a delayed result from before reset cannot win over a new request", async () => {
const capture = new RenameObservations();
capture.begin(target);
const old = deferred();
const sending = capture.invoke("lsp_rename", { ...target, request: 1 }, () => old.promise);
capture.reset();
const current = capture.begin(target);
old.resolve(answer);
await sending;
expect(capture.completed(current)).toBeNull();
const fresh = { ...answer, preview: true };
await capture.invoke("lsp_rename", { ...target, request: 2 }, async () => fresh);
expect(await capture.wait(current)).toEqual(fresh);
});
test("a superseded in-flight request cannot overwrite the latest failure", async () => {
const capture = new RenameObservations();
const scope = capture.begin(target);
const old = deferred();
const sending = capture.invoke("lsp_rename", { ...target, request: 1 }, () => old.promise);
await expect(
capture.invoke("lsp_rename", { ...target, request: 2 }, async () => {
throw new Error("latest failed");
}),
).rejects.toThrow("latest failed");
old.resolve(answer);
await sending;
expect(capture.completed(scope)).toBeNull();
await expect(capture.wait(scope)).rejects.toThrow("latest failed");
});
});
+74
Переглянути файл
@@ -0,0 +1,74 @@
/** Command capture shared by the Session relay and rename's measured operation. */
export interface RenameTarget {
doc: number;
pos: { line: number; col: number };
newName: string;
}
interface Operation {
scope: number;
target: RenameTarget;
request: number;
result: { ok: true; value: unknown } | { ok: false; error: unknown } | null;
listeners: Array<{ resolve(value: unknown): void; reject(error: unknown): void }>;
}
export class RenameObservations {
private generation = 0;
private operation: Operation | null = null;
begin(target: RenameTarget): number {
this.reset();
this.operation = { scope: this.generation, target, request: 0, result: null, listeners: [] };
return this.generation;
}
reset() {
this.generation++;
for (const listener of this.operation?.listeners ?? []) listener.reject(new Error("rename operation expired"));
this.operation = null;
}
/** Captures the invocation, not just its answer: old requests retain their original scope. */
async invoke<T>(cmd: string, args: unknown, send: () => Promise<T>): Promise<T> {
const op = this.operation;
const actual = args as Partial<RenameTarget> | null;
const matching =
cmd === "lsp_rename" &&
op &&
actual &&
actual.doc === op.target.doc &&
actual.newName === op.target.newName &&
actual.pos?.line === op.target.pos.line &&
actual.pos?.col === op.target.pos.col;
const request = matching ? ++op.request : 0;
if (matching) op.result = null;
try {
const value = await send();
if (matching && this.operation === op && op.request === request) {
op.result = { ok: true, value };
for (const listener of op.listeners.splice(0)) listener.resolve(value);
}
return value;
} catch (error) {
if (matching && this.operation === op && op.request === request) {
op.result = { ok: false, error };
for (const listener of op.listeners.splice(0)) listener.reject(error);
}
throw error;
}
}
completed(scope: number): unknown | null {
const op = this.operation;
return op?.scope === scope && op.result?.ok ? op.result.value : null;
}
wait(scope: number): Promise<unknown> {
const op = this.operation;
if (!op || op.scope !== scope) return Promise.reject(new Error("rename operation expired"));
if (op.result) return op.result.ok ? Promise.resolve(op.result.value) : Promise.reject(op.result.error);
// ES2023 harnesses cannot use Promise.withResolvers().
return new Promise((resolve, reject) => op.listeners.push({ resolve, reject }));
}
}
+10 -2
Переглянути файл
@@ -37,7 +37,11 @@ export function pinnedTools(file: string): Record<string, string> {
function which(cmd: string): string | null {
try {
const found = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], { encoding: "utf8" })
const found = execFileSync(process.platform === "win32" ? "where" : "which", [cmd], {
encoding: "utf8",
timeout: 10_000,
killSignal: "SIGKILL",
})
.split("\n")[0]!
.trim();
return found ? realpathSync(found) : null;
@@ -69,7 +73,11 @@ function jdtlsVersion(): string | null {
function javaVersion(): string | null {
const home = process.env.JAVA_HOME;
const java = home ? join(home, "bin", process.platform === "win32" ? "java.exe" : "java") : "java";
const r = spawnSync(java, ["-XshowSettings:properties", "-version"], { encoding: "utf8" });
const r = spawnSync(java, ["-XshowSettings:properties", "-version"], {
encoding: "utf8",
timeout: 10_000,
killSignal: "SIGKILL",
});
const props = `${r.stdout ?? ""}${r.stderr ?? ""}`;
const version = /java\.runtime\.version = (\S+)/.exec(props)?.[1];
const vendor = /java\.vendor = (.+)/.exec(props)?.[1]?.trim();
+77
Переглянути файл
@@ -0,0 +1,77 @@
// @vitest-environment node
import { chromium, type Browser, type Page } from "@playwright/test";
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
import { track } from "./measure.ts";
let browser: Browser;
let page: Page;
beforeAll(async () => {
browser = await chromium.launch({ headless: true });
});
beforeEach(async () => {
page = await browser.newPage();
await page.setContent('<div role="dialog">Previous dialog</div><div id="result">Previous result</div>');
await page.evaluate(() => {
Object.assign(window, {
__openideaPerf: {
editorState: () => null,
runAction: async () => false,
},
});
});
});
afterEach(async () => {
await page.close();
});
afterAll(async () => {
await browser.close();
});
const existingResult = () => document.querySelector("#result") !== null;
describe("tracking the current action", () => {
it("rejects an action that declines to run even with an old result visible", async () => {
await expect(
track(page, { action: "unavailable", arg: null, first: existingResult, done: existingResult, timeoutMs: 1000 }),
).rejects.toThrow(/did not run/);
});
it("cannot report success before an asynchronous action later rejects", async () => {
await expect(
track(page, {
// Real browser frames exercise ordering against track's rAF observer; no elapsed-time guess.
run: () =>
new Promise((_, reject) => {
requestAnimationFrame(() => requestAnimationFrame(() => reject(new Error("operation failed"))));
}),
arg: null,
first: existingResult,
done: existingResult,
timeoutMs: 1000,
}),
).rejects.toThrow("operation failed");
});
it("waits for successful action completion and observes its current result", async () => {
const timing = await track(page, {
run: () =>
new Promise<void>((resolve) => {
requestAnimationFrame(() => {
document.querySelector("#result")!.textContent = "Current result";
requestAnimationFrame(() => {
document.querySelector("#result")!.setAttribute("data-completed", "true");
resolve();
});
});
}),
arg: null,
first: () => document.querySelector("#result")?.textContent === "Current result",
done: () => document.querySelector("#result")?.textContent === "Current result",
timeoutMs: 1000,
});
expect(await page.locator("#result").textContent()).toBe("Current result");
expect(timing.completeMs).toBeGreaterThanOrEqual(timing.firstResultMs);
expect(timing.feedbackMs).toBeGreaterThanOrEqual(timing.firstResultMs);
expect(await page.locator("#result").getAttribute("data-completed")).toBe("true");
});
});
+46 -14
Переглянути файл
@@ -3,6 +3,7 @@
* what the user would see. A condition true at the start of a frame is painted by it.
*/
import type { Page } from "@playwright/test";
import { withDeadline } from "../../perf/lib/lifecycle.ts";
/**
* A check of the page, run in it every frame: self-contained (it is re-created from its
@@ -55,7 +56,7 @@ export class TimeoutError extends Error {
}
export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked> {
const r = await page.evaluate(
const operation = page.evaluate(
({ action, actionArg, openFile, run, arg, first, done, feedback, signature, settleMs, timeoutMs }) => {
const w = window as unknown as {
__openideaPerf: {
@@ -75,26 +76,57 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
let lastSig: string | null = null;
let lastChange = 0;
const before = w.__openideaPerf.editorState();
const visible = (sel: string) =>
[...document.querySelectorAll(sel)].some((el) => (el as HTMLElement).getClientRects().length > 0);
const feedbackSelector = '.cm-lsp-hint, [data-testid="usages-popup"], [role="dialog"], [role="listbox"]';
const beforeFeedback = new Map<Element, { text: string | null; loading: string | null; busy: string | null }>();
for (const el of document.querySelectorAll(feedbackSelector)) {
if (el.getClientRects().length) {
beforeFeedback.set(el, {
text: el.textContent,
loading: el.getAttribute("data-loading"),
busy: el.getAttribute("aria-busy"),
});
}
}
const anyFeedback = () => {
if (visible('.cm-lsp-hint, [data-testid="usages-popup"], [role="dialog"], [role="listbox"]')) return true;
for (const el of document.querySelectorAll(feedbackSelector)) {
if (!el.getClientRects().length) continue;
const previous = beforeFeedback.get(el);
if (
!previous ||
previous.text !== el.textContent ||
previous.loading !== el.getAttribute("data-loading") ||
previous.busy !== el.getAttribute("aria-busy")
)
return true;
}
const now = w.__openideaPerf.editorState();
if ((now?.path ?? null) !== (before?.path ?? null) || (now && before && now.head !== before.head)) return true;
return checks.feedback?.(arg, before) ?? false;
};
const times: { feedbackMs?: number; firstResultMs?: number; completeMs?: number } = {};
const t0 = performance.now();
let failed: unknown = null;
const started = run
? new Promise((resolve) => resolve(make(run)!(arg, before)))
: openFile
? w.__openideaPerf.openFile(openFile)
: w.__openideaPerf.runAction(action!, actionArg);
void started.catch((e: unknown) => (failed = e));
let completed = false;
let failed: string | null = null;
const started = Promise.resolve().then<unknown>(() =>
run
? make(run)!(arg, before)
: openFile
? w.__openideaPerf.openFile(openFile)
: w.__openideaPerf.runAction(action!, actionArg),
);
void started.then(
(value) => {
if (!run && !openFile && value !== true) failed = "action did not run";
else completed = true;
},
(error: unknown) => {
failed = error instanceof Error ? error.message : String(error);
},
);
return new Promise<{ times: typeof times; timedOut: boolean; error: string | null }>((resolve) => {
const tick = () => {
const t = performance.now() - t0;
if (failed !== null) return resolve({ times, timedOut: false, error: failed });
try {
if (times.feedbackMs === undefined && anyFeedback()) times.feedbackMs = t;
if (times.firstResultMs === undefined && checks.first(arg, before)) times.firstResultMs = t;
@@ -106,7 +138,7 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
}
}
const settled = !sign || t - lastChange >= (settleMs ?? 0);
if (times.firstResultMs !== undefined && settled && checks.done(arg, before)) {
if (completed && times.firstResultMs !== undefined && settled && checks.done(arg, before)) {
// Session.reset waits out the time in which invoking it again widens it.
if (action === "find.showUsages")
(window as unknown as { __openideaEvalShowUsagesAt?: number }).__openideaEvalShowUsagesAt =
@@ -118,7 +150,6 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
} catch (e) {
return resolve({ times, timedOut: false, error: String(e) });
}
if (failed) return resolve({ times, timedOut: false, error: String((failed as Error).message ?? failed) });
if (t > timeoutMs) return resolve({ times, timedOut: true, error: null });
requestAnimationFrame(tick);
};
@@ -139,8 +170,9 @@ export async function track<A>(page: Page, spec: TrackSpec<A>): Promise<Tracked>
timeoutMs: spec.timeoutMs,
},
);
const r = await withDeadline(operation, spec.timeoutMs + 1000, "page measurement");
const what = spec.action ?? (spec.openFile ? `open ${spec.openFile}` : "step");
if (r.error) throw new Error(`${what}: ${r.error}`);
if (r.error !== null) throw new Error(`${what}: ${r.error}`);
if (r.timedOut) {
const seen =
r.times.firstResultMs !== undefined
+26
Переглянути файл
@@ -0,0 +1,26 @@
// @vitest-environment node
import { expect, test } from "vitest";
import { launchBrowser } from "../../perf/lib/lifecycle.ts";
import { track } from "./measure.ts";
test("track times out on Node's clock when animation frames stop", { timeout: 20_000 }, async () => {
const runtime = await launchBrowser({ headless: true });
try {
const page = await runtime.browser.newPage();
await page.evaluate(() => {
// Install the otherwise undeclared probe consumed by the serialized measurement.
const w = window as unknown as { __openideaPerf: unknown };
w.__openideaPerf = {
editorState: () => null,
runAction: async () => true,
};
window.requestAnimationFrame = () => 0;
});
// The platform-clock boundary is the regression; a fake Node clock cannot drive Chromium.
await expect(
track(page, { action: "fixture.action", arg: null, first: () => false, done: () => false, timeoutMs: 20 }),
).rejects.toThrow("page measurement timed out");
} finally {
await runtime.close();
}
});
+104
Переглянути файл
@@ -0,0 +1,104 @@
import { afterEach, expect, test } from "vitest";
import { renameFinished, renameResult, type RenameStep } from "./renameObservation.ts";
import type { Renamed } from "../../src/bindings.ts";
const original = "int order = 1;\nuse(order);";
const answer: Renamed = {
edit: {
files: [
{
kind: "edit",
path: "/p/A.java",
edits: [
{ range: { start: { line: 0, col: 4 }, end: { line: 0, col: 9 } }, new_text: "placedOrder" },
{ range: { start: { line: 1, col: 4 }, end: { line: 1, col: 9 } }, new_text: "placedOrder" },
],
},
],
},
incomplete: null,
};
const step: RenameStep = {
scope: 1,
path: "/p/A.java",
root: "/p",
oldName: "order",
newName: "placedOrder",
original,
mode: "applied",
answer,
};
let text = original;
let state = { path: step.path, word: "order", head: 9, line: 0 };
const w = window as unknown as { __openideaPerf?: unknown };
function fixture() {
w.__openideaPerf = { editorText: () => text, editorState: () => state };
document.body.innerHTML = '<div class="cm-content"><div class="cm-line"></div></div>';
}
afterEach(() => {
document.body.innerHTML = "";
delete w.__openideaPerf;
text = original;
state = { path: step.path, word: "order", head: 9, line: 0 };
});
test("a successful response and typed new name are not an applied rename", () => {
fixture();
document.body.insertAdjacentHTML("beforeend", '<span class="cm-lsp-hint">Rename failed</span>');
text = original.replace("order", "placedOrder");
expect(renameFinished(step)).toBe(false);
text = original.replaceAll("order", "placedOrder");
state = { ...state, word: "placedOrder", head: 14 };
expect(renameFinished(step)).toBe(false);
document.querySelector(".cm-lsp-hint")!.remove();
expect(renameFinished(step)).toBe(true);
expect(renameFinished({ ...step, answer: null })).toBe(false);
state = { ...state, path: "/p/other.java" };
expect(renameFinished(step)).toBe(false);
});
test("preview requires the matching title, files and counts without applying text", () => {
fixture();
const preview: RenameStep = { ...step, mode: "preview" };
document.body.insertAdjacentHTML(
"beforeend",
'<div role="dialog"><h2>Rename \'order\' to \'placedOrder\'</h2><ul data-testid="refactor-preview"><li><span title="A.java">A.java</span><span>2 occurrences</span></li></ul></div>',
);
expect(renameFinished(preview)).toBe(true);
expect(renameFinished(step)).toBe(false);
text = original.replaceAll("order", "placedOrder");
expect(renameFinished(preview)).toBe(false);
text = original;
document.querySelector("[title]")!.setAttribute("title", "other.java");
expect(renameFinished(preview)).toBe(false);
});
test("incomplete responses retain warning identity instead of claiming local application", () => {
fixture();
text = original.replaceAll("order", "placedOrder");
state = { ...state, word: "placedOrder", head: 14 };
expect(renameFinished({ ...step, answer: { ...answer, incomplete: "indexing" } })).toBe(false);
const incomplete: Renamed = { ...answer, incomplete: "indexing" };
expect(renameResult("/p", incomplete, "placedOrder")).toEqual({
results: { changes: ["A.java:1", "A.java:2"] },
degraded: "Rename may be incomplete: indexing",
});
text = original;
document.body.insertAdjacentHTML(
"beforeend",
'<div role="dialog"><h2>Rename \'order\' to \'placedOrder\'</h2><div role="note">May be incomplete: the language server is still indexing</div><ul data-testid="refactor-preview"><li><span title="A.java">A.java</span><span>2 occurrences</span></li></ul></div>',
);
expect(renameFinished({ ...step, answer: incomplete })).toBe(true);
expect(renameResult("/p", answer, "placedOrder").degraded).toBeNull();
});
test("an incomplete empty answer reports degradation only with its warning, never a terminal error", () => {
fixture();
const incomplete: Renamed = { edit: { files: [] }, incomplete: "indexing" };
document.body.insertAdjacentHTML("beforeend", '<span class="cm-lsp-hint">Rename failed</span>');
expect(renameFinished({ ...step, answer: incomplete })).toBe(false);
document.querySelector(".cm-lsp-hint")!.textContent = "May be incomplete: the language server is still indexing";
expect(renameFinished({ ...step, answer: incomplete })).toBe(true);
expect(renameResult("/p", incomplete, "placedOrder").degraded).toBe("Rename may be incomplete: indexing");
expect(renameFinished({ ...step, answer: { edit: { files: [] }, incomplete: null } })).toBe(false);
});
+121
Переглянути файл
@@ -0,0 +1,121 @@
import { normalizePath } from "./scenario.ts";
import type { Renamed } from "../../src/bindings.ts";
export interface RenameStep {
scope: number;
root: string;
path: string;
original: string;
oldName: string;
newName: string;
mode: "preview" | "applied";
answer: Renamed | null;
}
/** Self-contained: track serializes this check into the measured page. */
export function renameFinished(arg: RenameStep): boolean {
const answer = arg.answer;
if (!answer || document.querySelector(".cm-lsp-inplace")) return false;
type ProbeWindow = {
__openideaPerf: {
editorText(): string | null;
editorState(): { path: string; head: number; word: string } | null;
};
};
const w = window as unknown as ProbeWindow;
const probe = w.__openideaPerf;
const state = probe.editorState();
const text = probe.editorText();
if (state?.path !== arg.path || text === null) return false;
if (!answer.edit.files.length) {
return (
text === arg.original &&
!!answer.incomplete &&
/may be incomplete/i.test(document.querySelector(".cm-lsp-hint:not([data-pending])")?.textContent ?? "")
);
}
if (document.querySelector(".cm-lsp-hint:not([data-pending]):not(.cm-lsp-inplace-hint)")) return false;
const preview = document.querySelector('[data-testid="refactor-preview"]');
if (arg.mode === "preview" || answer.incomplete) {
if (!preview || text !== arg.original) return false;
const dialog = preview.closest('[role="dialog"]');
const title = dialog?.querySelector('h1, h2, [data-slot="dialog-title"]')?.textContent ?? dialog?.textContent ?? "";
if (!title.includes(`'${arg.oldName}'`) || !title.includes(`'${arg.newName}'`)) return false;
if (answer.incomplete && !dialog?.querySelector('[role="note"]')) return false;
const entries = new Map<string, { edits: number; operation?: string; to?: string }>();
for (const file of answer.edit.files) {
const path = file.kind === "rename" ? file.from : file.path;
let entry = entries.get(path);
if (!entry) entries.set(path, (entry = { edits: 0 }));
if (file.kind === "edit") entry.edits += file.edits.length;
else {
entry.operation = file.kind;
if (file.kind === "rename") entry.to = file.to;
}
}
const expected = [...entries].filter(([, entry]) => entry.edits || entry.operation);
const rows = [...preview.querySelectorAll("li")];
return (
rows.length === expected.length &&
expected.every(([path, entry]) => {
const relative = path.startsWith(arg.root + "/") ? path.slice(arg.root.length + 1) : path;
const row = rows.find((row) =>
[...row.querySelectorAll("[title]")].some((el) => el.getAttribute("title") === relative),
);
if (!row) return false;
const count = `${entry.edits} ${entry.edits === 1 ? "occurrence" : "occurrences"}`;
if (entry.edits && ![...row.querySelectorAll("span")].some((el) => el.textContent === count)) return false;
if (entry.operation === "rename")
return !!entry.to && !!row.textContent?.includes(`→ ${entry.to.slice(entry.to.lastIndexOf("/") + 1)}`);
return !entry.operation || !!row.textContent?.includes(entry.operation);
})
);
}
if (preview || answer.preview || answer.edit.files.some((file) => file.kind !== "edit" || file.path !== arg.path))
return false;
const edits = answer.edit.files.flatMap((file) => (file.kind === "edit" ? file.edits : []));
if (!edits.length) return false;
const lines = arg.original.split("\n");
const offset = (pos: { line: number; col: number }) => {
if (pos.line < 0 || pos.line >= lines.length || pos.col < 0 || pos.col > lines[pos.line]!.length) return -1;
let at = pos.col;
for (let i = 0; i < pos.line; i++) at += lines[i]!.length + 1;
return at;
};
const changes = edits
.map((edit) => ({ from: offset(edit.range.start), to: offset(edit.range.end), text: edit.new_text }))
.sort((a, b) => b.from - a.from);
let expected = arg.original;
let previous = expected.length;
for (const change of changes) {
if (change.from < 0 || change.to < change.from || change.to > previous) return false;
expected = expected.slice(0, change.from) + change.text + expected.slice(change.to);
previous = change.from;
}
// Exact edit application excludes the temporary, optimistically typed in-place name.
return (
expected !== arg.original &&
text === expected &&
state.word === arg.newName &&
state.head >= 0 &&
state.head <= text.length
);
}
export function renameResult(root: string, answer: Renamed, newName: string) {
const changes = answer.edit.files.flatMap((file) =>
file.kind === "edit"
? file.edits.flatMap((edit) =>
edit.new_text
.split("\n")
.flatMap((line, i) =>
line.includes(newName) ? [`${normalizePath(root, file.path)}:${edit.range.start.line + i + 1}`] : [],
),
)
: [],
);
return {
results: { changes },
degraded: answer.incomplete ? `Rename may be incomplete: ${answer.incomplete}` : null,
};
}
+37
Переглянути файл
@@ -0,0 +1,37 @@
import { describe, expect, test } from "vitest";
import { planSelection } from "./selection.ts";
const scenarios = [
{ id: "java.a.one", title: "One", conditions: ["warm", "cold"] as const },
{ id: "java.b.two", title: "Two", conditions: ["warm"] as const },
];
describe("eval workload planning", () => {
test("full and deduplicated subset plans are independent of collected outcomes", () => {
expect(planSelection(scenarios, {}).expected).toHaveLength(3);
const plan = planSelection(scenarios, { only: " java.a, java.a.one ", condition: "cold" });
expect(plan.selected).toEqual([scenarios[0]]);
expect(plan.expected).toEqual([{ scenario: "java.a.one", title: "One", condition: "cold" }]);
});
test.each([
{ condition: "hot" },
{ only: "java.a,unknown" },
{ only: "" },
{ only: "java.a," },
{ only: "java.b", condition: "cold" },
{ only: "java.a,java.b", condition: "cold" },
{ runs: "0" },
{ runs: "NaN" },
{ runs: "Infinity" },
{ runs: "1.5" },
{ runs: "9007199254740992" },
{ warmup: "-1" },
{ warmup: "Infinity" },
{ warmup: "0.5" },
])("rejects invalid selection/counts %j", (args) => {
expect(() => planSelection(scenarios, args)).toThrow();
});
test("rejects zero work", () => {
expect(() => planSelection([], {})).toThrow(/no compatible/);
});
});
+42
Переглянути файл
@@ -0,0 +1,42 @@
import { countOption } from "../../perf/lib/options.ts";
import type { Condition } from "./verdict.ts";
interface Scenario {
id: string;
title: string;
conditions: readonly Condition[];
}
export interface ExpectedOutcome {
scenario: string;
title: string;
condition: Condition;
}
export function planSelection<T extends Scenario>(
scenarios: readonly T[],
args: { only?: string; condition?: string; runs?: string; warmup?: string },
) {
const runs = countOption("runs", args.runs ?? "3", 1);
const warmup = countOption("warmup", args.warmup ?? "1", 0);
if (args.condition !== undefined && args.condition !== "warm" && args.condition !== "cold")
throw new Error("--condition must be warm or cold");
const condition = args.condition as Condition | undefined;
const selectors = args.only?.split(",").map((s) => s.trim());
const matches = (s: T, selector: string) => s.id === selector || s.id.startsWith(`${selector}.`);
for (const selector of selectors ?? []) {
if (!selector) throw new Error("--only contains an empty selector");
const matching = scenarios.filter((s) => matches(s, selector));
if (!matching.length) throw new Error(`no scenario matches ${selector} (see --list)`);
if (!matching.some((s) => s.conditions.some((c) => !condition || c === condition)))
throw new Error(`no compatible scenario for selector ${selector} under ${condition}`);
}
const selected = scenarios.filter((s) => !selectors || selectors.some((selector) => matches(s, selector)));
const expected: ExpectedOutcome[] = selected.flatMap((s) =>
s.conditions
.filter((c) => !condition || c === condition)
.map((c) => ({ scenario: s.id, title: s.title, condition: c })),
);
if (!expected.length) throw new Error("no compatible scenarios selected");
return { selected, expected, runs, warmup, condition };
}
+71 -51
Переглянути файл
@@ -8,9 +8,12 @@ import { homedir, tmpdir } from "node:os";
import { join, sep } from "node:path";
import type { Browser, BrowserContext, Page } from "@playwright/test";
import { installInPage } from "../../perf/lib/inpage.ts";
import { withDeadline } from "../../perf/lib/lifecycle.ts";
import { Server } from "../../smoke/server.ts";
import { copyProject } from "./projects.ts";
import { installTauriShim, type ShimWindow } from "../../smoke/tauriShim.ts";
import { RenameObservations } from "./commandObservation.ts";
import { openFileMeasured } from "../../perf/lib/editing.ts";
/** How long after its answer Show Usages invoked again widens it (`HINT_MS` in code-insight/usages.ts), plus a margin. */
const SHOW_USAGES_HINT_MS = 4200;
@@ -125,11 +128,11 @@ export class Session {
private server!: Server;
private relayQueue: Promise<unknown> = Promise.resolve();
private pendingNotes: Array<[kind: "channel" | "event", a: unknown, b: unknown]> = [];
/** The last answer to each command that succeeded, for what the UI only summarises. */
readonly lastAnswer = new Map<string, unknown>();
readonly renameObservations = new RenameObservations();
/** Editors changed by a scenario: path → the text to put back. */
private readonly edited = new Map<string, string>();
readonly pageErrors: string[] = [];
private closed = false;
private constructor(opts: SessionOptions) {
this.root = join(opts.workDir, "projects", opts.fixture);
@@ -138,46 +141,71 @@ export class Session {
static async start(browser: Browser, url: string, repoRoot: string, opts: SessionOptions): Promise<Session> {
const s = new Session(opts);
copyProject(repoRoot, opts.fixture, s.root);
if (!opts.keepHome) rmSync(s.home, { recursive: true, force: true, maxRetries: 5, retryDelay: 500 });
mkdirSync(s.home, { recursive: true });
try {
await withDeadline(s.initialize(browser, url, repoRoot, opts), 5 * 60_000, "session startup");
return s;
} catch (error) {
try {
await s.close();
} catch (cleanup) {
throw new AggregateError([error, cleanup], "Session startup and cleanup failed", { cause: cleanup });
}
throw error;
}
}
s.server = await Server.start(s.home, opts.log ? { OPENIDEA_LOG: opts.log } : {});
s.server.onEvent = (target, event) => {
private async initialize(browser: Browser, url: string, repoRoot: string, opts: SessionOptions) {
copyProject(repoRoot, opts.fixture, this.root);
if (!opts.keepHome) rmSync(this.home, { recursive: true, force: true, maxRetries: 5, retryDelay: 500 });
mkdirSync(this.home, { recursive: true });
this.server = await Server.start(this.home, opts.log ? { OPENIDEA_LOG: opts.log } : {});
if (this.closed) {
await this.server.close();
throw new Error("session already closed");
}
this.server.onEvent = (target, event) => {
if (target !== null && target !== "main") return;
s.timeline.onEvent(event as { type: string });
s.notify("event", target, event);
this.timeline.onEvent(event as { type: string });
this.notify("event", target, event);
};
s.server.onChannel = (id, data) => s.notify("channel", id, data);
await s.server.invoke("project_trust_set", { path: s.root, trusted: true, folder: false });
this.server.onChannel = (id, data) => this.notify("channel", id, data);
await this.server.invoke("project_trust_set", { path: this.root, trusted: true, folder: false });
s.context = await browser.newContext({
this.context = await browser.newContext({
baseURL: url,
viewport: { width: 1400, height: 900 },
deviceScaleFactor: 1,
});
await s.context.exposeFunction("__openideaRelay", async (cmd: string, args: unknown) => {
const start = s.timeline.now();
s.timeline.inFlight++;
const answered = s.timeline.sent(cmd, start);
if (this.closed) {
await withDeadline(this.context.close(), 5000, "late session context close");
throw new Error("session already closed");
}
await this.context.exposeFunction("__openideaEvalRenameAnswer", (scope: number) =>
this.renameObservations.wait(scope),
);
await this.context.exposeFunction("__openideaRelay", async (cmd: string, args: unknown) => {
const start = this.timeline.now();
this.timeline.inFlight++;
const answered = this.timeline.sent(cmd, start);
try {
const value = await s.server.invoke(cmd, args);
s.record(cmd, start, true, value);
const value = await this.renameObservations.invoke(cmd, args, () => this.server.invoke(cmd, args));
this.record(cmd, start, true, value);
return { ok: value ?? null };
} catch (err) {
s.record(cmd, start, false, err);
this.record(cmd, start, false, err);
return { err };
} finally {
answered();
s.timeline.inFlight--;
s.timeline.lastActivity = s.timeline.now();
this.timeline.inFlight--;
this.timeline.lastActivity = this.timeline.now();
}
});
await s.context.addInitScript(installTauriShim, {
await this.context.addInitScript(installTauriShim, {
directories: { 12: tmpdir(), 21: homedir() },
sep: sep as "/" | "\\",
});
await s.context.addInitScript(() => {
await this.context.addInitScript(() => {
const w = window as unknown as ShimWindow & {
__openideaRelay(cmd: string, args: unknown): Promise<{ ok: unknown } | { err: unknown }>;
};
@@ -187,25 +215,24 @@ export class Session {
return r.ok;
};
});
await s.context.addInitScript(installInPage);
s.page = await s.context.newPage();
s.page.on("pageerror", (e) => s.pageErrors.push(e.message));
await this.context.addInitScript(installInPage);
this.page = await this.context.newPage();
this.page.on("pageerror", (e) => this.pageErrors.push(e.message));
if (process.env.OPENIDEA_EVAL_DEBUG) {
s.page.on("console", (m) => console.log("[page]", m.type(), m.text().slice(0, 300)));
s.page.on("pageerror", (e) => console.log("[pageerror]", e.message));
this.page.on("console", (m) => console.log("[page]", m.type(), m.text().slice(0, 300)));
this.page.on("pageerror", (e) => console.log("[pageerror]", e.message));
}
await s.page.goto("/");
await s.page.waitForFunction(() => "__openideaPerf" in window && "__openideaShim" in window);
await s.page.evaluate(
await this.page.goto("/");
await this.page.waitForFunction(() => "__openideaPerf" in window && "__openideaShim" in window);
await this.page.evaluate(
(root) =>
(window as unknown as { __openideaPerf: { openProject(p: string): Promise<void> } }).__openideaPerf.openProject(
root,
),
s.root,
this.root,
);
await s.page.waitForSelector('[role="tree"][aria-label="Project"] [role="treeitem"]', { timeout: 60_000 });
return s;
await this.page.waitForSelector('[role="tree"][aria-label="Project"] [role="treeitem"]', { timeout: 60_000 });
}
private record(cmd: string, start: number, ok: boolean, value: unknown) {
@@ -221,7 +248,6 @@ export class Session {
? (value as { locations: unknown[] }).locations.length
: undefined;
this.timeline.calls.push({ cmd, start, ms: this.timeline.now() - start, ok, bytes, items });
if (ok) this.lastAnswer.set(cmd, value);
}
/** Delivers server notifications in order, batched per turn of the event loop. */
@@ -263,20 +289,7 @@ export class Session {
/** Opens `rel` (project-relative, or a URI) in an editor and waits until its text is shown. */
async openFile(rel: string) {
const path = /^[a-z]+:\/\//.test(rel) ? rel : join(this.root, rel);
const bare = rel.replace(/[?#].*$/, "");
const name = bare.slice(bare.lastIndexOf("/") + 1);
await this.page.evaluate(
async ({ path, name }) => {
const w = window as unknown as {
__perf: { waitShown(s: string, t: string | null, ms: number): Promise<number> };
__openideaPerf: { openFile(p: string): Promise<void> };
};
await w.__openideaPerf.openFile(path);
await w.__perf.waitShown('[role="tab"][aria-selected="true"]', name, 30_000);
await w.__perf.waitShown(".cm-content .cm-line", null, 30_000);
},
{ path, name },
);
await this.page.evaluate(openFileMeasured, { path, timeoutMs: 30_000 });
}
/**
@@ -399,6 +412,7 @@ export class Session {
/** Back to an idle workbench: popups dismissed, edits undone, every editor closed. */
async reset() {
this.renameObservations.reset();
// Show Usages invoked again within 4 s of its hint widens the previous search: wait it out.
const since = await this.page.evaluate(() => {
const at = (window as unknown as { __openideaEvalShowUsagesAt?: number }).__openideaEvalShowUsagesAt;
@@ -419,7 +433,13 @@ export class Session {
}
async close() {
await this.context?.close().catch(() => {});
await this.server?.close();
this.closed = true;
this.renameObservations.reset();
const results = await Promise.allSettled([
this.context ? withDeadline(this.context.close(), 5000, "session context close") : Promise.resolve(),
this.server?.close(),
]);
const errors = results.flatMap((r) => (r.status === "rejected" ? [r.reason] : []));
if (errors.length) throw new AggregateError(errors, "Session cleanup failed");
}
}
+46 -4
Переглянути файл
@@ -20,10 +20,11 @@ const outcome = (o: Partial<Outcome>): Outcome => ({
});
const repro = () => "pnpm eval --only usages";
const expected = [{ scenario: "usages", title: "Show Usages", condition: "warm" as const }];
describe("judge", () => {
test("within budgets and matching the golden passes", () => {
const [v] = judge([outcome({})], budgets, null, repro);
const [v] = judge([outcome({})], budgets, null, repro, expected);
expect(v).toMatchObject({ id: "usages@warm", status: "pass", failures: [], repro: "pnpm eval --only usages" });
});
@@ -39,6 +40,7 @@ describe("judge", () => {
budgets,
null,
repro,
expected,
);
expect(v!.status).toBe("fail");
expect(v!.failures.map((f) => [f.kind, f.metric])).toEqual([
@@ -52,21 +54,29 @@ describe("judge", () => {
test("condition budgets override scenario budgets", () => {
const [v] = judge(
[outcome({ condition: "cold", metrics: { feedbackMs: 40, completeMs: 5000, recall: 1, precision: 1 } })],
[
outcome({
condition: "cold",
metrics: { feedbackMs: 40, firstResultMs: 300, completeMs: 5000, recall: 1, precision: 1 },
}),
],
budgets,
null,
repro,
[{ ...expected[0]!, condition: "cold" }],
);
expect(v!.status).toBe("pass");
});
test("timeouts and missing goldens fail", () => {
const [timedOut, noGolden] = judge(
[outcome({ error: "find.showUsages timed out after 30000 ms" }), outcome({ comparison: undefined })],
const [timedOut] = judge(
[outcome({ error: "find.showUsages timed out after 30000 ms" })],
budgets,
null,
repro,
expected,
);
const [noGolden] = judge([outcome({ comparison: undefined })], budgets, null, repro, expected);
expect(timedOut!.failures[0]!.kind).toBe("timeout");
expect(noGolden!.failures[0]!.kind).toBe("golden");
});
@@ -78,9 +88,41 @@ describe("judge", () => {
budgets,
baseline,
repro,
expected,
);
expect(v!.status).toBe("pass");
expect(v!.regressions.map((r) => r.metric)).toEqual(["completeMs"]);
expect(table([v!], false)).toContain("regressed: completeMs");
});
test("missing, duplicate, unexpected and empty workloads fail", () => {
for (const actual of [[], [outcome({}), outcome({})], [outcome({ scenario: "other" })]]) {
expect(judge(actual, budgets, null, repro, expected).some((v) => v.status === "fail")).toBe(true);
}
expect(judge([], budgets, null, repro, []).some((v) => v.status === "fail")).toBe(true);
});
test.each(["feedbackMs", "firstResultMs", "completeMs", "recall", "precision"])("requires finite %s", (metric) => {
for (const value of [undefined, NaN, Infinity, -Infinity]) {
const o = outcome({});
if (value === undefined) delete o.metrics[metric];
else o.metrics[metric] = value;
const [v] = judge([o], budgets, null, repro, expected);
expect(v!.status).toBe("fail");
expect(v!.failures.some((f) => f.metric === metric)).toBe(true);
}
});
test("requires scenario budget metrics and rejects nonfinite unbudgeted values", () => {
const custom = { ...budgets, scenarios: { usages: { readyMs: 100 } } };
expect(judge([outcome({})], custom, null, repro, expected)[0]!.status).toBe("fail");
const o = outcome({});
o.metrics.extraMs = NaN;
expect(judge([o], budgets, null, repro, expected)[0]!.status).toBe("fail");
});
test("a clean empty result set with a perfect comparison passes", () => {
const o = outcome({ results: { problems: [] } });
expect(judge([o], budgets, null, repro, expected)[0]!.status).toBe("pass");
});
});
+30 -2
Переглянути файл
@@ -4,6 +4,7 @@
*/
import { readFileSync } from "node:fs";
import type { Comparison, ResultSet } from "./golden.ts";
import type { ExpectedOutcome } from "./selection.ts";
export type Condition = "warm" | "cold";
@@ -97,15 +98,42 @@ export function judge(
budgets: Budgets,
baseline: Outcome[] | null,
repro: (o: Outcome) => string,
expected: readonly ExpectedOutcome[],
): Verdict[] {
const base = new Map((baseline ?? []).map((o) => [idOf(o), o.metrics]));
return outcomes.map((o) => {
const expectedIds = new Set(expected.map(idOf));
const counts = new Map<string, number>();
for (const o of outcomes) counts.set(idOf(o), (counts.get(idOf(o)) ?? 0) + 1);
const work: Outcome[] = [...outcomes];
for (const e of expected) {
if (!counts.has(idOf(e))) work.push({ ...e, metrics: {}, samples: {}, error: "missing expected outcome" });
}
if (!work.length) work.push({ scenario: "workload", title: "Workload", condition: "warm", metrics: {}, samples: {} });
return work.map((o) => {
const failures: Failure[] = [];
if (!expected.length) failures.push({ kind: "error", detail: "expected workload is empty" });
if (expectedIds.size !== expected.length) failures.push({ kind: "error", detail: "duplicate expected outcome" });
if (!expectedIds.has(idOf(o))) failures.push({ kind: "error", detail: "unexpected outcome" });
if ((counts.get(idOf(o)) ?? 0) > 1) failures.push({ kind: "error", detail: "duplicate outcome" });
if (o.error) failures.push({ kind: /timed out/.test(o.error) ? "timeout" : "error", detail: o.error });
if (o.degraded) failures.push({ kind: "degraded", detail: o.degraded });
if (o.results && !o.comparison && !o.error)
failures.push({ kind: "golden", detail: "no golden recorded: run with --update-golden and review it" });
for (const [metric, limit] of Object.entries(budgetsFor(budgets, o))) {
const limits = budgetsFor(budgets, o);
const required = new Set(["feedbackMs", "firstResultMs", "completeMs", ...Object.keys(limits)]);
if (o.results || o.comparison) {
required.add("recall");
required.add("precision");
}
for (const metric of new Set([...required, ...Object.keys(o.metrics)])) {
if (!Number.isFinite(o.metrics[metric]))
failures.push({
kind: lowerBound(metric) ? "correctness" : "budget",
metric,
detail: `${metric} is missing or nonfinite`,
});
}
for (const [metric, limit] of Object.entries(limits)) {
const value = o.metrics[metric];
if (value === undefined || !Number.isFinite(value)) continue;
const over = lowerBound(metric) ? value < limit : value > limit;
+193 -84
Переглянути файл
@@ -13,18 +13,29 @@
* and target/eval/report.md. Timings go over the remote-development route (one stdio hop
* more than Tauri IPC): compare them before / after on one machine, not as absolute numbers.
*/
import { execFileSync, spawnSync } from "node:child_process";
import { execFileSync } from "node:child_process";
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
import type { Server as HttpServer } from "node:http";
import { join, resolve } from "node:path";
import { parseArgs } from "node:util";
import { chromium, type Browser } from "@playwright/test";
import type { Browser } from "@playwright/test";
import { buildBundle, serveBundle } from "../perf/lib/bundle.ts";
import { median } from "../perf/lib/stats.ts";
import { runCommand } from "../perf/lib/process.ts";
import { closeServer, DeadlineError, launchBrowser, withDeadline, type BrowserSession } from "../perf/lib/lifecycle.ts";
import {
errorMessage,
evidenceJson,
metricErrors,
summarizeMetrics,
summarizeTrials,
type Trial,
} from "../perf/lib/trials.ts";
import { JAVA_SCENARIOS } from "./java/scenarios.ts";
import { compare, readGolden, toolDrift, writeGolden, type ResultSet } from "./lib/golden.ts";
import { TimeoutError } from "./lib/measure.ts";
import { fingerprint, pinnedTools, sameMachine, toolVersions, type Fingerprint } from "./lib/machine.ts";
import type { EvalScenario } from "./lib/scenario.ts";
import { planSelection } from "./lib/selection.ts";
import { Session } from "./lib/session.ts";
import { idOf, judge, loadBudgets, table, type Condition, type Diagnostics, type Outcome } from "./lib/verdict.ts";
@@ -56,25 +67,22 @@ if (args.list) {
process.exit(0);
}
const runs = Math.max(1, Number(args.runs));
const warmup = Math.max(0, Number(args.warmup));
const only = args.only?.split(",").map((s) => s.trim());
const conditionFilter = args.condition as Condition | undefined;
const selected = SCENARIOS.filter((s) => !only || only.some((o) => s.id === o || s.id.startsWith(`${o}.`)));
if (only && !selected.length) throw new Error(`no scenario matches ${args.only} (see --list)`);
const { runs, warmup, selected, expected, condition: conditionFilter } = planSelection(SCENARIOS, args);
const trialEvidence: Record<string, Array<Trial & { results?: ResultSet; degraded?: string | null }>> = {};
const evalBudgets = loadBudgets(join(ROOT, "evals", "budgets.json"));
const goldenFile = (id: string) => join(ROOT, "evals", id.slice(0, id.indexOf(".")), "golden", `${id}.json`);
function serverBinary(): string {
async function serverBinary(): Promise<string> {
const exe = process.platform === "win32" ? ".exe" : "";
const bin = process.env.OPENIDEA_SERVER ?? join(ROOT, "target", "release", `openidea-server${exe}`);
if (!args["no-build"]) {
console.log("Building openidea-server (cargo build --release)…");
const r = spawnSync("cargo", ["build", "--release", "-p", "ide-host", "--bin", "openidea-server"], {
await runCommand("cargo", ["build", "--release", "-p", "ide-host", "--bin", "openidea-server"], {
cwd: ROOT,
stdio: ["ignore", "ignore", "inherit"],
timeoutMs: 60 * 60_000,
label: "cargo build",
});
if (r.status !== 0) throw new Error("cargo build failed");
}
if (!existsSync(bin)) throw new Error(`no server at ${bin}; run without --no-build`);
return bin;
@@ -82,23 +90,12 @@ function serverBinary(): string {
function git(...a: string[]): string {
try {
return execFileSync("git", a, { cwd: ROOT, encoding: "utf8" }).trim();
return execFileSync("git", a, { cwd: ROOT, encoding: "utf8", timeout: 10_000, killSignal: "SIGKILL" }).trim();
} catch {
return "";
}
}
/** Medians of the timings; correctness from the worst run. */
function summarize(samples: Array<Record<string, number>>): Record<string, number> {
const keys = [...new Set(samples.flatMap((s) => Object.keys(s)))];
return Object.fromEntries(
keys.map((k) => {
const values = samples.map((s) => s[k]!).filter(Number.isFinite);
return [k, k === "recall" || k === "precision" ? Math.min(...values) : median(values)];
}),
);
}
interface Run {
metrics: Record<string, number>;
results?: ResultSet;
@@ -157,8 +154,10 @@ function outcomeOf(
scenario: scenario.id,
title: scenario.title,
condition,
metrics: { ...summarize(samples), ...extra },
samples: Object.fromEntries(Object.keys(samples[0] ?? {}).map((k) => [k, samples.map((x) => x[k]!)])),
metrics: { ...summarizeMetrics(samples, ["recall", "precision"]), ...extra },
samples: Object.fromEntries(
[...new Set(samples.flatMap((s) => Object.keys(s)))].map((k) => [k, samples.map((x) => x[k]!)]),
),
results: done.at(-1)?.results,
comparison: worst,
drift: golden ? toolDrift(golden, tools) : undefined,
@@ -172,21 +171,59 @@ async function runScenario(
condition: Condition,
browser: Browser,
tools: Record<string, string>,
progress: () => void,
extra: Record<string, number> = {},
): Promise<Outcome> {
const total = condition === "cold" ? 1 : warmup + runs;
const done: Run[] = [];
process.stdout.write(`${idOf({ scenario: scenario.id, condition }).padEnd(52)} `);
const attempts: Array<Trial & { results?: ResultSet; degraded?: string | null }> = (trialEvidence[
idOf({ scenario: scenario.id, condition })
] = []);
let phase: Trial["phase"] = condition === "warm" && warmup ? "warmup" : "measured";
let index = 1;
try {
for (let i = 0; i < total; i++) {
const last = i === total - 1;
const trace = args.trace && last ? join(OUT, "traces", `${scenario.id}@${condition}.json`) : null;
const r = await measureOnce(s, scenario, trace, browser);
if (condition === "cold" || i >= warmup) done.push(r);
process.stdout.write(condition === "warm" && i < warmup ? "w" : ".");
phase = condition === "warm" && i < warmup ? "warmup" : "measured";
index = phase === "warmup" ? i + 1 : condition === "cold" ? 1 : i - warmup + 1;
const r = await withDeadline(measureOnce(s, scenario, trace, browser), 5 * 60_000, `${scenario.id} trial`);
const golden = readGolden(goldenFile(scenario.id));
const comparison = golden && r.results ? compare(r.results, golden.groups) : undefined;
const metrics = comparison
? { ...r.metrics, recall: comparison.recall, precision: comparison.precision }
: r.metrics;
const limits = {
...evalBudgets.defaults,
...evalBudgets.scenarios[scenario.id],
...evalBudgets.scenarios[idOf({ scenario: scenario.id, condition })],
};
const required = [
"feedbackMs",
"firstResultMs",
"completeMs",
...Object.keys(limits).filter((k) => k !== "recall" && k !== "precision"),
];
const errors = metricErrors(metrics, required);
if (r.degraded) errors.push(r.degraded);
if (comparison && (comparison.recall < 1 || comparison.precision < 1)) errors.push("result differs from golden");
attempts.push({
phase,
index,
status: errors.length ? "invalid" : "ok",
metrics,
results: r.results,
degraded: r.degraded,
error: errors.join("; ") || undefined,
});
if (phase === "measured") done.push(r);
progress();
process.stdout.write(errors.length ? "!" : phase === "warmup" ? "w" : ".");
}
console.log();
const o = outcomeOf(scenario, condition, done, tools, extra);
o.error = summarizeTrials(attempts, condition === "cold" ? 1 : runs).error;
const slowest = done.reduce((a, b) => ((b.metrics.completeMs ?? 0) > (a.metrics.completeMs ?? 0) ? b : a));
o.diagnostics = diagnose(
s,
@@ -199,6 +236,15 @@ async function runScenario(
const message = e instanceof Error ? e.message : String(e);
const partial = e instanceof TimeoutError ? (e.partial as Record<string, number>) : {};
const now = s.timeline.now();
if (!attempts.some((t) => t.phase === phase && t.index === index))
attempts.push({
phase,
index,
status: e instanceof DeadlineError || e instanceof TimeoutError ? "timeout" : "error",
metrics: partial,
error: message,
});
progress();
return {
...outcomeOf(scenario, condition, done, tools, extra),
metrics: { ...partial, ...extra },
@@ -210,69 +256,113 @@ async function runScenario(
async function main() {
mkdirSync(join(OUT, "traces"), { recursive: true });
process.env.OPENIDEA_SERVER = serverBinary();
if (!args["no-build"]) buildBundle(ROOT, DIST);
if (!existsSync(join(DIST, "index.html"))) throw new Error(`no build in ${DIST}; run without --no-build`);
const tools = toolVersions();
const pins = pinnedTools(join(ROOT, ".github", "tool-versions.env"));
const machine: Fingerprint = fingerprint();
for (const [k, want] of Object.entries(pins)) {
if (tools[k] !== undefined && !tools[k]!.startsWith(want))
console.warn(`warning: ${k} ${tools[k]} is not the pinned ${want} (.github/tool-versions.env)`);
}
const { server, url } = await serveBundle(DIST);
const browser = await chromium.launch({
channel: args.channel === "chromium" ? undefined : args.channel,
headless: !args.headed,
args: [
"--disable-renderer-backgrounding",
"--disable-background-timer-throttling",
"--disable-backgrounding-occluded-windows",
],
});
const outcomes: Outcome[] = [];
const infrastructure: string[] = [];
const machine: Fingerprint = fingerprint();
const date = new Date().toISOString();
let tools: Record<string, string> = {};
let pins: Record<string, string> = {};
let runtime: BrowserSession | undefined;
let server: HttpServer | undefined;
let browserVersion = "not started";
const progress = () => {
writeFileSync(
join(OUT, "report.json"),
evidenceJson({
meta: { date, runs, warmup, machine, tools, pins },
status: "running",
pass: false,
expected,
outcomes,
trials: trialEvidence,
}),
);
};
progress();
writeFileSync(join(OUT, "report.md"), "# OpenIDEA eval report\n\nRun in progress; no passing verdict.\n");
try {
// Warm: one session per fixture, its project imported once, scenarios one after another.
process.env.OPENIDEA_SERVER = await serverBinary();
if (!args["no-build"]) await buildBundle(ROOT, DIST);
if (!existsSync(join(DIST, "index.html"))) throw new Error(`no build in ${DIST}; run without --no-build`);
tools = toolVersions();
pins = pinnedTools(join(ROOT, ".github", "tool-versions.env"));
for (const [k, want] of Object.entries(pins)) {
if (tools[k] !== undefined && !tools[k]!.startsWith(want))
console.warn(`warning: ${k} ${tools[k]} is not the pinned ${want} (.github/tool-versions.env)`);
}
const serving = await serveBundle(DIST);
server = serving.server;
runtime = await launchBrowser({
channel: args.channel === "chromium" ? undefined : args.channel,
headless: !args.headed,
args: [
"--disable-renderer-backgrounding",
"--disable-background-timer-throttling",
"--disable-backgrounding-occluded-windows",
],
});
const browser = runtime.browser;
browserVersion = browser.version();
const warm = selected.filter(
(s) => s.conditions.includes("warm") && (!conditionFilter || conditionFilter === "warm"),
);
for (const fixture of [...new Set(warm.map((s) => s.fixture))]) {
const scenarios = warm.filter((s) => s.fixture === fixture);
const s = await Session.start(browser, url, ROOT, { fixture, workDir: join(OUT, "warm"), keepHome: false });
const s = await Session.start(browser, serving.url, ROOT, {
fixture,
workDir: join(OUT, "warm"),
keepHome: false,
});
try {
await scenarios[0]!.setup(s);
await withDeadline(scenarios[0]!.setup(s), 5 * 60_000, "warm fixture setup");
await s.settle(scenarios[0]!.server);
for (const scenario of scenarios) outcomes.push(await runScenario(s, scenario, "warm", browser, tools));
for (const scenario of scenarios) {
const outcome = await runScenario(s, scenario, "warm", browser, tools, progress);
outcomes.push(outcome);
progress();
if (outcome.error) break;
}
} finally {
await s.close();
}
}
// Cold: a fresh server and project import per scenario, measured once after the import settles.
const cold = selected.filter(
(s) => s.conditions.includes("cold") && (!conditionFilter || conditionFilter === "cold"),
);
for (const scenario of cold) {
const started = Date.now();
const s = await Session.start(browser, url, ROOT, {
const s = await Session.start(browser, serving.url, ROOT, {
fixture: scenario.fixture,
workDir: join(OUT, "cold"),
keepHome: false,
});
try {
await scenario.setup(s);
await withDeadline(scenario.setup(s), 5 * 60_000, "cold fixture setup");
await s.settle(scenario.server);
// Settling waits out the quiet period at its end.
const readyMs = Date.now() - started - 2000;
outcomes.push(await runScenario(s, scenario, "cold", browser, tools, { readyMs }));
outcomes.push(await runScenario(s, scenario, "cold", browser, tools, progress, { readyMs }));
progress();
} finally {
await s.close();
}
}
} catch (error) {
infrastructure.push(errorMessage(error));
} finally {
await browser.close();
server.close();
if (runtime) {
try {
await runtime.close();
} catch (error) {
infrastructure.push(`browser cleanup: ${errorMessage(error)}`);
}
}
if (server) {
try {
await closeServer(server);
} catch (error) {
infrastructure.push(`server cleanup: ${errorMessage(error)}`);
}
}
}
if (args["update-golden"]) {
@@ -291,15 +381,19 @@ async function main() {
const baselineFile = join(OUT, "baseline.json");
let baseline: Outcome[] | null = null;
if (existsSync(baselineFile)) {
const saved = JSON.parse(readFileSync(baselineFile, "utf8")) as { machine: Fingerprint; outcomes: Outcome[] };
if (sameMachine(saved.machine, machine)) baseline = saved.outcomes;
else console.warn("warning: target/eval/baseline.json is from another machine or OS: not compared");
try {
const saved = JSON.parse(readFileSync(baselineFile, "utf8")) as { machine: Fingerprint; outcomes: Outcome[] };
if (sameMachine(saved.machine, machine)) baseline = saved.outcomes;
else console.warn("warning: target/eval/baseline.json is from another machine or OS: not compared");
} catch (error) {
infrastructure.push(`baseline: ${errorMessage(error)}`);
}
}
const repro = (o: Outcome) => `pnpm eval --only ${o.scenario} --condition ${o.condition}`;
const verdicts = judge(outcomes, loadBudgets(join(ROOT, "evals", "budgets.json")), baseline, repro);
const verdicts = judge(outcomes, evalBudgets, baseline, repro, expected);
const meta = {
date: new Date().toISOString(),
date,
commit: git("rev-parse", "--short", "HEAD"),
dirty: git("status", "--porcelain", "--untracked-files=no") !== "",
runs,
@@ -307,27 +401,32 @@ async function main() {
machine,
tools,
pins,
browser: browser.version(),
browser: browserVersion,
};
const report = {
meta,
pass: verdicts.every((v) => v.status === "pass"),
pass: infrastructure.length === 0 && verdicts.every((v) => v.status === "pass"),
status: infrastructure.length || verdicts.some((v) => v.status === "fail") ? "failed" : "complete",
expected,
outcomes,
trials: trialEvidence,
infrastructure,
verdicts: verdicts.map((v) => {
const o = outcomes.find((x) => idOf(x) === v.id)!;
const o = outcomes.find((x) => idOf(x) === v.id);
return {
...v,
samples: o.samples,
results: o.results,
comparison: o.comparison,
drift: o.drift,
degraded: o.degraded,
error: o.error,
samples: o?.samples,
results: o?.results,
comparison: o?.comparison,
drift: o?.drift,
degraded: o?.degraded,
error: o?.error,
// Diagnostics only where something needs a look.
diagnostics: v.status === "fail" || v.regressions.length ? o.diagnostics : undefined,
diagnostics: v.status === "fail" || v.regressions.length ? o?.diagnostics : undefined,
};
}),
};
writeFileSync(join(OUT, "report.json"), JSON.stringify(report, null, 2));
writeFileSync(join(OUT, "report.json"), evidenceJson(report));
const failing = verdicts.filter((v) => v.status === "fail");
const md = [
"# OpenIDEA eval report",
@@ -337,6 +436,16 @@ async function main() {
table(verdicts, true),
"",
...failing.flatMap((v) => [`- **${v.id}**: ${v.failures.map((f) => f.detail).join("; ")} — \`${v.repro}\``]),
...infrastructure.map((error) => `- **Infrastructure**: ${error}`),
"",
"## Trials",
"",
"| Scenario | Valid / planned measured | Attempted measured | Valid / attempted warmup |",
"| --- | ---: | ---: | ---: |",
...Object.entries(trialEvidence).map(([id, attempts]) => {
const c = summarizeTrials(attempts, id.endsWith("@cold") ? 1 : runs).counts;
return `| ${id} | ${c.valid}/${c.planned} | ${c.attempted} | ${c.warmupValid}/${c.warmupAttempted} |`;
}),
].join("\n");
writeFileSync(join(OUT, "report.md"), md + "\n");
@@ -345,9 +454,9 @@ async function main() {
for (const v of failing) {
console.log(`\n${v.id} FAILED (${v.repro})`);
for (const f of v.failures) console.log(` ${f.kind}: ${f.detail}`);
const o = outcomes.find((x) => idOf(x) === v.id)!;
if (o.drift?.length) console.log(` golden recorded with other tools: ${o.drift.join(", ")}`);
const slow = [...(o.diagnostics?.calls ?? [])].sort((a, b) => b.ms - a.ms).slice(0, 5);
const o = outcomes.find((x) => idOf(x) === v.id);
if (o?.drift?.length) console.log(` golden recorded with other tools: ${o.drift.join(", ")}`);
const slow = [...(o?.diagnostics?.calls ?? [])].sort((a, b) => b.ms - a.ms).slice(0, 5);
if (slow.length)
console.log(
` slowest commands: ${slow.map((c) => `${c.cmd} ${Math.round(c.ms)} ms${c.pending ? " (no answer)" : c.ok ? "" : " (failed)"}`).join(", ")}`,
@@ -355,11 +464,11 @@ async function main() {
}
console.log(`\nReport: ${join(OUT, "report.json")}`);
if (args["save-baseline"]) {
writeFileSync(baselineFile, JSON.stringify({ machine, meta, outcomes }, null, 2));
writeFileSync(baselineFile, evidenceJson({ machine, meta, outcomes }));
console.log(`Baseline saved to ${baselineFile}`);
}
const regressed = verdicts.some((v) => v.regressions.length);
process.exit(failing.length || (args["fail-on-regression"] && regressed) ? 1 : 0);
process.exit(infrastructure.length || failing.length || (args["fail-on-regression"] && regressed) ? 1 : 0);
}
await main();
+1 -1
Переглянути файл
@@ -3,7 +3,7 @@ import type { KnipConfig } from "knip";
const config: KnipConfig = {
// Entries come from the Vite (index.html), Vitest, Playwright and package.json script plugins;
// standalone browser fixtures are loaded by their own HTML pages.
entry: ["e2e/*.fixture.{ts,tsx}"],
entry: ["e2e/*.fixture.{ts,tsx}", "perf/**/*.fixture.{ts,tsx}"],
project: [
"src/**/*.{ts,tsx,css}",
"!src/editor/core/cm/angular/parser.terms.ts",
+1
Переглянути файл
@@ -12,6 +12,7 @@ name = "dart"
command = "dart"
args = ["language-server", "--protocol=lsp"]
root-markers = ["pubspec.yaml", "analysis_options.yaml"]
initialization-options = { flutterOutline = true }
install-hint = "Install the Dart SDK (https://dart.dev/get-dart) or Flutter"
# `dart` here; a project that depends on the Flutter SDK is switched to
+42 -4
Переглянути файл
@@ -23,9 +23,46 @@ closes it, and records:
| `exit_s` | until every process has exited |
| `cache_mb`, install size | `cache_dirs`, `install_dir` |
Apps run interleaved, rotating the order, after `--warmup` discarded runs.
Output goes to `results/<time>-<project>/`: `report.md` (median, min–max),
`results.json`, and each run's stdout.
Apps run interleaved, rotating the order, after `--warmup` unaggregated runs.
Every attempt, including warmups and failed launches, is retained in
`results/<time>-<project>-<unique>/`: `report.md`, `results.json`, and each
launched run's stdout. Reports are refreshed before and after each attempt
and on errors or interruption; separate invocations never overwrite each other.
The table shows median (min–max) and **valid/attempted** measured-trial counts
for every fixed metric, even when there are zero valid values. Only completely
valid trials enter aggregates; failed trials retain partial measurements and
explicit reasons in JSON and the attempts table. Warmups never enter medians
but a failed warmup still fails the suite. An empty or incomplete suite is not
successful.
Startup timeout, early exit/crash, observation/access errors, invalid or missing
required metrics, quit-command errors, forced termination, and interruption
produce a nonzero exit. JSON records `status`, `reasons`, `warmup`, and
`metric_status` (`valid`, `missing`, `invalid`, or `unsupported`). Nonfinite
numeric evidence is preserved as an `invalid_number` object, never JSON NaN.
Unsupported window observation, non-Linux PSS, and unconfigured cache directories
are explicit exclusions rather than missing required values. Unobserved optional
log markers do not fail a trial; `ready_after` markers are required.
`--runs` must be positive; `--warmup` and `--cooldown` may be zero. Other
durations and the CPU threshold must be finite and positive, and the quiet
period cannot exceed the startup timeout.
Shutdown always runs after a launch, including observation errors and Ctrl-C.
`--close-timeout` bounds the quit command plus graceful wait; each forced cleanup
has at most two additional seconds to reap processes. `--command-timeout`
(default 60 seconds) bounds `--drop-os-cache`, including interactive commands.
Only processes attributed to the launch are terminated; preexisting instances
are refused, never killed. Configured `daemons` remain explicitly excluded from
shutdown and forced cleanup. POSIX launch-owned process groups retain orphaned
children; on Windows discovery uses the recorded process ancestry.
Run the small process-fixture regressions without launching an installed IDE:
```sh
python -m unittest discover -s perf/compare -p 'test_bench.py'
```
## Fair runs
@@ -46,6 +83,7 @@ Output goes to `results/<time>-<project>/`: `report.md` (median, min–max),
- Windows: windows via `user32`, closed with `WM_CLOSE`.
- macOS: windows via Quartz (`pyobjc-framework-Quartz`; titles need Screen
Recording permission). WebKit helpers are children of launchd and are
attributed through `responsibility_get_pid_responsible_for_pid`.
attributed through `responsibility_get_pid_responsible_for_pid`. Without that
API, unrelated WebKit processes are not guessed by name/start time or killed.
- Linux: windows via `wmctrl` (X11). Without it `window_s` is skipped and
readiness counts from launch.
+399 -188
Переглянути файл
@@ -14,6 +14,7 @@ import ctypes
import datetime as dt
import glob
import json
import math
import os
import platform
import re
@@ -24,6 +25,7 @@ import subprocess
import sys
import time
import tomllib
import tempfile
from pathlib import Path
try:
@@ -34,7 +36,7 @@ except ImportError:
OS = {"Windows": "windows", "Darwin": "macos", "Linux": "linux"}[platform.system()]
HERE = Path(__file__).resolve().parent
ANSI = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
GONE = (psutil.NoSuchProcess, psutil.ZombieProcess, psutil.AccessDenied)
GONE = (psutil.NoSuchProcess, psutil.ZombieProcess)
MB = 1024 * 1024
POLL_S = 0.2
@@ -140,10 +142,7 @@ def _mac_windows(pids: set[int]) -> list[tuple[object, str]] | None:
def _x11_windows(pids: set[int]) -> list[tuple[object, str]] | None:
if not shutil.which("wmctrl"):
return None
try:
out = subprocess.run(["wmctrl", "-lp"], capture_output=True, text=True, timeout=2).stdout
except (OSError, subprocess.TimeoutExpired):
return None
out = subprocess.run(["wmctrl", "-lp"], capture_output=True, text=True, timeout=2, check=True).stdout
found = []
for line in out.splitlines():
parts = line.split(None, 4)
@@ -174,11 +173,11 @@ if OS == "macos":
class Tree:
"""Every process the app started, including ones whose parent already exited.
"""Processes owned by this launch, identified by process identity and ancestry.
On macOS, WKWebView's helper processes are children of launchd, so they are
attributed through the responsible-pid API (or, failing that, by name and
start time).
POSIX launches have a private process group, retaining orphaned children.
macOS launchd-owned WebKit helpers require responsible-pid attribution:
name/start-time guesses cannot safely authorize terminating a process.
"""
def __init__(self, root: psutil.Process, started: float):
@@ -187,14 +186,22 @@ class Tree:
self.procs: dict[tuple[int, float], psutil.Process] = {}
self.cpu: dict[tuple[int, float], float] = {}
self.cpu_exited = 0.0
self.group = root.pid if os.name == "posix" else None
def _discover(self):
found = [self.root]
for p in list(self.procs.values()):
for p in [self.root, *self.procs.values()]:
try:
found += p.children(recursive=True)
except GONE:
pass
if self.group is not None:
for p in psutil.process_iter():
try:
if os.getpgid(p.pid) == self.group:
found.append(p)
except (ProcessLookupError, PermissionError):
continue
if OS == "macos":
found += self._webkit()
for p in found:
@@ -211,8 +218,7 @@ class Tree:
if _responsible:
if _responsible(p.pid) == self.root.pid:
out.append(p)
elif (p.info["create_time"] or 0) >= self.started - 1:
out.append(p)
# Without attribution, leave unrelated WebKit processes untouched.
return out
def sample(self) -> tuple[float, int]:
@@ -234,7 +240,14 @@ class Tree:
return {pid for pid, _ in self.procs}
def alive(self) -> list[psutil.Process]:
return [p for p in self.procs.values() if p.is_running()]
out = []
for p in self.procs.values():
try:
if p.is_running() and p.status() != psutil.STATUS_ZOMBIE:
out.append(p)
except GONE:
pass
return out
def memory(self) -> dict:
"""Summed memory of the live tree. RSS double-counts shared pages, USS leaves them out."""
@@ -284,7 +297,7 @@ class LogTail:
f.seek(self.offsets.get(path, 0))
chunk = f.read()
self.offsets[path] = f.tell()
except OSError:
except FileNotFoundError:
continue
if not chunk:
continue
@@ -310,151 +323,246 @@ def dir_size(path: Path) -> int:
if path.is_file():
return path.stat().st_size
total = 0
for root, _, files in os.walk(path):
def walk_error(error):
raise error
for root, _, files in os.walk(path, onerror=walk_error):
for f in files:
try:
total += os.lstat(os.path.join(root, f)).st_size
except OSError:
except FileNotFoundError:
pass
return total
def close(app: App, tree: Tree, proc: subprocess.Popen, timeout: float) -> tuple[float | None, list[str]]:
"""Asks the app to quit, waits for the whole tree, kills what's left.
def failure(result: dict, reason: str):
result["reasons"].append(reason)
if result["status"] != "interrupted":
result["status"] = "failed"
Returns (seconds until every process exited, or None if it had to kill; names of killed leftovers).
"""
t0 = time.perf_counter()
if app.quit_command:
subprocess.run(app.quit_command, check=False)
elif OS == "windows":
# Only the project windows: closing a framework's hidden message windows
# (Tauri's single-instance and event-target ones) stalls the real shutdown.
for hwnd, title in _win_windows(tree.pids()):
if app.window_title.search(title):
_user32.PostMessageW(hwnd, 0x0010, 0, 0) # WM_CLOSE
else:
proc.send_signal(signal.SIGTERM)
def remaining() -> list[psutil.Process]:
out = []
for p in tree.alive():
try:
if p.name().lower() not in app.daemons:
out.append(p)
except GONE:
pass
return out
while time.perf_counter() - t0 < timeout:
tree.sample()
if not remaining():
return time.perf_counter() - t0, []
time.sleep(POLL_S)
leftovers = remaining()
def force_cleanup(tree: Tree | None, proc: subprocess.Popen, daemons: set[str], result: dict) -> list[str]:
"""Kill only launch-owned identities; allow at most two seconds to reap."""
names = []
for p in leftovers:
targets = []
if tree is not None:
try:
names.append(p.name())
tree._discover()
except Exception as exc:
failure(result, f"cleanup discovery: {type(exc).__name__}: {exc}")
targets = list(tree.procs.values())
try:
# A reaped PID may already belong to somebody else.
if proc.poll() is None:
root = psutil.Process(proc.pid)
if all(p.pid != root.pid for p in targets):
targets.append(root)
except GONE:
pass
killed = []
for p in targets:
try:
if not p.is_running() or p.status() == psutil.STATUS_ZOMBIE:
continue
name = p.name()
if name.lower() in daemons:
result.setdefault("excluded_daemons", []).append({"pid": p.pid, "name": name})
continue
p.kill()
names.append(name)
killed.append(p)
except GONE:
pass
psutil.wait_procs(leftovers, timeout=10)
return None, names
def run_once(app: App, args, out_dir: Path, label: str) -> dict:
running = running_instances(app) if app.single_instance else []
if running:
pids = ", ".join(str(p.pid) for p in running)
raise SystemExit(f"{app.name} is already running (pid {pids}); close it first, it would take over the launch.")
if args.wipe_caches:
for path in app.cache_paths():
shutil.rmtree(path, ignore_errors=True) if path.is_dir() else path.unlink(missing_ok=True)
if args.drop_os_cache:
subprocess.run(args.drop_os_cache, shell=True, check=True)
if args.cooldown:
time.sleep(args.cooldown)
stdout_path = out_dir / f"{label}.stdout.log"
tail = LogTail(app.logs, [stdout_path])
started_wall = time.time()
with open(stdout_path, "wb") as stdout:
t0 = time.perf_counter()
proc = subprocess.Popen(app.command, stdout=stdout, stderr=subprocess.STDOUT, stdin=subprocess.DEVNULL)
tree = Tree(psutil.Process(proc.pid), started_wall)
result: dict = {"app": app.key, "label": label, "markers_first_s": {}, "markers_last_s": {}}
window_supported = True
window_s = None
history: collections.deque[tuple[float, float]] = collections.deque()
peak_rss = 0
ready_s = None
while True:
now = time.perf_counter() - t0
cpu, rss = tree.sample()
peak_rss = max(peak_rss, rss)
history.append((now, cpu))
while history and now - history[0][0] > args.quiet_secs:
history.popleft()
for line in tail.lines():
for name, rx in app.markers.items():
if rx.search(line):
result["markers_first_s"].setdefault(name, now)
result["markers_last_s"][name] = now
if window_s is None and window_supported:
windows = visible_windows(tree.pids())
if windows is None:
window_supported = False
elif any(app.window_title.search(title) for _, title in windows):
window_s = now
if not tree.alive():
raise SystemExit(
f"{app.name} exited during startup (code {proc.poll()}); an instance started elsewhere may have "
f"taken the launch. Output: {stdout_path}"
)
waited = (window_s is not None or not window_supported) and all(
m in result["markers_first_s"] for m in app.ready_after
)
span = now - history[0][0]
if waited and span >= args.quiet_secs * 0.95:
busy = (cpu - history[0][1]) / span
if busy < args.quiet_cores:
# Never before what it waited for (the quiet span can start earlier).
ready_s = max(now - span, window_s or 0, *(result["markers_first_s"][m] for m in app.ready_after))
break
if now > args.timeout:
result["timed_out"] = True
break
time.sleep(POLL_S)
result["window_s"] = window_s
result["ready_s"] = ready_s
result["peak_rss_mb"] = peak_rss / MB
# Idle: what it costs to just sit there with the project open.
idle_cpu0, _ = tree.sample()
i0 = time.perf_counter()
while time.perf_counter() - i0 < args.idle_secs:
time.sleep(POLL_S * 5)
_, rss = tree.sample()
peak_rss = max(peak_rss, rss)
idle_cpu1, _ = tree.sample()
result["idle_cpu_pct"] = 100 * (idle_cpu1 - idle_cpu0) / (time.perf_counter() - i0)
result["peak_rss_mb"] = peak_rss / MB
result.update(tree.memory())
result["total_cpu_s"] = idle_cpu0
exit_s, killed = close(app, tree, proc, args.close_timeout)
result["exit_s"] = exit_s
except Exception as exc:
failure(result, f"cleanup pid {p.pid}: {type(exc).__name__}: {exc}")
deadline = time.perf_counter() + 2
if killed:
result["killed_on_exit"] = killed
result["cache_mb"] = sum(dir_size(p) for p in app.cache_paths()) / MB
_, alive = psutil.wait_procs(killed, timeout=max(0, deadline - time.perf_counter()))
if alive:
failure(result, f"cleanup survivors: {[p.pid for p in alive]}")
try:
proc.wait(timeout=max(0, deadline - time.perf_counter()))
except subprocess.TimeoutExpired:
# The root can itself be an explicitly excluded daemon.
if not any(p["pid"] == proc.pid for p in result.get("excluded_daemons", [])):
failure(result, f"cleanup root {proc.pid} did not exit")
return names
def bounded_command(command, timeout: float, *, shell=False):
"""External cache/quit commands have their own launch-owned cleanup."""
proc = subprocess.Popen(command, shell=shell, stdin=subprocess.DEVNULL,
start_new_session=os.name == "posix")
tree = None
evidence = {"status": "valid", "reasons": []}
try:
tree = Tree(psutil.Process(proc.pid), time.time())
deadline = time.perf_counter() + timeout
while proc.poll() is None:
tree._discover()
remaining = deadline - time.perf_counter()
if remaining <= 0:
raise subprocess.TimeoutExpired(command, timeout)
time.sleep(min(POLL_S, remaining))
if proc.returncode:
raise subprocess.CalledProcessError(proc.returncode, command)
finally:
force_cleanup(tree, proc, set(), evidence)
if evidence["reasons"]:
raise RuntimeError("; ".join(evidence["reasons"]))
def close(app: App, tree: Tree, proc: subprocess.Popen, timeout: float, result: dict) -> tuple[float | None, list[str]]:
"""The quit command and graceful wait share one budget; forced reap is bounded."""
t0 = time.perf_counter()
deadline = t0 + timeout
exit_s = None
killed = []
try:
tree._discover()
if app.quit_command:
try:
bounded_command(app.quit_command, max(0.001, deadline - time.perf_counter()))
except Exception as exc:
failure(result, f"quit command: {type(exc).__name__}: {exc}")
elif OS == "windows":
for hwnd, title in _win_windows(tree.pids()):
if app.window_title.search(title):
_user32.PostMessageW(hwnd, 0x0010, 0, 0)
elif proc.poll() is None:
proc.send_signal(signal.SIGTERM)
while time.perf_counter() < deadline:
tree._discover()
remaining = [p for p in tree.alive() if p.name().lower() not in app.daemons]
if not remaining:
exit_s = time.perf_counter() - t0
break
time.sleep(min(POLL_S, max(0, deadline - time.perf_counter())))
if exit_s is None:
failure(result, "graceful-close timeout")
except KeyboardInterrupt:
result["status"] = "interrupted"
failure(result, "interrupted during shutdown")
except Exception as exc:
failure(result, f"shutdown observation: {type(exc).__name__}: {exc}")
finally:
killed = force_cleanup(tree, proc, app.daemons, result)
if killed:
failure(result, "forced cleanup: " + ", ".join(killed))
exit_s = None
return exit_s, killed
def new_trial(app: App, label: str, warmup=False) -> dict:
return {"app": app.key, "label": label, "warmup": warmup, "status": "running", "reasons": [],
"markers_first_s": {}, "markers_last_s": {}, "metric_status": {},
**{key: None for key, _ in METRICS}}
def run_once(app: App, args, out_dir: Path, label: str, result: dict | None = None) -> dict:
result = new_trial(app, label) if result is None else result
proc = tree = None
try:
running = running_instances(app) if app.single_instance else []
if running:
raise RuntimeError(f"{app.name} already running (pid {', '.join(str(p.pid) for p in running)}); close it first")
if args.wipe_caches:
for path in app.cache_paths():
shutil.rmtree(path) if path.is_dir() else path.unlink(missing_ok=True)
if args.drop_os_cache:
bounded_command(args.drop_os_cache, args.command_timeout, shell=True)
if args.cooldown:
time.sleep(args.cooldown)
stdout_path = out_dir / f"{label}.stdout.log"
result["stdout"] = str(stdout_path)
tail = LogTail(app.logs, [stdout_path])
started_wall = time.time()
with open(stdout_path, "wb") as stdout:
t0 = time.perf_counter()
proc = subprocess.Popen(app.command, stdout=stdout, stderr=subprocess.STDOUT,
stdin=subprocess.DEVNULL, start_new_session=os.name == "posix")
result["pid"] = proc.pid
tree = Tree(psutil.Process(proc.pid), started_wall)
window_supported = True
history: collections.deque[tuple[float, float]] = collections.deque()
peak_rss = 0
while True:
now = time.perf_counter() - t0
cpu, rss = tree.sample()
peak_rss = max(peak_rss, rss)
result["peak_rss_mb"] = peak_rss / MB
history.append((now, cpu))
while history and now - history[0][0] > args.quiet_secs:
history.popleft()
for line in tail.lines():
for name, rx in app.markers.items():
if rx.search(line):
result["markers_first_s"].setdefault(name, now)
result["markers_last_s"][name] = now
if result["window_s"] is None and window_supported:
windows = visible_windows(tree.pids())
if windows is None:
window_supported = False
result["metric_status"]["window_s"] = "unsupported"
elif any(app.window_title.search(title) for _, title in windows):
result["window_s"] = now
if proc.poll() is not None or not tree.alive():
raise RuntimeError(f"{app.name} exited during startup (code {proc.poll()})")
waited = (result["window_s"] is not None or not window_supported) and all(
m in result["markers_first_s"] for m in app.ready_after)
span = now - history[0][0]
if waited and span >= args.quiet_secs * 0.95:
busy = (cpu - history[0][1]) / span
if busy < args.quiet_cores:
result["ready_s"] = max(now - span, result["window_s"] or 0,
*(result["markers_first_s"][m] for m in app.ready_after))
break
if now > args.timeout:
result["timed_out"] = True
raise TimeoutError("startup timeout: CPU/window/required markers never became ready")
time.sleep(POLL_S)
idle_cpu0, _ = tree.sample()
result["total_cpu_s"] = idle_cpu0
i0 = time.perf_counter()
while time.perf_counter() - i0 < args.idle_secs:
time.sleep(min(POLL_S * 5, max(0, args.idle_secs - (time.perf_counter() - i0))))
_, rss = tree.sample()
peak_rss = max(peak_rss, rss)
result["peak_rss_mb"] = peak_rss / MB
if proc.poll() is not None or not tree.alive():
raise RuntimeError(f"{app.name} exited during idle (code {proc.poll()})")
idle_cpu1, _ = tree.sample()
result["idle_cpu_pct"] = 100 * (idle_cpu1 - idle_cpu0) / (time.perf_counter() - i0)
result.update(tree.memory())
result["cache_mb"] = sum(dir_size(p) for p in app.cache_paths()) / MB
result["status"] = "valid"
except KeyboardInterrupt:
result["status"] = "interrupted"
failure(result, "interrupted")
except Exception as exc:
failure(result, f"{type(exc).__name__}: {exc}")
finally:
if proc is not None:
try:
if tree is not None:
result["exit_s"], result["killed_on_exit"] = close(app, tree, proc, args.close_timeout, result)
else:
result["killed_on_exit"] = force_cleanup(tree, proc, app.daemons, result)
except KeyboardInterrupt:
result["status"] = "interrupted"
failure(result, "interrupted during cleanup")
result["killed_on_exit"] = force_cleanup(tree, proc, app.daemons, result)
except Exception as exc:
failure(result, f"cleanup: {type(exc).__name__}: {exc}")
result["killed_on_exit"] = force_cleanup(tree, proc, app.daemons, result)
result["exit_code"] = proc.poll()
validate_metrics(app, result)
return result
@@ -475,8 +583,67 @@ METRICS = [
]
def valid_number(value) -> bool:
return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value) and value >= 0
def validate_metrics(app: App, result: dict):
states = result["metric_status"]
for key, _ in METRICS:
if (key == "pss_mb" and OS != "linux") or (key == "cache_mb" and not app.cache_dirs):
states[key] = "unsupported"
continue
if key == "window_s" and states.get(key) == "unsupported":
continue
value = result.get(key)
good = valid_number(value) and (key != "procs" or (value > 0 and value == int(value)))
states[key] = "valid" if good else "missing" if value is None else "invalid"
if not good:
reason = f"required metric {key}: {states[key]}"
if reason not in result["reasons"]:
failure(result, reason)
for marker in app.ready_after:
if not valid_number(result["markers_first_s"].get(marker)):
reason = f"required marker {marker}: missing or invalid"
if reason not in result["reasons"]:
failure(result, reason)
def json_safe(value):
"""Strict JSON retains invalid numeric evidence without emitting NaN/Infinity."""
if isinstance(value, float) and not math.isfinite(value):
return {"invalid_number": str(value)}
if isinstance(value, dict):
return {key: json_safe(v) for key, v in value.items()}
if isinstance(value, list):
return [json_safe(v) for v in value]
return value
def suite_status(apps: list[App], runs: list[dict], meta: dict) -> str:
if meta.get("suite_errors") or not runs or any(r["status"] != "valid" for r in runs):
return "failed"
for app in apps:
measured = [r for r in runs if r["app"] == app.key and not r["warmup"]]
if len(measured) != meta["runs"]:
return "failed"
return "valid"
def persist(apps: list[App], runs: list[dict], meta: dict, out_dir: Path):
meta["status"] = suite_status(apps, runs, meta)
# JSON first: report rendering must never discard the raw failure evidence.
def replace(name, text):
temporary = out_dir / (name + ".tmp")
temporary.write_text(text, encoding="utf-8")
temporary.replace(out_dir / name)
replace("results.json", json.dumps(json_safe({"meta": meta, "runs": runs}), indent=2, allow_nan=False))
replace("report.md", report(apps, runs, meta))
def fmt(value: float | None) -> str:
return "–" if value is None else f"{value:.2f}"
return "–" if not valid_number(value) else f"{value:.2f}"
def summarize(values: list[float]) -> str:
@@ -489,15 +656,25 @@ def summarize(values: list[float]) -> str:
def report(apps: list[App], runs: list[dict], meta: dict) -> str:
def column(app: App, getter) -> str:
vals = [v for r in runs if r["app"] == app.key and (v := getter(r)) is not None]
return summarize(vals)
measured = [r for r in runs if not r.get("warmup", False)]
rows = [(title, lambda r, k=key: r.get(k)) for key, title in METRICS]
def column(app: App, key, getter, owner=None) -> str:
attempts = [r for r in measured if r["app"] == app.key]
vals = [v for r in attempts if r["status"] == "valid"
and (owner is None or owner == app.key)
and r.get("metric_status", {}).get(key) != "unsupported"
and valid_number(v := getter(r))]
unsupported = sum(r.get("metric_status", {}).get(key) == "unsupported" for r in attempts)
suffix = " unsupported" if unsupported or (owner is not None and owner != app.key) else ""
return f"{summarize(vals)} [{len(vals)}/{len(attempts)}]{suffix}"
rows = [(key, title, lambda r, k=key: r.get(k), None) for key, title in METRICS]
for app in apps:
for m in app.markers:
rows.append((f"{app.name}: log `{m}` first (s)", lambda r, m=m: r["markers_first_s"].get(m)))
rows.append((f"{app.name}: log `{m}` last (s)", lambda r, m=m: r["markers_last_s"].get(m)))
rows.append((None, f"{app.name}: log `{m}` first (s)",
lambda r, m=m: r["markers_first_s"].get(m), app.key))
rows.append((None, f"{app.name}: log `{m}` last (s)",
lambda r, m=m: r["markers_last_s"].get(m), app.key))
lines = [
f"# IDE benchmark: {meta['project']}",
@@ -505,24 +682,34 @@ def report(apps: list[App], runs: list[dict], meta: dict) -> str:
f"{meta['os']} · {meta['cpu']} · {meta['cores']} cores · {meta['ram_gb']:.0f} GB RAM · "
f"mode **{meta['mode']}** · {meta['runs']} runs · {meta['date']}",
"",
"Median (min–max). Times are seconds from launch.",
f"Status: **{meta.get('status', 'failed')}**. Median (min–max), [valid/attempted] measured trials.",
"Only valid trials enter aggregates; warmups and partial evidence remain below and in JSON.",
"Times are seconds from launch. Unsupported metrics are not required; missing required metrics fail a trial.",
"",
"| Metric | " + " | ".join(a.name for a in apps) + " |",
"|---|" + "---|" * len(apps),
]
for title, getter in rows:
cells = [column(a, getter) for a in apps]
if any(c != "–" for c in cells):
lines.append(f"| {title} | " + " | ".join(cells) + " |")
for key, title, getter, owner in rows:
cells = [column(a, key, getter, owner) for a in apps]
lines.append(f"| {title} | " + " | ".join(cells) + " |")
lines += ["", "## Attempts (including warmups)", "", "| Trial | Status | Reasons |",
"|---|---|---|"]
for r in runs:
label = r["label"] + (" (warmup)" if r.get("warmup") else "")
reasons = "; ".join(r["reasons"]).replace("|", "\\|").replace("\n", " ")
lines.append(f"| {label} | {r['status']} | {reasons or '–'} |")
for error in meta.get("suite_errors", []):
lines.append(f"\nSuite error: {error}")
if not runs:
lines.append("\nNo trials completed: suite is not successful.")
for app in apps:
if app.install_dir and Path(app.install_dir).exists():
lines.append(f"\n{app.name} install size: {dir_size(Path(app.install_dir)) / MB:.0f} MB")
timeouts = [r["label"] for r in runs if r.get("timed_out")]
if timeouts:
lines.append(f"\n⚠ CPU never settled within the timeout: {', '.join(timeouts)}")
killed = [f"{r['label']}: {', '.join(r['killed_on_exit'])}" for r in runs if r.get("killed_on_exit")]
if killed:
lines.append("\n⚠ Killed after the exit timeout: " + "; ".join(killed))
if app.install_dir:
try:
path = Path(app.install_dir)
if path.exists():
lines.append(f"\n{app.name} install size: {dir_size(path) / MB:.0f} MB")
except OSError as exc:
lines.append(f"\n{app.name} install size unavailable: {exc}")
return "\n".join(lines) + "\n"
@@ -535,7 +722,7 @@ def main():
ap.add_argument("--config", type=Path, default=HERE / "apps.toml")
ap.add_argument("--apps", help="comma-separated keys from the config (default: all)")
ap.add_argument("--runs", type=int, default=5, help="measured runs per app (default 5)")
ap.add_argument("--warmup", type=int, default=1, help="discarded runs per app first (default 1)")
ap.add_argument("--warmup", type=int, default=1, help="unaggregated warmup runs per app first (default 1)")
ap.add_argument("--wipe-caches", action="store_true", help="delete each app's cache_dirs before every run (cold index)")
ap.add_argument("--drop-os-cache", metavar="CMD", help="shell command run before every run to drop the OS file cache")
ap.add_argument("--quiet-secs", type=float, default=5, help="CPU must stay low this long to count as ready")
@@ -543,10 +730,19 @@ def main():
ap.add_argument("--idle-secs", type=float, default=30, help="idle period measured after ready")
ap.add_argument("--timeout", type=float, default=900, help="give up waiting for ready after this many seconds")
ap.add_argument("--close-timeout", type=float, default=60)
ap.add_argument("--command-timeout", type=float, default=60, help="OS cache command deadline in seconds")
ap.add_argument("--cooldown", type=float, default=5, help="pause before each launch")
ap.add_argument("--out", type=Path, default=HERE / "results")
ap.add_argument("--yes", action="store_true", help="don't ask before wiping caches")
args = ap.parse_args()
if args.runs <= 0 or args.warmup < 0:
ap.error("--runs must be positive and --warmup must be nonnegative")
for name in ("quiet_secs", "quiet_cores", "idle_secs", "timeout", "close_timeout", "command_timeout", "cooldown"):
value = getattr(args, name)
if not math.isfinite(value) or value < 0 or (name != "cooldown" and value == 0):
ap.error(f"--{name.replace('_', '-')} must be finite and {'nonnegative' if name == 'cooldown' else 'positive'}")
if args.quiet_secs > args.timeout:
ap.error("--quiet-secs must not exceed --timeout")
if hasattr(sys.stdout, "reconfigure"):
sys.stdout.reconfigure(encoding="utf-8")
@@ -555,6 +751,8 @@ def main():
raise SystemExit(f"not a directory: {project}")
config = tomllib.loads(args.config.read_text(encoding="utf-8"))
keys = args.apps.split(",") if args.apps else list(config["apps"])
if not keys or any(not key or key not in config["apps"] for key in keys) or len(set(keys)) != len(keys):
ap.error("--apps must select at least one known app without duplicates")
apps = [App(k, config["apps"][k], project) for k in keys]
if args.wipe_caches:
@@ -567,8 +765,8 @@ def main():
return
stamp = dt.datetime.now().strftime("%Y%m%d-%H%M%S")
out_dir = args.out / f"{stamp}-{project.name}"
out_dir.mkdir(parents=True)
args.out.mkdir(parents=True, exist_ok=True)
out_dir = Path(tempfile.mkdtemp(prefix=f"{stamp}-{project.name}-", dir=args.out))
mode = "cold index" if args.wipe_caches else "warm"
if args.drop_os_cache:
mode += " + cold OS cache"
@@ -586,29 +784,42 @@ def main():
}
runs: list[dict] = []
total = args.warmup + args.runs
for i in range(total):
# Rotate the order so neither app always runs right after the other.
order = apps[i % len(apps) :] + apps[: i % len(apps)]
for app in order:
warm = i < args.warmup
label = f"{app.key}-{'warmup' if warm else 'run'}{i + 1 if warm else i - args.warmup + 1}"
print(f"[{label}] launching…", flush=True)
r = run_once(app, args, out_dir, label)
print(
f"[{label}] window {fmt(r['window_s'])} s · ready {fmt(r['ready_s'])} s · "
f"USS {r['uss_mb']:.0f} MB · idle CPU {r['idle_cpu_pct']:.1f}%",
flush=True,
)
if not warm:
previous_term = signal.signal(signal.SIGTERM, lambda *_: (_ for _ in ()).throw(KeyboardInterrupt()))
try:
persist(apps, runs, meta, out_dir)
total = args.warmup + args.runs
for i in range(total):
# Rotate the order so neither app always runs right after the other.
order = apps[i % len(apps) :] + apps[: i % len(apps)]
for app in order:
warm = i < args.warmup
label = f"{app.key}-{'warmup' if warm else 'run'}{i + 1 if warm else i - args.warmup + 1}"
r = new_trial(app, label, warm)
runs.append(r)
(out_dir / "results.json").write_text(json.dumps({"meta": meta, "runs": runs}, indent=2), encoding="utf-8")
text = report(apps, runs, meta)
(out_dir / "report.md").write_text(text, encoding="utf-8")
print("\n" + text)
persist(apps, runs, meta, out_dir)
print(f"[{label}] launching…", flush=True)
run_once(app, args, out_dir, label, r)
persist(apps, runs, meta, out_dir)
print(f"[{label}] {r['status']} · window {fmt(r['window_s'])} s · ready {fmt(r['ready_s'])} s", flush=True)
if r["status"] == "interrupted":
raise KeyboardInterrupt
except KeyboardInterrupt:
meta.setdefault("suite_errors", []).append("interrupted")
for r in runs:
if r["status"] == "running":
r["status"] = "interrupted"
failure(r, "interrupted before launch completed")
except Exception as exc:
meta.setdefault("suite_errors", []).append(f"{type(exc).__name__}: {exc}")
for r in runs:
if r["status"] == "running":
failure(r, "suite aborted before launch completed")
finally:
signal.signal(signal.SIGTERM, previous_term)
persist(apps, runs, meta, out_dir)
print(f"Raw results: {out_dir / 'results.json'}")
return 0 if meta["status"] == "valid" else 1
if __name__ == "__main__":
main()
sys.exit(main())
Loaded 100 of 314 files, more files were not shown because too many files have changed in this diff. Show more