дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-21 17:10:45 +02:00
Порівняти коміти
59
Коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
18bdd908ca | ||
|
|
af281341b1 | ||
|
|
313a5f3a14 | ||
|
|
18cd2ef63b | ||
|
|
4fc55f7520 | ||
|
|
795413c366 | ||
|
|
dd3c9c7b0a | ||
|
|
361ca01cc0 | ||
|
|
1b9c330613 | ||
|
|
2d7bb56a8d | ||
|
|
2c8a029939 | ||
|
|
6e2c19846c | ||
|
|
a4ee6110e8 | ||
|
|
6c2ae13387 | ||
|
|
34cb4ad5e0 | ||
|
|
d080ca28f8 | ||
|
|
22a5e4c9e6 | ||
|
|
e93ac42489 | ||
|
|
ae604b7933 | ||
|
|
bd27eb5474 | ||
|
|
15fcf4f2c1 | ||
|
|
65415a03bd | ||
|
|
58585e1064 | ||
|
|
0f355c286d | ||
|
|
a0a51a63cb | ||
|
|
b44393a989 | ||
|
|
eda632866a | ||
|
|
3eaaa71ae1 | ||
|
|
77503e5fee | ||
|
|
8edab7b8e6 | ||
|
|
f8474fc2a2 | ||
|
|
0558c1127c | ||
|
|
e335e8bcf6 | ||
|
|
7e2e2e6cc9 | ||
|
|
de73495ab0 | ||
|
|
6c848b9a43 | ||
|
|
4812adba97 | ||
|
|
af938d0726 | ||
|
|
8562fadde2 | ||
|
|
a50813eb56 | ||
|
|
282f1fd482 | ||
|
|
2129efd196 | ||
|
|
a4de18796b | ||
|
|
cbf09b8962 | ||
|
|
f9077a1f93 | ||
|
|
68d2370c8f | ||
|
|
d735a7b7ce | ||
|
|
4ac0cbd908 | ||
|
|
142552741a | ||
|
|
685b458ad0 | ||
|
|
846794450a | ||
|
|
5e78713188 | ||
|
|
33c802c048 | ||
|
|
1e75b7717b | ||
|
|
28a464d3b7 | ||
|
|
0b9048ce02 | ||
|
|
4567540b95 | ||
|
|
3a0288111d | ||
|
|
a83fc0f3d1 |
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",
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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(¤t).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(¤t).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(¤t).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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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};
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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`,
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -239,6 +239,8 @@ pub enum SymbolKind {
|
||||
Event,
|
||||
Operator,
|
||||
Key,
|
||||
/// A Flutter widget built in the code (Flutter outline only).
|
||||
Widget,
|
||||
Unknown,
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
|
||||
@@ -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}"),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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,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
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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)));
|
||||
}
|
||||
}
|
||||
@@ -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(¶ms.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, ¶ms),
|
||||
"window/logMessage" => {
|
||||
let text = params.get("message").and_then(Value::as_str).unwrap_or_default();
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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())]);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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")? {
|
||||
|
||||
@@ -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"#;
|
||||
|
||||
@@ -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="https://dev.example" --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);
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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('&', "&").replace('<', "<").replace('>', ">")
|
||||
}
|
||||
|
||||
/// 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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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&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();
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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 };
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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 ----
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -847,6 +847,9 @@ mod tests {
|
||||
"disabledPluginChecks": [],
|
||||
"doubleClickOpensDiff": null,
|
||||
"agentInstructions": "",
|
||||
"agent": "",
|
||||
"agentModel": "",
|
||||
"agentEffort": "",
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
|
||||
|
||||
@@ -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)。
|
||||
@@ -78,7 +78,7 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
|
||||
|
||||
在你自己的消息上可以 **编辑**(其后的消息会被替换,已经改动的文件保持不变)或 **撤回消息**。在回复上可以 **复制 Markdown**、**引用回复**、**重新生成回复**,以及 **从此处创建分支对话**,从这一点开始一个新任务。
|
||||
|
||||
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会在下一条消息重新打开原会话时才应用。如果无法恢复会话,或原会话不接受所选模型,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
|
||||
在已有对话中,打开**模型 › 刷新模型**即可查找新上线的模型,不会发送消息或更改当前选择。如果 agent 无法直接切换,所选模型会保持待应用状态。提供商返回新模型支持的思考强度后,你就可以选择强度。发送下一条消息时,OpenIDEA 会先恢复原会话并应用所选模型和思考强度,再发送消息。如果无法恢复会话,或原会话不接受其中任何一项,OpenIDEA 会还原之前的选择并提示错误,不会发送该消息。
|
||||
|
||||
所有内置按键映射中,**聚焦 Agent 输入框** 的默认快捷键都是 macOS 上的 `⌘L`、Windows / Linux 上的 `Ctrl+L`。焦点位于你自己的可输入任务对话中时,无论对话显示在编辑器标签页还是工具窗口中,它都会将焦点移回消息输入框,保留草稿、光标位置和选区;重复按下也不会改变这些内容。它不会发送消息,也不会跳转消息历史。
|
||||
|
||||
|
||||
@@ -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`)命令相同的条目会被跳过。
|
||||
|
||||
导入完成后会有通知告诉你导入了多少、哪些被跳过以及原因。
|
||||
|
||||
|
||||
@@ -175,7 +175,7 @@ Git 工具窗口的 **日志** 标签页显示提交图。
|
||||
- **转到哈希/分支/标签**(在日志中按 `⌘F` / `Ctrl+F`)。
|
||||
- **图形选项**:按日期、拓扑或传入优先排序;仅第一父提交;不显示合并提交。
|
||||
- **视图选项**:引用显示方式、详情面板,以及列(**作者**、**日期**、**哈希**、**签名**、**GitHub 提交检查**)。
|
||||
- 左侧的分支面板可以按分支过滤日志,并提供分支操作。
|
||||
- 左侧的分支面板可以按分支过滤日志,并提供分支操作。选中多个本地分支后选择 **Update Selected**,会把每个分支快进到它的跟踪分支,每个远程只 fetch 一次;结果汇总在一条通知里,列出已更新的分支,以及因不能快进或没有跟踪分支而未更新的分支。
|
||||
- 详情面板显示变更文件、提交消息、提交者、包含该提交的分支以及签名。
|
||||
|
||||
右键提交可以选择 **复制修订号**(`⌥⇧⌘C` / `Ctrl+Alt+Shift+C`)、**创建补丁…**、**拣选**、**签出修订**、**浏览此修订版本的仓库**、**与本地比较**、**将当前分支重置到此处…**、**还原提交**、**撤消提交…**、**新建分支…**、**新建标签…**、**在浏览器中查看** 等。选中两个提交时,**比较版本** 会比较它们。
|
||||
|
||||
@@ -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`、插件命令等)都会被标记为已忽略,不会执行。
|
||||
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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,
|
||||
}) => {
|
||||
|
||||
@@ -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]!);
|
||||
});
|
||||
}
|
||||
@@ -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";
|
||||
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
}) => {
|
||||
|
||||
@@ -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();
|
||||
});
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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 () => {
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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",
|
||||
),
|
||||
];
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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 }));
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
});
|
||||
@@ -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);
|
||||
});
|
||||
@@ -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,
|
||||
};
|
||||
}
|
||||
@@ -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/);
|
||||
});
|
||||
});
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
});
|
||||
});
|
||||
@@ -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",
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
Reference in new issue
Заблокувати користувача