дзеркало
https://github.com/l0ng-ai/openidea.git
синхронізовано 2026-11-16 22:55:42 +02:00
Порівняти коміти
| Автор | SHA1 | Дата | |
|---|---|---|---|
|
|
a738209cbe |
No files matched your search
Бінарний файл не відображається.
|
До Ширина: | Висота: | Розмір: 160 KiB |
Бінарний файл не відображається.
|
Після Ширина: | Висота: | Розмір: 86 KiB |
@@ -208,15 +208,11 @@ jobs:
|
||||
- run: pnpm build
|
||||
|
||||
e2e:
|
||||
name: E2E (${{ matrix.shard }}/2)
|
||||
name: E2E
|
||||
needs: changes
|
||||
if: needs.changes.outputs.frontend == 'true'
|
||||
timeout-minutes: 30
|
||||
runs-on: ubuntu-24.04
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
shard: [1, 2]
|
||||
# Browsers and their system libraries are preinstalled; keep the tag in step with @playwright/test.
|
||||
container: mcr.microsoft.com/playwright:v1.64.1-noble
|
||||
steps:
|
||||
@@ -226,12 +222,12 @@ jobs:
|
||||
- uses: actions/setup-node@v5
|
||||
with: { node-version: 22, cache: pnpm }
|
||||
- run: pnpm install --frozen-lockfile
|
||||
- run: pnpm e2e --shard=${{ matrix.shard }}/2
|
||||
- run: pnpm e2e
|
||||
env:
|
||||
HOME: /root
|
||||
- uses: actions/upload-artifact@v6
|
||||
if: failure()
|
||||
with:
|
||||
name: playwright-report-${{ matrix.shard }}
|
||||
name: playwright-report
|
||||
path: playwright-report/
|
||||
retention-days: 7
|
||||
@@ -262,46 +262,26 @@ jobs:
|
||||
}
|
||||
// The update's notes: the release body without its Download section. That
|
||||
// section only matters on the release page, and What's new follows it.
|
||||
// A translated section, "## 中文" added at the end of the draft before it is
|
||||
// published (it runs to the next heading of its level, or the end), becomes
|
||||
// `notes.zh-CN`: What's new shows it in that UI language and falls back to
|
||||
// `notes`, the English rest of the body. HTML comments are dropped.
|
||||
const { data: release } = await github.rest.repos.getRelease({ owner, repo, release_id });
|
||||
const languages = { "中文": "zh-CN" };
|
||||
const notesByLanguage = (body) => {
|
||||
const parts = { "": [] };
|
||||
let lang = "";
|
||||
let langLevel = 0;
|
||||
const withoutDownloadSection = (body) => {
|
||||
const kept = [];
|
||||
let skip = 0;
|
||||
for (const line of body.replace(/<!--[\s\S]*?-->/g, "").split(/\r?\n/)) {
|
||||
for (const line of body.split(/\r?\n/)) {
|
||||
const heading = /^(#{1,6})\s+(.*)$/.exec(line);
|
||||
if (heading) {
|
||||
const level = heading[1].length;
|
||||
const title = heading[2].trim();
|
||||
if (skip && level <= skip) skip = 0;
|
||||
if (lang && level <= langLevel) lang = "";
|
||||
if (!skip && level <= 3 && /^download$/i.test(title)) {
|
||||
if (!skip && level <= 3 && /^download$/i.test(heading[2].trim())) {
|
||||
skip = level;
|
||||
continue;
|
||||
}
|
||||
if (!skip && !lang && level <= 2 && languages[title]) {
|
||||
lang = languages[title];
|
||||
langLevel = level;
|
||||
parts[lang] ??= [];
|
||||
continue;
|
||||
}
|
||||
if (skip && level <= skip) skip = 0;
|
||||
}
|
||||
if (!skip) parts[lang].push(line);
|
||||
if (!skip) kept.push(line);
|
||||
}
|
||||
return Object.fromEntries(Object.entries(parts).map(([key, lines]) => [key, lines.join("\n").trim()]));
|
||||
};
|
||||
const { "": notes, ...translated } = notesByLanguage(String(release.body ?? ""));
|
||||
const translations = Object.fromEntries(
|
||||
Object.entries(translated).filter(([, text]) => text).map(([lang, text]) => [`notes.${lang}`, text]),
|
||||
);
|
||||
const manifest = {
|
||||
version: tag.replace(/^v/, ""), notes, ...translations, pub_date: new Date().toISOString(), platforms,
|
||||
return kept.join("\n").trim();
|
||||
};
|
||||
const notes = withoutDownloadSection(String(release.body ?? ""));
|
||||
const manifest = { version: tag.replace(/^v/, ""), notes, pub_date: new Date().toISOString(), platforms };
|
||||
const old = assets.find((a) => a.name === "latest.json");
|
||||
if (old) await github.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
|
||||
await github.rest.repos.uploadReleaseAsset({
|
||||
|
||||
@@ -42,7 +42,6 @@ Visual style: dark, low-contrast greys, one cool accent
|
||||
shortcuts live in `src/platform/keymaps/`.
|
||||
- Styling: CSS Modules + tokens only (no hex literals in components). Inline SVG
|
||||
icons from `src/ui/icons.tsx`, never emoji. Real `<button>`/`<input>`; `aria-label` on icon buttons.
|
||||
`gap` uses the `--space-*` scale (`src/styles/tokens.css`, 4px grid) where a value is on it.
|
||||
- User-visible text goes through the text catalog: add every new string to both
|
||||
`src/platform/locales/text/en.json` and `zh.json` (`textCatalog.test.ts` enforces it).
|
||||
Other locales may lack entries; their UI shows the English text until a translator adds it.
|
||||
|
||||
Створено
+6
-131
@@ -199,7 +199,7 @@ dependencies = [
|
||||
"wayland-backend",
|
||||
"wayland-client",
|
||||
"wayland-protocols",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5722,20 +5722,6 @@ dependencies = [
|
||||
"serde_repr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mac-notification-sys"
|
||||
version = "0.6.15"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fd604973958ddcc11b561193c0fb96ba146506ef2f231ef2e7c35fd2cbc9beca"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"log",
|
||||
"objc2 0.6.5",
|
||||
"objc2-foundation 0.3.2",
|
||||
"time",
|
||||
"uuid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "mach2"
|
||||
version = "0.6.0"
|
||||
@@ -6008,20 +5994,6 @@ dependencies = [
|
||||
"windows-sys 0.60.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "notify-rust"
|
||||
version = "4.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57da5b5d3b7809bf71858da5a2818c3404ca4688c02c8abecdda0fcdec235df3"
|
||||
dependencies = [
|
||||
"futures-lite",
|
||||
"log",
|
||||
"mac-notification-sys",
|
||||
"serde",
|
||||
"tauri-winrt-notification",
|
||||
"zbus 6.3.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "notify-types"
|
||||
version = "2.1.0"
|
||||
@@ -6694,7 +6666,6 @@ dependencies = [
|
||||
"tauri-build",
|
||||
"tauri-plugin-dialog",
|
||||
"tauri-plugin-mcp-bridge",
|
||||
"tauri-plugin-notification",
|
||||
"tauri-plugin-opener",
|
||||
"tauri-plugin-single-instance",
|
||||
"tauri-plugin-updater",
|
||||
@@ -8182,7 +8153,7 @@ dependencies = [
|
||||
"once_cell",
|
||||
"serde",
|
||||
"sha2 0.11.1",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9458,26 +9429,6 @@ dependencies = [
|
||||
"windows-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-notification"
|
||||
version = "2.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "14a226bfb8189ec4ab2c1936e66330ad06c44d9f6c54a674338208491dee177f"
|
||||
dependencies = [
|
||||
"log",
|
||||
"notify-rust",
|
||||
"rand 0.10.3",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"serde_repr",
|
||||
"tauri",
|
||||
"tauri-plugin",
|
||||
"thiserror 2.0.21",
|
||||
"time",
|
||||
"url",
|
||||
"zbus 5.19.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-opener"
|
||||
version = "2.7.2"
|
||||
@@ -9497,7 +9448,7 @@ dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"url",
|
||||
"windows",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9513,7 +9464,7 @@ dependencies = [
|
||||
"tokio",
|
||||
"tracing",
|
||||
"windows-sys 0.61.2",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -9696,17 +9647,6 @@ dependencies = [
|
||||
"toml 1.1.8+spec-1.1.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tauri-winrt-notification"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f37a6c354fd28fc9e322ed9bd47e3959576dad28c9d58ea1cf888cce1c7ccb36"
|
||||
dependencies = [
|
||||
"thiserror 2.0.21",
|
||||
"windows",
|
||||
"windows-version",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tempfile"
|
||||
version = "3.27.0"
|
||||
@@ -12197,38 +12137,11 @@ dependencies = [
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros 5.19.0",
|
||||
"zbus_macros",
|
||||
"zbus_names",
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus"
|
||||
version = "6.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b4aae740b23927ceabed962431abab2cdefb9f7f885e5bbab062da09bf580e4"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"bitflags 2.13.2",
|
||||
"endi",
|
||||
"futures-core",
|
||||
"hex",
|
||||
"libc",
|
||||
"ordered-stream",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_repr",
|
||||
"socket2",
|
||||
"uds_windows",
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow 1.0.4",
|
||||
"zbus_macros 6.3.0",
|
||||
"zbus_utils",
|
||||
"zcheapstr",
|
||||
"zruntime",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus-secret-service-keyring-store"
|
||||
version = "1.0.1"
|
||||
@@ -12237,7 +12150,7 @@ checksum = "74801d001b9e7729adb4f1825b67b398185fed424749aa3d8bacf70417137d9a"
|
||||
dependencies = [
|
||||
"keyring-core",
|
||||
"secret-service",
|
||||
"zbus 5.19.0",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -12255,18 +12168,6 @@ dependencies = [
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_macros"
|
||||
version = "6.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37c9dd4beaf145c16fcb2902862f50da86e54aed13dd368ddf64a1d17e6b8529"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
"zbus_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_names"
|
||||
version = "4.3.5"
|
||||
@@ -12278,19 +12179,6 @@ dependencies = [
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_utils"
|
||||
version = "6.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af55e52da295311b368c45bcae221f020e28e97a2420360170ce389218e76ec7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde",
|
||||
"syn 3.0.9",
|
||||
"winnow 1.0.4",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zcheapstr"
|
||||
version = "1.1.0"
|
||||
@@ -12447,19 +12335,6 @@ dependencies = [
|
||||
"simd-adler32",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zruntime"
|
||||
version = "0.2.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ce6a55d4f521760475a30f7b96779508fe8c40dc834478709454dd1d5f0ebc72"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
"futures-io",
|
||||
"rustix",
|
||||
"socket2",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zune-core"
|
||||
version = "0.5.3"
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ the [official plugins](plugins/official). The plugin API is still a preview.
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP) — questions, feedback and release news.
|
||||
- WeChat group — scan to join:
|
||||
|
||||
<img src=".github/assets/wechat-group-3.png" alt="WeChat group QR code" width="200">
|
||||
<img src=".github/assets/wechat-group.png" alt="WeChat group QR code" width="200">
|
||||
|
||||
- Contributing: see [CONTRIBUTING.md](CONTRIBUTING.md) and the [contributor docs](https://openidea.sh/en/contribute/setup).
|
||||
|
||||
|
||||
+9
-9
@@ -38,14 +38,14 @@ Editör, kod analizi, hata ayıklayıcı (debugger), Git, terminal, veritabanı
|
||||
[freqtrade](https://github.com/freqtrade/freqtrade) projesini (Python, ~770 dosya)
|
||||
önbellekler hazırken açma, 5 çalıştırmanın ortancası:
|
||||
|
||||
| | OpenIDEA | IntelliJ IDEA 2026.2.3 |
|
||||
| ---------------------------- | ----------------------- | ---------------------- |
|
||||
| Projeyle pencerenin açılması | **0,9 sn** | 3,1 sn |
|
||||
| Hazır (CPU sakinleşti) | **1,1 sn** | 13,2 sn |
|
||||
| Bellek (USS, tüm işlemler) | **169 MB** | 2011 MB |
|
||||
| Hazır olana kadar CPU süresi | **2,4 sn** | 47,9 sn |
|
||||
| Boştayken CPU | Bir çekirdeğin **%4**'ü | Bir çekirdeğin %7'si |
|
||||
| Kapanma | **0,3 sn** | 5,9 sn |
|
||||
| | OpenIDEA | IntelliJ IDEA 2026.2.3 |
|
||||
| ---------------------------------- | --------------------- | ---------------------- |
|
||||
| Projeyle pencerenin açılması | **0,9 sn** | 3,1 sn |
|
||||
| Hazır (CPU sakinleşti) | **1,1 sn** | 13,2 sn |
|
||||
| Bellek (USS, tüm işlemler) | **169 MB** | 2011 MB |
|
||||
| Hazır olana kadar CPU süresi | **2,4 sn** | 47,9 sn |
|
||||
| Boştayken CPU | Bir çekirdeğin **%4**'ü | Bir çekirdeğin %7'si |
|
||||
| Kapanma | **0,3 sn** | 5,9 sn |
|
||||
|
||||
`main` dalından derlenmiş bir OpenIDEA sürümü ve varsayılan ayar ve eklentilerle IDEA;
|
||||
Windows 11, 32 çekirdekli AMD, 62 GB RAM.
|
||||
@@ -68,7 +68,7 @@ Eklentileri Ayarlar › Eklentiler (Settings › Plugins) bölümünden kur ya d
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP): sorular, geri bildirim ve sürüm haberleri.
|
||||
- WeChat grubu, katılmak için kodu okut:
|
||||
|
||||
<img src=".github/assets/wechat-group-3.png" alt="WeChat grubu QR kodu" width="200">
|
||||
<img src=".github/assets/wechat-group.png" alt="WeChat grubu QR kodu" width="200">
|
||||
|
||||
- Katkıda bulunmak için: [CONTRIBUTING.md](CONTRIBUTING.md) ve [katkıcı belgeleri](https://openidea.sh/en/contribute/setup).
|
||||
|
||||
|
||||
@@ -66,7 +66,7 @@ WebAssembly 组件运行;主题、图标主题和语言无需编写代码。
|
||||
- [Discord](https://discord.gg/2Zy4yn7gP):提问、反馈和版本发布消息。
|
||||
- 微信群,扫码加入:
|
||||
|
||||
<img src=".github/assets/wechat-group-3.png" alt="微信群二维码" width="200">
|
||||
<img src=".github/assets/wechat-group.png" alt="微信群二维码" width="200">
|
||||
|
||||
- 参与贡献:参见 [CONTRIBUTING.md](CONTRIBUTING.md) 和[贡献者文档](https://openidea.sh/zh/contribute/setup)。
|
||||
|
||||
|
||||
@@ -10,14 +10,12 @@ use crate::provider::ProviderSpec;
|
||||
use crate::{Shared, client_info};
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
|
||||
|
||||
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
|
||||
/// session's model: they describe that model only, and other models may offer different ones.
|
||||
/// Opens `session/new`, reads `configOptions`, and records per-model `thought_level` choices.
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
|
||||
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
|
||||
match run_once(shared, spec, prefer_stored).await {
|
||||
@@ -64,17 +62,21 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
.map_err(|e| e.to_string())?;
|
||||
let mut options = config::options_of(&new);
|
||||
config::add_client_options(&launch.id, &mut options);
|
||||
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
|
||||
let levels = match (model, levels_for_model_from_slice(&options)) {
|
||||
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
|
||||
_ => BTreeMap::new(),
|
||||
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
|
||||
let effort = levels_for_model_from_slice(&options);
|
||||
let levels: Vec<(String, Vec<AgentConfigOption>)> = match (model_option, effort) {
|
||||
(Some(model), Some(effort)) if !model.values.is_empty() => {
|
||||
model.values.iter().map(|v| (v.value.clone(), effort.clone())).collect()
|
||||
}
|
||||
(Some(model), Some(effort)) => model.current.clone().map(|m| vec![(m, effort)]).unwrap_or_default(),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let commands = updates
|
||||
.commands
|
||||
.lock()
|
||||
.clone()
|
||||
.or_else(|| new.get("availableCommands").map(|_| config::commands_of(&new, &launch.id)));
|
||||
Ok::<_, String>(Discovered { config: options, commands, levels })
|
||||
Ok::<_, String>(Discovered { config: options, commands, levels: levels.into_iter().collect() })
|
||||
};
|
||||
let result = tokio::time::timeout(DISCOVER_TIMEOUT, work).await;
|
||||
peer.kill();
|
||||
@@ -106,17 +108,18 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
}
|
||||
}
|
||||
|
||||
fn is_thought_level(o: &AgentConfigOption) -> bool {
|
||||
o.category.as_deref() == Some("thought_level")
|
||||
|| matches!(o.id.as_str(), "effort" | "reasoning_effort" | "thinking" | "reasoning")
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
|
||||
let levels: Vec<_> = options
|
||||
.iter()
|
||||
.filter(|o| config::is_per_model_option(o))
|
||||
.filter(|o| is_thought_level(o))
|
||||
.cloned()
|
||||
.map(|mut o| {
|
||||
if config::is_context_option(&o.id) {
|
||||
if o.category.is_none() {
|
||||
o.category = Some("model_config".into());
|
||||
}
|
||||
} else if o.category.as_deref() != Some("thought_level") {
|
||||
if o.category.as_deref() != Some("thought_level") {
|
||||
o.category = Some("thought_level".into());
|
||||
}
|
||||
o
|
||||
|
||||
@@ -58,8 +58,6 @@ fn client_capabilities() -> Value {
|
||||
"terminal": false,
|
||||
// Subagents as sessions of their own (ACP subagents RFD; v2 baseline).
|
||||
"subagents": {},
|
||||
// Forms the agent asks the user to fill in (`elicitation/create`); not URL mode.
|
||||
"elicitation": { "form": {} },
|
||||
// Cursor exposes model parameters (e.g. Composer `fast`) as separate config options
|
||||
// only when the client advertises this flag (undocumented Cursor ACP extension).
|
||||
"_meta": { "parameterizedModelPicker": true },
|
||||
@@ -322,13 +320,6 @@ impl Handler for Dialect {
|
||||
}
|
||||
self.inner.on_request(method, params)
|
||||
}
|
||||
|
||||
fn on_request_raw(&self, method: &str, params: Value, raw: &[u8]) -> Result<Value, (i64, String, Option<Value>)> {
|
||||
if self.v2() && method == "session/request_permission" {
|
||||
return self.on_request_with_data(method, params);
|
||||
}
|
||||
self.inner.on_request_raw(method, params, raw)
|
||||
}
|
||||
}
|
||||
|
||||
/// A v2 permission request with the v1 `toolCall` (its subject's, titled with the request's title).
|
||||
|
||||
@@ -97,13 +97,10 @@ fn the_negotiating_request_carries_both_versions() {
|
||||
p["clientCapabilities"]["_meta"]["parameterizedModelPicker"], true,
|
||||
"Cursor and similar agents need parameterized model options (e.g. fast on/off)"
|
||||
);
|
||||
// Forms only: URL mode would open pages the agent names.
|
||||
assert_eq!(p["clientCapabilities"]["elicitation"], json!({ "form": {} }));
|
||||
// What we sent in the capture is what claude-agent-acp negotiated v2 and v1 from.
|
||||
let sent = frames(TURN, "out")[0]["params"]["clientCapabilities"].clone();
|
||||
let mut expected = sent;
|
||||
expected["_meta"] = p["clientCapabilities"]["_meta"].clone();
|
||||
expected["elicitation"] = p["clientCapabilities"]["elicitation"].clone();
|
||||
assert_eq!(expected, p["clientCapabilities"]);
|
||||
}
|
||||
|
||||
@@ -171,8 +168,7 @@ async fn discovery_reads_effort_and_fast_from_session_new_then_stops_the_agent()
|
||||
let fast = cursor.config.iter().find(|o| o.id == "fast").expect("fast option");
|
||||
assert_eq!(fast.category.as_deref(), Some("model_config"));
|
||||
assert_eq!(fast.current.as_deref(), Some("false"));
|
||||
// The effort option belongs to the session's model; m2 may offer other levels.
|
||||
assert_eq!(cursor.thought_levels.keys().collect::<Vec<_>>(), ["m1"]);
|
||||
assert!(cursor.thought_levels.contains_key("m1") && cursor.thought_levels.contains_key("m2"));
|
||||
assert!(cursor.thought_levels["m1"].iter().any(|o| o.category.as_deref() == Some("thought_level")));
|
||||
}
|
||||
|
||||
|
||||
@@ -56,16 +56,6 @@ pub(crate) struct CatalogData {
|
||||
pub refreshed_at_ms: Option<f64>,
|
||||
}
|
||||
|
||||
impl CatalogData {
|
||||
fn model_option(&self) -> Option<&AgentConfigOption> {
|
||||
self.config.iter().find(|o| o.category.as_deref() == Some("model"))
|
||||
}
|
||||
|
||||
fn lists(&self, model: &str) -> bool {
|
||||
self.model_option().is_some_and(|o| o.values.iter().any(|v| v.value == model))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct SavedCatalog {
|
||||
@@ -339,17 +329,11 @@ impl AgentCatalogs {
|
||||
Ok(found) => {
|
||||
let mut cache = shared.known.lock();
|
||||
let known = cache.entry(key.2.clone()).or_default();
|
||||
let mut catalog = CatalogData {
|
||||
let catalog = CatalogData {
|
||||
config: found.config,
|
||||
thought_levels: found.levels,
|
||||
refreshed_at_ms: Some(self.epoch_ms()),
|
||||
};
|
||||
// Efforts sessions reported for models discovery doesn't read stay while listed.
|
||||
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
|
||||
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
|
||||
catalog.thought_levels.insert(model, levels);
|
||||
}
|
||||
}
|
||||
known.config = catalog.config.clone();
|
||||
known.thought_levels = catalog.thought_levels.clone();
|
||||
if let Some(commands) = found.commands {
|
||||
@@ -382,42 +366,6 @@ impl AgentCatalogs {
|
||||
}
|
||||
}
|
||||
|
||||
/// Records the efforts a session reported for a listed `model` other than the one discovery
|
||||
/// read: ACP discovery opens one session, so it knows only that model's efforts.
|
||||
pub(crate) fn learn_levels(&self, shared: &Shared, provider: &str, model: &str, levels: Vec<AgentConfigOption>) {
|
||||
let lacks = |catalog: &CatalogData| {
|
||||
catalog.lists(model)
|
||||
&& catalog.model_option().and_then(|o| o.current.as_deref()) != Some(model)
|
||||
&& catalog.thought_levels.get(model) != Some(&levels)
|
||||
};
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
let mut learned = false;
|
||||
if let Some(catalog) = state.entries.get_mut(&key).and_then(|e| e.catalog.as_mut()).filter(|c| lacks(c)) {
|
||||
catalog.thought_levels.insert(model.to_owned(), levels.clone());
|
||||
learned = true;
|
||||
}
|
||||
let mut cache = shared.known.lock();
|
||||
if let Some(saved) = cache
|
||||
.get_mut(provider)
|
||||
.and_then(|known| known.catalogs.get_mut(&shared.root_key()))
|
||||
.filter(|saved| lacks(&saved.catalog))
|
||||
{
|
||||
saved.catalog.thought_levels.insert(model.to_owned(), levels);
|
||||
learned = true;
|
||||
}
|
||||
if !learned {
|
||||
return;
|
||||
}
|
||||
shared.persist_known(&cache);
|
||||
drop(cache);
|
||||
let snapshot = state.entries.get(&key).map(|entry| self.snapshot(shared, provider, entry));
|
||||
drop(state);
|
||||
if let Some(snapshot) = snapshot {
|
||||
self.broadcast(shared, &snapshot);
|
||||
}
|
||||
}
|
||||
|
||||
fn subscribers(&self, shared: &Shared) -> Vec<Arc<Shared>> {
|
||||
self.state
|
||||
.lock()
|
||||
|
||||
@@ -199,8 +199,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
pending.reply.send(Ok(response(&["retained", "new"], &["medium"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
assert_eq!(model_values(&fresh), ["retained", "new"]);
|
||||
// The session's efforts describe its own model, not "new".
|
||||
assert_eq!(fresh.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["retained"]);
|
||||
assert_eq!(fresh.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["new", "retained"]);
|
||||
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
|
||||
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
@@ -221,42 +220,6 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
assert!(!tmp.path().join("store").exists(), "refresh never creates tasks");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
|
||||
// "first" with other efforts, changes nothing.
|
||||
let second = config::options_of(&response(&["second"], &["off", "auto"]));
|
||||
manager.shared.remember(PROVIDER, Some(&second), None, Some("second"));
|
||||
manager.shared.remember(PROVIDER, Some(&config::options_of(&response(&["gone"], &["x"]))), None, Some("gone"));
|
||||
manager.shared.remember(PROVIDER, Some(&config::options_of(&response(&["first"], &["max"]))), None, Some("first"));
|
||||
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
|
||||
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
|
||||
};
|
||||
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
|
||||
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
|
||||
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
|
||||
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
|
||||
// Discovery again reads "first" only; "second" keeps what its session reported.
|
||||
advance(&catalogs, 60);
|
||||
while events.try_recv().is_ok() {}
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
assert_eq!(efforts(&fresh, "first"), ["medium"]);
|
||||
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -20,22 +20,17 @@ pub(crate) fn add_client_options(provider: &str, config: &mut Vec<AgentConfigOpt
|
||||
description: Some("Tool approvals for this Cursor conversation".into()),
|
||||
category: Some("approval".into()),
|
||||
current: Some("ask".into()),
|
||||
default_value: Some("ask".into()),
|
||||
via: AgentConfigVia::Option,
|
||||
values: vec![
|
||||
AgentConfigValue {
|
||||
value: "ask".into(),
|
||||
name: "Ask for approval".into(),
|
||||
description: Some("Show permission requests from Cursor".into()),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
},
|
||||
AgentConfigValue {
|
||||
value: "bypass".into(),
|
||||
name: "Bypass approvals".into(),
|
||||
description: Some("Automatically approve tool requests in this conversation".into()),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
},
|
||||
],
|
||||
});
|
||||
@@ -123,18 +118,6 @@ pub(crate) fn options_of(result: &Value) -> Vec<AgentConfigOption> {
|
||||
out
|
||||
}
|
||||
|
||||
pub(crate) fn is_context_option(id: &str) -> bool {
|
||||
matches!(id, "context_tier" | "contextTier")
|
||||
}
|
||||
|
||||
/// Whether an option's available values and default belong to the selected model
|
||||
/// (`thought_level` and model context-tier options) rather than the provider as a whole.
|
||||
pub(crate) fn is_per_model_option(o: &AgentConfigOption) -> bool {
|
||||
matches!(o.category.as_deref(), Some("thought_level" | "context_tier"))
|
||||
|| matches!(o.id.as_str(), "effort" | "reasoning_effort" | "thinking" | "reasoning")
|
||||
|| is_context_option(&o.id)
|
||||
}
|
||||
|
||||
/// A `configOptions` array; only select options are kept (the UI shows them as dropdowns).
|
||||
pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
|
||||
let Some(list) = options.as_array() else { return Vec::new() };
|
||||
@@ -150,8 +133,6 @@ pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
|
||||
None => values.extend(value_of(v)),
|
||||
}
|
||||
}
|
||||
let current = str_of(o, "currentValue");
|
||||
let default_value = str_of(o, "defaultValue").or_else(|| current.clone());
|
||||
Some(AgentConfigOption {
|
||||
name: str_of(o, "name").unwrap_or_else(|| id.clone()),
|
||||
description: str_of(o, "description"),
|
||||
@@ -162,10 +143,9 @@ pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
|
||||
matches!(id.as_str(), "effort" | "reasoning_effort" | "thinking" | "reasoning")
|
||||
.then(|| "thought_level".into())
|
||||
})
|
||||
.or_else(|| (id == "fast" || is_context_option(&id)).then(|| "model_config".into()))
|
||||
.or_else(|| matches!(id.as_str(), "fast").then(|| "model_config".into()))
|
||||
}),
|
||||
current,
|
||||
default_value,
|
||||
current: str_of(o, "currentValue"),
|
||||
values,
|
||||
via: AgentConfigVia::Option,
|
||||
id,
|
||||
@@ -175,24 +155,9 @@ pub(crate) fn parse_options(options: &Value) -> Vec<AgentConfigOption> {
|
||||
}
|
||||
|
||||
/// A `config_option_update`: its options replace the config-option ones; `modes` / `models`
|
||||
/// stand-ins stay, and initial `default_value`s survive same-model option edits for Reset.
|
||||
/// stand-ins stay.
|
||||
pub(crate) fn merge_update(config: &mut Vec<AgentConfigOption>, options: &Value) {
|
||||
let mut fresh = parse_options(options);
|
||||
let old_model = config.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
|
||||
let new_model = fresh.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
|
||||
let same_model = old_model == new_model;
|
||||
for f in &mut fresh {
|
||||
if f.default_value == f.current
|
||||
&& (same_model || !is_per_model_option(f))
|
||||
&& let Some(prev_default) = config
|
||||
.iter()
|
||||
.find(|p| p.id == f.id)
|
||||
.and_then(|p| p.default_value.as_ref())
|
||||
.filter(|def| f.values.iter().any(|v| v.value == **def))
|
||||
{
|
||||
f.default_value = Some(prev_default.clone());
|
||||
}
|
||||
}
|
||||
let fresh = parse_options(options);
|
||||
let covered = |o: &AgentConfigOption| fresh.iter().any(|f| f.category.is_some() && f.category == o.category);
|
||||
config.retain(|o| o.id == CURSOR_APPROVAL || (o.via != AgentConfigVia::Option && !covered(o)));
|
||||
let legacy = std::mem::take(config);
|
||||
@@ -286,20 +251,16 @@ fn legacy(
|
||||
Some(AgentConfigValue {
|
||||
name: str_of(m, "name").unwrap_or_else(|| value.clone()),
|
||||
description: str_of(m, "description"),
|
||||
cost_category: None,
|
||||
usage_multiplier: None,
|
||||
value,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let current = str_of(v, current);
|
||||
AgentConfigOption {
|
||||
id: id.to_owned(),
|
||||
name: name.to_owned(),
|
||||
description: None,
|
||||
category: Some(id.to_owned()),
|
||||
default_value: current.clone(),
|
||||
current,
|
||||
current: str_of(v, current),
|
||||
values,
|
||||
via,
|
||||
}
|
||||
@@ -307,23 +268,9 @@ fn legacy(
|
||||
|
||||
fn value_of(v: &Value) -> Option<AgentConfigValue> {
|
||||
let value = v.get("value")?.as_str()?.to_owned();
|
||||
let meta = v.get("_meta");
|
||||
let cost_category = meta
|
||||
.and_then(|m| m.get("copilotPriceCategory").or_else(|| m.get("priceCategory")))
|
||||
.and_then(Value::as_str)
|
||||
.map(|s| s.trim().to_ascii_lowercase())
|
||||
.filter(|s| !s.is_empty());
|
||||
let usage_multiplier = meta
|
||||
.and_then(|m| m.get("copilotUsage").or_else(|| m.get("usageMultiplier")))
|
||||
.and_then(Value::as_str)
|
||||
.map(str::trim)
|
||||
.filter(|s| !s.is_empty())
|
||||
.map(str::to_owned);
|
||||
Some(AgentConfigValue {
|
||||
name: str_of(v, "name").unwrap_or_else(|| value.clone()),
|
||||
description: str_of(v, "description"),
|
||||
cost_category,
|
||||
usage_multiplier,
|
||||
value,
|
||||
})
|
||||
}
|
||||
@@ -455,53 +402,17 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn effort_and_fast_categories_are_inferred_from_ids() {
|
||||
let mut c = options_of(&json!({
|
||||
let c = options_of(&json!({
|
||||
"configOptions": [
|
||||
{"id": "model", "type": "select", "currentValue": "gemini-4-carbon",
|
||||
"options": [{"value": "gemini-4-carbon", "name": "Gemini 4 Carbon",
|
||||
"description": "Powerful · Medium cost",
|
||||
"_meta": {"copilotPriceCategory": "Medium", "copilotUsage": "1x"}}]},
|
||||
{"id": "effort", "type": "select", "currentValue": "medium",
|
||||
"options": [{"value": "low"}, {"value": "medium"}, {"value": "high"}]},
|
||||
{"id": "contextTier", "type": "select", "currentValue": "default",
|
||||
"options": [{"value": "default", "name": "200K"}, {"value": "long_context", "name": "1M"}]},
|
||||
{"id": "effort", "type": "select", "currentValue": "high",
|
||||
"options": [{"value": "low"}, {"value": "high"}]},
|
||||
{"id": "fast", "type": "select", "currentValue": "false",
|
||||
"options": [{"value": "false", "name": "Off"}, {"value": "true", "name": "On"}]}
|
||||
]
|
||||
}));
|
||||
assert_eq!(c.len(), 4);
|
||||
assert_eq!(c[0].values[0].cost_category.as_deref(), Some("medium"));
|
||||
assert_eq!(c[0].values[0].usage_multiplier.as_deref(), Some("1x"));
|
||||
assert_eq!(c[1].category.as_deref(), Some("thought_level"));
|
||||
assert_eq!(c[1].default_value.as_deref(), Some("medium"));
|
||||
assert_eq!(c[2].category.as_deref(), Some("model_config"));
|
||||
assert!(is_per_model_option(&c[1]) && is_per_model_option(&c[2]) && !is_per_model_option(&c[3]));
|
||||
|
||||
// Editing effort on the same model preserves its initial `default_value` for Reset.
|
||||
merge_update(
|
||||
&mut c,
|
||||
&json!([
|
||||
{"id": "model", "type": "select", "currentValue": "gemini-4-carbon",
|
||||
"options": [{"value": "gemini-4-carbon"}]},
|
||||
{"id": "effort", "type": "select", "currentValue": "high",
|
||||
"options": [{"value": "low"}, {"value": "medium"}, {"value": "high"}]}
|
||||
]),
|
||||
);
|
||||
let effort = c.iter().find(|o| o.id == "effort").unwrap();
|
||||
assert_eq!((effort.current.as_deref(), effort.default_value.as_deref()), (Some("high"), Some("medium")));
|
||||
|
||||
// Switching models refreshes per-model `default_value` to the new model's default.
|
||||
merge_update(
|
||||
&mut c,
|
||||
&json!([
|
||||
{"id": "model", "type": "select", "currentValue": "gpt-6-sol",
|
||||
"options": [{"value": "gemini-4-carbon"}, {"value": "gpt-6-sol"}]},
|
||||
{"id": "effort", "type": "select", "currentValue": "low",
|
||||
"options": [{"value": "low"}, {"value": "medium"}, {"value": "high"}]}
|
||||
]),
|
||||
);
|
||||
let effort = c.iter().find(|o| o.id == "effort").unwrap();
|
||||
assert_eq!((effort.current.as_deref(), effort.default_value.as_deref()), (Some("low"), Some("low")));
|
||||
assert_eq!(c.len(), 2);
|
||||
assert_eq!(c[0].category.as_deref(), Some("thought_level"));
|
||||
assert_eq!(c[1].category.as_deref(), Some("model_config"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -1,305 +0,0 @@
|
||||
//! ACP elicitation in form mode: the agent's restricted JSON Schema as form fields, and the
|
||||
//! user's answer as the `elicitation/create` response.
|
||||
|
||||
use crate::model::{AgentForm, AgentFormField, AgentFormFieldKind, AgentFormOption, AgentPermissionOption};
|
||||
use serde::Deserialize;
|
||||
use serde::de::{Deserializer, IgnoredAny, MapAccess, Visitor};
|
||||
use serde_json::{Map, Value, json};
|
||||
|
||||
/// The reply that declines the form; a JSON object of field name to values accepts it, and
|
||||
/// anything else cancels it.
|
||||
const DECLINE: &str = "decline";
|
||||
|
||||
/// The form `elicitation/create` asks for; `Err` when it asks for something else.
|
||||
pub(crate) fn form_of(params: &Value) -> Result<AgentForm, String> {
|
||||
if params.get("mode").and_then(Value::as_str) != Some("form") {
|
||||
return Err("only form elicitation is supported".to_owned());
|
||||
}
|
||||
let schema = params.get("requestedSchema").ok_or("requestedSchema is missing")?;
|
||||
let required: Vec<&str> = schema
|
||||
.get("required")
|
||||
.and_then(Value::as_array)
|
||||
.map(|names| names.iter().filter_map(Value::as_str).collect())
|
||||
.unwrap_or_default();
|
||||
let properties = schema.get("properties").and_then(Value::as_object).ok_or("requestedSchema has no properties")?;
|
||||
let fields = properties
|
||||
.iter()
|
||||
.map(|(name, property)| field(name, property, required.contains(&name.as_str())))
|
||||
.collect::<Result<_, _>>()?;
|
||||
Ok(AgentForm { fields })
|
||||
}
|
||||
|
||||
/// Orders the fields as the request's schema lists them: `Value` keeps object keys sorted, and
|
||||
/// the agent's order is the one its form reads in.
|
||||
pub(crate) fn in_schema_order(form: &mut AgentForm, raw: &[u8]) {
|
||||
#[derive(Deserialize)]
|
||||
struct Request {
|
||||
params: Params,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct Params {
|
||||
#[serde(rename = "requestedSchema")]
|
||||
schema: Schema,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct Schema {
|
||||
properties: Keys,
|
||||
}
|
||||
struct Keys(Vec<String>);
|
||||
impl<'de> Deserialize<'de> for Keys {
|
||||
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
|
||||
struct Visit;
|
||||
impl<'de> Visitor<'de> for Visit {
|
||||
type Value = Keys;
|
||||
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
||||
f.write_str("an object")
|
||||
}
|
||||
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Keys, A::Error> {
|
||||
let mut keys = Vec::new();
|
||||
while let Some((key, IgnoredAny)) = map.next_entry::<String, IgnoredAny>()? {
|
||||
keys.push(key);
|
||||
}
|
||||
Ok(Keys(keys))
|
||||
}
|
||||
}
|
||||
deserializer.deserialize_map(Visit)
|
||||
}
|
||||
}
|
||||
let Ok(request) = serde_json::from_slice::<Request>(raw) else { return };
|
||||
let order = request.params.schema.properties.0;
|
||||
form.fields.sort_by_key(|field| order.iter().position(|name| *name == field.name).unwrap_or(usize::MAX));
|
||||
}
|
||||
|
||||
fn field(name: &str, property: &Value, required: bool) -> Result<AgentFormField, String> {
|
||||
let text = |key: &str| property.get(key).and_then(Value::as_str).unwrap_or_default().trim().to_owned();
|
||||
let number = |key: &str| property.get(key).and_then(Value::as_f64);
|
||||
let unsupported = || format!("field {name} has an unsupported schema");
|
||||
let (kind, options, min, max) = match property.get("type").and_then(Value::as_str) {
|
||||
Some("string") => match choices(property) {
|
||||
Some(options) => (AgentFormFieldKind::Choice, options, None, None),
|
||||
None => (AgentFormFieldKind::Text, Vec::new(), number("minLength"), number("maxLength")),
|
||||
},
|
||||
Some("number") => (AgentFormFieldKind::Number, Vec::new(), number("minimum"), number("maximum")),
|
||||
Some("integer") => (AgentFormFieldKind::Integer, Vec::new(), number("minimum"), number("maximum")),
|
||||
Some("boolean") => (AgentFormFieldKind::Boolean, Vec::new(), None, None),
|
||||
Some("array") => {
|
||||
let options = property.get("items").and_then(choices).ok_or_else(unsupported)?;
|
||||
(AgentFormFieldKind::Choices, options, number("minItems"), number("maxItems"))
|
||||
}
|
||||
_ => return Err(unsupported()),
|
||||
};
|
||||
let default = match property.get("default") {
|
||||
Some(Value::Array(values)) => values.iter().filter_map(scalar).collect(),
|
||||
Some(value) => scalar(value).into_iter().collect(),
|
||||
None => Vec::new(),
|
||||
};
|
||||
let title = text("title");
|
||||
Ok(AgentFormField {
|
||||
name: name.to_owned(),
|
||||
title: if title.is_empty() { name.to_owned() } else { title },
|
||||
description: text("description"),
|
||||
required,
|
||||
kind,
|
||||
options,
|
||||
default,
|
||||
min,
|
||||
max,
|
||||
})
|
||||
}
|
||||
|
||||
/// The values of a choice: `enum` (titled by the legacy `enumNames`), or `oneOf` / `anyOf`
|
||||
/// of `{ const, title }`.
|
||||
fn choices(schema: &Value) -> Option<Vec<AgentFormOption>> {
|
||||
let option = |value: &str, label: Option<&str>, description: Option<&str>| AgentFormOption {
|
||||
value: value.to_owned(),
|
||||
label: label.filter(|l| !l.trim().is_empty()).unwrap_or(value).to_owned(),
|
||||
description: description.unwrap_or_default().trim().to_owned(),
|
||||
};
|
||||
if let Some(values) = schema.get("enum").and_then(Value::as_array) {
|
||||
let names = schema.get("enumNames").and_then(Value::as_array);
|
||||
return Some(
|
||||
values
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(i, value)| {
|
||||
Some(option(value.as_str()?, names.and_then(|n| n.get(i)).and_then(Value::as_str), None))
|
||||
})
|
||||
.collect(),
|
||||
);
|
||||
}
|
||||
let listed = schema.get("oneOf").or_else(|| schema.get("anyOf"))?.as_array()?;
|
||||
Some(
|
||||
listed
|
||||
.iter()
|
||||
.filter_map(|o| {
|
||||
let text = |key: &str| o.get(key).and_then(Value::as_str);
|
||||
Some(option(text("const")?, text("title"), text("description")))
|
||||
})
|
||||
.collect(),
|
||||
)
|
||||
}
|
||||
|
||||
fn scalar(value: &Value) -> Option<String> {
|
||||
match value {
|
||||
Value::String(text) => Some(text.clone()),
|
||||
Value::Number(number) => Some(number.to_string()),
|
||||
Value::Bool(flag) => Some(flag.to_string()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// A form is submitted from its own card; this option only names a declined form.
|
||||
pub(crate) fn options() -> Vec<AgentPermissionOption> {
|
||||
vec![AgentPermissionOption { id: DECLINE.to_owned(), name: "Decline".to_owned(), kind: "reject_once".to_owned() }]
|
||||
}
|
||||
|
||||
/// The `elicitation/create` response to the user's `reply`, and what the conversation
|
||||
/// records as chosen.
|
||||
pub(crate) fn answer(form: &AgentForm, reply: Option<&str>) -> (Value, String) {
|
||||
let values = match reply {
|
||||
Some(DECLINE) => return (json!({ "action": "decline" }), "Decline".to_owned()),
|
||||
Some(reply) => serde_json::from_str::<Map<String, Value>>(reply).ok(),
|
||||
None => None,
|
||||
};
|
||||
let Some(values) = values else { return (json!({ "action": "cancel" }), "Cancelled".to_owned()) };
|
||||
let mut content = Map::new();
|
||||
let mut shown = Vec::new();
|
||||
for field in &form.fields {
|
||||
let given: Vec<&str> = match values.get(&field.name) {
|
||||
Some(Value::Array(items)) => items.iter().filter_map(Value::as_str).collect(),
|
||||
Some(Value::String(item)) => vec![item.as_str()],
|
||||
_ => Vec::new(),
|
||||
};
|
||||
let given: Vec<&str> = given.into_iter().map(str::trim).filter(|v| !v.is_empty()).collect();
|
||||
let Some(&first) = given.first() else { continue };
|
||||
let value = match field.kind {
|
||||
AgentFormFieldKind::Text | AgentFormFieldKind::Choice => json!(first),
|
||||
AgentFormFieldKind::Number => match first.parse::<f64>() {
|
||||
Ok(number) => json!(number),
|
||||
Err(_) => continue,
|
||||
},
|
||||
AgentFormFieldKind::Integer => match first.parse::<i64>() {
|
||||
Ok(number) => json!(number),
|
||||
Err(_) => continue,
|
||||
},
|
||||
AgentFormFieldKind::Boolean => json!(first == "true"),
|
||||
AgentFormFieldKind::Choices => json!(given),
|
||||
};
|
||||
let label = |value: &str| {
|
||||
field.options.iter().find(|o| o.value == value).map_or_else(|| value.to_owned(), |o| o.label.clone())
|
||||
};
|
||||
let text = match field.kind {
|
||||
AgentFormFieldKind::Boolean => (if first == "true" { "yes" } else { "no" }).to_owned(),
|
||||
AgentFormFieldKind::Choices => given.iter().map(|v| label(v)).collect::<Vec<_>>().join(", "),
|
||||
_ => label(first),
|
||||
};
|
||||
shown.push(format!("{}: {text}", field.title));
|
||||
content.insert(field.name.clone(), value);
|
||||
}
|
||||
let chosen = if shown.is_empty() { "Submitted".to_owned() } else { shown.join("; ") };
|
||||
(json!({ "action": "accept", "content": content }), chosen)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The form OMP's `ask` tool sends: a choice with a recommended default, then an
|
||||
/// optional typed answer beside it.
|
||||
fn ask() -> Value {
|
||||
json!({
|
||||
"sessionId": "s", "mode": "form", "message": "Which database?",
|
||||
"requestedSchema": { "type": "object", "properties": {
|
||||
"q0": { "type": "string", "title": "Which database?", "description": "Storage",
|
||||
"oneOf": [{ "const": "pg", "title": "Postgres", "description": "Relational" },
|
||||
{ "const": "sqlite", "title": "SQLite" }],
|
||||
"default": "pg" },
|
||||
"q0__other": { "type": "string", "title": "Other (type your own)" }
|
||||
} }
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fields_follow_the_schema_order() {
|
||||
let raw = br#"{ "jsonrpc": "2.0", "id": 3, "method": "elicitation/create", "params": { "mode": "form",
|
||||
"requestedSchema": { "type": "object", "properties": {
|
||||
"strategy": { "type": "string" }, "tests": { "type": "boolean" }, "note": { "type": "string" }
|
||||
} } } }"#;
|
||||
let params = serde_json::from_slice::<Value>(raw).unwrap()["params"].take();
|
||||
let mut form = form_of(¶ms).unwrap();
|
||||
in_schema_order(&mut form, raw);
|
||||
assert_eq!(form.fields.iter().map(|f| f.name.as_str()).collect::<Vec<_>>(), ["strategy", "tests", "note"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_choices_and_text_fields() {
|
||||
let form = form_of(&ask()).unwrap();
|
||||
let [choice, other] = form.fields.as_slice() else { panic!("{form:?}") };
|
||||
assert_eq!((choice.name.as_str(), choice.kind, choice.required), ("q0", AgentFormFieldKind::Choice, false));
|
||||
assert_eq!(choice.options[0].label, "Postgres");
|
||||
assert_eq!(choice.options[0].description, "Relational");
|
||||
assert_eq!(choice.default, ["pg"]);
|
||||
assert_eq!((other.kind, other.title.as_str()), (AgentFormFieldKind::Text, "Other (type your own)"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_every_restricted_schema_kind() {
|
||||
let form = form_of(&json!({ "mode": "form", "requestedSchema": {
|
||||
"type": "object", "required": ["count"],
|
||||
"properties": {
|
||||
"count": { "type": "integer", "minimum": 1, "maximum": 5 },
|
||||
"ratio": { "type": "number" },
|
||||
"ok": { "type": "boolean", "default": true },
|
||||
"size": { "type": "string", "enum": ["s", "l"], "enumNames": ["Small", "Large"] },
|
||||
"tags": { "type": "array", "items": { "anyOf": [{ "const": "a" }, { "const": "b" }] },
|
||||
"default": ["b"], "maxItems": 2 }
|
||||
}
|
||||
} }))
|
||||
.unwrap();
|
||||
let field = |name: &str| form.fields.iter().find(|f| f.name == name).unwrap();
|
||||
use AgentFormFieldKind::*;
|
||||
let kinds: Vec<_> = ["count", "ratio", "ok", "size", "tags"].map(|name| field(name).kind).into();
|
||||
assert_eq!(kinds, [Integer, Number, Boolean, Choice, Choices]);
|
||||
assert!(field("count").required && !field("ratio").required);
|
||||
assert_eq!((field("count").min, field("count").max), (Some(1.0), Some(5.0)));
|
||||
assert_eq!(field("ok").default, ["true"]);
|
||||
assert_eq!(field("size").options[1].label, "Large");
|
||||
assert_eq!((field("tags").default.as_slice(), field("tags").max), (["b".to_owned()].as_slice(), Some(2.0)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn url_mode_and_unsupported_fields_are_refused() {
|
||||
assert!(form_of(&json!({ "mode": "url", "url": "https://example.com" })).is_err());
|
||||
let nested = json!({ "mode": "form", "requestedSchema": { "type": "object", "properties": {
|
||||
"address": { "type": "object" }
|
||||
} } });
|
||||
assert!(form_of(&nested).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_answer_is_typed_by_its_field() {
|
||||
let form = form_of(&json!({ "mode": "form", "requestedSchema": { "type": "object", "properties": {
|
||||
"count": { "type": "integer" },
|
||||
"ok": { "type": "boolean" },
|
||||
"size": { "type": "string", "oneOf": [{ "const": "s", "title": "Small" }] },
|
||||
"tags": { "type": "array", "items": { "enum": ["a", "b"] } },
|
||||
"note": { "type": "string" }
|
||||
} } }))
|
||||
.unwrap();
|
||||
let reply = json!({ "count": ["3"], "ok": ["false"], "size": ["s"], "tags": ["a", "b"], "note": [" "] });
|
||||
let (response, chosen) = answer(&form, Some(&reply.to_string()));
|
||||
assert_eq!(
|
||||
response,
|
||||
json!({ "action": "accept", "content": { "count": 3, "ok": false, "size": "s", "tags": ["a", "b"] } })
|
||||
);
|
||||
assert_eq!(chosen, "count: 3; ok: no; size: Small; tags: a, b");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn declining_and_dismissing_send_no_content() {
|
||||
let form = form_of(&ask()).unwrap();
|
||||
assert_eq!(answer(&form, Some(DECLINE)), (json!({ "action": "decline" }), "Decline".to_owned()));
|
||||
assert_eq!(answer(&form, None).0, json!({ "action": "cancel" }));
|
||||
assert_eq!(answer(&form, Some("cancel")).0, json!({ "action": "cancel" }));
|
||||
}
|
||||
}
|
||||
@@ -134,10 +134,7 @@ fn codex_meta(line: &serde_json::Value) -> Option<(String, Option<String>)> {
|
||||
let payload =
|
||||
line.get("payload").filter(|p| p.get("type").and_then(serde_json::Value::as_str) == Some("session_meta"));
|
||||
let inner = payload.and_then(|p| p.get("payload")).or_else(|| {
|
||||
line.get("type")
|
||||
.and_then(serde_json::Value::as_str)
|
||||
.filter(|t| *t == "session_meta")
|
||||
.map(|_| line.get("payload").unwrap_or(line))
|
||||
line.get("type").and_then(serde_json::Value::as_str).filter(|t| *t == "session_meta").and(Some(line))
|
||||
})?;
|
||||
let id = inner.get("id").and_then(serde_json::Value::as_str)?.to_owned();
|
||||
let cwd = inner.get("cwd").and_then(serde_json::Value::as_str).map(str::to_owned);
|
||||
@@ -296,28 +293,16 @@ mod tests {
|
||||
assert_eq!(sessions[0].title, "hello there");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn codex_meta_accepts_current_and_legacy_shapes() {
|
||||
let meta = json!({"id": "thread-1", "cwd": "/work/app"});
|
||||
for line in [
|
||||
json!({"type": "session_meta", "payload": meta}),
|
||||
json!({"payload": {"type": "session_meta", "payload": meta}}),
|
||||
json!({"type": "session_meta", "id": "thread-1", "cwd": "/work/app"}),
|
||||
] {
|
||||
assert_eq!(codex_meta(&line), Some(("thread-1".to_owned(), Some("/work/app".to_owned()))));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lists_codex_rollouts_with_meta() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
write(
|
||||
&tmp.path().join("sessions/2026/01/02/rollout-01.jsonl"),
|
||||
&[
|
||||
json!({"timestamp": "t", "type": "session_meta",
|
||||
"payload": {"id": "thread-1", "cwd": "/work/app"}}),
|
||||
json!({"timestamp": "t", "type": "event_msg",
|
||||
"payload": {"type": "user_message", "message": "add tests"}}),
|
||||
json!({"timestamp": "t", "payload": {"type": "session_meta",
|
||||
"payload": {"id": "thread-1", "cwd": "/work/app"}}}),
|
||||
json!({"timestamp": "t", "payload": {"type": "user_message",
|
||||
"payload": {"message": "add tests"}}}),
|
||||
],
|
||||
);
|
||||
write(&tmp.path().join("sessions/notes.jsonl"), &[json!({"nope": true})]);
|
||||
|
||||
@@ -11,7 +11,6 @@ mod acp;
|
||||
mod catalogs;
|
||||
mod config;
|
||||
mod conversation;
|
||||
mod elicitation;
|
||||
mod external;
|
||||
pub mod mcp;
|
||||
mod model;
|
||||
@@ -135,8 +134,6 @@ struct Shared {
|
||||
/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).
|
||||
idle_release_ms: AtomicU64,
|
||||
mcp_servers_hook: RwLock<Option<Arc<McpServersFn>>>,
|
||||
/// Monotonic id for [`AgentEvent::Attention`] episodes.
|
||||
attention_seq: AtomicU64,
|
||||
}
|
||||
|
||||
/// What an agent offered in its last session, for the New Task page.
|
||||
@@ -190,7 +187,7 @@ impl Shared {
|
||||
|
||||
fn config_for_new_task(&self, mut config: Vec<AgentConfigOption>, provider: &str) -> Vec<AgentConfigOption> {
|
||||
// Model-specific options are offered separately, never as provider-wide defaults.
|
||||
config.retain(|o| !config::is_per_model_option(o));
|
||||
config.retain(|o| o.category.as_deref() != Some("thought_level"));
|
||||
config::add_client_options(provider, &mut config);
|
||||
let hook = self.new_task_approvals.read().clone();
|
||||
if hook.is_some_and(|ask| ask() == ide_core::settings::NewTaskApprovals::Ask) {
|
||||
@@ -226,7 +223,6 @@ impl Shared {
|
||||
commands: Option<&[AgentCommand]>,
|
||||
model: Option<&str>,
|
||||
) {
|
||||
let acp = self.spec(provider).is_some_and(|spec| spec.driver == provider::Driver::Acp);
|
||||
let mut cache = self.known.lock();
|
||||
let known = cache.entry(provider.to_owned()).or_default();
|
||||
let mut changed = false;
|
||||
@@ -236,7 +232,8 @@ impl Shared {
|
||||
&& let Some(config) = config.filter(|c| !c.is_empty())
|
||||
{
|
||||
if let Some(model) = model {
|
||||
let levels: Vec<_> = config.iter().filter(|o| config::is_per_model_option(o)).cloned().collect();
|
||||
let levels: Vec<_> =
|
||||
config.iter().filter(|o| o.category.as_deref() == Some("thought_level")).cloned().collect();
|
||||
if known.thought_levels.get(model) != Some(&levels) {
|
||||
known.thought_levels.insert(model.to_owned(), levels);
|
||||
changed = true;
|
||||
@@ -247,11 +244,6 @@ impl Shared {
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
// Discovery reads one model's options; a session on another model reports that model's.
|
||||
let learned = model.filter(|_| acp && known.authoritative).zip(config).map(|(model, config)| {
|
||||
let levels: Vec<_> = config.iter().filter(|o| config::is_per_model_option(o)).cloned().collect();
|
||||
(model, levels)
|
||||
});
|
||||
if let Some(commands) = commands.filter(|c| !c.is_empty())
|
||||
&& known.commands.get(&self.root_key()).map(Vec::as_slice) != Some(commands)
|
||||
{
|
||||
@@ -262,9 +254,6 @@ impl Shared {
|
||||
self.persist_known(&cache);
|
||||
}
|
||||
drop(cache);
|
||||
if let Some((model, levels)) = learned.filter(|(_, levels)| !levels.is_empty()) {
|
||||
self.paths.catalogs.learn_levels(self, provider, model, levels);
|
||||
}
|
||||
if changed {
|
||||
self.emit(AgentEvent::Providers);
|
||||
}
|
||||
@@ -419,7 +408,6 @@ impl AgentManager {
|
||||
probes: Mutex::new(HashMap::new()),
|
||||
idle_release_ms: AtomicU64::new(IDLE_RELEASE.as_millis() as u64),
|
||||
mcp_servers_hook: RwLock::new(None),
|
||||
attention_seq: AtomicU64::new(0),
|
||||
});
|
||||
shared.paths.catalogs.subscribe(&shared);
|
||||
let mut tasks = HashMap::new();
|
||||
@@ -1012,11 +1000,8 @@ impl AgentManager {
|
||||
task.emit_task();
|
||||
|
||||
let live = task.live.lock().clone().filter(|l| !l.peer.is_closed());
|
||||
// The task's copy holds its model's per-model options unless a model switch the agent
|
||||
// never reported dropped them: caching that copy would erase the model's known levels.
|
||||
let mut model_options = (target.category.as_deref() != Some("model")
|
||||
|| previous.as_deref() == Some(value.as_str()))
|
||||
&& task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
let mut model_options =
|
||||
target.category.as_deref() != Some("model") || previous.as_deref() == Some(value.as_str());
|
||||
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
|
||||
let (method, mut params) = config::set_request(&target, &value);
|
||||
params["sessionId"] = json!(live.session);
|
||||
@@ -1047,7 +1032,7 @@ impl AgentManager {
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
if !model_options {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.retain(|o| o.category.as_deref() != Some("thought_level"));
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = Some(value);
|
||||
@@ -1207,10 +1192,7 @@ impl AgentManager {
|
||||
}
|
||||
|
||||
/// What `provider` reports about itself, from `initialize` alone: no session is opened,
|
||||
/// so no MCP server, hook or sign-in runs. A successful answer is remembered until
|
||||
/// `refresh`; a failed one is not, so a transient startup failure (a CLI updating itself,
|
||||
/// a busy machine) is retried on the next call instead of being shown for the rest of
|
||||
/// the session.
|
||||
/// so no MCP server, hook or sign-in runs. Remembered until `refresh`.
|
||||
pub async fn probe(&self, provider: &str, refresh: bool) -> IdeResult<AgentProbe> {
|
||||
if !refresh && let Some(p) = self.shared.probes.lock().get(provider) {
|
||||
return Ok(p.clone());
|
||||
@@ -1272,9 +1254,7 @@ impl AgentManager {
|
||||
}
|
||||
Err(e) => probe.error = Some(e),
|
||||
}
|
||||
if probe.error.is_none() {
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
}
|
||||
self.shared.probes.lock().insert(spec.id, probe.clone());
|
||||
Ok(probe)
|
||||
}
|
||||
|
||||
@@ -1698,28 +1678,6 @@ impl Task {
|
||||
self.emit_task();
|
||||
}
|
||||
|
||||
fn emit_attention(&self, reason: AgentAttentionReason) {
|
||||
let n = self.shared.attention_seq.fetch_add(1, Ordering::Relaxed);
|
||||
let tag = match reason {
|
||||
AgentAttentionReason::Finished => "finished",
|
||||
AgentAttentionReason::Input => "input",
|
||||
AgentAttentionReason::Failed => "failed",
|
||||
};
|
||||
self.shared.emit(AgentEvent::Attention {
|
||||
task: self.id.clone(),
|
||||
event_id: format!("{}:{tag}:{n}", self.id),
|
||||
reason,
|
||||
});
|
||||
}
|
||||
|
||||
/// After NeedsInput + optional auto-approve: notify only when the user must still answer.
|
||||
fn emit_attention_if_input_pending(&self) {
|
||||
let waiting = !self.permissions.lock().is_empty() && self.state.lock().task.status == AgentStatus::NeedsInput;
|
||||
if waiting {
|
||||
self.emit_attention(AgentAttentionReason::Input);
|
||||
}
|
||||
}
|
||||
|
||||
fn persist(&self) {
|
||||
// Held from snapshot to rename, so saves land in order and none follows a delete.
|
||||
let deleted = self.deleted.lock();
|
||||
@@ -1822,11 +1780,8 @@ impl Task {
|
||||
}
|
||||
match (next, result) {
|
||||
(Some(queued), _) => prompt = queued.prompt,
|
||||
(None, Ok(stop)) => {
|
||||
(None, Ok(_)) => {
|
||||
self.set_status(AgentStatus::Ready, None);
|
||||
if stop != "cancelled" {
|
||||
self.emit_attention(AgentAttentionReason::Finished);
|
||||
}
|
||||
return self.release_when_idle();
|
||||
}
|
||||
(None, Err(failure)) => return self.fail(failure),
|
||||
@@ -1897,7 +1852,6 @@ impl Task {
|
||||
}
|
||||
None => self.set_status(AgentStatus::Failed, Some(failure.message)),
|
||||
}
|
||||
self.emit_attention(AgentAttentionReason::Failed);
|
||||
}
|
||||
|
||||
/// Adds `prompt` to the running turn when the agent takes that; gives it back otherwise.
|
||||
@@ -1907,24 +1861,12 @@ impl Task {
|
||||
let s = self.state.lock();
|
||||
s.busy && s.task.status == AgentStatus::Running
|
||||
};
|
||||
let Some((live, method)) = live
|
||||
.filter(|l| running && (prompt.images.is_empty() || l.capabilities.images))
|
||||
.and_then(|l| steer_method(&l.init).map(|m| (l, m)))
|
||||
else {
|
||||
let Some(live) = live.filter(|l| running && (prompt.images.is_empty() || l.capabilities.images)) else {
|
||||
return Err(prompt);
|
||||
};
|
||||
let content = self.content(&live, &prompt).await;
|
||||
let sent: Result<Value, RpcError> =
|
||||
live.peer.request(method, json!({ "sessionId": live.session, "prompt": content }), None).await;
|
||||
// `_session/steering` answers with an outcome: only `injected` joined the turn
|
||||
// (`promptRequired`: no turn is running any more).
|
||||
let sent = match sent {
|
||||
Ok(reply) => match reply.get("outcome").and_then(Value::as_str) {
|
||||
None | Some("injected") => Ok(()),
|
||||
Some(outcome) => Err(reply.get("reason").and_then(Value::as_str).unwrap_or(outcome).to_owned()),
|
||||
},
|
||||
Err(e) => Err(e.to_string()),
|
||||
};
|
||||
live.peer.request("_openidea/steer", json!({ "sessionId": live.session, "prompt": content }), None).await;
|
||||
if let Err(e) = sent {
|
||||
// The turn ended meanwhile: the message waits for the next one instead.
|
||||
tracing::debug!("agent task {}: steering failed: {e}", self.id);
|
||||
@@ -2156,10 +2098,10 @@ impl Task {
|
||||
(if known { reported } else { s.task.config.clone() }, s.wanted.clone())
|
||||
};
|
||||
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,
|
||||
// Changing model can replace the effort choices; validate those only afterwards.
|
||||
wanted.sort_by_key(|c| match options.iter().find(|o| o.id == c.id).and_then(|o| o.category.as_deref()) {
|
||||
Some("model") => 0,
|
||||
Some("thought_level") => 2,
|
||||
_ => 1,
|
||||
});
|
||||
let mut model_options = known;
|
||||
@@ -2172,7 +2114,7 @@ impl Task {
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if config::is_per_model_option(&o) && !model_options {
|
||||
if o.category.as_deref() == Some("thought_level") && !model_options {
|
||||
continue;
|
||||
}
|
||||
let already = known && o.current.as_deref() == Some(choice.value.as_str());
|
||||
@@ -2189,7 +2131,7 @@ impl Task {
|
||||
model_options = true;
|
||||
} else if o.category.as_deref() == Some("model") {
|
||||
if o.current.as_deref() != Some(choice.value.as_str()) {
|
||||
options.retain(|o| !config::is_per_model_option(o));
|
||||
options.retain(|o| o.category.as_deref() != Some("thought_level"));
|
||||
}
|
||||
model_options = false;
|
||||
}
|
||||
@@ -2253,17 +2195,14 @@ impl Task {
|
||||
if let Some(fresh) = reply.get("configOptions") {
|
||||
config::merge_update(&mut s.task.config, fresh);
|
||||
} else if option.category.as_deref() == Some("model") {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.retain(|o| o.category.as_deref() != Some("thought_level"));
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option.id) {
|
||||
o.current = Some(value);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
// As in `set_config`: a copy without per-model options can't vouch for them.
|
||||
let model = s.task.model.clone().filter(|_| {
|
||||
reply.get("configOptions").is_some()
|
||||
|| (option.category.as_deref() != Some("model")
|
||||
&& s.task.config.iter().any(config::is_per_model_option))
|
||||
reply.get("configOptions").is_some() || option.category.as_deref() != Some("model")
|
||||
});
|
||||
let (provider, options) = (s.task.provider.clone(), s.task.config.clone());
|
||||
drop(s);
|
||||
@@ -2427,7 +2366,12 @@ impl Task {
|
||||
// first question says what it wants, as the Claude Code adapter titles its own.
|
||||
let title =
|
||||
if by_index { questions.first().map(|question| question.question.clone()).unwrap_or(title) } else { title };
|
||||
let title = self.labelled(params, title);
|
||||
// A subagent's request is answered in the task's conversation, named after the subagent.
|
||||
let session = params.get("sessionId").and_then(Value::as_str);
|
||||
let title = match session.and_then(|s| self.state.lock().conversation.label(s)) {
|
||||
Some(label) => format!("{label}: {title}"),
|
||||
None => title,
|
||||
};
|
||||
let options: Vec<AgentPermissionOption> = params
|
||||
.get("options")
|
||||
.and_then(Value::as_array)
|
||||
@@ -2459,7 +2403,6 @@ impl Task {
|
||||
command: None,
|
||||
options,
|
||||
questions: Vec::new(),
|
||||
form: None,
|
||||
chosen: Some("Denied: side conversations are read-only".to_owned()),
|
||||
});
|
||||
return match reject {
|
||||
@@ -2486,7 +2429,6 @@ impl Task {
|
||||
command: shown.clone(),
|
||||
options,
|
||||
questions: Vec::new(),
|
||||
form: None,
|
||||
chosen: Some(format!("Blocked by policy ({pattern})")),
|
||||
});
|
||||
return match reject {
|
||||
@@ -2507,7 +2449,6 @@ impl Task {
|
||||
command: shown.clone(),
|
||||
options,
|
||||
questions: Vec::new(),
|
||||
form: None,
|
||||
chosen: Some(format!("{} (whitelisted)", allow.name)),
|
||||
});
|
||||
return json!({ "outcome": { "outcome": "selected", "optionId": allow.id } });
|
||||
@@ -2523,13 +2464,11 @@ impl Task {
|
||||
command: shown,
|
||||
options: options.clone(),
|
||||
questions,
|
||||
form: None,
|
||||
chosen: None,
|
||||
});
|
||||
self.permissions.lock().insert(id, tx);
|
||||
self.set_status(AgentStatus::NeedsInput, None);
|
||||
self.approve_pending();
|
||||
self.emit_attention_if_input_pending();
|
||||
|
||||
let answer = rx.recv().ok().flatten();
|
||||
let answers = answer
|
||||
@@ -2551,7 +2490,17 @@ impl Task {
|
||||
.and_then(|reply| options.iter().find(|option| &option.id == reply))
|
||||
.map_or_else(|| "Cancelled".to_owned(), |option| option.name.clone()),
|
||||
};
|
||||
self.settle(entry, name);
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if let Some(AgentEntry::Permission { chosen, .. }) = s.conversation.main.entries.get_mut(entry) {
|
||||
*chosen = Some(name);
|
||||
}
|
||||
}
|
||||
self.mark_dirty([(None, entry)]);
|
||||
let still_asking = !self.permissions.lock().is_empty();
|
||||
if !still_asking && self.state.lock().task.status == AgentStatus::NeedsInput {
|
||||
self.set_status(AgentStatus::Running, None);
|
||||
}
|
||||
// An agent that answers by index reads the answers beside the outcome, keyed by
|
||||
// question index, with its Submit option chosen; anything less cancels the request.
|
||||
if by_index {
|
||||
@@ -2583,58 +2532,6 @@ impl Task {
|
||||
}
|
||||
}
|
||||
|
||||
/// A request from a subagent is answered in the task's conversation, named after the subagent.
|
||||
fn labelled(&self, params: &Value, title: String) -> String {
|
||||
let session = params.get("sessionId").and_then(Value::as_str);
|
||||
match session.and_then(|s| self.state.lock().conversation.label(s)) {
|
||||
Some(label) => format!("{label}: {title}"),
|
||||
None => title,
|
||||
}
|
||||
}
|
||||
|
||||
/// An agent's form (`elicitation/create`): asked in the conversation like a permission
|
||||
/// request, and answered with its values, declined or cancelled. Blocks like `ask_permission`.
|
||||
fn elicit(self: &Arc<Self>, params: &Value, raw: Option<&[u8]>) -> Result<Value, String> {
|
||||
let mut form = elicitation::form_of(params)?;
|
||||
if let Some(raw) = raw {
|
||||
elicitation::in_schema_order(&mut form, raw);
|
||||
}
|
||||
let id = self.next_permission.fetch_add(1, Ordering::Relaxed);
|
||||
let message = params.get("message").and_then(Value::as_str).unwrap_or_default().trim().to_owned();
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
let entry = self.push_entry(AgentEntry::Permission {
|
||||
id,
|
||||
title: self.labelled(params, message),
|
||||
command: None,
|
||||
options: elicitation::options(),
|
||||
questions: Vec::new(),
|
||||
form: Some(form.clone()),
|
||||
chosen: None,
|
||||
});
|
||||
self.permissions.lock().insert(id, tx);
|
||||
self.set_status(AgentStatus::NeedsInput, None);
|
||||
self.emit_attention_if_input_pending();
|
||||
let reply = rx.recv().ok().flatten();
|
||||
let (response, chosen) = elicitation::answer(&form, reply.as_deref());
|
||||
self.settle(entry, chosen);
|
||||
Ok(response)
|
||||
}
|
||||
|
||||
/// Records the answer to the request at `entry`; the turn runs on once nothing else waits.
|
||||
fn settle(self: &Arc<Self>, entry: usize, chosen: String) {
|
||||
{
|
||||
let mut s = self.state.lock();
|
||||
if let Some(AgentEntry::Permission { chosen: answer, .. }) = s.conversation.main.entries.get_mut(entry) {
|
||||
*answer = Some(chosen);
|
||||
}
|
||||
}
|
||||
self.mark_dirty([(None, entry)]);
|
||||
let still_asking = !self.permissions.lock().is_empty();
|
||||
if !still_asking && self.state.lock().task.status == AgentStatus::NeedsInput {
|
||||
self.set_status(AgentStatus::Running, None);
|
||||
}
|
||||
}
|
||||
|
||||
fn approve_pending(&self) {
|
||||
let s = self.state.lock();
|
||||
if self.cancel_pending.load(Ordering::Acquire) || !config::bypass_approvals(&s.task.config) {
|
||||
@@ -2699,18 +2596,9 @@ impl Handler for Client {
|
||||
let task = self.task.upgrade().ok_or((codes::INTERNAL_ERROR, "task closed".to_owned()))?;
|
||||
match method {
|
||||
"session/request_permission" => Ok(task.ask_permission(¶ms)),
|
||||
"elicitation/create" => task.elicit(¶ms, None).map_err(|e| (codes::INVALID_PARAMS, e)),
|
||||
_ => Err((codes::METHOD_NOT_FOUND, format!("unsupported method {method}"))),
|
||||
}
|
||||
}
|
||||
|
||||
fn on_request_raw(&self, method: &str, params: Value, raw: &[u8]) -> Result<Value, (i64, String, Option<Value>)> {
|
||||
if method != "elicitation/create" {
|
||||
return self.on_request_with_data(method, params);
|
||||
}
|
||||
let task = self.task.upgrade().ok_or((codes::INTERNAL_ERROR, "task closed".to_owned(), None))?;
|
||||
task.elicit(¶ms, Some(raw)).map_err(|e| (codes::INVALID_PARAMS, e, None))
|
||||
}
|
||||
}
|
||||
|
||||
/// The prompt trimmed, or `None` when there is nothing to send.
|
||||
@@ -2977,27 +2865,13 @@ fn shown_background(tasks: &[Value], known: &[AgentBackgroundTask]) -> Vec<Agent
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The method that adds a message to the running turn: OpenIDEA's own, or the
|
||||
/// `_session/steering` extension an agent advertises in the response's top-level `_meta`
|
||||
/// (OMP).
|
||||
fn steer_method(init: &acp::Negotiated) -> Option<&'static str> {
|
||||
let supported = |v: Option<&Value>| v.and_then(Value::as_bool) == Some(true);
|
||||
if supported(init.meta("/openidea/steer")) {
|
||||
Some("_openidea/steer")
|
||||
} else if supported(init.meta.as_ref().and_then(|m| m.pointer("/steering/supported"))) {
|
||||
Some("_session/steering")
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn capabilities_of(init: &acp::Negotiated) -> (AgentCapabilities, bool) {
|
||||
let meta = |p: &str| init.meta(p).and_then(Value::as_bool) == Some(true);
|
||||
let capabilities = AgentCapabilities {
|
||||
images: init.prompt("image"),
|
||||
fork: init.session("fork"),
|
||||
rollback: meta("/openidea/rollback"),
|
||||
steer: steer_method(init).is_some(),
|
||||
steer: meta("/openidea/steer"),
|
||||
background_tasks: meta("/openidea/backgroundTasks"),
|
||||
read_only: false,
|
||||
};
|
||||
|
||||
@@ -5,15 +5,6 @@ use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// Why a task needs the user's attention (native / in-app notify).
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentAttentionReason {
|
||||
Finished,
|
||||
Input,
|
||||
Failed,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentStatus {
|
||||
@@ -139,14 +130,6 @@ pub struct AgentConfigValue {
|
||||
pub value: String,
|
||||
pub name: String,
|
||||
pub description: Option<String>,
|
||||
/// Relative cost category from ACP `_meta` (`copilotPriceCategory`, e.g. `low`, `medium`, `high`, `very_high`).
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub cost_category: Option<String>,
|
||||
/// Usage multiplier from ACP `_meta` (`copilotUsage`, e.g. `1x`, `0x`, `3x`).
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub usage_multiplier: Option<String>,
|
||||
}
|
||||
|
||||
/// How a setting is changed.
|
||||
@@ -172,10 +155,6 @@ pub struct AgentConfigOption {
|
||||
/// ACP category: `model`, `mode`, `thought_level`, or agent-specific.
|
||||
pub category: Option<String>,
|
||||
pub current: Option<String>,
|
||||
/// Initial default value reported by the agent, preserved across session updates for Reset.
|
||||
#[serde(default)]
|
||||
#[specta(optional)]
|
||||
pub default_value: Option<String>,
|
||||
pub values: Vec<AgentConfigValue>,
|
||||
pub via: AgentConfigVia,
|
||||
}
|
||||
@@ -337,59 +316,6 @@ pub struct AgentQuestionOption {
|
||||
pub preview: Option<String>,
|
||||
}
|
||||
|
||||
/// A form the agent asks the user to fill in (ACP `elicitation/create`, form mode).
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentForm {
|
||||
pub fields: Vec<AgentFormField>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentFormField {
|
||||
/// The property name the answer is keyed by.
|
||||
pub name: String,
|
||||
pub title: String,
|
||||
#[serde(default)]
|
||||
pub description: String,
|
||||
#[serde(default)]
|
||||
pub required: bool,
|
||||
pub kind: AgentFormFieldKind,
|
||||
/// The choices of a `choice` or `choices` field.
|
||||
#[serde(default)]
|
||||
pub options: Vec<AgentFormOption>,
|
||||
/// The initial answer: option values, a text, a number, or `true` / `false`.
|
||||
#[serde(default)]
|
||||
pub default: Vec<String>,
|
||||
/// Bounds: the number of a `number` / `integer`, the length of a `text`, the count of `choices`.
|
||||
#[serde(default)]
|
||||
pub min: Option<f64>,
|
||||
#[serde(default)]
|
||||
pub max: Option<f64>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AgentFormFieldKind {
|
||||
Text,
|
||||
Number,
|
||||
Integer,
|
||||
Boolean,
|
||||
/// One of `options`.
|
||||
Choice,
|
||||
/// Any of `options`.
|
||||
Choices,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct AgentFormOption {
|
||||
pub value: String,
|
||||
pub label: String,
|
||||
#[serde(default)]
|
||||
pub description: String,
|
||||
}
|
||||
|
||||
/// One item of a task's conversation.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "type", rename_all = "camelCase", rename_all_fields = "camelCase")]
|
||||
@@ -470,10 +396,6 @@ pub enum AgentEntry {
|
||||
/// of question to answer instead of an option.
|
||||
#[serde(default)]
|
||||
questions: Vec<AgentQuestion>,
|
||||
/// Set when the agent asks for a form (ACP elicitation); answered with a JSON object of
|
||||
/// field name to its values, `decline`, or nothing to cancel.
|
||||
#[serde(default)]
|
||||
form: Option<AgentForm>,
|
||||
/// Name of the chosen option, or `None` while pending. Cancelled requests read "Cancelled".
|
||||
chosen: Option<String>,
|
||||
},
|
||||
@@ -675,12 +597,6 @@ pub enum AgentEvent {
|
||||
},
|
||||
/// The installed or configured agent providers changed.
|
||||
Providers,
|
||||
/// The task needs attention once (finished turn, explicit input, or failure).
|
||||
Attention {
|
||||
task: String,
|
||||
event_id: String,
|
||||
reason: AgentAttentionReason,
|
||||
},
|
||||
}
|
||||
|
||||
pub use ide_core::settings::{AgentMcpServer, McpTransport};
|
||||
|
||||
@@ -51,9 +51,6 @@ struct FakeAgent {
|
||||
/// Config options `session/new` reports after the model one (per-model efforts, say).
|
||||
extra_options: Mutex<Vec<Value>>,
|
||||
model_options: Mutex<HashMap<String, Vec<Value>>>,
|
||||
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
|
||||
/// instead of `_meta.openidea.steer`.
|
||||
session_steering: bool,
|
||||
}
|
||||
|
||||
impl FakeAgent {
|
||||
@@ -159,10 +156,6 @@ impl Handler for FakeAgent {
|
||||
if params.pointer("/clientCapabilities/subagents").is_some_and(Value::is_object) {
|
||||
self.calls.lock().push("subagents".into());
|
||||
}
|
||||
if self.session_steering {
|
||||
return Ok(json!({"protocolVersion": 1, "agentCapabilities": {"loadSession": true},
|
||||
"_meta": {"steering": {"supported": true}}}));
|
||||
}
|
||||
Ok(
|
||||
json!({"protocolVersion": 1, "authMethods": self.auth_methods, "agentCapabilities": {"loadSession": !self.no_load,
|
||||
"sessionCapabilities": {"fork": {}}, "_meta": {"openidea": {"rollback": true, "steer": true, "backgroundTasks": true}}}}),
|
||||
@@ -190,13 +183,6 @@ impl Handler for FakeAgent {
|
||||
self.calls.lock().push(format!("{method} {detail}"));
|
||||
Ok(json!({}))
|
||||
}
|
||||
"_session/steering" => {
|
||||
let text = params["prompt"][0]["text"].clone();
|
||||
self.calls.lock().push(format!("{method} {text}"));
|
||||
// OMP answers whether the message joined the turn rather than failing.
|
||||
let outcome = if text == "too late" { "promptRequired" } else { "injected" };
|
||||
Ok(json!({"outcome": outcome, "queue": "steering"}))
|
||||
}
|
||||
"session/load" => {
|
||||
self.say(&session, "replayed history");
|
||||
Ok(json!({}))
|
||||
@@ -295,23 +281,6 @@ impl Handler for FakeAgent {
|
||||
self.say(&session, &format!("escalation chose {chosen}"));
|
||||
return Ok(json!({"stopReason": "end_turn"}));
|
||||
}
|
||||
if text == "form" {
|
||||
let peer = self.latest();
|
||||
let answer: Value = tokio::runtime::Handle::current()
|
||||
.block_on(peer.request(
|
||||
"elicitation/create",
|
||||
json!({"sessionId": session, "mode": "form", "message": "How should I refactor?",
|
||||
"requestedSchema": {"type": "object", "required": ["strategy"], "properties": {
|
||||
"strategy": {"type": "string", "title": "Strategy",
|
||||
"oneOf": [{"const": "safe", "title": "Conservative"},
|
||||
{"const": "bold", "title": "Aggressive"}]},
|
||||
"tests": {"type": "boolean", "title": "Run tests"}}}}),
|
||||
None,
|
||||
))
|
||||
.unwrap();
|
||||
self.say(&session, &format!("form {answer}"));
|
||||
return Ok(json!({ "stopReason": "end_turn" }));
|
||||
}
|
||||
if text == "ask" {
|
||||
let peer = self.latest();
|
||||
let answer: Value = tokio::runtime::Handle::current()
|
||||
@@ -1091,42 +1060,6 @@ fn text(t: &str) -> AgentPrompt {
|
||||
AgentPrompt { text: t.into(), ..AgentPrompt::default() }
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn steers_through_session_steering() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent { session_steering: true, ..FakeAgent::default() });
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("wait"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Running).await;
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.capabilities.steer);
|
||||
|
||||
mgr.prompt(&task.id, text("also this"), true).await.unwrap();
|
||||
assert!(agent.calls.lock().iter().any(|c| c == "_session/steering \"also this\""));
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(matches!(entries.last(), Some(AgentEntry::User { steered: true, .. })));
|
||||
assert!(mgr.task(&task.id).unwrap().state.lock().task.queue.is_empty());
|
||||
|
||||
// The agent didn't take it into the turn: the turn stops and it goes next, as without
|
||||
// steering (the fake agent's next turn asks for permission).
|
||||
mgr.prompt(&task.id, text("too late"), true).await.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: false, .. } if text == "too late")));
|
||||
assert!(!entries.iter().any(|e| matches!(e, AgentEntry::User { text, steered: true, .. } if text == "too late")));
|
||||
mgr.cancel(&task.id, None).unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn messages_sent_while_busy_are_queued_and_send_now_interrupts() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -1795,45 +1728,6 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
// After a model switch no session reported, picking that model again or changing
|
||||
// another setting must not record the task's effort-less copy as the model's levels.
|
||||
for (option, value) in [("mode", "code"), ("model", "big")] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
restored.set_config(&task.id, "model", "big".into()).await.unwrap();
|
||||
restored.set_config(&task.id, option, value.into()).await.unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude").unwrap();
|
||||
let big = p.thought_levels.get("big").and_then(|levels| levels.first());
|
||||
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels);
|
||||
let saved: HashMap<String, Known> =
|
||||
serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap();
|
||||
assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}");
|
||||
restored.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
|
||||
for (effort, applied) in [("medium", true), ("high", false)] {
|
||||
@@ -2091,58 +1985,6 @@ async fn bypass_approvals_keeps_both_question_dialects_pending_but_allows_permis
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn an_agent_form_is_answered_declined_or_cancelled_even_when_approvals_are_bypassed() {
|
||||
let accept = json!({"strategy": ["bold"], "tests": ["true"]}).to_string();
|
||||
for (reply, said, chosen) in [
|
||||
(
|
||||
Some(accept.as_str()),
|
||||
r#"form {"action":"accept","content":{"strategy":"bold","tests":true}}"#,
|
||||
"Strategy: Aggressive; Run tests: yes",
|
||||
),
|
||||
(Some("decline"), r#"form {"action":"decline"}"#, "Decline"),
|
||||
(None, r#"form {"action":"cancel"}"#, "Cancelled"),
|
||||
] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("form"),
|
||||
provider: "cursor".into(),
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
|
||||
let (id, form) = mgr
|
||||
.entries(&task.id, None)
|
||||
.unwrap()
|
||||
.into_iter()
|
||||
.find_map(|entry| match entry {
|
||||
AgentEntry::Permission { id, title, form: Some(form), chosen: None, .. }
|
||||
if title == "How should I refactor?" =>
|
||||
{
|
||||
Some((id, form))
|
||||
}
|
||||
_ => None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(form.fields.iter().map(|f| f.name.as_str()).collect::<Vec<_>>(), ["strategy", "tests"]);
|
||||
mgr.respond(&task.id, id, reply.map(str::to_owned)).unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
let entries = mgr.entries(&task.id, None).unwrap();
|
||||
assert!(entries.iter().any(|e| matches!(e, AgentEntry::Agent { text } if text == said)), "{entries:?}");
|
||||
assert!(
|
||||
entries.iter().any(|e| matches!(e, AgentEntry::Permission { chosen: Some(c), .. } if c == chosen)),
|
||||
"{entries:?}"
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn cursor_approval_choice_applies_before_first_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
@@ -2474,40 +2316,6 @@ async fn reload_providers_updates_registry_install_clears_stale_probes_and_notif
|
||||
assert!(probe.error.is_none());
|
||||
}
|
||||
|
||||
/// A probe that fails is not remembered, so the next new-task page tries the agent again
|
||||
/// instead of showing the same startup failure until the IDE restarts.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_failed_probe_is_retried_instead_of_remembered() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let calls = Arc::new(Mutex::new(0usize));
|
||||
let connector: Connector = {
|
||||
let calls = calls.clone();
|
||||
Arc::new(move |_spec, _cwd, _client, _stderr| {
|
||||
*calls.lock() += 1;
|
||||
Err(std::io::Error::from(std::io::ErrorKind::NotFound))
|
||||
})
|
||||
};
|
||||
let mgr = AgentManager::with_connector(
|
||||
AgentPaths {
|
||||
project_root: tmp.path().to_path_buf(),
|
||||
store_dir: tmp.path().join("store"),
|
||||
worktrees_dir: tmp.path().join("worktrees"),
|
||||
models_file: tmp.path().join("models.json"),
|
||||
custom_agents_dir: None,
|
||||
home_dir: None,
|
||||
env_secrets: None,
|
||||
catalogs: Arc::default(),
|
||||
},
|
||||
tokio::runtime::Handle::current(),
|
||||
connector,
|
||||
);
|
||||
|
||||
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
|
||||
assert!(mgr.probe("claude", false).await.unwrap().error.is_some());
|
||||
assert_eq!(*calls.lock(), 2, "the second call must start the agent again");
|
||||
assert!(!mgr.shared.probes.lock().contains_key("claude"));
|
||||
}
|
||||
|
||||
/// A session report that changes the cached provider config notifies subscribers,
|
||||
/// so the composer re-lists models without waiting for the next task (#1490).
|
||||
/// Reports that change nothing stay silent.
|
||||
@@ -3619,177 +3427,3 @@ async fn ephemeral_tasks_deny_write_permissions() {
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
fn attention_reasons(events: &[AgentEvent]) -> Vec<AgentAttentionReason> {
|
||||
events
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
AgentEvent::Attention { reason, .. } => Some(*reason),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `wait_for(Ready/Failed/…)` can return after status is written but before the
|
||||
/// following `emit_attention` runs on the agent thread — poll the sink instead.
|
||||
async fn wait_for_attention(events: &Mutex<Vec<AgentEvent>>, reason: AgentAttentionReason) {
|
||||
for _ in 0..500 {
|
||||
if attention_reasons(&events.lock()).contains(&reason) {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
panic!("never saw Attention::{reason:?}: {:?}", *events.lock());
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_finished_not_cancelled() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
|
||||
let done = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &done.id, AgentStatus::Ready).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Finished).await;
|
||||
events.lock().clear();
|
||||
|
||||
let cancelled = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("wait"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &cancelled.id, AgentStatus::Running).await;
|
||||
mgr.cancel(&cancelled.id, None).unwrap();
|
||||
wait_for(&mgr, &cancelled.id, AgentStatus::Ready).await;
|
||||
// Give a late Finished emission a chance; cancellation must not produce one.
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(
|
||||
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Finished),
|
||||
"cancelled must not notify finished: {:?}",
|
||||
*events.lock()
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_failed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent {
|
||||
request_error: Some((codes::INTERNAL_ERROR, "boom".into())),
|
||||
auth_on_new: true,
|
||||
..Default::default()
|
||||
});
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Failed).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Failed).await;
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_input_not_auto_bypass() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
mgr.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
|
||||
let asked = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &asked.id, AgentStatus::NeedsInput).await;
|
||||
wait_for_attention(&events, AgentAttentionReason::Input).await;
|
||||
events.lock().clear();
|
||||
mgr.cancel(&asked.id, None).unwrap();
|
||||
wait_for(&mgr, &asked.id, AgentStatus::Ready).await;
|
||||
|
||||
let bypassed = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("Fix"),
|
||||
provider: "cursor".into(),
|
||||
config: vec![AgentConfigChoice { id: config::CURSOR_APPROVAL.into(), value: "bypass".into() }],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &bypassed.id, AgentStatus::Ready).await;
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(
|
||||
!attention_reasons(&events.lock()).contains(&AgentAttentionReason::Input),
|
||||
"auto-bypass must not notify input: {:?}",
|
||||
*events.lock()
|
||||
);
|
||||
mgr.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn attention_not_emitted_on_restore() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
let mgr = manager(tmp.path(), agent);
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
config: Vec::new(),
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
|
||||
let restored = manager(tmp.path(), Arc::new(FakeAgent::default()));
|
||||
let events = Arc::new(Mutex::new(Vec::<AgentEvent>::new()));
|
||||
let sink = events.clone();
|
||||
let tasks = restored.subscribe(Arc::new(move |e| sink.lock().push(e)));
|
||||
assert!(tasks.iter().any(|t| t.id == task.id));
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert!(attention_reasons(&events.lock()).is_empty(), "snapshot restore must not re-notify: {:?}", *events.lock());
|
||||
restored.shutdown();
|
||||
}
|
||||
@@ -441,7 +441,6 @@ mod tests {
|
||||
command: None,
|
||||
options: vec![],
|
||||
questions: vec![],
|
||||
form: None,
|
||||
chosen: None,
|
||||
});
|
||||
assert_eq!(t.end_turn(None), vec![2, 3]);
|
||||
|
||||
@@ -7,7 +7,6 @@ mod fingerprint;
|
||||
mod launch_resources;
|
||||
mod parse;
|
||||
mod single;
|
||||
mod structure;
|
||||
mod up_to_date;
|
||||
|
||||
pub use fingerprint::{LaunchFingerprint, launch_fingerprint, menu_fingerprint};
|
||||
@@ -16,10 +15,6 @@ pub use single::{
|
||||
SingleFileTarget, compile_file_plan, find_javac, javac_step, module_classpath, single_file_classpath,
|
||||
single_file_target,
|
||||
};
|
||||
pub use structure::{
|
||||
StructureJdk, StructureRoots, artifact_file, artifact_output, language_release, structure_outputs, structure_plan,
|
||||
structure_war_plan, structure_web_artifacts,
|
||||
};
|
||||
pub use up_to_date::{menu_up_to_date, record_menu_build};
|
||||
|
||||
use crate::process::{self, Stream};
|
||||
@@ -60,8 +55,6 @@ pub enum BuildSystem {
|
||||
CMake,
|
||||
#[serde(rename = "dotnet")]
|
||||
Dotnet,
|
||||
/// A Java project without a build tool, compiled from its Project Structure.
|
||||
Javac,
|
||||
}
|
||||
|
||||
/// One command of a build.
|
||||
@@ -72,10 +65,6 @@ pub struct BuildStep {
|
||||
pub cwd: PathBuf,
|
||||
pub env: BTreeMap<String, String>,
|
||||
format: Format,
|
||||
/// Folders created before the command runs (a compiler's output).
|
||||
mkdirs: Vec<PathBuf>,
|
||||
/// Work done in the IDE instead of a command, with its console title.
|
||||
action: Option<(structure::Action, String)>,
|
||||
}
|
||||
|
||||
impl BuildStep {
|
||||
@@ -86,26 +75,16 @@ impl BuildStep {
|
||||
cwd: cwd.to_path_buf(),
|
||||
env: BTreeMap::new(),
|
||||
format,
|
||||
mkdirs: Vec::new(),
|
||||
action: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn action(action: structure::Action, root: &Path) -> Self {
|
||||
let title = action.display(root);
|
||||
BuildStep { action: Some((action, title)), ..Self::new("", &[], root, Format::Gradle) }
|
||||
}
|
||||
|
||||
/// A CMake configure/build invocation, parsed as compiler output in the Build view.
|
||||
pub fn cmake(program: &str, args: Vec<String>, cwd: PathBuf, env: BTreeMap<String, String>) -> Self {
|
||||
Self { program: program.into(), args, cwd, env, format: Format::Gcc, mkdirs: Vec::new(), action: None }
|
||||
Self { program: program.into(), args, cwd, env, format: Format::Gcc }
|
||||
}
|
||||
|
||||
/// The command line as echoed in the console.
|
||||
pub fn display(&self) -> String {
|
||||
if let Some((_, title)) = &self.action {
|
||||
return title.clone();
|
||||
}
|
||||
let program = Path::new(&self.program).file_name().map_or(self.program.clone(), |n| n.to_string_lossy().into());
|
||||
std::iter::once(program)
|
||||
.chain(self.args.iter().map(|a| if a.contains(' ') { format!("\"{a}\"") } else { a.clone() }))
|
||||
@@ -270,8 +249,6 @@ pub fn plan(
|
||||
BuildSystem::TypeScript => ts_steps(&dir, kind),
|
||||
BuildSystem::CMake => cmake_steps(&dir, kind, cmake.and_then(<[_]>::first)),
|
||||
BuildSystem::Dotnet => dotnet_steps(&dir, kind)?,
|
||||
// Never detected from a folder: it comes from the Project Structure (`structure_plan`).
|
||||
BuildSystem::Javac => return Err(IdeError::invalid("no build tool to run")),
|
||||
};
|
||||
Ok(BuildPlan { system, title, steps })
|
||||
}
|
||||
@@ -673,36 +650,6 @@ pub fn run(
|
||||
let command = step.display();
|
||||
on_event(BuildEvent::Step { command: command.clone(), cwd: step.cwd.clone().into() });
|
||||
on_event(BuildEvent::Progress { message: command.clone(), fraction: None });
|
||||
if let Some((action, _)) = &step.action {
|
||||
match action.run(cancel) {
|
||||
Ok(text) => {
|
||||
if !text.is_empty() {
|
||||
on_event(BuildEvent::Output { text: format!("{text}\n"), stderr: false });
|
||||
}
|
||||
continue;
|
||||
}
|
||||
Err(e) if e.kind == ide_core::error::ErrorKind::Cancelled => return Err(e),
|
||||
Err(e) => {
|
||||
let m = BuildMessage {
|
||||
severity: Severity::Error,
|
||||
text: e.message.clone(),
|
||||
path: None,
|
||||
range: None,
|
||||
code: None,
|
||||
};
|
||||
on_event(BuildEvent::Output { text: format!("{}\n", e.message), stderr: true });
|
||||
on_event(BuildEvent::Message { message: m.clone() });
|
||||
messages.push(m);
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
for dir in &step.mkdirs {
|
||||
if let Err(e) = std::fs::create_dir_all(dir) {
|
||||
tracing::debug!(dir = %dir.display(), %e, "cannot create the build output folder");
|
||||
}
|
||||
}
|
||||
let mut parser = OutputParser::new(step.format);
|
||||
let mut emit = |raws: Vec<RawMessage>, messages: &mut Vec<BuildMessage>| {
|
||||
for raw in raws {
|
||||
|
||||
@@ -1,817 +0,0 @@
|
||||
//! A Java project without a build tool, built from its Project Structure: `javac` compiles
|
||||
//! the source roots to the module's output folder against the project libraries and the
|
||||
//! Web facet's `WEB-INF/lib`, and the resources are copied next to the classes; tests the
|
||||
//! same way into the test output, which also sees the production classes.
|
||||
use super::*;
|
||||
use ide_core::settings::{
|
||||
ArtifactConfig, ArtifactKind, DependencyScope, ModuleStructureSettings, ProjectStructureSettings,
|
||||
};
|
||||
use std::fs;
|
||||
|
||||
/// The roots of the project as the IDE resolved them (absolute folders).
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct StructureRoots {
|
||||
pub sources: Vec<PathBuf>,
|
||||
pub tests: Vec<PathBuf>,
|
||||
pub resources: Vec<PathBuf>,
|
||||
pub test_resources: Vec<PathBuf>,
|
||||
pub excluded: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
/// The JDK compiling the project.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct StructureJdk {
|
||||
pub home: PathBuf,
|
||||
pub major: u32,
|
||||
}
|
||||
|
||||
/// Where the project's classes go: `<compiler output>/production/<module>` and
|
||||
/// `<compiler output>/test/<module>` (`out` by default), unless the module names its own.
|
||||
pub fn structure_outputs(root: &Path, ps: &ProjectStructureSettings) -> (PathBuf, PathBuf) {
|
||||
let module = root_module(root, ps);
|
||||
let name = module_name(root);
|
||||
let base = resolve_dir(root, &ps.compiler_output).unwrap_or_else(|| root.join("out"));
|
||||
let main = module
|
||||
.and_then(|m| resolve_dir(root, &m.compiler_output))
|
||||
.unwrap_or_else(|| base.join("production").join(&name));
|
||||
let test = module
|
||||
.and_then(|m| resolve_dir(root, &m.test_compiler_output))
|
||||
.unwrap_or_else(|| base.join("test").join(&name));
|
||||
(main, test)
|
||||
}
|
||||
|
||||
fn module_name(root: &Path) -> String {
|
||||
root.file_name().map_or_else(|| "project".to_owned(), |n| n.to_string_lossy().into_owned())
|
||||
}
|
||||
|
||||
fn root_module<'a>(root: &Path, ps: &'a ProjectStructureSettings) -> Option<&'a ModuleStructureSettings> {
|
||||
ps.modules.get(".").or_else(|| ps.module_settings(root, root))
|
||||
}
|
||||
|
||||
fn resolve_dir(root: &Path, value: &str) -> Option<PathBuf> {
|
||||
let value = value.trim();
|
||||
(!value.is_empty()).then(|| root.join(value))
|
||||
}
|
||||
|
||||
/// `.java` files below `dir`, not inside an excluded folder or another root of `skip`.
|
||||
fn java_files(dir: &Path, excluded: &[PathBuf], out: &mut Vec<PathBuf>) {
|
||||
let Ok(entries) = fs::read_dir(dir) else { return };
|
||||
let mut entries: Vec<_> = entries.flatten().collect();
|
||||
entries.sort_by_key(|e| e.file_name());
|
||||
for e in entries {
|
||||
let path = e.path();
|
||||
match e.file_type() {
|
||||
Ok(t) if t.is_dir() => {
|
||||
if !excluded.iter().any(|x| path.starts_with(x)) {
|
||||
java_files(&path, excluded, out);
|
||||
}
|
||||
}
|
||||
Ok(t) if t.is_file() && path.extension().is_some_and(|x| x == "java") => out.push(path),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Folders and archives of the libraries a module compiles against, for `scope`.
|
||||
fn library_entries(root: &Path, ps: &ProjectStructureSettings, test: bool) -> Vec<String> {
|
||||
let wanted = |scope: DependencyScope| match scope {
|
||||
DependencyScope::Compile | DependencyScope::Provided => true,
|
||||
DependencyScope::Test => test,
|
||||
DependencyScope::Runtime => false,
|
||||
};
|
||||
let mut out: Vec<String> = Vec::new();
|
||||
let mut add = |entry: String| {
|
||||
if !out.contains(&entry) {
|
||||
out.push(entry);
|
||||
}
|
||||
};
|
||||
let module_deps = root_module(root, ps).map(|m| m.dependencies.as_slice()).unwrap_or_default();
|
||||
for lib in &ps.libraries {
|
||||
// A library a module dependency names takes that dependency's scope.
|
||||
let scope =
|
||||
module_deps.iter().find(|d| d.kind == "library" && d.target == lib.name).map_or(lib.scope, |d| d.scope);
|
||||
if wanted(scope) {
|
||||
for class in &lib.classes {
|
||||
add(class_entry(root, class));
|
||||
}
|
||||
}
|
||||
}
|
||||
for dep in module_deps.iter().filter(|d| d.kind == "library" && wanted(d.scope)) {
|
||||
if !ps.libraries.iter().any(|l| l.name == dep.target) && !dep.target.trim().is_empty() {
|
||||
add(class_entry(root, &dep.target));
|
||||
}
|
||||
}
|
||||
for facet in ps.facets.iter().filter(|f| f.kind == "web") {
|
||||
let lib = web_root(root, facet).join("WEB-INF").join("lib");
|
||||
if lib.is_dir() {
|
||||
add(format!("{}{}*", lib.to_string_lossy(), std::path::MAIN_SEPARATOR));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The web resource folder of a Web facet: its own, else the folder holding `WEB-INF/web.xml`.
|
||||
fn web_root(root: &Path, facet: &ide_core::settings::FacetConfig) -> PathBuf {
|
||||
let dir = facet.web_root.trim();
|
||||
let dir = if dir.is_empty() {
|
||||
facet.descriptor.trim().replace('\\', "/").strip_suffix("/WEB-INF/web.xml").unwrap_or("").to_owned()
|
||||
} else {
|
||||
dir.to_owned()
|
||||
};
|
||||
root.join(dir)
|
||||
}
|
||||
|
||||
/// The class archives and folders of a library path (`lib/*.jar` lists the folder's jars).
|
||||
fn library_files(root: &Path, value: &str) -> Vec<PathBuf> {
|
||||
let entry = class_entry(root, value);
|
||||
match entry.strip_suffix('*') {
|
||||
Some(dir) => {
|
||||
let mut jars: Vec<PathBuf> = fs::read_dir(dir)
|
||||
.map(|d| d.flatten().map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "jar")).collect())
|
||||
.unwrap_or_default();
|
||||
jars.sort();
|
||||
jars
|
||||
}
|
||||
None => vec![PathBuf::from(entry)],
|
||||
}
|
||||
}
|
||||
|
||||
/// A classpath entry for a library path: a folder of jars (`lib/*`) stays a wildcard javac expands.
|
||||
fn class_entry(root: &Path, value: &str) -> String {
|
||||
let path = root.join(value.trim());
|
||||
let text = path.to_string_lossy().into_owned();
|
||||
if text.ends_with("/*.jar") || text.ends_with("\\*.jar") {
|
||||
return text[..text.len() - 4].to_owned();
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
fn classpath(entries: &[String]) -> String {
|
||||
entries.join(if cfg!(windows) { ";" } else { ":" })
|
||||
}
|
||||
|
||||
/// `--release N` from JDK 9 on; older compilers only know `-source` / `-target`.
|
||||
fn release_args(level: Option<u32>, jdk: Option<&StructureJdk>) -> Vec<String> {
|
||||
let Some(level) = level else { return Vec::new() };
|
||||
if jdk.is_none_or(|j| j.major >= 9) {
|
||||
vec!["--release".into(), level.to_string()]
|
||||
} else {
|
||||
vec!["-source".into(), format!("1.{level}"), "-target".into(), format!("1.{level}")]
|
||||
}
|
||||
}
|
||||
|
||||
/// `"17"`, `"1.8"`, `"JDK_17"` → the release number.
|
||||
pub fn language_release(level: &str) -> Option<u32> {
|
||||
let digits = level.trim().trim_start_matches("JDK_").trim_start_matches("jdk").replace('_', ".");
|
||||
let digits = digits.strip_prefix("1.").unwrap_or(&digits);
|
||||
digits.split(['.', ' ']).next()?.parse().ok().filter(|n| *n > 0)
|
||||
}
|
||||
|
||||
/// The Build / Rebuild plan of a project without a build tool, or `None` when it has no
|
||||
/// Java sources under its source roots. `language_level`: the project's, unless the module
|
||||
/// overrides it. Writes the javac argument files below `cache`.
|
||||
pub fn structure_plan(
|
||||
root: &Path,
|
||||
ps: &ProjectStructureSettings,
|
||||
roots: &StructureRoots,
|
||||
jdk: Option<&StructureJdk>,
|
||||
language_level: &str,
|
||||
kind: BuildKind,
|
||||
cache: &Path,
|
||||
) -> IdeResult<Option<BuildPlan>> {
|
||||
let mut main_sources = Vec::new();
|
||||
for dir in &roots.sources {
|
||||
java_files(dir, &roots.excluded, &mut main_sources);
|
||||
}
|
||||
let mut test_sources = Vec::new();
|
||||
for dir in &roots.tests {
|
||||
java_files(dir, &roots.excluded, &mut test_sources);
|
||||
}
|
||||
if main_sources.is_empty() && test_sources.is_empty() {
|
||||
return Ok(None);
|
||||
}
|
||||
let (main_out, test_out) = structure_outputs(root, ps);
|
||||
let module = root_module(root, ps);
|
||||
let level = module
|
||||
.map(|m| m.language_level.as_str())
|
||||
.filter(|l| !l.trim().is_empty())
|
||||
.or(Some(language_level))
|
||||
.and_then(language_release);
|
||||
let env: BTreeMap<String, String> = jdk
|
||||
.map(|j| BTreeMap::from([("JAVA_HOME".to_owned(), j.home.to_string_lossy().into_owned())]))
|
||||
.unwrap_or_default();
|
||||
let javac = find_javac(&env);
|
||||
let args_dir = cache.join("javac");
|
||||
fs::create_dir_all(&args_dir)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", args_dir.display())))?;
|
||||
|
||||
let mut steps = Vec::new();
|
||||
if kind == BuildKind::Rebuild {
|
||||
steps.push(BuildStep::action(Action::Clean(vec![main_out.clone(), test_out.clone()]), root));
|
||||
}
|
||||
let main_cp = library_entries(root, ps, false);
|
||||
let compile = |name: &str, sources: &[PathBuf], out: &Path, cp: &[String]| -> IdeResult<BuildStep> {
|
||||
let args_file = args_dir.join(format!("{name}.args"));
|
||||
// One quoted path per line: the sources outgrow a command line quickly.
|
||||
let text: String = sources
|
||||
.iter()
|
||||
.map(|p| format!("\"{}\"\n", p.to_string_lossy().replace('\\', "\\\\").replace('"', "\\\"")))
|
||||
.collect();
|
||||
fs::write(&args_file, text)
|
||||
.map_err(|e| IdeError::internal(format!("cannot write {} ({e})", args_file.display())))?;
|
||||
let mut step = BuildStep::new(&javac, &[], root, Format::Gradle);
|
||||
step.args.extend(["-encoding".into(), "UTF-8".into(), "-g".into()]);
|
||||
step.args.extend(["-d".into(), out.to_string_lossy().into_owned()]);
|
||||
if !cp.is_empty() {
|
||||
step.args.extend(["-cp".into(), classpath(cp)]);
|
||||
}
|
||||
step.args.extend(release_args(level, jdk));
|
||||
step.args.push(format!("@{}", args_file.to_string_lossy()));
|
||||
step.env = env.clone();
|
||||
step.mkdirs = vec![out.to_path_buf()];
|
||||
Ok(step)
|
||||
};
|
||||
if !main_sources.is_empty() {
|
||||
steps.push(compile("production", &main_sources, &main_out, &main_cp)?);
|
||||
}
|
||||
steps.push(BuildStep::action(
|
||||
Action::CopyResources {
|
||||
from: roots.sources.iter().chain(&roots.resources).cloned().collect(),
|
||||
to: main_out.clone(),
|
||||
},
|
||||
root,
|
||||
));
|
||||
// Artifacts hold production classes only.
|
||||
if !test_sources.is_empty() && kind != BuildKind::Artifacts {
|
||||
let mut test_cp = vec![main_out.to_string_lossy().into_owned()];
|
||||
test_cp.extend(library_entries(root, ps, true));
|
||||
steps.push(compile("test", &test_sources, &test_out, &test_cp)?);
|
||||
steps.push(BuildStep::action(
|
||||
Action::CopyResources {
|
||||
from: roots.tests.iter().chain(&roots.test_resources).cloned().collect(),
|
||||
to: test_out.clone(),
|
||||
},
|
||||
root,
|
||||
));
|
||||
}
|
||||
if kind == BuildKind::Artifacts {
|
||||
if ps.artifacts.is_empty() {
|
||||
return Err(IdeError::invalid("No artifacts are configured: add one in Project Structure › Artifacts"));
|
||||
}
|
||||
for artifact in &ps.artifacts {
|
||||
steps.extend(artifact_steps(root, ps, artifact, &main_out, None, cache));
|
||||
}
|
||||
}
|
||||
Ok(Some(BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps }))
|
||||
}
|
||||
|
||||
/// Where an artifact goes: its output folder, else `out/artifacts/<name>`.
|
||||
pub fn artifact_output(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
|
||||
resolve_dir(root, &artifact.output_directory)
|
||||
.unwrap_or_else(|| root.join("out").join("artifacts").join(file_name(&artifact.name)))
|
||||
}
|
||||
|
||||
/// An artifact name as a file name (`shop:war exploded` → `shop_war_exploded`).
|
||||
fn file_name(name: &str) -> String {
|
||||
name.chars().map(|c| if c.is_alphanumeric() || c == '-' || c == '.' { c } else { '_' }).collect()
|
||||
}
|
||||
|
||||
/// The archive a `jar` / `war` artifact writes (`<output>/<name>.war`), or its folder (exploded).
|
||||
pub fn artifact_file(root: &Path, artifact: &ArtifactConfig) -> PathBuf {
|
||||
let out = artifact_output(root, artifact);
|
||||
let base = artifact.name.split(':').next().filter(|n| !n.trim().is_empty()).unwrap_or(&artifact.name);
|
||||
match artifact.kind {
|
||||
ArtifactKind::Jar => out.join(format!("{}.jar", file_name(base))),
|
||||
ArtifactKind::War => out.join(format!("{}.war", file_name(base))),
|
||||
ArtifactKind::WarExploded => out,
|
||||
}
|
||||
}
|
||||
|
||||
/// The steps laying out one artifact from the module output `classes`; `war`: write a
|
||||
/// WAR there instead of the artifact's own output (an application server's deployment).
|
||||
fn artifact_steps(
|
||||
root: &Path,
|
||||
ps: &ProjectStructureSettings,
|
||||
artifact: &ArtifactConfig,
|
||||
classes: &Path,
|
||||
war: Option<&Path>,
|
||||
cache: &Path,
|
||||
) -> Vec<BuildStep> {
|
||||
let libraries: Vec<PathBuf> = ps
|
||||
.libraries
|
||||
.iter()
|
||||
.filter(|l| artifact.include_libraries.contains(&l.name))
|
||||
.flat_map(|l| l.classes.iter().flat_map(|c| library_files(root, c)))
|
||||
.collect();
|
||||
let facet = ps
|
||||
.facets
|
||||
.iter()
|
||||
.filter(|f| f.kind == "web")
|
||||
.find(|f| f.module == artifact.module || f.module.is_empty() && artifact.module == ".")
|
||||
.or_else(|| ps.facets.iter().find(|f| f.kind == "web"));
|
||||
let staging = cache.join("artifacts").join(file_name(&artifact.name));
|
||||
let mut steps = Vec::new();
|
||||
match (artifact.kind, war) {
|
||||
(ArtifactKind::Jar, None) => {
|
||||
let out = artifact_output(root, artifact);
|
||||
let mut manifest = String::from("Manifest-Version: 1.0\r\n");
|
||||
if !artifact.main_class.trim().is_empty() {
|
||||
manifest.push_str(&format!("Main-Class: {}\r\n", artifact.main_class.trim()));
|
||||
}
|
||||
let names: Vec<String> =
|
||||
libraries.iter().filter_map(|l| l.file_name()).map(|n| n.to_string_lossy().into_owned()).collect();
|
||||
if !names.is_empty() {
|
||||
manifest.push_str(&format!("Class-Path: {}\r\n", names.join(" ")));
|
||||
}
|
||||
steps.push(BuildStep::action(
|
||||
Action::Layout { into: staging.clone(), entries: vec![(classes.to_path_buf(), PathBuf::new())] },
|
||||
root,
|
||||
));
|
||||
// The jar's Class-Path names the libraries next to it.
|
||||
steps.push(BuildStep::action(
|
||||
Action::Layout {
|
||||
into: out.clone(),
|
||||
entries: libraries.iter().map(|l| (l.clone(), file_of(l))).collect(),
|
||||
},
|
||||
root,
|
||||
));
|
||||
steps.push(BuildStep::action(
|
||||
Action::Archive { from: staging, to: artifact_file(root, artifact), manifest: Some(manifest) },
|
||||
root,
|
||||
));
|
||||
}
|
||||
(kind, war) => {
|
||||
let exploded = match (kind, war) {
|
||||
(ArtifactKind::WarExploded, None) => artifact_output(root, artifact),
|
||||
_ => staging.clone(),
|
||||
};
|
||||
let mut entries = Vec::new();
|
||||
if let Some(facet) = facet {
|
||||
entries.push((web_root(root, facet), PathBuf::new()));
|
||||
}
|
||||
entries.push((classes.to_path_buf(), PathBuf::from("WEB-INF/classes")));
|
||||
for lib in &libraries {
|
||||
entries.push((lib.clone(), Path::new("WEB-INF/lib").join(file_of(lib))));
|
||||
}
|
||||
steps.push(BuildStep::action(Action::Layout { into: exploded.clone(), entries }, root));
|
||||
let archive = war
|
||||
.map(Path::to_path_buf)
|
||||
.or_else(|| (kind != ArtifactKind::WarExploded).then(|| artifact_file(root, artifact)));
|
||||
if let Some(to) = archive {
|
||||
steps.push(BuildStep::action(Action::Archive { from: exploded, to, manifest: None }, root));
|
||||
}
|
||||
}
|
||||
}
|
||||
steps
|
||||
}
|
||||
|
||||
fn file_of(path: &Path) -> PathBuf {
|
||||
path.file_name().map(PathBuf::from).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// The WAR artifacts of a project without a build tool: an application server deploys them.
|
||||
pub fn structure_web_artifacts(ps: &ProjectStructureSettings) -> Vec<&ArtifactConfig> {
|
||||
ps.artifacts.iter().filter(|a| matches!(a.kind, ArtifactKind::War | ArtifactKind::WarExploded)).collect()
|
||||
}
|
||||
|
||||
/// A build of `artifact` into the WAR `war` (Tomcat's deployment), compiling first.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn structure_war_plan(
|
||||
root: &Path,
|
||||
ps: &ProjectStructureSettings,
|
||||
roots: &StructureRoots,
|
||||
jdk: Option<&StructureJdk>,
|
||||
language_level: &str,
|
||||
artifact: &ArtifactConfig,
|
||||
war: &Path,
|
||||
cache: &Path,
|
||||
) -> IdeResult<BuildPlan> {
|
||||
let mut plan = structure_plan(root, ps, roots, jdk, language_level, BuildKind::Build, cache)?
|
||||
.unwrap_or_else(|| BuildPlan { system: BuildSystem::Javac, title: module_name(root), steps: Vec::new() });
|
||||
let (main_out, _) = structure_outputs(root, ps);
|
||||
// Tests are not part of a deployment.
|
||||
plan.steps.retain(|s| !s.args.iter().any(|a| a.ends_with("test.args")));
|
||||
plan.steps
|
||||
.retain(|s| !matches!(&s.action, Some((Action::CopyResources { to, .. }, _)) if !to.starts_with(&main_out)));
|
||||
plan.steps.extend(artifact_steps(root, ps, artifact, &main_out, Some(war), cache));
|
||||
plan.title = artifact.name.clone();
|
||||
Ok(plan)
|
||||
}
|
||||
|
||||
/// Work a build does in the IDE itself rather than through a tool.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) enum Action {
|
||||
/// Deletes these output folders (Rebuild).
|
||||
Clean(Vec<PathBuf>),
|
||||
/// Copies the files of these folders that are not Java sources into `to`, keeping their
|
||||
/// relative paths; files that are already up to date are left alone.
|
||||
CopyResources { from: Vec<PathBuf>, to: PathBuf },
|
||||
/// Lays out an artifact in `into`: each folder's content or file goes to its relative
|
||||
/// place (`""` = the top). What is no longer laid out is removed.
|
||||
Layout { into: PathBuf, entries: Vec<(PathBuf, PathBuf)> },
|
||||
/// Zips the folder `from` into the archive `to`, with this manifest first.
|
||||
Archive { from: PathBuf, to: PathBuf, manifest: Option<String> },
|
||||
}
|
||||
|
||||
impl Action {
|
||||
pub(crate) fn display(&self, root: &Path) -> String {
|
||||
let rel = |p: &Path| p.strip_prefix(root).unwrap_or(p).to_string_lossy().into_owned();
|
||||
match self {
|
||||
Action::Clean(dirs) => format!("Clean {}", dirs.iter().map(|d| rel(d)).collect::<Vec<_>>().join(", ")),
|
||||
Action::CopyResources { to, .. } => format!("Copy resources to {}", rel(to)),
|
||||
Action::Layout { into, .. } => format!("Lay out {}", rel(into)),
|
||||
Action::Archive { to, .. } => format!("Pack {}", rel(to)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs the action; the text is a summary for the console.
|
||||
pub(crate) fn run(&self, cancel: &CancellationToken) -> IdeResult<String> {
|
||||
match self {
|
||||
Action::Clean(dirs) => {
|
||||
for dir in dirs.iter().filter(|d| d.exists()) {
|
||||
fs::remove_dir_all(dir)
|
||||
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", dir.display())))?;
|
||||
}
|
||||
Ok(String::new())
|
||||
}
|
||||
Action::CopyResources { from, to } => {
|
||||
let mut copied = 0;
|
||||
for dir in from {
|
||||
copied += copy_resources(dir, dir, to, cancel)?;
|
||||
}
|
||||
Ok(format!("{copied} resource file(s) copied"))
|
||||
}
|
||||
Action::Layout { into, entries } => {
|
||||
// A fresh layout: files dropped from the sources must not linger in the artifact.
|
||||
if entries.iter().any(|(from, _)| from.starts_with(into)) {
|
||||
return Err(IdeError::invalid(format!(
|
||||
"The artifact output folder {} holds files the artifact is made of",
|
||||
into.display()
|
||||
)));
|
||||
}
|
||||
if into.exists() {
|
||||
fs::remove_dir_all(into)
|
||||
.map_err(|e| IdeError::internal(format!("cannot delete {} ({e})", into.display())))?;
|
||||
}
|
||||
let mut copied = 0;
|
||||
for (from, to) in entries {
|
||||
let target = into.join(to);
|
||||
if from.is_dir() {
|
||||
copied += copy_tree(from, &target, cancel)?;
|
||||
} else if from.is_file() {
|
||||
copy_file(from, &target)?;
|
||||
copied += 1;
|
||||
}
|
||||
}
|
||||
Ok(format!("{copied} file(s) laid out"))
|
||||
}
|
||||
Action::Archive { from, to, manifest } => {
|
||||
archive(from, to, manifest.as_deref(), cancel)?;
|
||||
Ok(format!("Wrote {}", to.display()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn copy_file(from: &Path, to: &Path) -> IdeResult<()> {
|
||||
if let Some(parent) = to.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
|
||||
}
|
||||
fs::copy(from, to).map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", from.display())))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_tree(from: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Ok(entries) = fs::read_dir(from) else { return Ok(0) };
|
||||
let mut copied = 0;
|
||||
for e in entries.flatten() {
|
||||
let Ok(t) = e.file_type() else { continue };
|
||||
let target = to.join(e.file_name());
|
||||
if t.is_dir() {
|
||||
copied += copy_tree(&e.path(), &target, cancel)?;
|
||||
} else if t.is_file() {
|
||||
copy_file(&e.path(), &target)?;
|
||||
copied += 1;
|
||||
}
|
||||
}
|
||||
Ok(copied)
|
||||
}
|
||||
|
||||
fn archive(from: &Path, to: &Path, manifest: Option<&str>, cancel: &CancellationToken) -> IdeResult<()> {
|
||||
use std::io::Write;
|
||||
let err = |e: &dyn std::fmt::Display| IdeError::internal(format!("cannot write {} ({e})", to.display()));
|
||||
if let Some(parent) = to.parent() {
|
||||
fs::create_dir_all(parent).map_err(|e| err(&e))?;
|
||||
}
|
||||
let mut zip = zip::ZipWriter::new(fs::File::create(to).map_err(|e| err(&e))?);
|
||||
let options = zip::write::SimpleFileOptions::default();
|
||||
if let Some(manifest) = manifest {
|
||||
zip.add_directory("META-INF/", options).map_err(|e| err(&e))?;
|
||||
zip.start_file("META-INF/MANIFEST.MF", options).map_err(|e| err(&e))?;
|
||||
zip.write_all(manifest.as_bytes()).map_err(|e| err(&e))?;
|
||||
}
|
||||
let mut stack = vec![from.to_path_buf()];
|
||||
while let Some(dir) = stack.pop() {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Ok(entries) = fs::read_dir(&dir) else { continue };
|
||||
let mut entries: Vec<_> = entries.flatten().collect();
|
||||
entries.sort_by_key(|e| e.file_name());
|
||||
for e in entries {
|
||||
let path = e.path();
|
||||
let name = path.strip_prefix(from).unwrap_or(&path).to_string_lossy().replace('\\', "/");
|
||||
if manifest.is_some() && name.eq_ignore_ascii_case("META-INF/MANIFEST.MF") {
|
||||
continue;
|
||||
}
|
||||
match e.file_type() {
|
||||
Ok(t) if t.is_dir() => {
|
||||
if !(manifest.is_some() && name == "META-INF") {
|
||||
zip.add_directory(format!("{name}/"), options).map_err(|e| err(&e))?;
|
||||
}
|
||||
stack.push(path);
|
||||
}
|
||||
Ok(t) if t.is_file() => {
|
||||
zip.start_file(name, options).map_err(|e| err(&e))?;
|
||||
let mut file = fs::File::open(&path).map_err(|e| err(&e))?;
|
||||
std::io::copy(&mut file, &mut zip).map_err(|e| err(&e))?;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
zip.finish().map_err(|e| err(&e))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn copy_resources(base: &Path, dir: &Path, to: &Path, cancel: &CancellationToken) -> IdeResult<usize> {
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
let Ok(entries) = fs::read_dir(dir) else { return Ok(0) };
|
||||
let mut copied = 0;
|
||||
for e in entries.flatten() {
|
||||
let path = e.path();
|
||||
let Ok(t) = e.file_type() else { continue };
|
||||
if t.is_dir() {
|
||||
// The output folder can sit inside a source root (`src` holding `classes`).
|
||||
if path != to && !path.starts_with(to) {
|
||||
copied += copy_resources(base, &path, to, cancel)?;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if !t.is_file() || path.extension().is_some_and(|x| x == "java") {
|
||||
continue;
|
||||
}
|
||||
let target = to.join(path.strip_prefix(base).unwrap_or(&path));
|
||||
let newer =
|
||||
match (fs::metadata(&path).and_then(|m| m.modified()), fs::metadata(&target).and_then(|m| m.modified())) {
|
||||
(Ok(source), Ok(existing)) => source > existing,
|
||||
_ => true,
|
||||
};
|
||||
if newer {
|
||||
if let Some(parent) = target.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|e| IdeError::internal(format!("cannot create {} ({e})", parent.display())))?;
|
||||
}
|
||||
fs::copy(&path, &target)
|
||||
.map_err(|e| IdeError::internal(format!("cannot copy {} ({e})", path.display())))?;
|
||||
copied += 1;
|
||||
}
|
||||
}
|
||||
Ok(copied)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use ide_core::settings::{FacetConfig, ModuleDependency, ProjectLibrary};
|
||||
|
||||
fn write(path: &Path, text: &str) {
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
fs::write(path, text).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reads_language_levels() {
|
||||
assert_eq!(language_release("17"), Some(17));
|
||||
assert_eq!(language_release("1.8"), Some(8));
|
||||
assert_eq!(language_release("JDK_11"), Some(11));
|
||||
assert_eq!(language_release(""), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plans_javac_over_source_roots_with_libraries_and_web_lib() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("shop");
|
||||
write(&root.join("src/com/a/A.java"), "package com.a; class A {}");
|
||||
write(&root.join("src/com/a/app.properties"), "x=1");
|
||||
write(&root.join("test/com/a/ATest.java"), "package com.a; class ATest {}");
|
||||
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
|
||||
write(&root.join("WebRoot/WEB-INF/lib/x.jar"), "");
|
||||
let ps = ProjectStructureSettings {
|
||||
libraries: vec![
|
||||
ProjectLibrary { name: "tools".into(), classes: vec!["lib/*.jar".into()], ..Default::default() },
|
||||
ProjectLibrary {
|
||||
name: "junit".into(),
|
||||
classes: vec!["junit.jar".into()],
|
||||
scope: DependencyScope::Test,
|
||||
..Default::default()
|
||||
},
|
||||
],
|
||||
facets: vec![FacetConfig {
|
||||
kind: "web".into(),
|
||||
module: ".".into(),
|
||||
descriptor: "WebRoot/WEB-INF/web.xml".into(),
|
||||
web_root: String::new(),
|
||||
}],
|
||||
..Default::default()
|
||||
};
|
||||
let roots =
|
||||
StructureRoots { sources: vec![root.join("src")], tests: vec![root.join("test")], ..Default::default() };
|
||||
let jdk = StructureJdk { home: PathBuf::from("/jdk"), major: 21 };
|
||||
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "17", BuildKind::Rebuild, &tmp.path().join("cache"))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(plan.system, BuildSystem::Javac);
|
||||
let shown: Vec<String> = plan.steps.iter().map(BuildStep::display).collect();
|
||||
assert_eq!(shown[0], "Clean out/production/shop, out/test/shop");
|
||||
let javac = &plan.steps[1];
|
||||
let cp = |s: &BuildStep| s.args[s.args.iter().position(|a| a == "-cp").unwrap() + 1].clone();
|
||||
let sep = if cfg!(windows) { ";" } else { ":" };
|
||||
let main_cp = cp(javac);
|
||||
let entries: Vec<&str> = main_cp.split(sep).collect();
|
||||
assert_eq!(entries.len(), 2, "{main_cp}");
|
||||
assert!(entries[0].ends_with("lib/*"));
|
||||
assert!(entries[1].ends_with("WEB-INF/lib/*"));
|
||||
assert!(javac.args.windows(2).any(|w| w == ["--release", "17"]));
|
||||
let args = fs::read_to_string(tmp.path().join("cache/javac/production.args")).unwrap();
|
||||
assert!(args.contains("A.java") && !args.contains("ATest.java"));
|
||||
assert_eq!(shown[2], "Copy resources to out/production/shop");
|
||||
let test = &plan.steps[3];
|
||||
let test_cp = cp(test);
|
||||
assert!(test_cp.starts_with(&root.join("out/production/shop").to_string_lossy().into_owned()));
|
||||
assert!(test_cp.contains("junit.jar"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_module_dependency_gives_its_library_a_scope_and_jdk_8_gets_source_and_target() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("p");
|
||||
write(&root.join("src/A.java"), "class A {}");
|
||||
let mut ps = ProjectStructureSettings {
|
||||
libraries: vec![ProjectLibrary {
|
||||
name: "junit".into(),
|
||||
classes: vec!["junit.jar".into()],
|
||||
..Default::default()
|
||||
}],
|
||||
compiler_output: "build/classes".into(),
|
||||
..Default::default()
|
||||
};
|
||||
ps.modules.insert(
|
||||
".".into(),
|
||||
ModuleStructureSettings {
|
||||
language_level: "1.8".into(),
|
||||
dependencies: vec![ModuleDependency {
|
||||
kind: "library".into(),
|
||||
target: "junit".into(),
|
||||
scope: DependencyScope::Test,
|
||||
exported: false,
|
||||
}],
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
let roots = StructureRoots { sources: vec![root.join("src")], ..Default::default() };
|
||||
let jdk = StructureJdk { home: PathBuf::from("/jdk8"), major: 8 };
|
||||
let plan = structure_plan(&root, &ps, &roots, Some(&jdk), "21", BuildKind::Build, &tmp.path().join("c"))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
let javac = &plan.steps[0];
|
||||
assert!(!javac.args.iter().any(|a| a == "-cp"), "{:?}", javac.args);
|
||||
assert!(javac.args.windows(4).any(|w| w == ["-source", "1.8", "-target", "1.8"]));
|
||||
assert!(javac.args.windows(2).any(|w| w[0] == "-d" && w[1].ends_with("build/classes/production/p")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_plan_without_java_sources() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let roots = StructureRoots { sources: vec![tmp.path().join("src")], ..Default::default() };
|
||||
let plan =
|
||||
structure_plan(tmp.path(), &Default::default(), &roots, None, "", BuildKind::Build, &tmp.path().join("c"));
|
||||
assert!(plan.unwrap().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn copies_resources_but_not_sources_and_skips_up_to_date_files() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let src = tmp.path().join("src");
|
||||
write(&src.join("a/A.java"), "class A {}");
|
||||
write(&src.join("a/x.xml"), "<x/>");
|
||||
let out = tmp.path().join("out");
|
||||
let action = Action::CopyResources { from: vec![src], to: out.clone() };
|
||||
let cancel = CancellationToken::new();
|
||||
assert_eq!(action.run(&cancel).unwrap(), "1 resource file(s) copied");
|
||||
assert!(out.join("a/x.xml").is_file() && !out.join("a/A.java").exists());
|
||||
assert_eq!(action.run(&cancel).unwrap(), "0 resource file(s) copied");
|
||||
Action::Clean(vec![out.clone()]).run(&cancel).unwrap();
|
||||
assert!(!out.exists());
|
||||
}
|
||||
|
||||
fn entries(archive: &Path) -> Vec<String> {
|
||||
let mut zip = zip::ZipArchive::new(fs::File::open(archive).unwrap()).unwrap();
|
||||
(0..zip.len()).map(|i| zip.by_index(i).unwrap().name().unwrap().into_owned()).collect()
|
||||
}
|
||||
|
||||
fn run_plan(plan: &BuildPlan) {
|
||||
let cancel = CancellationToken::new();
|
||||
for step in &plan.steps {
|
||||
if let Some((action, _)) = &step.action {
|
||||
action.run(&cancel).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lays_out_war_jar_and_exploded_artifacts() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = tmp.path().join("shop");
|
||||
write(&root.join("WebRoot/index.jsp"), "hi");
|
||||
write(&root.join("WebRoot/WEB-INF/web.xml"), "<web-app/>");
|
||||
write(&root.join("WebRoot/WEB-INF/lib/inside.jar"), "");
|
||||
write(&root.join("lib/extra.jar"), "");
|
||||
let classes = root.join("out/production/shop");
|
||||
write(&classes.join("com/a/A.class"), "");
|
||||
let artifact = |name: &str, kind| ArtifactConfig {
|
||||
name: name.into(),
|
||||
kind,
|
||||
module: ".".into(),
|
||||
include_libraries: vec!["extra".into()],
|
||||
main_class: "com.a.A".into(),
|
||||
..Default::default()
|
||||
};
|
||||
let ps = ProjectStructureSettings {
|
||||
libraries: vec![ProjectLibrary {
|
||||
name: "extra".into(),
|
||||
classes: vec!["lib/*.jar".into()],
|
||||
..Default::default()
|
||||
}],
|
||||
facets: vec![FacetConfig {
|
||||
kind: "web".into(),
|
||||
module: ".".into(),
|
||||
descriptor: "WebRoot/WEB-INF/web.xml".into(),
|
||||
web_root: String::new(),
|
||||
}],
|
||||
artifacts: vec![
|
||||
artifact("shop:war", ArtifactKind::War),
|
||||
artifact("shop:war exploded", ArtifactKind::WarExploded),
|
||||
artifact("shop:jar", ArtifactKind::Jar),
|
||||
],
|
||||
..Default::default()
|
||||
};
|
||||
let cache = tmp.path().join("cache");
|
||||
for a in &ps.artifacts {
|
||||
let plan = BuildPlan {
|
||||
system: BuildSystem::Javac,
|
||||
title: String::new(),
|
||||
steps: artifact_steps(&root, &ps, a, &classes, None, &cache),
|
||||
};
|
||||
run_plan(&plan);
|
||||
}
|
||||
let war = entries(&root.join("out/artifacts/shop_war/shop.war"));
|
||||
for name in [
|
||||
"index.jsp",
|
||||
"WEB-INF/web.xml",
|
||||
"WEB-INF/lib/inside.jar",
|
||||
"WEB-INF/lib/extra.jar",
|
||||
"WEB-INF/classes/com/a/A.class",
|
||||
] {
|
||||
assert!(war.iter().any(|e| e == name), "{name} in {war:?}");
|
||||
}
|
||||
let exploded = root.join("out/artifacts/shop_war_exploded");
|
||||
assert!(exploded.join("WEB-INF/classes/com/a/A.class").is_file());
|
||||
assert!(exploded.join("WEB-INF/lib/extra.jar").is_file());
|
||||
let jar_dir = root.join("out/artifacts/shop_jar");
|
||||
let jar = entries(&jar_dir.join("shop.jar"));
|
||||
assert_eq!(jar[..2], ["META-INF/".to_owned(), "META-INF/MANIFEST.MF".to_owned()]);
|
||||
assert!(jar.iter().any(|e| e == "com/a/A.class"));
|
||||
assert!(jar_dir.join("extra.jar").is_file());
|
||||
let mut zip = zip::ZipArchive::new(fs::File::open(jar_dir.join("shop.jar")).unwrap()).unwrap();
|
||||
let mut manifest = String::new();
|
||||
std::io::Read::read_to_string(&mut zip.by_name("META-INF/MANIFEST.MF").unwrap(), &mut manifest).unwrap();
|
||||
assert!(manifest.contains("Main-Class: com.a.A") && manifest.contains("Class-Path: extra.jar"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn never_lays_out_over_its_own_sources() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let web = tmp.path().join("WebRoot");
|
||||
write(&web.join("a.jsp"), "");
|
||||
let action = Action::Layout { into: tmp.path().to_path_buf(), entries: vec![(web.clone(), PathBuf::new())] };
|
||||
assert!(action.run(&CancellationToken::new()).is_err());
|
||||
assert!(web.join("a.jsp").is_file());
|
||||
}
|
||||
}
|
||||
@@ -12,8 +12,6 @@ use std::collections::BTreeMap;
|
||||
pub struct EditorGeneralSettings {
|
||||
/// Change font size with ⌘ + mouse wheel.
|
||||
pub wheel_zoom: bool,
|
||||
/// Scope of ⌘ + mouse wheel font zoom: `active` editor | `all` editors.
|
||||
pub wheel_zoom_scope: String,
|
||||
pub markdown_image_folder: String,
|
||||
pub markdown_image_name_pattern: String,
|
||||
/// Drag-and-drop of selected text inside the editor.
|
||||
@@ -39,7 +37,6 @@ impl Default for EditorGeneralSettings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
wheel_zoom: false,
|
||||
wheel_zoom_scope: "active".into(),
|
||||
markdown_image_folder: "assets".into(),
|
||||
markdown_image_name_pattern: "image-{timestamp}".into(),
|
||||
drag_and_drop: true,
|
||||
|
||||
@@ -14,8 +14,7 @@ pub fn inside_git_repo(dir: &Path) -> bool {
|
||||
dir.ancestors().any(|d| d.join(".git").exists() || d.join(".jj").exists())
|
||||
}
|
||||
|
||||
/// IDEA's default list, plus `.jj`, rope's `.ropeproject` (pylsp-rope creates it in the
|
||||
/// project root) and the Windows shell files.
|
||||
/// IDEA's default list, plus `.jj` and the Windows shell files.
|
||||
pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
|
||||
"*.pyc",
|
||||
"*.pyo",
|
||||
@@ -26,7 +25,6 @@ pub const DEFAULT_IGNORED_NAMES: &[&str] = &[
|
||||
".git",
|
||||
".hg",
|
||||
".jj",
|
||||
".ropeproject",
|
||||
".svn",
|
||||
"CVS",
|
||||
"__pycache__",
|
||||
|
||||
@@ -67,12 +67,6 @@ pub struct Settings {
|
||||
pub mcp_server: McpServerSettings,
|
||||
/// Tools › Agents: Command Execution Policy.
|
||||
pub agent_security: AgentSecuritySettings,
|
||||
/// Appearance & Behavior › Scopes: named file sets other settings refer to.
|
||||
pub scopes: Vec<NamedScope>,
|
||||
/// Appearance & Behavior › File Colors.
|
||||
pub file_colors: FileColorSettings,
|
||||
/// Database › Query Execution, Languages & Frameworks › SQL Resolution Scopes.
|
||||
pub database: DatabaseSettings,
|
||||
/// Plugin settings (`[contributes.settings]`): plugin id → its values by key.
|
||||
#[specta(type = BTreeMap<String, BTreeMap<String, specta_typescript::Unknown>>)]
|
||||
pub plugins: BTreeMap<String, serde_json::Map<String, serde_json::Value>>,
|
||||
@@ -224,20 +218,16 @@ where
|
||||
Ok(serde_json::from_value(serde_json::Value::deserialize(d)?).unwrap_or_default())
|
||||
}
|
||||
|
||||
/// The built-in themes that were removed (#2981; the One Dark Pro plugin
|
||||
/// maintains their look) and the built-in that stands in for each: read by
|
||||
/// [`theme_id`], and the removal notice looks for them in settings files.
|
||||
pub const REMOVED_THEMES: [(&str, &str); 2] = [("one-light", "light"), ("one-dark", "dark")];
|
||||
|
||||
/// A theme id, with the built-in themes that were removed read as the Islands theme of their kind.
|
||||
fn theme_id<'de, D>(d: D) -> Result<String, D::Error>
|
||||
where
|
||||
D: serde::Deserializer<'de>,
|
||||
{
|
||||
let id = String::deserialize(d)?;
|
||||
Ok(match REMOVED_THEMES.iter().find(|(removed, _)| *removed == id.as_str()) {
|
||||
Some((_, stand_in)) => (*stand_in).to_owned(),
|
||||
None => id,
|
||||
Ok(match id.as_str() {
|
||||
"one-light" => "light".into(),
|
||||
"one-dark" => "dark".into(),
|
||||
_ => id,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -508,9 +498,6 @@ impl Default for Settings {
|
||||
agents: AgentSettings::default(),
|
||||
mcp_server: McpServerSettings::default(),
|
||||
agent_security: AgentSecuritySettings::default(),
|
||||
scopes: Vec::new(),
|
||||
file_colors: FileColorSettings::default(),
|
||||
database: DatabaseSettings::default(),
|
||||
plugins: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
@@ -521,47 +508,6 @@ fn default_keymap() -> &'static str {
|
||||
if cfg!(target_os = "macos") { "intellij-macos" } else { "intellij-windows" }
|
||||
}
|
||||
|
||||
/// A named set of files: `file:src//*.ts && !file:*.test.ts` (project-relative path patterns
|
||||
/// joined with `||`, `&&`, `!` and parentheses).
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct NamedScope {
|
||||
pub name: String,
|
||||
pub pattern: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FileColorSettings {
|
||||
pub enabled: bool,
|
||||
pub editor_tabs: bool,
|
||||
pub project_view: bool,
|
||||
/// Scope → colour; the first scope that holds a file gives its colour.
|
||||
pub colors: Vec<FileColor>,
|
||||
}
|
||||
|
||||
impl Default for FileColorSettings {
|
||||
fn default() -> Self {
|
||||
let color = |scope: &str, color: &str| FileColor { scope: scope.into(), color: color.into() };
|
||||
Self {
|
||||
enabled: true,
|
||||
editor_tabs: true,
|
||||
project_view: true,
|
||||
colors: vec![color("Non-Project Files", "yellow"), color("Tests", "green")],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct FileColor {
|
||||
/// A built-in scope (`Tests`, `Production`, `Project Files`, `Non-Project Files`) or a
|
||||
/// `scopes` entry, by name.
|
||||
pub scope: String,
|
||||
/// A palette name (`blue`, `green`, `orange`, `rose`, `violet`, `yellow`, `gray`) or `#rrggbb`.
|
||||
pub color: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct CustomKeymap {
|
||||
@@ -650,20 +596,13 @@ impl Default for DateFormatSettings {
|
||||
pub struct NotificationSettings {
|
||||
pub balloons: bool,
|
||||
pub sound: bool,
|
||||
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
|
||||
#[serde(default = "default_true")]
|
||||
pub system_notifications: bool,
|
||||
/// Group id → display; groups not listed use their default.
|
||||
pub groups: BTreeMap<String, NotificationGroupSettings>,
|
||||
}
|
||||
|
||||
fn default_true() -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
impl Default for NotificationSettings {
|
||||
fn default() -> Self {
|
||||
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
|
||||
Self { balloons: true, sound: false, groups: BTreeMap::new() }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1347,9 +1286,6 @@ pub struct JavaSettings {
|
||||
pub jdtls_vm_args: String,
|
||||
/// Share one JDT LS across builds in an ordinary project window; other windows remain separate.
|
||||
pub jdtls_shared: bool,
|
||||
/// JDK homes added by hand (Platform Settings › SDKs › Add JDK from Disk…), listed with the
|
||||
/// detected ones.
|
||||
pub added_jdks: Vec<String>,
|
||||
/// Build Tools › Maven.
|
||||
pub maven: MavenSettings,
|
||||
/// Build Tools › Gradle.
|
||||
|
||||
@@ -19,7 +19,6 @@ pub enum Tool {
|
||||
Maven,
|
||||
Gradle,
|
||||
Ruby,
|
||||
Zig,
|
||||
}
|
||||
|
||||
impl Tool {
|
||||
@@ -33,7 +32,6 @@ impl Tool {
|
||||
Tool::Maven => &["maven"],
|
||||
Tool::Gradle => &["gradle"],
|
||||
Tool::Ruby => &["ruby"],
|
||||
Tool::Zig => &["zig"],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -69,9 +69,6 @@ pub struct GitSettings {
|
||||
pub push_dialog_only_protected: bool,
|
||||
/// Stashes and shelves share one tab.
|
||||
pub combine_stash_and_shelf: bool,
|
||||
/// The non-modal Commit tool window works on the index: Staged / Unstaged groups,
|
||||
/// stage and unstage instead of inclusion checkboxes, and no change lists.
|
||||
pub staging_area: bool,
|
||||
}
|
||||
|
||||
impl Default for GitSettings {
|
||||
@@ -93,7 +90,6 @@ impl Default for GitSettings {
|
||||
show_push_dialog: true,
|
||||
push_dialog_only_protected: false,
|
||||
combine_stash_and_shelf: false,
|
||||
staging_area: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -241,30 +237,6 @@ impl Default for LogLevelColors {
|
||||
}
|
||||
}
|
||||
|
||||
/// Database settings: Query Execution and SQL Resolution Scopes.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct DatabaseSettings {
|
||||
/// A console's result sets show under the statements that produced them, in the editor,
|
||||
/// instead of in the Services view's result tabs.
|
||||
pub in_editor_results: bool,
|
||||
/// Languages & Frameworks › SQL Resolution Scopes: the data source SQL in a file or folder
|
||||
/// resolves against (completion, inspections, navigation), most specific path first.
|
||||
pub resolution_scopes: Vec<SqlResolutionScope>,
|
||||
}
|
||||
|
||||
/// One row of SQL Resolution Scopes.
|
||||
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
pub struct SqlResolutionScope {
|
||||
/// Project-relative file or folder, `/`-separated; empty for the whole project.
|
||||
pub path: String,
|
||||
/// Data source id.
|
||||
pub data_source: String,
|
||||
/// Schema unqualified names resolve in; empty for the data source's default.
|
||||
pub schema: String,
|
||||
}
|
||||
|
||||
/// Build, Execution, Deployment › Console.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
|
||||
#[serde(default, rename_all = "camelCase")]
|
||||
|
||||
@@ -120,12 +120,6 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
"stdio",
|
||||
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
|
||||
),
|
||||
"unity" => cfg(
|
||||
"unity-debug",
|
||||
&[],
|
||||
"stdio",
|
||||
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
|
||||
),
|
||||
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
|
||||
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
|
||||
"java-debug" => cfg(
|
||||
|
||||
@@ -12,7 +12,6 @@ use std::path::Path;
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AttachKind {
|
||||
Unity,
|
||||
Java,
|
||||
Node,
|
||||
Python,
|
||||
|
||||
@@ -19,7 +19,6 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
use connection::{Connection, DapError};
|
||||
@@ -1122,16 +1121,6 @@ impl DebugManager {
|
||||
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
|
||||
}
|
||||
|
||||
if s.adapter == "unity" {
|
||||
if launch_result.is_none()
|
||||
&& let Some(launch) = launch.as_mut()
|
||||
{
|
||||
launch.await?;
|
||||
launch_result = Some(());
|
||||
}
|
||||
unity::wait_for_threads(s).await?;
|
||||
}
|
||||
|
||||
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
|
||||
// others go out together, as VS Code sends them, instead of one round trip per file.
|
||||
let (files, idle): (Vec<_>, Vec<_>) = self
|
||||
@@ -1213,10 +1202,6 @@ impl DebugManager {
|
||||
if let Some(link) = s.jdwp_link.lock().as_ref() {
|
||||
link.release();
|
||||
}
|
||||
if s.adapter == "unity" {
|
||||
unity::settle_startup(s).await;
|
||||
s.emit(ide_core::event::DebugEvent::Initialized);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -1244,18 +1229,11 @@ impl DebugManager {
|
||||
// rdbg's terminate exits the Ruby process without terminating its children.
|
||||
let graceful =
|
||||
terminate && s.request == "launch" && s.adapter != "rdbg" && s.supports("supportsTerminateRequest");
|
||||
// A program suspended in the debugger cannot act on SIGTERM, and on macOS not even die of
|
||||
// SIGKILL while the debugger holds it: it is killed (with what it started) and the adapter
|
||||
// is told to end it. A killed program has no shutdown output to wait for.
|
||||
let killed = own_terminate && !graceful && s.suspended.get();
|
||||
if killed {
|
||||
crate::session::signal_debuggee(s, true).await;
|
||||
}
|
||||
if !s.conn.is_closed() {
|
||||
if graceful {
|
||||
let _ = s.conn.request_timeout("terminate", json!({ "restart": false }), SHUTDOWN_TIMEOUT).await;
|
||||
}
|
||||
if !graceful && (!own_terminate || killed) {
|
||||
if !graceful && !own_terminate {
|
||||
let _ = s
|
||||
.conn
|
||||
.request_timeout(
|
||||
@@ -1266,7 +1244,7 @@ impl DebugManager {
|
||||
.await;
|
||||
}
|
||||
}
|
||||
if own_terminate && !graceful && !killed {
|
||||
if own_terminate && !graceful {
|
||||
// Signal before anything else: waiting on a request the adapter may not answer
|
||||
// would delay the shutdown the console is supposed to show.
|
||||
crate::session::signal_debuggee(s, false).await;
|
||||
@@ -1285,7 +1263,7 @@ impl DebugManager {
|
||||
// lets Run start again into an occupied port, so wait for the program first — with the
|
||||
// connection still open, so a second Stop can find the session and kill it.
|
||||
crate::session::wait_for_debuggee(s, terminate).await;
|
||||
if terminate && s.request == "launch" && !killed {
|
||||
if terminate && s.request == "launch" {
|
||||
// The adapter reports `terminated` only after it has drained the program's console
|
||||
// (java-debug waits up to 5 s for the pump): closing before that drops the last
|
||||
// shutdown lines from the console.
|
||||
|
||||
@@ -17,7 +17,7 @@ use std::process::Stdio;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Weak;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
|
||||
use std::time::{Duration, Instant};
|
||||
use std::time::Duration;
|
||||
use tokio::io::{AsyncRead, AsyncReadExt};
|
||||
use tokio::process::Child;
|
||||
use tokio::sync::{mpsc, watch};
|
||||
@@ -116,7 +116,6 @@ pub(crate) struct Session {
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
|
||||
pub(crate) quirks: kotlin_lsp::Quirks,
|
||||
pub(crate) unity_startup_activity: Mutex<Instant>,
|
||||
}
|
||||
|
||||
/// Which threads of the program are suspended: each from its `stopped` event until a
|
||||
@@ -271,7 +270,6 @@ impl Session {
|
||||
kotlin_mirror: Mutex::new(None),
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -718,15 +716,6 @@ pub(crate) async fn event_loop(
|
||||
}
|
||||
|
||||
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
|
||||
if s.adapter == "unity"
|
||||
&& event == "output"
|
||||
&& body
|
||||
.get("output")
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
|
||||
{
|
||||
*s.unity_startup_activity.lock() = Instant::now();
|
||||
}
|
||||
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
|
||||
mirror.translate(&mut body);
|
||||
}
|
||||
@@ -735,9 +724,7 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
match event {
|
||||
"initialized" => {
|
||||
s.initialized.send_replace(true);
|
||||
if s.adapter != "unity" {
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
|
||||
@@ -158,7 +158,6 @@ struct Script {
|
||||
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
|
||||
gdb15_starts_at_launch: bool,
|
||||
launch_after_configuration: bool,
|
||||
empty_thread_responses: usize,
|
||||
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
|
||||
accept: &'static [&'static str],
|
||||
/// Requests of the adapter's own answered with a body and followed by events.
|
||||
@@ -199,7 +198,6 @@ impl Default for Script {
|
||||
close_during_startup: false,
|
||||
gdb15_starts_at_launch: false,
|
||||
launch_after_configuration: false,
|
||||
empty_thread_responses: 0,
|
||||
accept: &[],
|
||||
custom: None,
|
||||
}
|
||||
@@ -246,8 +244,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
let mut held: Vec<Value> = Vec::new();
|
||||
let mut stopped = false;
|
||||
let mut running = false;
|
||||
let mut thread_requests = 0;
|
||||
let mut unity = false;
|
||||
macro_rules! send {
|
||||
($v:expr) => {{
|
||||
let mut v: Value = $v;
|
||||
@@ -272,14 +268,13 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
match msg["command"].as_str().unwrap_or_default() {
|
||||
"initialize" => {
|
||||
unity = msg["arguments"]["adapterID"] == "unity";
|
||||
if let Some(delay) = script.delay_initialize {
|
||||
tokio::time::sleep(delay).await;
|
||||
}
|
||||
ok!(
|
||||
msg,
|
||||
json!({
|
||||
"supportsConfigurationDoneRequest": !unity,
|
||||
"supportsConfigurationDoneRequest": true,
|
||||
"supportsCompletionsRequest": true,
|
||||
"supportsTerminateRequest": script.supports_terminate,
|
||||
"supportsSetVariable": true,
|
||||
@@ -298,15 +293,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
// defers it sends late).
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
if unity {
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
}
|
||||
"launch" | "attach" => {
|
||||
if unity {
|
||||
ok!(msg, Value::Null);
|
||||
continue;
|
||||
}
|
||||
if script.gdb15_starts_at_launch {
|
||||
// GDB 15 starts the program here and answers `launch` right away.
|
||||
running = true;
|
||||
@@ -460,14 +448,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
|
||||
}
|
||||
"threads" => {
|
||||
thread_requests += 1;
|
||||
if thread_requests <= script.empty_thread_responses {
|
||||
ok!(msg, json!({"threads": []}));
|
||||
} else {
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
|
||||
}
|
||||
}
|
||||
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
|
||||
"stackTrace" => ok!(
|
||||
msg,
|
||||
json!({"stackFrames": [
|
||||
@@ -527,14 +508,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
}
|
||||
"disconnect" => {
|
||||
// Like Delve: the adapter ends the program it launched.
|
||||
#[cfg(unix)]
|
||||
if msg["arguments"]["terminateDebuggee"] == true
|
||||
&& let Some(pid) = script.debuggee_pid
|
||||
{
|
||||
// SAFETY: plain syscall on the test's own child process.
|
||||
unsafe { libc::kill(pid as i32, libc::SIGKILL) };
|
||||
}
|
||||
ok!(msg, Value::Null);
|
||||
let _ = w.lock().await.shutdown().await;
|
||||
break;
|
||||
@@ -905,32 +878,6 @@ async fn stop_terminates_and_disconnects() {
|
||||
assert!(h.manager.threads(id).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
|
||||
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
|
||||
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
|
||||
let start = h.start(LaunchConfig {
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
|
||||
..config()
|
||||
});
|
||||
let ready = async {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
|
||||
let commands = h.commands();
|
||||
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
|
||||
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
|
||||
assert!(commands.iter().any(|c| c == "setBreakpoints"));
|
||||
};
|
||||
let (id, ()) = tokio::join!(start, ready);
|
||||
let id = id.unwrap();
|
||||
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
|
||||
h.manager.stop(id).await.unwrap();
|
||||
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
|
||||
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn concurrent_sessions_are_independent() {
|
||||
let h = harness(Script::default());
|
||||
@@ -2327,44 +2274,6 @@ async fn stop_waits_for_the_launched_program_to_exit() {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Terminated)).await;
|
||||
}
|
||||
|
||||
/// Delve and other adapters without `terminate`: a program stopped at a breakpoint cannot
|
||||
/// handle the SIGTERM Stop sends, so Stop has the adapter end it instead of waiting out the grace period.
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn stop_kills_a_program_suspended_at_a_breakpoint_at_once() {
|
||||
let mut child = std::process::Command::new("python3")
|
||||
.args(["-c", "import signal,time; signal.signal(signal.SIGTERM, signal.SIG_IGN); time.sleep(30)"])
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let pid = child.id();
|
||||
let exited = Arc::new(AtomicBool::new(false));
|
||||
{
|
||||
let exited = exited.clone();
|
||||
std::thread::spawn(move || {
|
||||
let _ = child.wait();
|
||||
exited.store(true, Ordering::Release);
|
||||
});
|
||||
}
|
||||
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate: false, ..Default::default() });
|
||||
let id = h.start(config()).await.unwrap();
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
|
||||
let session = h.manager.session(id).unwrap();
|
||||
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(200)).await; // let the program install its trap
|
||||
let started = Instant::now();
|
||||
h.manager.stop(id).await.unwrap();
|
||||
let elapsed = started.elapsed();
|
||||
assert!(elapsed < Duration::from_secs(3), "stop waited {elapsed:?} for a suspended program");
|
||||
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], true);
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
while !exited.load(Ordering::Acquire) {
|
||||
assert!(Instant::now() < deadline, "the suspended program was left running");
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn a_second_stop_kills_the_program_instead_of_waiting() {
|
||||
|
||||
@@ -1,187 +0,0 @@
|
||||
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
|
||||
|
||||
use crate::{
|
||||
adapter,
|
||||
attach::{AttachKind, AttachableProcess},
|
||||
};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::{path::PathBuf, process::Stdio, time::Duration};
|
||||
|
||||
/// Waits until Mono reports its threads.
|
||||
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
loop {
|
||||
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
|
||||
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
|
||||
return Ok(());
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable(
|
||||
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
|
||||
)
|
||||
})?
|
||||
}
|
||||
|
||||
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
|
||||
pub(crate) async fn settle_startup(session: &crate::session::Session) {
|
||||
*session.unity_startup_activity.lock() = std::time::Instant::now();
|
||||
let _ = tokio::time::timeout(Duration::from_secs(3), async {
|
||||
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
|
||||
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
|
||||
return Err(IdeError::unavailable(
|
||||
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
|
||||
|
||||
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
|
||||
require_runtime(&cwd)?;
|
||||
let command = command.unwrap_or_else(|| "unity-debug".into());
|
||||
let lookup = command.clone();
|
||||
let dir = cwd.clone();
|
||||
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
|
||||
let mut cmd = tokio::process::Command::new(binary);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.arg("list")
|
||||
.current_dir(&cwd)
|
||||
.env("PATH", ide_core::tool_path::search_path())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
|
||||
})?
|
||||
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
|
||||
if !out.status.success() {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"Unity process discovery failed: {}",
|
||||
String::from_utf8_lossy(&out.stderr).trim()
|
||||
)));
|
||||
}
|
||||
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
|
||||
#[cfg(windows)]
|
||||
if !rows.is_empty() {
|
||||
match editor_process_ids() {
|
||||
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
|
||||
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
|
||||
}
|
||||
}
|
||||
// The Editor of the open project comes first; the user picks which one to attach to.
|
||||
let path = cwd.join("Library/EditorInstance.json");
|
||||
let pid = std::fs::File::open(path).ok().and_then(|file| {
|
||||
use std::io::Read;
|
||||
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
|
||||
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
|
||||
});
|
||||
for row in &mut rows {
|
||||
if Some(row.pid) == pid {
|
||||
row.command_line = cwd.to_string_lossy().into_owned();
|
||||
}
|
||||
}
|
||||
rows.sort_by_key(|p| Some(p.pid) != pid);
|
||||
Ok(rows)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
|
||||
use std::collections::HashMap;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
|
||||
System::Diagnostics::ToolHelp::{
|
||||
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
|
||||
},
|
||||
};
|
||||
|
||||
let mut unity = HashMap::new();
|
||||
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
|
||||
unsafe {
|
||||
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
if snapshot == INVALID_HANDLE_VALUE {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
|
||||
let mut found = Process32FirstW(snapshot, &mut entry);
|
||||
if found == 0 {
|
||||
let error = std::io::Error::last_os_error();
|
||||
CloseHandle(snapshot);
|
||||
return Err(error.into());
|
||||
}
|
||||
while found != 0 {
|
||||
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
|
||||
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
|
||||
if name.eq_ignore_ascii_case("Unity.exe") {
|
||||
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
|
||||
}
|
||||
found = Process32NextW(snapshot, &mut entry);
|
||||
}
|
||||
CloseHandle(snapshot);
|
||||
}
|
||||
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
|
||||
}
|
||||
|
||||
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
|
||||
let mut editors = Vec::new();
|
||||
for line in output.lines() {
|
||||
let line = line.trim().trim_start_matches('\u{feff}');
|
||||
if !line.starts_with("Unity Editor (") {
|
||||
continue;
|
||||
}
|
||||
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
|
||||
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
|
||||
let (id, project) = line[at + 2..].split_once(')')?;
|
||||
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
|
||||
Some((&line[..at], pid, project))
|
||||
}) else {
|
||||
continue;
|
||||
};
|
||||
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
|
||||
continue;
|
||||
}
|
||||
editors.push(AttachableProcess {
|
||||
pid,
|
||||
name: "Unity Editor".into(),
|
||||
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
|
||||
kind: AttachKind::Unity,
|
||||
adapter: "unity".into(),
|
||||
host: None,
|
||||
port: None,
|
||||
});
|
||||
}
|
||||
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
|
||||
editors
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
|
||||
let rows = parse_editors(
|
||||
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
|
||||
);
|
||||
assert_eq!(rows.len(), 2);
|
||||
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
|
||||
assert_eq!(rows[1].pid, 7);
|
||||
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
|
||||
}
|
||||
}
|
||||
@@ -1,187 +0,0 @@
|
||||
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
|
||||
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
|
||||
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
|
||||
|
||||
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
|
||||
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
|
||||
use ide_language::LanguageRegistry;
|
||||
use parking_lot::Mutex;
|
||||
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
|
||||
|
||||
const SCRIPT: &str = r#"using System.IO;
|
||||
using UnityEditor;
|
||||
using UnityEngine;
|
||||
[InitializeOnLoad]
|
||||
public static class OpenIdeaAttachProbe
|
||||
{
|
||||
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
|
||||
static OpenIdeaAttachProbe()
|
||||
{
|
||||
EditorApplication.update += Tick;
|
||||
}
|
||||
static void Tick()
|
||||
{
|
||||
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
|
||||
if (!File.Exists(Path.Combine(Root, "ready")))
|
||||
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
|
||||
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
|
||||
if (!File.Exists(Path.Combine(Root, "go"))) return;
|
||||
File.Delete(Path.Combine(Root, "go"));
|
||||
int result = Hit(41);
|
||||
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
|
||||
}
|
||||
static int Hit(int seed)
|
||||
{
|
||||
int answer = seed + 1;
|
||||
return answer;
|
||||
}
|
||||
}
|
||||
"#;
|
||||
|
||||
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
|
||||
for _ in 0..600 {
|
||||
if let Some(thread) = events.lock().iter().find_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
|
||||
if reason == expected_reason =>
|
||||
{
|
||||
Some(*thread_id)
|
||||
}
|
||||
_ => None,
|
||||
}) {
|
||||
return thread;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
let events = events.lock();
|
||||
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
|
||||
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
|
||||
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
|
||||
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
|
||||
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
|
||||
// Keep the Editor log for diagnosing a failure.
|
||||
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
|
||||
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
|
||||
let root = PathBuf::from(root);
|
||||
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
|
||||
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
|
||||
std::fs::create_dir(root.join("Packages")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("ProjectSettings/ProjectVersion.txt"),
|
||||
format!(
|
||||
"m_EditorVersion: {}\n",
|
||||
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
|
||||
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
|
||||
std::fs::write(&source, SCRIPT).unwrap();
|
||||
let mut command = tokio::process::Command::new(&editor);
|
||||
ide_core::process::prepare(command.as_std_mut());
|
||||
// The test project has no packages: skip the package manager.
|
||||
command
|
||||
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
|
||||
.arg(&root)
|
||||
.arg("-logFile")
|
||||
.arg(root.join("Editor.log"))
|
||||
.current_dir(&root)
|
||||
.kill_on_drop(true);
|
||||
let mut child = command.spawn().unwrap();
|
||||
let pid = child.id().unwrap();
|
||||
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
|
||||
for _ in 0..1200 {
|
||||
if root.join("ready").exists() {
|
||||
break;
|
||||
}
|
||||
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
assert!(root.join("ready").exists(), "Editor failed to load the test script");
|
||||
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
|
||||
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
|
||||
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
|
||||
let saved = events.clone();
|
||||
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
|
||||
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
|
||||
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
|
||||
manager
|
||||
.set_breakpoints(
|
||||
source.clone(),
|
||||
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let start = || {
|
||||
manager.start_with(
|
||||
LaunchConfig {
|
||||
name: format!("Unity Editor ({pid})"),
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
args: vec![],
|
||||
cwd: Some(root.clone().into()),
|
||||
env: BTreeMap::new(),
|
||||
extra_json: Some(
|
||||
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
|
||||
.to_string(),
|
||||
),
|
||||
},
|
||||
SessionOwner::new("smoke", sink.clone()),
|
||||
|_| Some(adapter.clone()),
|
||||
)
|
||||
};
|
||||
let session = start().await.unwrap();
|
||||
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
|
||||
// Mono is ready to run once the start returns.
|
||||
assert!(!manager.threads(session).await.unwrap().is_empty());
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
|
||||
assert_eq!(frames[0].line, line);
|
||||
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
|
||||
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
|
||||
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
|
||||
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
|
||||
events.lock().clear();
|
||||
manager.step(session, thread, StepKind::Over).await.unwrap();
|
||||
let thread = stopped(&events, "step").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
|
||||
assert!(frames[0].line > line);
|
||||
// Detaching at a breakpoint resumes the Editor.
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
|
||||
// Attaching again to the same Editor hits the existing breakpoint.
|
||||
std::fs::remove_file(root.join("done")).unwrap();
|
||||
events.lock().clear();
|
||||
let session = start().await.unwrap_or_else(|error| {
|
||||
let events = events.lock();
|
||||
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
|
||||
});
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
std::fs::write(root.join("exit"), "").unwrap();
|
||||
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
|
||||
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
|
||||
}
|
||||
|
||||
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
|
||||
let path = root.join("done");
|
||||
for _ in 0..100 {
|
||||
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
|
||||
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
|
||||
}
|
||||
@@ -48,9 +48,6 @@ pub enum Capability {
|
||||
Ipc(String),
|
||||
/// Run one external program. Full code execution: never fine-grained.
|
||||
Process(String),
|
||||
/// Send a running language server (its name in the language definition) its own
|
||||
/// requests. The server reads and edits project files on the plugin's behalf.
|
||||
Lsp(String),
|
||||
/// Read files outside the project under one path.
|
||||
FsRead(String),
|
||||
/// Write files outside the project under one path.
|
||||
@@ -88,7 +85,6 @@ impl Capability {
|
||||
| Self::IdeCommands
|
||||
| Self::Ipc(_)
|
||||
| Self::Process(_)
|
||||
| Self::Lsp(_)
|
||||
| Self::FsRead(_)
|
||||
| Self::FsWrite(_) => Risk::High,
|
||||
}
|
||||
@@ -130,9 +126,6 @@ impl Capability {
|
||||
format!("Connect to local socket {path} — equivalent to running arbitrary code on the project machine")
|
||||
}
|
||||
Self::Process(bin) => format!("Run {bin} — equivalent to running arbitrary code on this machine"),
|
||||
Self::Lsp(server) => {
|
||||
format!("Send requests to the {server} language server, which reads and changes the project's files")
|
||||
}
|
||||
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
|
||||
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
|
||||
}
|
||||
@@ -256,7 +249,6 @@ impl fmt::Display for Capability {
|
||||
Self::NetHttp(h) => write!(f, "net.http:{h}"),
|
||||
Self::Ipc(p) => write!(f, "ipc:{p}"),
|
||||
Self::Process(b) => write!(f, "process:{b}"),
|
||||
Self::Lsp(s) => write!(f, "lsp:{s}"),
|
||||
Self::FsRead(p) => write!(f, "fs.read:{p}"),
|
||||
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
|
||||
}
|
||||
@@ -306,12 +298,6 @@ impl FromStr for Capability {
|
||||
}
|
||||
Ok(Self::Process(arg.to_owned()))
|
||||
}
|
||||
"lsp" => {
|
||||
if arg.len() > 128 || arg.chars().any(|c| c.is_whitespace() || c.is_control() || c == ':') {
|
||||
return Err(format!("{s:?}: use the server's name in its language definition"));
|
||||
}
|
||||
Ok(Self::Lsp(arg.to_owned()))
|
||||
}
|
||||
"fs.read" | "fs.write" => {
|
||||
if !std::path::Path::new(arg).is_absolute() && !arg.starts_with('~') {
|
||||
return Err(format!("{s:?}: use an absolute path (or ~/…)"));
|
||||
@@ -390,8 +376,6 @@ mod tests {
|
||||
"net:crates.io",
|
||||
"net:*.github.com",
|
||||
"process:cargo",
|
||||
"lsp:phoxite",
|
||||
"lsp:rust-analyzer",
|
||||
] {
|
||||
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
|
||||
}
|
||||
@@ -408,9 +392,6 @@ mod tests {
|
||||
assert!("net:".parse::<Capability>().is_err());
|
||||
assert!("net:a b".parse::<Capability>().is_err());
|
||||
assert!("process:./evil".parse::<Capability>().is_err());
|
||||
assert!("lsp:".parse::<Capability>().is_err());
|
||||
assert!("lsp:a b".parse::<Capability>().is_err());
|
||||
assert!("lsp:phoxite:phoxite/laravel".parse::<Capability>().is_err());
|
||||
assert!("fs.read:rel".parse::<Capability>().is_err());
|
||||
assert!("fs.write:rel".parse::<Capability>().is_err());
|
||||
assert!("network".parse::<Capability>().is_err());
|
||||
@@ -424,8 +405,6 @@ mod tests {
|
||||
assert_eq!("clipboard".parse::<Capability>().unwrap(), Capability::Clipboard);
|
||||
assert_eq!(Capability::Clipboard.risk(), Risk::Medium);
|
||||
assert_eq!(Capability::Process("cargo".into()).risk(), Risk::High);
|
||||
assert_eq!(Capability::Lsp("phoxite".into()).risk(), Risk::High);
|
||||
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
|
||||
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
|
||||
}
|
||||
|
||||
|
||||
@@ -357,9 +357,6 @@ impl Manifest {
|
||||
if matches!(cap, Capability::NetAsk) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 5)?;
|
||||
}
|
||||
if matches!(cap, Capability::Lsp(_)) {
|
||||
self.needs_api(&format!("capability `{cap}`"), 9)?;
|
||||
}
|
||||
}
|
||||
if let Some(dark) = &self.icon_dark {
|
||||
if self.icon.is_none() {
|
||||
@@ -715,21 +712,6 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn language_server_capabilities_need_api_1_9() {
|
||||
let caps = "[capabilities]
|
||||
required = [\"lsp:phoxite\"]
|
||||
";
|
||||
for engine in ["^1.2", "^1.8"] {
|
||||
assert!(
|
||||
err(&format!("{}{caps}", BASE.replace("^1.2", engine))).contains("new in plugin API 1.9"),
|
||||
"{engine}"
|
||||
);
|
||||
}
|
||||
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).unwrap();
|
||||
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_icons() {
|
||||
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
|
||||
|
||||
@@ -190,7 +190,6 @@ impl Host {
|
||||
open_locks: Default::default(),
|
||||
};
|
||||
host.apply_proxy();
|
||||
host.apply_added_jdks();
|
||||
ops::agent::move_user_mcp_values(&host);
|
||||
host
|
||||
}
|
||||
@@ -565,11 +564,3 @@ mod tests {
|
||||
host.close_project("main");
|
||||
}
|
||||
}
|
||||
|
||||
impl Host {
|
||||
/// Lists the JDKs added by hand (global Settings › SDKs) with the detected ones.
|
||||
pub fn apply_added_jdks(&self) {
|
||||
let homes = self.global_settings.effective().languages.java.added_jdks;
|
||||
ide_sdk::java::set_added_jdks(homes.into_iter().map(PathBuf::from));
|
||||
}
|
||||
}
|
||||
@@ -1,252 +0,0 @@
|
||||
//! HTTP Client tools: list and run requests from project `.http` / `.rest` files.
|
||||
|
||||
use crate::mcp::tool::{Call, Output, Param, ParamType, Tool};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use serde_json::json;
|
||||
use std::path::Path;
|
||||
|
||||
/// Response body characters returned at most (keeps agent context bounded).
|
||||
const MAX_BODY_CHARS: usize = 8_192;
|
||||
|
||||
pub fn tools() -> Vec<Tool> {
|
||||
vec![http_list_requests(), http_run_request()]
|
||||
}
|
||||
|
||||
fn is_http_file(path: &Path) -> bool {
|
||||
path.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.is_some_and(|e| e.eq_ignore_ascii_case("http") || e.eq_ignore_ascii_case("rest"))
|
||||
}
|
||||
|
||||
async fn resolve_http_file(call: &Call, path: &str) -> IdeResult<std::path::PathBuf> {
|
||||
let path = call.resolve_inside(path)?;
|
||||
if !is_http_file(&path) {
|
||||
return Err(IdeError::invalid("path must be a .http or .rest file"));
|
||||
}
|
||||
if !path.is_file() {
|
||||
return Err(IdeError::not_found(format!("No such file: {}", call.display(&path))));
|
||||
}
|
||||
Ok(path)
|
||||
}
|
||||
|
||||
fn http_list_requests() -> Tool {
|
||||
Tool::new(
|
||||
"http_list_requests",
|
||||
"Lists the HTTP requests in a project `.http` or `.rest` file (IntelliJ-style HTTP Client).
|
||||
Returns each request's 0-based `index`, optional `name`, `method`, URL as written (variables not substituted), and `line`.
|
||||
Use `http_run_request` with the same `path` and an `index` to send one.",
|
||||
|call| async move {
|
||||
let path = resolve_http_file(&call, &call.str("path")?).await?;
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path).await?;
|
||||
let requests: Vec<_> = ide_http::parse::requests(&text)
|
||||
.into_iter()
|
||||
.map(|b| {
|
||||
json!({
|
||||
"index": b.index,
|
||||
"name": b.name,
|
||||
"method": b.method,
|
||||
"url": b.url,
|
||||
"line": b.line,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Output::json(json!({ "requests": requests }))
|
||||
},
|
||||
)
|
||||
.param(Param::required(
|
||||
"path",
|
||||
ParamType::String,
|
||||
"Project-relative path to a `.http` or `.rest` file",
|
||||
))
|
||||
.output(json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"requests": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"index": { "type": "integer" },
|
||||
"name": { "type": ["string", "null"] },
|
||||
"method": { "type": "string" },
|
||||
"url": { "type": "string" },
|
||||
"line": { "type": "integer" },
|
||||
},
|
||||
"required": ["index", "method", "url", "line"],
|
||||
},
|
||||
},
|
||||
},
|
||||
"required": ["requests"],
|
||||
}))
|
||||
}
|
||||
|
||||
fn truncate_chars(text: &str, max: usize) -> (String, bool) {
|
||||
let count = text.chars().count();
|
||||
if count <= max {
|
||||
return (text.to_owned(), false);
|
||||
}
|
||||
(text.chars().take(max).collect(), true)
|
||||
}
|
||||
|
||||
/// Drop resolved URLs from transport errors so MCP JSON does not echo env-substituted targets.
|
||||
fn redact_transport_error(error: Option<String>, resolved_url: &str) -> Option<String> {
|
||||
let error = error?;
|
||||
let mut out = error.replace(resolved_url, "<url>");
|
||||
// reqwest often embeds `https://host/...` even when the primary URL string differs slightly.
|
||||
out = redact_urls(&out);
|
||||
Some(out)
|
||||
}
|
||||
|
||||
fn redact_urls(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len());
|
||||
let mut rest = s;
|
||||
loop {
|
||||
// Prefer `https://` so we don't match the `http://` prefix inside it.
|
||||
let start = match (rest.find("https://"), rest.find("http://")) {
|
||||
(Some(a), Some(b)) => Some(a.min(b)),
|
||||
(Some(a), None) => Some(a),
|
||||
(None, Some(b)) => Some(b),
|
||||
(None, None) => None,
|
||||
};
|
||||
let Some(start) = start else {
|
||||
out.push_str(rest);
|
||||
break;
|
||||
};
|
||||
out.push_str(&rest[..start]);
|
||||
out.push_str("<url>");
|
||||
let after = &rest[start..];
|
||||
let end = after.find(|c: char| c.is_whitespace() || c == '\'' || c == '"' || c == ')').unwrap_or(after.len());
|
||||
rest = &after[end..];
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn http_run_request() -> Tool {
|
||||
Tool::new(
|
||||
"http_run_request",
|
||||
"Runs one request from a project `.http` or `.rest` file by 0-based `index`, using the IDE HTTP Client
|
||||
(same as Run Request in the editor). Variables resolve from `http-client.env.json` / `http-client.private.env.json`
|
||||
for the optional `env` name. Asks for confirmation with the resolved URL (and header names) first.
|
||||
Returns status, timing and a truncated response body — not request headers or body (those may hold secrets).
|
||||
The `url` field in the result is as written in the file (unsubstituted); transport errors redact URLs.",
|
||||
|call| async move {
|
||||
let rel = call.str("path")?;
|
||||
let path = resolve_http_file(&call, &rel).await?;
|
||||
let index =
|
||||
call.opt_i64("index")?.ok_or_else(|| IdeError::invalid("missing or invalid argument `index`"))?;
|
||||
if index < 0 {
|
||||
return Err(IdeError::invalid("index must be >= 0"));
|
||||
}
|
||||
let index = index as u32;
|
||||
let env = call.opt_str("env")?;
|
||||
let text = crate::ops::fs::read_text(&call.host(), call.window(), path.clone()).await?;
|
||||
let blocks = ide_http::parse::requests(&text);
|
||||
let block =
|
||||
blocks.get(index as usize).ok_or_else(|| IdeError::not_found(format!("no request #{}", index + 1)))?;
|
||||
|
||||
let input = ide_http::RunInput {
|
||||
text: &text,
|
||||
index,
|
||||
file: Some(&path),
|
||||
root: Some(call.root()),
|
||||
env: env.as_deref(),
|
||||
};
|
||||
// Prepare before confirm so the dialog shows the real destination (after env substitution).
|
||||
let prepared = ide_http::prepare(&input)?;
|
||||
let subject = prepared.name.clone().unwrap_or_else(|| format!("{} {}", prepared.method, prepared.url));
|
||||
let headers: Vec<_> = prepared.headers.iter().map(|(k, _)| k.as_str()).collect();
|
||||
let mut detail = format!("{} {}\nFile: {rel}\nIndex: {index}", prepared.method, prepared.url);
|
||||
if let Some(env) = &env {
|
||||
detail.push_str(&format!("\nEnvironment: {env}"));
|
||||
}
|
||||
if !headers.is_empty() {
|
||||
detail.push_str(&format!("\nHeaders: {}", headers.join(", ")));
|
||||
}
|
||||
if prepared.body.is_some() {
|
||||
detail.push_str("\nBody: present");
|
||||
}
|
||||
call.confirm(&subject, Some(detail)).await?;
|
||||
|
||||
let exchange = ide_http::run(input, &call.cancel).await?;
|
||||
let history = call.project().http_history.clone();
|
||||
let saved = exchange.clone();
|
||||
let _ = call.host().blocking(move || history.add(&saved)).await;
|
||||
|
||||
let (body, body_truncated) = match exchange.response.as_ref().and_then(|r| r.body.as_deref()) {
|
||||
Some(b) => {
|
||||
let (t, truncated) = truncate_chars(b, MAX_BODY_CHARS);
|
||||
(Some(t), truncated)
|
||||
}
|
||||
None => (None, false),
|
||||
};
|
||||
let response = exchange.response.as_ref();
|
||||
Output::json(json!({
|
||||
"index": index,
|
||||
"name": block.name,
|
||||
"method": block.method,
|
||||
"url": block.url,
|
||||
"status": response.map(|r| r.status),
|
||||
"statusText": response.map(|r| r.status_text.clone()),
|
||||
"totalMs": response.map(|r| r.total_ms).or(exchange.entry.total_ms),
|
||||
"error": redact_transport_error(exchange.entry.error.clone(), &prepared.url),
|
||||
"body": body,
|
||||
"bodyTruncated": body_truncated,
|
||||
}))
|
||||
},
|
||||
)
|
||||
.write()
|
||||
.param(Param::required("path", ParamType::String, "Project-relative path to a `.http` or `.rest` file"))
|
||||
.param(Param::required("index", ParamType::Integer, "0-based request index from `http_list_requests`"))
|
||||
.param(Param::optional(
|
||||
"env",
|
||||
ParamType::String,
|
||||
"Environment name from `http-client.env.json` / `http-client.private.env.json`",
|
||||
))
|
||||
.output(json!({
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"index": { "type": "integer" },
|
||||
"name": { "type": ["string", "null"] },
|
||||
"method": { "type": "string" },
|
||||
"url": { "type": "string" },
|
||||
"status": { "type": ["integer", "null"] },
|
||||
"statusText": { "type": ["string", "null"] },
|
||||
"totalMs": { "type": ["number", "null"] },
|
||||
"error": { "type": ["string", "null"] },
|
||||
"body": { "type": ["string", "null"] },
|
||||
"bodyTruncated": { "type": "boolean" },
|
||||
},
|
||||
"required": ["index", "method", "url", "bodyTruncated"],
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn accepts_http_and_rest_extensions() {
|
||||
assert!(is_http_file(Path::new("a.http")));
|
||||
assert!(is_http_file(Path::new("a.REST")));
|
||||
assert!(!is_http_file(Path::new("a.txt")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn truncates_long_bodies() {
|
||||
let long = "x".repeat(MAX_BODY_CHARS + 10);
|
||||
let (t, truncated) = truncate_chars(&long, MAX_BODY_CHARS);
|
||||
assert!(truncated);
|
||||
assert_eq!(t.chars().count(), MAX_BODY_CHARS);
|
||||
assert_eq!(truncate_chars("ok", MAX_BODY_CHARS), ("ok".into(), false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn redacts_urls_in_transport_errors() {
|
||||
let url = "https://secret.example/v1?token=abc";
|
||||
assert_eq!(
|
||||
redact_transport_error(Some(format!("error sending request for {url}")), url).as_deref(),
|
||||
Some("error sending request for <url>")
|
||||
);
|
||||
assert_eq!(redact_urls("fail https://a.example/x and http://b/y"), "fail <url> and <url>");
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,6 @@ pub(crate) mod run;
|
||||
mod vcs;
|
||||
pub use requests::Requests;
|
||||
mod files;
|
||||
mod http;
|
||||
mod page;
|
||||
mod reports;
|
||||
mod search;
|
||||
@@ -40,7 +39,6 @@ fn tools() -> Vec<tool::Tool> {
|
||||
tools.extend(edit::tools());
|
||||
tools.extend(run::tools());
|
||||
tools.extend(vcs::tools());
|
||||
tools.extend(http::tools());
|
||||
tools
|
||||
}
|
||||
|
||||
|
||||
@@ -641,82 +641,6 @@ pub async fn maven_exclude_dependency(
|
||||
.map_err(join_err)?
|
||||
}
|
||||
|
||||
/// Build / Rebuild / Build Artifacts of a Java project without a build tool, from its
|
||||
/// Project Structure; `None` when it has no Java sources under its source roots.
|
||||
fn structure_plan(
|
||||
root: &Path,
|
||||
settings: &Settings,
|
||||
detected: &[ide_workspace::roots::SourceFolder],
|
||||
kind: BuildKind,
|
||||
cache: &Path,
|
||||
) -> IdeResult<Option<compile::BuildPlan>> {
|
||||
let (ps, roots, jdk) = structure_inputs(root, settings, detected);
|
||||
compile::structure_plan(root, &ps, &roots, jdk.as_ref(), &settings.languages.java.language_level, kind, cache)
|
||||
}
|
||||
|
||||
/// The Project Structure, roots and JDK a build of a project without a build tool uses.
|
||||
/// An Eclipse project's `.classpath` libraries and its web content folder count as if they
|
||||
/// were configured, and a web project with no artifacts gets IDEA's `<name>:war exploded`.
|
||||
pub(crate) fn structure_inputs(
|
||||
root: &Path,
|
||||
settings: &Settings,
|
||||
detected: &[ide_workspace::roots::SourceFolder],
|
||||
) -> (ide_core::settings::ProjectStructureSettings, compile::StructureRoots, Option<compile::StructureJdk>) {
|
||||
use ide_core::settings::{ArtifactConfig, ArtifactKind, FacetConfig, ProjectLibrary};
|
||||
use ide_workspace::roots::{ProjectRoots, RootKind, eclipse};
|
||||
let mut ps = settings.project_structure.clone();
|
||||
let mut included = Vec::new();
|
||||
if let Some(cp) = eclipse::classpath(root).filter(|cp| !cp.libraries.is_empty()) {
|
||||
let name = "Eclipse classpath".to_owned();
|
||||
if !ps.libraries.iter().any(|l| l.name == name) {
|
||||
ps.libraries.push(ProjectLibrary { name: name.clone(), classes: cp.libraries, ..Default::default() });
|
||||
}
|
||||
included.push(name);
|
||||
}
|
||||
if !ps.facets.iter().any(|f| f.kind == "web")
|
||||
&& let Some(web) = eclipse::web_root(root)
|
||||
{
|
||||
ps.facets.push(FacetConfig {
|
||||
kind: "web".into(),
|
||||
module: ".".into(),
|
||||
descriptor: format!("{web}/WEB-INF/web.xml"),
|
||||
web_root: web,
|
||||
});
|
||||
if ps.artifacts.is_empty() {
|
||||
let name = root.file_name().map_or_else(|| "app".into(), |n| n.to_string_lossy().into_owned());
|
||||
ps.artifacts.push(ArtifactConfig {
|
||||
name: format!("{name}:war exploded"),
|
||||
kind: ArtifactKind::WarExploded,
|
||||
module: ".".into(),
|
||||
include_libraries: included,
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
}
|
||||
let roots = ProjectRoots::compute(detected.to_vec(), &ps);
|
||||
let of = |kind: RootKind| roots.roots.iter().filter(|r| r.kind == kind).map(|r| root.join(&r.path)).collect();
|
||||
let module = ps.module_settings(root, root);
|
||||
let level = module
|
||||
.map(|m| m.language_level.as_str())
|
||||
.filter(|l| !l.trim().is_empty())
|
||||
.unwrap_or(&settings.languages.java.language_level);
|
||||
// Without a configured SDK, an installed JDK that can compile the language level.
|
||||
let jdk = ide_sdk::apply::module_jdk(root, root, settings)
|
||||
.or_else(|| {
|
||||
let installed = ide_sdk::java::installed_jdks();
|
||||
ide_sdk::java::pick_jdk(&installed, compile::language_release(level)).cloned()
|
||||
})
|
||||
.map(|j| compile::StructureJdk { home: j.home, major: j.major });
|
||||
let roots = compile::StructureRoots {
|
||||
sources: of(RootKind::Source),
|
||||
tests: of(RootKind::Test),
|
||||
resources: of(RootKind::Resources),
|
||||
test_resources: of(RootKind::TestResources),
|
||||
excluded: of(RootKind::Excluded),
|
||||
};
|
||||
(ps, roots, jdk)
|
||||
}
|
||||
|
||||
fn cmake_plan(root: &Path, kind: BuildKind, configs: &[ide_run::RunConfig], id: &str) -> IdeResult<compile::BuildPlan> {
|
||||
let commands = ide_run::cmake_build_configs(configs, id)?;
|
||||
let title = commands.last().map(|c| c.name.clone()).unwrap_or_default();
|
||||
@@ -751,7 +675,6 @@ pub async fn build_run(
|
||||
let project = host.project(window)?;
|
||||
let (root, cache, sink) = (project.root.clone(), project.build_cache_dir(), project.sink.clone());
|
||||
let settings = project.settings.effective();
|
||||
let detected = project.detected_roots.read().clone();
|
||||
let config_dir = host.config_dir.clone();
|
||||
let token = host.begin_project_request(window, request);
|
||||
let result = tokio::task::spawn_blocking(move || {
|
||||
@@ -815,15 +738,17 @@ pub async fn build_run(
|
||||
plan.title = workspace.name;
|
||||
plan
|
||||
} else {
|
||||
let model = with_profiles(load(&root, &cache, &settings), &cache);
|
||||
match compile::plan(&root, &model, kind, file.as_deref(), settings.cmake.profiles.as_deref()) {
|
||||
Ok(plan) => prepare_plan(plan, &root, &settings),
|
||||
// No build tool: a Java project builds from its Project Structure.
|
||||
Err(e) if e.kind == ide_core::error::ErrorKind::NotFound => {
|
||||
structure_plan(&root, &settings, &detected, kind, &cache)?.ok_or(e)?
|
||||
}
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
prepare_plan(
|
||||
compile::plan(
|
||||
&root,
|
||||
&with_profiles(load(&root, &cache, &settings), &cache),
|
||||
kind,
|
||||
file.as_deref(),
|
||||
settings.cmake.profiles.as_deref(),
|
||||
)?,
|
||||
&root,
|
||||
&settings,
|
||||
)
|
||||
};
|
||||
let result = compile::run(&root, &plan, &token, &|e| {
|
||||
let _ = on_event.send(e);
|
||||
|
||||
@@ -12,25 +12,6 @@ use std::path::PathBuf;
|
||||
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
|
||||
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
|
||||
host.require_trust(window)?;
|
||||
let unity_pid = if config.adapter == "unity" {
|
||||
if config.request != "attach" {
|
||||
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
|
||||
}
|
||||
let arguments = launch_arguments(&config)?;
|
||||
let pid = arguments["name"]
|
||||
.as_str()
|
||||
.and_then(|name| name.strip_prefix("Unity Editor ("))
|
||||
.and_then(|name| name.strip_suffix(')'))
|
||||
.and_then(|pid| pid.parse::<u32>().ok());
|
||||
if let Some(pid) = pid {
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
|
||||
unity::require_runtime(cwd)?;
|
||||
pid
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
&& config.request == "launch"
|
||||
@@ -119,26 +100,12 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
let server_port = debug_server_port(&config);
|
||||
let result = host.debugger.start_with(config, owner, custom).await;
|
||||
flush_output();
|
||||
if result.is_err()
|
||||
&& let Some(pid) = unity_pid
|
||||
{
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
if let (Ok(id), Some(port)) = (&result, server_port) {
|
||||
attach_jvm_inspector(host, window, *id, port);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn require_unity_editor(pid: u32) -> IdeResult<()> {
|
||||
if !ide_core::process::process_alive(pid) {
|
||||
return Err(ide_core::IdeError::unavailable(format!(
|
||||
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
|
||||
/// names an adapter on another machine, whose jdtls is not ours to ask.
|
||||
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
|
||||
@@ -493,17 +460,6 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
|
||||
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
|
||||
}
|
||||
|
||||
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
if ide_workspace::unity::detect(&project.root).is_none() {
|
||||
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
|
||||
}
|
||||
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
|
||||
.map(|p| p.to_string_lossy().into_owned());
|
||||
unity::editors(command, project.root.clone()).await
|
||||
}
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
pub async fn debug_listen_for_jvm(
|
||||
@@ -708,7 +664,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
});
|
||||
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
|
||||
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
|
||||
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
|
||||
d.add("debug_listen_for_jvm", |c| async move {
|
||||
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
|
||||
});
|
||||
|
||||
@@ -1057,11 +1057,6 @@ pub async fn lsp_apply_code_action(host: &Host, window: &str, doc: DocId, action
|
||||
blocking(move || apply_edit(&documents, &edit)).await?;
|
||||
}
|
||||
open_plugin_action_target(&action, window);
|
||||
if let Some(command) = &action.command
|
||||
&& let Some(result) = run_plugin_server_command(host, window, doc, None, command).await
|
||||
{
|
||||
return result;
|
||||
}
|
||||
if let Some(command) = action.command
|
||||
&& !(action.edit.is_some() && is_client_follow_up(&project, doc, None, &command).await)
|
||||
{
|
||||
@@ -1613,47 +1608,9 @@ pub async fn lsp_execute_command(host: &Host, window: &str, doc: DocId, command:
|
||||
return blocking(move || plugins.run_language_command(&plugin, &command_id, argument.as_deref(), invocation))
|
||||
.await;
|
||||
}
|
||||
if let Some(result) = run_plugin_server_command(host, window, doc, None, &command).await {
|
||||
return result;
|
||||
}
|
||||
host.project(window)?.lsp.execute_command(doc, command).await
|
||||
}
|
||||
|
||||
/// Runs `command` through the plugin that claims it (`[[contributes.serverCommands]]`)
|
||||
/// when no server of the document executes it itself: a code lens, code action or inlay
|
||||
/// hint may carry a command the server leaves to the client. `None` when no plugin does.
|
||||
async fn run_plugin_server_command(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
doc: DocId,
|
||||
server: Option<ServerId>,
|
||||
command: &Command,
|
||||
) -> Option<IdeResult<()>> {
|
||||
let plugins = crate::plugins::editor_plugin_host()?;
|
||||
let project = host.project(window).ok()?;
|
||||
if project.lsp.provides_command(doc, server, &command.command).await {
|
||||
return None;
|
||||
}
|
||||
let (plugin, run) = plugins.server_command(&project.lsp.server_names(doc, server), &command.command)?;
|
||||
let snap = match project.documents.snapshot(doc) {
|
||||
Ok(snap) => snap,
|
||||
Err(e) => return Some(Err(e)),
|
||||
};
|
||||
let invocation = ide_plugin::Invocation {
|
||||
client: Some(window.into()),
|
||||
workspace_root: Some(project.root.clone()),
|
||||
editor: Some(ide_plugin::EditorContext {
|
||||
path: snap.path.0.clone(),
|
||||
language: snap.language.0,
|
||||
selections: vec![],
|
||||
}),
|
||||
selected_paths: vec![snap.path.0],
|
||||
..Default::default()
|
||||
};
|
||||
let arguments = serde_json::Value::Array(command.arguments.clone()).to_string();
|
||||
Some(blocking(move || plugins.run_language_command(&plugin, &run, Some(&arguments), invocation)).await)
|
||||
}
|
||||
|
||||
/// Resolves an interactive command without applying edits or executing it.
|
||||
pub async fn lsp_resolve_command(
|
||||
host: &Host,
|
||||
@@ -1695,11 +1652,6 @@ pub async fn lsp_execute_code_action(
|
||||
.await
|
||||
.map_err(|e| ide_core::IdeError::internal(e.to_string()))??;
|
||||
}
|
||||
if let Some(command) = &action.command
|
||||
&& let Some(result) = run_plugin_server_command(host, window, doc, Some(action.server), command).await
|
||||
{
|
||||
return result.map(|()| Vec::new());
|
||||
}
|
||||
match action.command {
|
||||
Some(command) if edited && is_client_follow_up(&project, doc, Some(action.server), &command).await => {
|
||||
Ok(Vec::new())
|
||||
|
||||
@@ -54,9 +54,8 @@ pub fn index_file_extensions(host: &Host, window: &str) -> IdeResult<Vec<Extensi
|
||||
Ok(host.project(window)?.index.file_extensions())
|
||||
}
|
||||
|
||||
pub async fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.find_files(&query, limit as usize))).await
|
||||
pub fn find_files(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
Ok(host.project(window)?.index.find_files(&query, limit as usize))
|
||||
}
|
||||
|
||||
pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeResult<Vec<IpcPath>> {
|
||||
@@ -64,33 +63,18 @@ pub async fn find_files_named(host: &Host, window: &str, name: String) -> IdeRes
|
||||
blocking(move || Ok(project.index.files_named(&name).into_iter().map(Into::into).collect())).await
|
||||
}
|
||||
|
||||
pub async fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.find_dirs(&query, limit as usize))).await
|
||||
pub fn find_dirs(host: &Host, window: &str, query: String, limit: u32) -> IdeResult<Vec<FileMatch>> {
|
||||
Ok(host.project(window)?.index.find_dirs(&query, limit as usize))
|
||||
}
|
||||
|
||||
pub async fn find_symbols(
|
||||
pub fn find_symbols(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
query: String,
|
||||
filter: SymbolFilter,
|
||||
limit: u32,
|
||||
) -> IdeResult<Vec<SymbolMatch>> {
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.find_symbols(&query, filter, limit as usize))).await
|
||||
}
|
||||
|
||||
/// Index symbols named exactly one of `names` inside `within` (an agent task's folder),
|
||||
/// at most `SYMBOLS_PER_NAME` each: every name an agent reply shows, in one lookup.
|
||||
pub async fn find_symbols_named(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
names: Vec<String>,
|
||||
within: IpcPath,
|
||||
) -> IdeResult<Vec<SymbolMatch>> {
|
||||
const SYMBOLS_PER_NAME: usize = 50;
|
||||
let project = host.project(window)?;
|
||||
blocking(move || Ok(project.index.symbols_named_any(&names, &PathBuf::from(within), SYMBOLS_PER_NAME))).await
|
||||
Ok(host.project(window)?.index.find_symbols(&query, filter, limit as usize))
|
||||
}
|
||||
|
||||
pub fn mark_recent(host: &Host, window: &str, path: PathBuf) -> IdeResult<()> {
|
||||
@@ -334,14 +318,11 @@ pub async fn web_unresolved_references(host: &Host, window: &str, doc: DocId) ->
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("index_status", |c| async move { index_status(&c.host, &c.window) });
|
||||
d.add("index_file_extensions", |c| async move { index_file_extensions(&c.host, &c.window) });
|
||||
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
|
||||
d.add("find_files", |c| async move { find_files(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
|
||||
d.add("find_files_named", |c| async move { find_files_named(&c.host, &c.window, c.arg("name")?).await });
|
||||
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?).await });
|
||||
d.add("find_dirs", |c| async move { find_dirs(&c.host, &c.window, c.arg("query")?, c.arg("limit")?) });
|
||||
d.add("find_symbols", |c| async move {
|
||||
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?).await
|
||||
});
|
||||
d.add("find_symbols_named", |c| async move {
|
||||
find_symbols_named(&c.host, &c.window, c.arg("names")?, c.arg("within")?).await
|
||||
find_symbols(&c.host, &c.window, c.arg("query")?, c.arg("filter")?, c.arg("limit")?)
|
||||
});
|
||||
d.add("mark_recent", |c| async move { mark_recent(&c.host, &c.window, c.arg("path")?) });
|
||||
d.add("remove_recent", |c| async move { remove_recent(&c.host, &c.window, c.arg("path")?) });
|
||||
|
||||
@@ -65,15 +65,6 @@ pub fn settings(host: &Host, window: &str) -> Settings {
|
||||
})
|
||||
}
|
||||
|
||||
/// The removed built-in theme a settings file of this window still names, if any
|
||||
/// (`settings` reports its stand-in): the "provided by a plugin now" notice targets these.
|
||||
pub fn settings_removed_theme(host: &Host, window: &str) -> Option<String> {
|
||||
match host.project(window) {
|
||||
Ok(p) => p.settings.named_removed_theme().or_else(|| host.global_settings.named_removed_theme()),
|
||||
Err(_) => host.global_settings.named_removed_theme(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn roots(host: &Host, window: &str) -> IdeResult<ide_workspace::ProjectRoots> {
|
||||
Ok(host.project(window)?.roots())
|
||||
}
|
||||
@@ -232,9 +223,6 @@ pub fn set_settings(
|
||||
if key == "ssh" || key.starts_with("ssh.") {
|
||||
host.ssh.set_configs(host.global_settings.effective().ssh.configs);
|
||||
}
|
||||
if key == "languages" || key == "languages.java" || key.starts_with("languages.java.addedJdks") {
|
||||
host.apply_added_jdks();
|
||||
}
|
||||
if is_proxy {
|
||||
host.apply_proxy();
|
||||
}
|
||||
|
||||
@@ -202,86 +202,12 @@ pub async fn run_tomcat_installations(
|
||||
.map_err(|e| IdeError::internal(e.to_string()))
|
||||
}
|
||||
|
||||
/// Id prefix of a Project Structure WAR artifact (a project without a build tool).
|
||||
const PROJECT_ARTIFACT: &str = "project:";
|
||||
|
||||
fn project_web_artifacts(ps: &ide_core::settings::ProjectStructureSettings) -> Vec<ide_build::web::WebArtifact> {
|
||||
ide_build::compile::structure_web_artifacts(ps)
|
||||
.into_iter()
|
||||
.map(|a| ide_build::web::WebArtifact {
|
||||
id: format!("{PROJECT_ARTIFACT}{}", a.name),
|
||||
name: a.name.split(':').next().unwrap_or(&a.name).to_owned(),
|
||||
module: if a.module == "." { String::new() } else { a.module.clone() },
|
||||
tool: "project".into(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Compiles the project and packs the Project Structure artifact `name` as the WAR Tomcat
|
||||
/// deploys, recorded in `base` like a build tool's archive.
|
||||
fn build_project_war(
|
||||
root: &std::path::Path,
|
||||
settings: &ide_core::settings::Settings,
|
||||
detected: &[ide_workspace::roots::SourceFolder],
|
||||
name: &str,
|
||||
base: &std::path::Path,
|
||||
cache: &std::path::Path,
|
||||
) -> IdeResult<()> {
|
||||
use ide_build::compile;
|
||||
let (ps, roots, jdk) = crate::ops::build::structure_inputs(root, settings, detected);
|
||||
let artifact = ps
|
||||
.artifacts
|
||||
.iter()
|
||||
.find(|a| a.name == name)
|
||||
.ok_or_else(|| IdeError::invalid(format!("No artifact named {name} in Project Structure › Artifacts")))?;
|
||||
let war = base.join("artifact").join(format!(
|
||||
"{}.war",
|
||||
name.split(':').next().unwrap_or(name).replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
|
||||
));
|
||||
let plan = compile::structure_war_plan(
|
||||
root,
|
||||
&ps,
|
||||
&roots,
|
||||
jdk.as_ref(),
|
||||
&settings.languages.java.language_level,
|
||||
artifact,
|
||||
&war,
|
||||
cache,
|
||||
)?;
|
||||
let result = compile::run(root, &plan, &ide_core::CancellationToken::new(), &|_| {})?;
|
||||
if !result.success {
|
||||
let first = result.messages.iter().find(|m| m.severity == ide_core::Severity::Error);
|
||||
let text = match first {
|
||||
Some(m) => match (&m.path, m.range) {
|
||||
(Some(path), Some(range)) => {
|
||||
format!("{}:{}: {}", std::path::PathBuf::from(path.clone()).display(), range.start.line + 1, m.text)
|
||||
}
|
||||
_ => m.text.clone(),
|
||||
},
|
||||
None => "the build failed".into(),
|
||||
};
|
||||
return Err(IdeError::invalid(format!("Cannot build {name}: {text}")));
|
||||
}
|
||||
std::fs::create_dir_all(base)?;
|
||||
std::fs::write(base.join("artifact-id.txt"), format!("{PROJECT_ARTIFACT}{name}"))?;
|
||||
std::fs::write(base.join("artifact-path.txt"), war.to_string_lossy().as_bytes())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn run_tomcat_artifacts(host: &Host, window: &str) -> IdeResult<Vec<ide_build::web::WebArtifact>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let settings = project.settings.effective();
|
||||
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &settings);
|
||||
let mut artifacts = ide_build::web::artifacts(&project.root, &model);
|
||||
// Without a build tool, the Project Structure's WAR artifacts are built by the IDE.
|
||||
if model.maven.is_none() && model.gradle.is_empty() {
|
||||
let detected = project.detected_roots.read().clone();
|
||||
let (ps, _, _) = crate::ops::build::structure_inputs(&project.root, &settings, &detected);
|
||||
artifacts.extend(project_web_artifacts(&ps));
|
||||
}
|
||||
artifacts
|
||||
let model = crate::ops::build::load(&project.root, &project.build_cache_dir(), &project.settings.effective());
|
||||
ide_build::web::artifacts(&project.root, &model)
|
||||
})
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))
|
||||
@@ -304,12 +230,6 @@ pub async fn run_tomcat_build(host: &Host, window: &str, config: RunConfig) -> I
|
||||
.or_else(|| artifacts.first().map(|a| &a.id))
|
||||
.ok_or_else(|| IdeError::invalid("Choose a WAR artifact"))?;
|
||||
let base = ide_run::tomcat::effective_base_dir(&project.root, &project.cache_dir, &config)?;
|
||||
if let Some(name) = id.strip_prefix(PROJECT_ARTIFACT) {
|
||||
let settings = project.settings.effective();
|
||||
let detected = project.detected_roots.read().clone();
|
||||
build_project_war(&project.root, &settings, &detected, name, &base, &project.build_cache_dir())?;
|
||||
return Ok(None);
|
||||
}
|
||||
// "Build before launch" is skipped when the built WAR is already newer than the
|
||||
// sources of every module in the build, so a repeated run does not rebuild (IDEA's
|
||||
// up-to-date check) but a change in a dependency module does.
|
||||
|
||||
@@ -37,9 +37,6 @@ pub struct ProjectInterpreter {
|
||||
pub async fn sdk_detect(host: &Host, window: &str, kind: SdkKind) -> IdeResult<Vec<Sdk>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window).ok();
|
||||
if kind == SdkKind::Jdk {
|
||||
host.apply_added_jdks();
|
||||
}
|
||||
let root = project.as_ref().map(|p| p.root.clone());
|
||||
// The interpreter the project uses is a choice even where detection doesn't look (a
|
||||
// virtualenv in a subfolder, one picked by path), so it shows by name and version.
|
||||
@@ -375,20 +372,9 @@ pub async fn sdk_python_pip(
|
||||
result?
|
||||
}
|
||||
|
||||
/// The JDK whose home is `path` (a macOS bundle too), as the SDK list shows it; `None` when
|
||||
/// `path` is no JDK home (Add JDK from Disk…).
|
||||
pub async fn sdk_jdk_at(path: String) -> IdeResult<Option<Sdk>> {
|
||||
tokio::task::spawn_blocking(move || {
|
||||
ide_sdk::java::jdk_at(std::path::Path::new(&path)).map(|j| ide_sdk::jdk_sdk(&j))
|
||||
})
|
||||
.await
|
||||
.map_err(join_err)
|
||||
}
|
||||
|
||||
/// Commands of this module the remote server answers.
|
||||
pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("sdk_detect", |c| async move { sdk_detect(&c.host, &c.window, c.arg("kind")?).await });
|
||||
d.add("sdk_jdk_at", |c| async move { sdk_jdk_at(c.arg("path")?).await });
|
||||
d.add(
|
||||
"sdk_python_project_interpreters",
|
||||
|c| async move { sdk_python_project_interpreters(&c.host, &c.window).await },
|
||||
|
||||
@@ -97,21 +97,6 @@ pub trait PluginWorkspace: Send + Sync {
|
||||
fn indexed_files(&self, _root: &Path, _matches: &dyn Fn(&Path) -> bool, _limit: usize) -> Option<Vec<PathBuf>> {
|
||||
None
|
||||
}
|
||||
/// Sends `method` to the running language server named `server` of the project at
|
||||
/// `root`: a request, or with `notify` a notification (the result is null).
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn lsp_request(
|
||||
&self,
|
||||
_root: &Path,
|
||||
server: &str,
|
||||
_method: &str,
|
||||
_params: Option<serde_json::Value>,
|
||||
_notify: bool,
|
||||
_cancel: &CancellationToken,
|
||||
_timeout: Duration,
|
||||
) -> Result<serde_json::Value, HostError> {
|
||||
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
|
||||
}
|
||||
/// Current index of the project rooted at `root`; never reads disk or calls LSP.
|
||||
fn symbols(
|
||||
&self,
|
||||
@@ -677,14 +662,9 @@ impl Shared {
|
||||
}
|
||||
let previous =
|
||||
self.setting_snapshots.lock().insert((client.map(str::to_owned), pkg.id().into()), current.clone());
|
||||
match previous {
|
||||
// First contact since the plugin loaded (fresh install, update,
|
||||
// re-enable): hand over every current key, so the synthetic
|
||||
// post-install `settings-changed` wakes the plugin instead of being
|
||||
// dropped for having no diff yet.
|
||||
None => current.into_keys().collect(),
|
||||
Some(old) => current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect(),
|
||||
}
|
||||
previous
|
||||
.map(|old| current.into_iter().filter(|(k, v)| old.get(k) != Some(v)).map(|(k, _)| k).collect())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
pub fn status_snapshot(&self, client: &str) -> Vec<super::PluginStatusItem> {
|
||||
@@ -2200,35 +2180,6 @@ impl HostApi for PluginApi {
|
||||
)
|
||||
}
|
||||
|
||||
fn lsp_request(
|
||||
&self,
|
||||
root: &Path,
|
||||
server: &str,
|
||||
method: &str,
|
||||
params: Option<String>,
|
||||
notify: bool,
|
||||
cancel: &CancellationToken,
|
||||
timeout: Duration,
|
||||
) -> Result<String, HostError> {
|
||||
self.require_api("`language-servers`", 9)?;
|
||||
if !ide_lsp::plugin_method_allowed(method) {
|
||||
return Err(HostError::Invalid(format!("`{method}` is not one of the server's own methods")));
|
||||
}
|
||||
let workspace = self
|
||||
.shared
|
||||
.workspace()
|
||||
.ok_or_else(|| HostError::NotFound(format!("no language server `{server}` is running for this project")))?;
|
||||
// The server reads and edits the project on the plugin's behalf, as a process would.
|
||||
if !workspace.trusted(root) {
|
||||
return Err(HostError::Denied("project is not trusted".into()));
|
||||
}
|
||||
let params = params
|
||||
.map(|p| serde_json::from_str(&p).map_err(|e| HostError::Invalid(format!("params are not JSON: {e}"))))
|
||||
.transpose()?;
|
||||
let result = workspace.lsp_request(root, server, method, params, notify, cancel, timeout)?;
|
||||
Ok(result.to_string())
|
||||
}
|
||||
|
||||
fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
|
||||
let matcher = globset::GlobBuilder::new(glob)
|
||||
.literal_separator(true)
|
||||
@@ -3351,34 +3302,6 @@ impl PluginWorkspace for HostWorkspace {
|
||||
}
|
||||
}
|
||||
|
||||
fn lsp_request(
|
||||
&self,
|
||||
root: &Path,
|
||||
server: &str,
|
||||
method: &str,
|
||||
params: Option<serde_json::Value>,
|
||||
notify: bool,
|
||||
cancel: &CancellationToken,
|
||||
timeout: Duration,
|
||||
) -> Result<serde_json::Value, HostError> {
|
||||
use ide_core::error::ErrorKind;
|
||||
let host = self.0.upgrade().ok_or(HostError::Cancelled)?;
|
||||
let project = HostWorkspace::project_covering(self, root)
|
||||
.ok_or_else(|| HostError::NotFound("the project is no longer open".into()))?;
|
||||
let result = if notify {
|
||||
project.lsp.server_notify(root, server, method, params).map(|()| serde_json::Value::Null)
|
||||
} else {
|
||||
host.runtime.block_on(project.lsp.server_request(root, server, method, params, cancel, timeout))
|
||||
};
|
||||
result.map_err(|e| match e.kind {
|
||||
// A server that stopped while the request was on its way is as absent as one never started.
|
||||
ErrorKind::NotFound | ErrorKind::Unavailable => HostError::NotFound(e.message),
|
||||
ErrorKind::InvalidInput => HostError::Invalid(e.message),
|
||||
ErrorKind::Cancelled => HostError::Cancelled,
|
||||
_ => HostError::Failed(e.message),
|
||||
})
|
||||
}
|
||||
|
||||
fn trusted(&self, root: &Path) -> bool {
|
||||
// A workspace member is as trusted as the group's project it was opened with.
|
||||
HostWorkspace::project_covering(self, root).is_some_and(|p| p.is_trusted())
|
||||
|
||||
@@ -313,35 +313,6 @@ impl PluginHost {
|
||||
}
|
||||
}
|
||||
|
||||
impl PluginHost {
|
||||
/// The plugin command that runs `command`, which one of the language servers
|
||||
/// `servers` handed to the client (`[[contributes.serverCommands]]`): the plugin
|
||||
/// and its command id. A plugin counts while it holds `lsp:<server>`; when several
|
||||
/// claim the same server and command, the first one loaded keeps it.
|
||||
pub(crate) fn server_command(&self, servers: &[String], command: &str) -> Option<(String, String)> {
|
||||
let mut claims = self.ui.items(super::ui_points::SERVER_COMMANDS, None).into_iter().filter_map(|item| {
|
||||
let decl: super::ui_points::ServerCommandDecl = serde_json::from_value(item.decl).ok()?;
|
||||
let claimed = decl.command == command && servers.contains(&decl.server);
|
||||
let grant = ide_extension::Capability::Lsp(decl.server.clone());
|
||||
let granted = claimed
|
||||
&& self.get(&item.plugin_id).is_ok_and(|p| p.meta.lock().granted.iter().any(|g| g.covers(&grant)));
|
||||
granted.then_some((item.plugin_id, decl.server, decl.run))
|
||||
});
|
||||
let (plugin, server, run) = claims.next()?;
|
||||
for (other, _, _) in claims.filter(|(other, s, _)| *other != plugin && *s == server) {
|
||||
static LOGGED: parking_lot::Mutex<std::collections::BTreeSet<(String, String, String)>> =
|
||||
parking_lot::Mutex::new(std::collections::BTreeSet::new());
|
||||
if LOGGED.lock().insert((other.clone(), server.clone(), command.to_owned())) {
|
||||
tracing::warn!(
|
||||
"plugins {plugin} and {other} both claim command `{command}` of language server {server}; \
|
||||
{plugin} was loaded first and keeps it"
|
||||
);
|
||||
}
|
||||
}
|
||||
Some((plugin, run))
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn signature_help(h: SignatureHelp) -> ide_lsp::types::SignatureHelp {
|
||||
let signatures: Vec<_> = h
|
||||
.signatures
|
||||
|
||||
@@ -93,7 +93,6 @@ pub fn register_builtin_points(
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_ICONS, ui.clone(), p::file_icon)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::FILE_TEMPLATES, ui.clone(), p::file_template)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::COMMIT_CHECKS, ui.clone(), p::commit_check)))?;
|
||||
registry.register(Arc::new(UiPoint::new(p::SERVER_COMMANDS, ui.clone(), p::server_command)))?;
|
||||
registry.register(Arc::new(UiPoint::new(ide_extension::LOCALES_POINT, ui.clone(), p::locales)))?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -46,11 +46,6 @@
|
||||
//! id = "conventional"
|
||||
//! title = "Conventional Commits" # Commit Options › Before Commit; `commit-checker.check` runs it
|
||||
//!
|
||||
//! [[contributes.serverCommands]]
|
||||
//! server = "phoxite" # the language server whose results carry the command
|
||||
//! command = "laravel.modelView" # a command the server leaves to the client
|
||||
//! run = "model-view" # this plugin's command; needs `lsp:phoxite`
|
||||
//!
|
||||
//! [[contributes.fileTemplates]]
|
||||
//! id = "drawing"
|
||||
//! name = "Excalidraw Drawing"
|
||||
@@ -77,7 +72,6 @@ pub const FILE_ICONS: &str = "fileIcons";
|
||||
pub const MARKER_ICONS: &str = "markerIcons";
|
||||
pub const FILE_TEMPLATES: &str = "fileTemplates";
|
||||
pub const COMMIT_CHECKS: &str = "commitChecks";
|
||||
pub const SERVER_COMMANDS: &str = "serverCommands";
|
||||
|
||||
const VIEW_ITEM_MENU: &str = "viewItem.context";
|
||||
/// The toolbar above the commit message (Commit tool window and dialog).
|
||||
@@ -970,37 +964,6 @@ pub(super) fn commit_check(pkg: &Package, decl: toml::Value) -> Result<UiDecl, S
|
||||
Ok(UiDecl::new(d.id.clone(), d.title.clone(), json(&d)?))
|
||||
}
|
||||
|
||||
/// A command a language server's code lens, code action or inlay hint carries and
|
||||
/// leaves to the client, and the plugin command that runs it.
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub(super) struct ServerCommandDecl {
|
||||
/// The server's name in its language definition.
|
||||
pub(super) server: String,
|
||||
pub(super) command: String,
|
||||
/// The plugin's command (`[[contributes.commands]]`); it gets the arguments as JSON.
|
||||
pub(super) run: String,
|
||||
}
|
||||
|
||||
/// `[[contributes.serverCommands]]` (API 1.9): routes a command no server executes
|
||||
/// itself to the plugin's own command.
|
||||
pub(super) fn server_command(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
|
||||
let d: ServerCommandDecl = decode(SERVER_COMMANDS, decl)?;
|
||||
pkg.manifest.needs_api(&format!("contributes.{SERVER_COMMANDS}"), 9)?;
|
||||
if d.command.is_empty() || d.command.len() > 256 {
|
||||
return Err(format!("contributes.{SERVER_COMMANDS}: command names are 1–256 bytes"));
|
||||
}
|
||||
declared_command(pkg, SERVER_COMMANDS, &d.run)?;
|
||||
let grant: ide_extension::Capability =
|
||||
format!("lsp:{}", d.server).parse().map_err(|e| format!("contributes.{SERVER_COMMANDS}: {e}"))?;
|
||||
if !pkg.manifest.capabilities.all().any(|c| *c == grant) {
|
||||
return Err(format!(
|
||||
"contributes.{SERVER_COMMANDS}: needs the `{grant}` capability (the command comes from that server)"
|
||||
));
|
||||
}
|
||||
Ok(UiDecl::new(format!("{}:{}", d.server, d.command), d.command.clone(), json(&d)?))
|
||||
}
|
||||
|
||||
const MAX_CATALOG_ENTRIES: usize = 20_000;
|
||||
|
||||
pub fn locale_asset(tag: &str) -> String {
|
||||
|
||||
@@ -144,7 +144,7 @@ impl Host {
|
||||
let lsp = LspManager::new(root.clone(), languages.clone(), sink.clone());
|
||||
crate::plugins::injections::configure_lsp(&lsp);
|
||||
lsp.set_execution_allowed(trusted.load(Ordering::Acquire));
|
||||
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
|
||||
lsp.set_content_roots(extra_roots.clone());
|
||||
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&root,
|
||||
&settings.effective().languages.java.maven.linked_projects,
|
||||
@@ -1224,7 +1224,7 @@ impl Project {
|
||||
return;
|
||||
}
|
||||
let (roots, excludes) = (self.content_roots(), self.exclude_globs());
|
||||
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
|
||||
self.lsp.set_content_roots(roots.clone());
|
||||
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
|
||||
&self.root,
|
||||
&self.settings.effective().languages.java.maven.linked_projects,
|
||||
@@ -1275,9 +1275,7 @@ impl Project {
|
||||
}
|
||||
let defaults = self.documents.file_defaults();
|
||||
let fallback = defaults.fallback_for(path);
|
||||
// The working file only when it is a regular file: a path that is a directory there
|
||||
// (a committed symlink to a folder, a file replaced by a folder) has only its blob.
|
||||
if path.is_file() {
|
||||
if path.exists() {
|
||||
let loaded = ide_vfs::load_text_with_fallback(path, fallback)?;
|
||||
return encoding_rs::Encoding::for_label(loaded.encoding.as_bytes())
|
||||
.ok_or_else(|| ide_core::IdeError::invalid("unknown file encoding"));
|
||||
@@ -1369,22 +1367,6 @@ fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cac
|
||||
extra_content_roots(settings, root, build_cache)
|
||||
}
|
||||
|
||||
/// The content roots plus the projects attached inside this one. The index covers those
|
||||
/// already, but each is a project of its own (a git worktree under the project, a nested
|
||||
/// Cargo workspace), so its files get a language server rooted there, not at this root.
|
||||
fn language_server_roots(root: &Path, mut roots: Vec<PathBuf>) -> Vec<PathBuf> {
|
||||
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root)
|
||||
&& !workspace.is_container(root)
|
||||
{
|
||||
for path in workspace.projects {
|
||||
if path != root && path.starts_with(root) && !roots.contains(&path) {
|
||||
roots.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
roots
|
||||
}
|
||||
|
||||
/// The roots a file may navigate into: its own root (the workspace member containing it, or
|
||||
/// the project root) plus that root's configured dependencies. A workspace member depends
|
||||
/// only on the roots picked per member in Project Structure › Dependencies —
|
||||
@@ -2179,25 +2161,4 @@ mod content_roots_tests {
|
||||
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
|
||||
assert_eq!(roots, vec![shared, dep]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn projects_attached_inside_the_root_get_their_own_language_server_root() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let ws = dunce::canonicalize(tmp.path()).unwrap();
|
||||
let (root, nested, other) = (ws.join("app"), ws.join("app/.wt/feature"), ws.join("other"));
|
||||
for dir in [&nested, &other] {
|
||||
std::fs::create_dir_all(dir).unwrap();
|
||||
}
|
||||
let settings = ide_core::settings::Settings::default();
|
||||
let build = ws.join("build");
|
||||
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build)).is_empty());
|
||||
|
||||
ide_workspace::workspace::Workspace::attach(&root, "app", vec![root.clone(), nested.clone(), other.clone()])
|
||||
.unwrap();
|
||||
// The index walks the nested project as part of the root ...
|
||||
let roots = content_roots(&settings, &root, &build);
|
||||
assert_eq!(roots, vec![other.clone()]);
|
||||
// ... while its files go to a language server of its own.
|
||||
assert_eq!(super::language_server_roots(&root, roots), vec![other, nested]);
|
||||
}
|
||||
}
|
||||
@@ -165,7 +165,6 @@ impl Dispatcher {
|
||||
})
|
||||
.add("project_roots", |c| async move { ops::project::roots(&c.host, &c.window) })
|
||||
.add("settings_get", |c| async move { Ok(ops::project::settings(&c.host, &c.window)) })
|
||||
.add("settings_removed_theme", |c| async move { Ok(ops::project::settings_removed_theme(&c.host, &c.window)) })
|
||||
.add("settings_set", |c| async move {
|
||||
let key: String = c.arg("key")?;
|
||||
let scope = c.arg("scope")?;
|
||||
|
||||
@@ -408,7 +408,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "settings_export"
|
||||
| "settings_get"
|
||||
| "settings_get_global"
|
||||
| "settings_removed_theme"
|
||||
| "settings_import"
|
||||
| "settings_list_jetbrains_ides"
|
||||
| "settings_read_jetbrains"
|
||||
@@ -500,7 +499,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
|
||||
| "find_files_named"
|
||||
| "find_dirs"
|
||||
| "find_symbols"
|
||||
| "find_symbols_named"
|
||||
| "mark_recent"
|
||||
| "remove_recent"
|
||||
| "recent_files"
|
||||
|
||||
@@ -697,76 +697,3 @@ async fn agent_commands_run_in_named_tabs_and_report_what_the_user_did() {
|
||||
let interrupted = h.json("wait_for_run", json!({"name": "interrupt", "timeout": 10000})).await;
|
||||
assert_eq!(interrupted["state"], "stoppedByAgent", "{interrupted}");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn http_list_and_run_require_confirmation() {
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
|
||||
let h = Harness::new();
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let addr = listener.local_addr().unwrap();
|
||||
tokio::spawn(async move {
|
||||
let (mut socket, _) = listener.accept().await.unwrap();
|
||||
let mut buf = [0u8; 1024];
|
||||
let _ = socket.read(&mut buf).await;
|
||||
let body = b"{\"ok\":true}";
|
||||
let response = format!(
|
||||
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
|
||||
body.len(),
|
||||
std::str::from_utf8(body).unwrap()
|
||||
);
|
||||
let _ = socket.write_all(response.as_bytes()).await;
|
||||
});
|
||||
|
||||
std::fs::write(
|
||||
h.root.join("api.http"),
|
||||
format!(
|
||||
"### Health\nGET http://{addr}/health\nAccept: application/json\n\n### Echo\n# @name echo\nGET http://{addr}/echo\n"
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(h.root.join("http-client.env.json"), r#"{"dev":{"unused":"x"}}"#).unwrap();
|
||||
|
||||
let listed = h.json("http_list_requests", json!({"path": "api.http"})).await;
|
||||
assert_eq!(listed["requests"].as_array().unwrap().len(), 2, "{listed}");
|
||||
assert_eq!(listed["requests"][0]["index"], 0);
|
||||
assert_eq!(listed["requests"][0]["name"], "Health");
|
||||
assert_eq!(listed["requests"][0]["method"], "GET");
|
||||
assert_eq!(listed["requests"][1]["name"], "echo");
|
||||
assert!(listed["requests"][0]["url"].as_str().unwrap().contains("/health"));
|
||||
|
||||
// Write tool is hidden until the project is trusted.
|
||||
assert!(Registry::new(h.host.clone()).tools(&h.root).unwrap().iter().all(|t| t.name != "http_run_request"));
|
||||
h.trust().await;
|
||||
assert!(
|
||||
Registry::new(h.host.clone())
|
||||
.tools(&h.root)
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|t| t.name == "http_run_request" && !t.read_only)
|
||||
);
|
||||
|
||||
h.host.mcp_requests.set_ready("main", true);
|
||||
let denied = h.error("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
|
||||
let deny = async {
|
||||
let id = h.request().await;
|
||||
h.host.mcp_requests.answer("main", id, false, None).unwrap();
|
||||
};
|
||||
let (error, ()) = tokio::join!(denied, deny);
|
||||
assert!(error.contains("denied by the user"), "{error}");
|
||||
|
||||
h.events.lock().unwrap().clear();
|
||||
let run = h.json("http_run_request", json!({"path": "api.http", "index": 0, "env": "dev"}));
|
||||
let allow = async {
|
||||
let id = h.request().await;
|
||||
h.host.mcp_requests.answer("main", id, true, None).unwrap();
|
||||
};
|
||||
let (result, ()) = tokio::join!(run, allow);
|
||||
assert_eq!(result["status"], 200, "{result}");
|
||||
assert_eq!(result["method"], "GET");
|
||||
assert!(result["body"].as_str().unwrap().contains("ok"), "{result}");
|
||||
assert_eq!(result["bodyTruncated"], false);
|
||||
// Secrets must not appear as request headers/body in the tool payload.
|
||||
assert!(result.get("headers").is_none(), "{result}");
|
||||
assert!(result.get("request").is_none(), "{result}");
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
//! `[[contributes.serverCommands]]` (plugin API 1.9): a command a language server hands to the
|
||||
//! client runs the plugin command that claims it. The fixture's command sends its argument
|
||||
//! back to the server (`mock/ran`), through the real component runtime and `language-servers`.
|
||||
use ide_host::plugins::{Consent, HostWorkspace, PluginHost, set_editor_providers};
|
||||
use ide_host::{Host, HostConfig, ops};
|
||||
use ide_jsonrpc::{Handler, Peer};
|
||||
use ide_lsp::types::Command;
|
||||
use ide_plugin::Limits;
|
||||
use parking_lot::Mutex;
|
||||
use serde_json::{Value, json};
|
||||
use std::{path::Path, sync::Arc, time::Duration};
|
||||
|
||||
const ID: &str = "test.lsp-requests";
|
||||
const SECOND: &str = "test.lsp-second";
|
||||
|
||||
fn fixture() -> std::path::PathBuf {
|
||||
Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/lsp-requests")
|
||||
}
|
||||
|
||||
/// The fixture under `dir` with `edit` applied to its manifest.
|
||||
fn variant(dir: &Path, edit: impl Fn(&str) -> String) -> std::path::PathBuf {
|
||||
fn copy(from: &Path, to: &Path) {
|
||||
std::fs::create_dir_all(to).unwrap();
|
||||
for entry in std::fs::read_dir(from).unwrap() {
|
||||
let entry = entry.unwrap();
|
||||
match entry.file_type().unwrap().is_dir() {
|
||||
true if entry.file_name() != "target" => copy(&entry.path(), &to.join(entry.file_name())),
|
||||
true => {}
|
||||
false => drop(std::fs::copy(entry.path(), to.join(entry.file_name())).unwrap()),
|
||||
}
|
||||
}
|
||||
}
|
||||
copy(&fixture(), dir);
|
||||
let manifest = dir.join("plugin.toml");
|
||||
std::fs::write(&manifest, edit(&std::fs::read_to_string(&manifest).unwrap())).unwrap();
|
||||
dir.to_path_buf()
|
||||
}
|
||||
|
||||
/// A language server named `mock`: it executes `mock.own` itself and records what it gets.
|
||||
#[derive(Default)]
|
||||
struct Mock {
|
||||
requests: Mutex<Vec<(String, Value)>>,
|
||||
notifications: Mutex<Vec<(String, Value)>>,
|
||||
}
|
||||
|
||||
impl Mock {
|
||||
fn ran(&self) -> Vec<Value> {
|
||||
self.notifications.lock().iter().filter(|(m, _)| m == "mock/ran").map(|(_, p)| p.clone()).collect()
|
||||
}
|
||||
fn executed(&self) -> Vec<Value> {
|
||||
let requests = self.requests.lock();
|
||||
requests.iter().filter(|(m, _)| m == "workspace/executeCommand").map(|(_, p)| p["command"].clone()).collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl Handler for Mock {
|
||||
fn on_notification(&self, method: &str, p: Value) {
|
||||
self.notifications.lock().push((method.to_owned(), p));
|
||||
}
|
||||
fn on_request(&self, method: &str, p: Value) -> Result<Value, (i64, String)> {
|
||||
self.requests.lock().push((method.to_owned(), p));
|
||||
Ok(match method {
|
||||
"initialize" => json!({ "capabilities": {
|
||||
"textDocumentSync": { "openClose": true, "change": 1 },
|
||||
"executeCommandProvider": { "commands": ["mock.own"] },
|
||||
} }),
|
||||
_ => Value::Null,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
async fn eventually(what: &str, mut f: impl FnMut() -> bool) {
|
||||
for _ in 0..500 {
|
||||
if f() {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
panic!("timed out waiting for {what}");
|
||||
}
|
||||
|
||||
fn command(name: &str, arguments: Vec<Value>) -> Command {
|
||||
Command { title: "Lens".into(), command: name.into(), arguments }
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_command_the_server_leaves_to_the_client_runs_the_plugin_that_claims_it() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let root = dunce::canonicalize(tmp.path()).unwrap().join("project");
|
||||
std::fs::create_dir(&root).unwrap();
|
||||
let host = Arc::new(Host::new(HostConfig {
|
||||
config_dir: tmp.path().join("config"),
|
||||
data_dir: tmp.path().join("data"),
|
||||
local_data_dir: tmp.path().join("local"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(ide_core::NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
}));
|
||||
// Language servers start only in a trusted project.
|
||||
host.set_project_trust(&root, true, false).await.unwrap();
|
||||
host.open_project("main", &root).unwrap();
|
||||
let plugins = Arc::new(
|
||||
PluginHost::new(tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
|
||||
);
|
||||
plugins.set_workspace(Some(Arc::new(HostWorkspace(Arc::downgrade(&host)))));
|
||||
set_editor_providers(Some(&plugins));
|
||||
|
||||
// The manifest must hold the grant of the server whose commands it claims.
|
||||
let ungranted = variant(&tmp.path().join("ungranted"), |m| m.replace("optional = [\"lsp:mock\"]", "optional = []"));
|
||||
let err = plugins.install_from_dir(&ungranted, &Consent::all()).unwrap_err();
|
||||
assert!(err.message.contains("needs the `lsp:mock` capability"), "{err:?}");
|
||||
plugins.install_from_dir(&fixture(), &Consent::all()).unwrap();
|
||||
|
||||
// The server `mock` serves the project's text files.
|
||||
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
|
||||
let port = listener.local_addr().unwrap().port();
|
||||
let mock = Arc::new(Mock::default());
|
||||
let peers = Arc::new(Mutex::new(Vec::<Peer>::new()));
|
||||
let (accepted, state) = (peers.clone(), mock.clone());
|
||||
let server = tokio::spawn(async move {
|
||||
while let Ok((stream, _)) = listener.accept().await {
|
||||
let (r, w) = stream.into_split();
|
||||
accepted.lock().push(Peer::connect(r, w, state.clone()));
|
||||
}
|
||||
});
|
||||
let cfg: ide_language::LanguageServerConfig =
|
||||
toml::from_str(&format!("name='mock'\ncommand='no-process-required'\nconnect='127.0.0.1:{port}'")).unwrap();
|
||||
let project = host.project("main").unwrap();
|
||||
project.lsp.set_servers_hook(Box::new(move |_, _| vec![cfg.clone()]));
|
||||
let path = root.join("a.txt");
|
||||
std::fs::write(&path, "class Post {}\n").unwrap();
|
||||
let doc = ops::doc::open(&host, "main", path.clone()).await.unwrap().id;
|
||||
project.lsp.did_open(
|
||||
doc,
|
||||
&path,
|
||||
&ide_core::LanguageId::plain_text(),
|
||||
0,
|
||||
"class Post {}
|
||||
",
|
||||
);
|
||||
eventually("the server to be ready", || {
|
||||
project.lsp.servers().iter().any(|s| s.name == "mock" && s.status == ide_core::event::ServerStatus::Ready)
|
||||
})
|
||||
.await;
|
||||
|
||||
// A lens command the server does not execute: the plugin's command gets the arguments as JSON.
|
||||
let lens = command("mock.modelView", vec![json!("App\\Models\\Post"), json!({ "line": 3 })]);
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
|
||||
eventually("the plugin's command", || !mock.ran().is_empty()).await;
|
||||
assert_eq!(mock.ran(), [json!(["App\\Models\\Post", { "line": 3 }])]);
|
||||
assert!(mock.executed().is_empty(), "the server was not asked to execute it");
|
||||
|
||||
// A command in the server's `executeCommandProvider` still goes to the server.
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.own", vec![])).await.unwrap();
|
||||
assert_eq!(mock.executed(), [json!("mock.own")]);
|
||||
assert_eq!(mock.ran().len(), 1);
|
||||
|
||||
// A command nobody claims fails as before.
|
||||
let err = ops::lsp::lsp_execute_command(&host, "main", doc, command("mock.unclaimed", vec![])).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
|
||||
|
||||
// Two plugins claim the same server and command: the first one loaded keeps it.
|
||||
let second = variant(&tmp.path().join("second"), |m| m.replace(ID, SECOND));
|
||||
plugins.install_from_dir(&second, &Consent::all()).unwrap();
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
|
||||
eventually("the first plugin's command again", || mock.ran().len() == 2).await;
|
||||
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 0, "the second plugin never ran");
|
||||
|
||||
// A claim counts only while the plugin holds the server's grant.
|
||||
plugins.set_capability(ID, "lsp:mock", false).unwrap();
|
||||
ops::lsp::lsp_execute_command(&host, "main", doc, lens.clone()).await.unwrap();
|
||||
eventually("the second plugin's command", || mock.ran().len() == 3).await;
|
||||
assert_eq!(plugins.info_of(SECOND).unwrap().stats.activations, 1);
|
||||
plugins.set_capability(SECOND, "lsp:mock", false).unwrap();
|
||||
let err = ops::lsp::lsp_execute_command(&host, "main", doc, lens).await.unwrap_err();
|
||||
assert_eq!(err.kind, ide_core::error::ErrorKind::Unavailable, "{err:?}");
|
||||
assert_eq!(mock.ran().len(), 3);
|
||||
|
||||
set_editor_providers(None);
|
||||
server.abort();
|
||||
}
|
||||
@@ -31,8 +31,6 @@ struct TestWorkspace {
|
||||
/// plugin → its settings as the user set them.
|
||||
settings: Mutex<std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>>,
|
||||
global_settings: Mutex<std::collections::BTreeMap<String, serde_json::Map<String, serde_json::Value>>>,
|
||||
/// What plugins sent the language server `mock`: (method, params, whether a notification).
|
||||
server_messages: Mutex<Vec<(String, Option<serde_json::Value>, bool)>>,
|
||||
}
|
||||
|
||||
impl TestWorkspace {
|
||||
@@ -51,7 +49,6 @@ impl TestWorkspace {
|
||||
diagnostics: Mutex::default(),
|
||||
settings: Mutex::default(),
|
||||
global_settings: Mutex::default(),
|
||||
server_messages: Mutex::default(),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -179,23 +176,6 @@ impl PluginWorkspace for TestWorkspace {
|
||||
fn trusted(&self, _root: &Path) -> bool {
|
||||
self.trusted
|
||||
}
|
||||
/// One language server runs for the project, `mock`: it answers with what it was sent.
|
||||
fn lsp_request(
|
||||
&self,
|
||||
_root: &Path,
|
||||
server: &str,
|
||||
method: &str,
|
||||
params: Option<serde_json::Value>,
|
||||
notify: bool,
|
||||
_cancel: &ide_core::CancellationToken,
|
||||
_timeout: Duration,
|
||||
) -> Result<serde_json::Value, HostError> {
|
||||
if server != "mock" {
|
||||
return Err(HostError::NotFound(format!("no language server `{server}` is running for this project")));
|
||||
}
|
||||
self.server_messages.lock().push((method.into(), params.clone(), notify));
|
||||
Ok(if notify { serde_json::Value::Null } else { serde_json::json!({ "method": method, "params": params }) })
|
||||
}
|
||||
fn project_windows(&self, root: &Path) -> Vec<String> {
|
||||
// `main` shows the fixture project; other open roots have no window left.
|
||||
if root == self.root { vec!["closing".into(), "main".into()] } else { Vec::new() }
|
||||
@@ -841,11 +821,10 @@ fn a_reporting_task_outlives_its_background_budget() {
|
||||
|
||||
#[test]
|
||||
fn background_tasks_scale_and_renew_cpu_fuel_budget() {
|
||||
// Room for activation (about 3_100 on macOS, more on Windows). A background task gets ten
|
||||
// times it (5 s / 500 ms): enough for each step of `patient` with its CPU work (32_000 to
|
||||
// 80_000), not for the whole run without the refill on each report.
|
||||
// Room for activation (about 3_100 on macOS, more on Windows) but not for `patient`'s
|
||||
// whole run (about 9_000) without the refill on each report.
|
||||
let f = fixture(Limits {
|
||||
fuel: 40_000,
|
||||
fuel: 6_000,
|
||||
timeout: Duration::from_millis(500),
|
||||
background: Duration::from_millis(5_000),
|
||||
..Limits::default()
|
||||
@@ -857,11 +836,11 @@ fn background_tasks_scale_and_renew_cpu_fuel_budget() {
|
||||
// Warm up activation in its own call so `patient` starts with a fresh budget.
|
||||
assert_eq!(f.run("misbehave", "echo", Some("warm")).unwrap().as_deref(), Some("warm"));
|
||||
|
||||
let out = f.run("misbehave", "patient", Some("4000")).expect("background task succeeds").expect("output");
|
||||
let out = f.run("misbehave", "patient", None).expect("background task succeeds").expect("output");
|
||||
assert_eq!(out, "still here");
|
||||
|
||||
let err = f.run("misbehave", "spin", None).unwrap_err();
|
||||
assert!(err.contains("exceeded its CPU budget (40000 fuel per call)"), "{err}");
|
||||
assert!(err.contains("exceeded its CPU budget (6000 fuel per call)"), "{err}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -2627,7 +2606,6 @@ fn git_toolbox_does_not_fetch_untrusted_projects() {
|
||||
diagnostics: Mutex::default(),
|
||||
settings: Mutex::default(),
|
||||
global_settings: Mutex::default(),
|
||||
server_messages: Mutex::default(),
|
||||
});
|
||||
f.host.set_workspace(Some(untrusted));
|
||||
let err = f.run("openidea.git-toolbox", "fetch", None).unwrap_err();
|
||||
@@ -6271,15 +6249,10 @@ fn api14_settings_and_input_events_use_other_and_capture_the_editor() {
|
||||
assert!(f.host.wait_events(Duration::from_secs(5)));
|
||||
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
|
||||
let events = received.as_array().unwrap();
|
||||
assert_eq!(events.len(), 4, "{received}");
|
||||
// The first synthetic post hands over the current keys ("enabled": false);
|
||||
// the second is a real diff to true. Keys come from the recomputed
|
||||
// snapshot, never from the event payload ("another-plugin-key").
|
||||
assert_eq!(events.len(), 3, "{received}");
|
||||
assert_eq!(events[0]["kind"], "settings-changed");
|
||||
assert_eq!(events[0]["data"], "[\"enabled\"]");
|
||||
assert_eq!(events[1]["kind"], "settings-changed");
|
||||
assert_eq!(events[1]["data"], "[\"enabled\"]");
|
||||
assert_eq!(events[3]["kind"], "input-mode-changed");
|
||||
assert_eq!(events[2]["kind"], "input-mode-changed");
|
||||
assert_eq!(events[2]["editor"][0], path);
|
||||
assert_eq!(events[2]["editor"][1][0], serde_json::json!([0, 0, 0, 0]));
|
||||
}
|
||||
@@ -6957,86 +6930,3 @@ fn project_write_judges_a_link_by_its_target() {
|
||||
assert_eq!(std::fs::read_to_string(&secret).unwrap(), "top secret", "{rel}");
|
||||
}
|
||||
}
|
||||
|
||||
/// A plugin reaches a running language server only with `lsp:<server>`, in a trusted
|
||||
/// project, and only with the server's own methods (API 1.9).
|
||||
#[test]
|
||||
fn language_server_requests_need_the_servers_grant_and_its_own_methods() {
|
||||
use serde_json::json;
|
||||
let f = fixture(Limits::default());
|
||||
let pkg = repo().join("crates/ide-plugin/tests/fixtures/lsp-requests");
|
||||
let id = "test.lsp-requests";
|
||||
let info = f.install(&pkg);
|
||||
assert!(info.capabilities.iter().any(|c| c.id == "lsp:mock" && c.granted && c.risk == ide_extension::Risk::High));
|
||||
|
||||
// The request and its JSON params reach the server; its answer comes back as JSON.
|
||||
let answer = f.run(id, "request", Some(r#"{"verb":"GET"}"#)).unwrap().unwrap();
|
||||
assert_eq!(
|
||||
serde_json::from_str::<serde_json::Value>(&answer).unwrap(),
|
||||
json!({ "method": "mock/routes", "params": { "verb": "GET" } })
|
||||
);
|
||||
assert_eq!(f.run(id, "notify", None).unwrap(), None);
|
||||
assert_eq!(
|
||||
*f.workspace.server_messages.lock(),
|
||||
[("mock/routes".to_owned(), Some(json!({ "verb": "GET" })), false), ("mock/changed".to_owned(), None, true)]
|
||||
);
|
||||
|
||||
// Params that are not JSON and LSP's own methods stop at the host.
|
||||
assert!(f.run(id, "request", Some("{")).unwrap_err().contains("params are not JSON"));
|
||||
assert!(f.run(id, "standard", None).unwrap_err().contains("not one of the server's own methods"));
|
||||
assert_eq!(f.workspace.server_messages.lock().len(), 2);
|
||||
|
||||
// The grant names one server: another one is denied, not merely absent.
|
||||
let err = f.host.run_command(id, "ungranted", None, f.inv()).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
|
||||
assert!(err.message.contains("lsp:other"), "{err:?}");
|
||||
|
||||
// Without the grant the call is denied and nothing is sent.
|
||||
f.host.set_capability(id, "lsp:mock", false).unwrap();
|
||||
let err = f.host.run_command(id, "request", None, f.inv()).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
|
||||
assert!(err.message.contains("lsp:mock"), "{err:?}");
|
||||
f.host.set_capability(id, "lsp:mock", true).unwrap();
|
||||
f.run(id, "request", None).unwrap();
|
||||
|
||||
// A server acts on the project's files: not in an untrusted project.
|
||||
let mut untrusted = TestWorkspace::new(&f.project);
|
||||
Arc::get_mut(&mut untrusted).unwrap().trusted = false;
|
||||
f.host.set_workspace(Some(untrusted.clone()));
|
||||
let err = f.host.run_command(id, "request", None, f.inv()).unwrap_err();
|
||||
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
|
||||
assert!(untrusted.server_messages.lock().is_empty());
|
||||
assert_eq!(f.host.info_of(id).unwrap().stats.crashes, 0);
|
||||
}
|
||||
|
||||
/// The grant is new in API 1.9: an older `engines.openidea` can't ask for it.
|
||||
#[test]
|
||||
fn the_language_server_grant_needs_api_1_9() {
|
||||
let f = fixture(Limits::default());
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let pkg = tmp.path().join("lsp-requests");
|
||||
copy_dir(&repo().join("crates/ide-plugin/tests/fixtures/lsp-requests"), &pkg);
|
||||
let manifest = std::fs::read_to_string(pkg.join("plugin.toml")).unwrap();
|
||||
std::fs::write(pkg.join("plugin.toml"), manifest.replace("\"^1.9\"", "\"^1.8\"")).unwrap();
|
||||
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
|
||||
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
|
||||
}
|
||||
|
||||
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
|
||||
/// subscribes to `on-event:settings-changed`, though it carries no keys.
|
||||
#[test]
|
||||
fn a_freshly_installed_plugin_gets_the_post_install_settings_event() {
|
||||
let f = fixture(Limits::default());
|
||||
f.install(&sample("api14"));
|
||||
use ide_plugin::WorkbenchEvent as E;
|
||||
// What refreshEventKinds() posts right after commandsChanged (install).
|
||||
f.host.post_events(Some("main"), vec![E::SettingsChanged(Vec::new())]);
|
||||
f.host.flush_events_at(Instant::now() + Duration::from_secs(2));
|
||||
assert!(f.host.wait_events(Duration::from_secs(5)));
|
||||
let received: serde_json::Value = serde_json::from_str(&f.run("api14", "events", None).unwrap().unwrap()).unwrap();
|
||||
let events = received.as_array().unwrap();
|
||||
assert!(
|
||||
events.iter().any(|e| e["kind"] == "settings-changed"),
|
||||
"freshly installed plugin got no post-install event: {received}"
|
||||
);
|
||||
}
|
||||
@@ -70,14 +70,10 @@ async fn open(fixture: &str) -> Opened {
|
||||
}
|
||||
|
||||
/// Polls `check` until it holds; fails with its last answer.
|
||||
async fn until<T: std::fmt::Debug, F, Fut>(what: &str, timeout: Duration, mut check: F)
|
||||
where
|
||||
F: FnMut() -> Fut,
|
||||
Fut: std::future::Future<Output = Result<(), T>>,
|
||||
{
|
||||
async fn until<T: std::fmt::Debug>(what: &str, timeout: Duration, mut check: impl FnMut() -> Result<(), T>) {
|
||||
let deadline = Instant::now() + timeout;
|
||||
loop {
|
||||
match check().await {
|
||||
match check() {
|
||||
Ok(()) => return,
|
||||
Err(last) if Instant::now() > deadline => panic!("{what}: timed out after {timeout:?}; last: {last:?}"),
|
||||
Err(_) => tokio::time::sleep(Duration::from_millis(100)).await,
|
||||
@@ -86,25 +82,25 @@ where
|
||||
}
|
||||
|
||||
impl Opened {
|
||||
async fn files(&self, query: &str) -> Vec<String> {
|
||||
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).await.unwrap();
|
||||
fn files(&self, query: &str) -> Vec<String> {
|
||||
let found = ops::nav::find_files(&self.host, WINDOW, query.into(), 20).unwrap();
|
||||
found.into_iter().map(|f| f.rel_path).collect()
|
||||
}
|
||||
|
||||
async fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
|
||||
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).await.unwrap();
|
||||
fn symbols(&self, query: &str, filter: SymbolFilter) -> Vec<(String, String)> {
|
||||
let found = ops::nav::find_symbols(&self.host, WINDOW, query.into(), filter, 20).unwrap();
|
||||
found.into_iter().map(|s| (s.name, s.rel_path)).collect()
|
||||
}
|
||||
|
||||
async fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
|
||||
let found = self.symbols(name, filter).await;
|
||||
fn has_symbol(&self, name: &str, file: &str, filter: SymbolFilter) -> Result<(), Vec<(String, String)>> {
|
||||
let found = self.symbols(name, filter);
|
||||
if found.iter().any(|(n, f)| n == name && f == file) { Ok(()) } else { Err(found) }
|
||||
}
|
||||
}
|
||||
|
||||
async fn smoke(f: Fixture) {
|
||||
let p = open(f.dir).await;
|
||||
until("indexing", Duration::from_secs(30), || async {
|
||||
until("indexing", Duration::from_secs(30), || {
|
||||
let s = ops::nav::index_status(&p.host, WINDOW).unwrap();
|
||||
if !s.indexing && s.files > 0 && s.symbols > 0 { Ok(()) } else { Err(s) }
|
||||
})
|
||||
@@ -119,12 +115,12 @@ async fn smoke(f: Fixture) {
|
||||
);
|
||||
}
|
||||
|
||||
let files = p.files(f.file.0).await;
|
||||
let files = p.files(f.file.0);
|
||||
assert!(files.iter().any(|r| r == f.file.1), "{}: files for {:?}: {files:?}", f.dir, f.file.0);
|
||||
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types).await {
|
||||
if let Err(found) = p.has_symbol(f.class.0, f.class.1, SymbolFilter::Types) {
|
||||
panic!("{}: Go to Class {:?}: {found:?}", f.dir, f.class.0);
|
||||
}
|
||||
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All).await {
|
||||
if let Err(found) = p.has_symbol(f.symbol.0, f.symbol.1, SymbolFilter::All) {
|
||||
panic!("{}: Go to Symbol {:?}: {found:?}", f.dir, f.symbol.0);
|
||||
}
|
||||
|
||||
@@ -134,8 +130,8 @@ async fn smoke(f: Fixture) {
|
||||
until("a new file's class", Duration::from_secs(20), || p.has_symbol("FreshWidget", added, SymbolFilter::Types))
|
||||
.await;
|
||||
std::fs::remove_file(p.root.join(added)).unwrap();
|
||||
until("a deleted file's class", Duration::from_secs(20), || async {
|
||||
let found = p.symbols("FreshWidget", SymbolFilter::Types).await;
|
||||
until("a deleted file's class", Duration::from_secs(20), || {
|
||||
let found = p.symbols("FreshWidget", SymbolFilter::Types);
|
||||
if found.is_empty() { Ok(()) } else { Err(found) }
|
||||
})
|
||||
.await;
|
||||
|
||||
@@ -111,49 +111,3 @@ async fn gbk_document_gutter_diff_stage_and_rollback_share_encoding() {
|
||||
assert_eq!(vcs::vcs_file_at(&host, "main", utf8, None).await.unwrap().as_deref(), Some(old));
|
||||
host.close_project("main");
|
||||
}
|
||||
|
||||
/// A committed symlink to a folder (#3528): its revision is the link target, even though the
|
||||
/// working path is a directory.
|
||||
#[cfg(unix)]
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
async fn a_directory_symlink_revision_is_its_target() {
|
||||
let temp = tempfile::tempdir().unwrap();
|
||||
let base = dunce::canonicalize(temp.path()).unwrap();
|
||||
let root = base.join("project");
|
||||
std::fs::create_dir_all(root.join("target")).unwrap();
|
||||
git(&root, &["init", "-b", "main"]);
|
||||
git(&root, &["config", "user.name", "Test"]);
|
||||
git(&root, &["config", "user.email", "[email protected]"]);
|
||||
git(&root, &["config", "commit.gpgsign", "false"]);
|
||||
std::fs::write(root.join("target/file.txt"), "example\n").unwrap();
|
||||
std::os::unix::fs::symlink("target", root.join("dir-link")).unwrap();
|
||||
git(&root, &["add", "."]);
|
||||
git(&root, &["commit", "-m", "Add a directory symlink"]);
|
||||
let host = Host::new(HostConfig {
|
||||
config_dir: base.join("config"),
|
||||
data_dir: base.join("data"),
|
||||
local_data_dir: base.join("data"),
|
||||
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
|
||||
syntax: Arc::default(),
|
||||
sink_for: Box::new(|_| Arc::new(NullSink)),
|
||||
owner: |w| w,
|
||||
runtime: tokio::runtime::Handle::current(),
|
||||
project_environment: false,
|
||||
});
|
||||
host.trust.decide(&root, true, false).unwrap();
|
||||
let project = host.open_project("main", &root).unwrap();
|
||||
for _ in 0..500 {
|
||||
if !project.repos().is_empty() {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
let link = root.join("dir-link");
|
||||
assert!(link.is_dir());
|
||||
assert_eq!(
|
||||
vcs::vcs_file_at(&host, "main", link.clone(), Some("HEAD".into())).await.unwrap().as_deref(),
|
||||
Some("target")
|
||||
);
|
||||
assert_eq!(vcs::vcs_file_mode(&host, "main", link, Some("HEAD".into())).await.unwrap().as_deref(), Some("120000"));
|
||||
host.close_project("main");
|
||||
}
|
||||
@@ -646,16 +646,8 @@ impl IndexData {
|
||||
}
|
||||
}
|
||||
|
||||
/// Refreshes on-disk metadata of an unchanged-content file in place and
|
||||
/// returns its persisted record.
|
||||
pub(crate) fn refresh_metadata(&mut self, path: &Path, mtime: u64, size: u64, ignored: bool) -> Option<FileRecord> {
|
||||
let slot = *self.by_path.get(path)?;
|
||||
let e = self.files[slot as usize].as_mut()?;
|
||||
e.mtime = mtime;
|
||||
e.size = size;
|
||||
e.ignored = ignored;
|
||||
let e = self.files[slot as usize].as_ref()?;
|
||||
Some(self.record(e))
|
||||
pub(crate) fn record_of(&self, path: &Path) -> Option<FileRecord> {
|
||||
self.get(path).map(|e| self.record(e))
|
||||
}
|
||||
|
||||
/// The symbols of one file, in declaration order.
|
||||
|
||||
@@ -323,11 +323,6 @@ impl ProjectIndex {
|
||||
matching::symbols_named_within(&self.shared.data.read(), name, kind, roots, limit)
|
||||
}
|
||||
|
||||
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per name.
|
||||
pub fn symbols_named_any(&self, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
|
||||
matching::symbols_named_any(&self.shared.data.read(), names, root, limit)
|
||||
}
|
||||
|
||||
/// Incrementally re-indexes changed paths (called from the vfs watcher).
|
||||
/// Cheap: the work is queued for the indexing thread.
|
||||
pub fn update(&self, changed: &[PathBuf], removed: &[PathBuf]) {
|
||||
|
||||
@@ -78,8 +78,8 @@ impl Needle {
|
||||
let mut b = 0;
|
||||
if n.eq_ignore_ascii_case(q) {
|
||||
b += EXACT;
|
||||
} else if let Some(dot) = n.iter().position(|&b| b == b'.')
|
||||
&& n[..dot].eq_ignore_ascii_case(q)
|
||||
} else if let Some(dot) = name.find('.')
|
||||
&& name.as_bytes()[..dot].eq_ignore_ascii_case(q)
|
||||
{
|
||||
b += EXACT_STEM;
|
||||
} else if n.len() >= q.len() && n[..q.len()].eq_ignore_ascii_case(q) {
|
||||
@@ -97,31 +97,17 @@ fn hump_bonus(s: &str, indices: &[u32]) -> u32 {
|
||||
if indices.is_empty() {
|
||||
return 0;
|
||||
}
|
||||
// One pass over `s`: `indices` is sorted, and whether position `i` is a
|
||||
// word start only needs the char before it, so no `Vec<char>` is collected.
|
||||
let is_start = |prev: Option<char>, c: char| match prev {
|
||||
None => true,
|
||||
Some(p) => {
|
||||
!p.is_alphanumeric()
|
||||
|| (p.is_lowercase() && c.is_uppercase())
|
||||
|| (!p.is_ascii_digit() && c.is_ascii_digit())
|
||||
let chars: Vec<char> = s.chars().collect();
|
||||
let is_start = |i: usize| {
|
||||
if i == 0 {
|
||||
return true;
|
||||
}
|
||||
let (p, c) = (chars[i - 1], chars[i]);
|
||||
!p.is_alphanumeric() || (p.is_lowercase() && c.is_uppercase()) || (!p.is_ascii_digit() && c.is_ascii_digit())
|
||||
};
|
||||
let (mut humps, mut next, mut first_start) = (0u32, 0usize, false);
|
||||
let (mut prev, mut at) = (None, 0u32);
|
||||
for c in s.chars() {
|
||||
if next < indices.len() && indices[next] == at {
|
||||
let started = is_start(prev, c);
|
||||
humps += u32::from(started);
|
||||
if next == 0 {
|
||||
first_start = started;
|
||||
}
|
||||
next += 1;
|
||||
}
|
||||
prev = Some(c);
|
||||
at += 1;
|
||||
}
|
||||
humps * HUMP + u32::from(first_start) * FIRST_AT_START
|
||||
let humps = indices.iter().filter(|&&i| (i as usize) < chars.len() && is_start(i as usize)).count() as u32;
|
||||
let first = if is_start(indices[0] as usize) { FIRST_AT_START } else { 0 };
|
||||
humps * HUMP + first
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
@@ -632,41 +618,6 @@ pub(crate) fn symbols_named_within(
|
||||
out
|
||||
}
|
||||
|
||||
/// Symbols named exactly one of `names` whose file is inside `root`, at most `limit` per
|
||||
/// name, by path then position: one walk over the index for every name an agent reply shows.
|
||||
pub(crate) fn symbols_named_any(data: &IndexData, names: &[String], root: &Path, limit: usize) -> Vec<SymbolMatch> {
|
||||
let wanted: Vec<(u64, &str)> = names.iter().map(|name| (char_mask(name), name.as_str())).collect();
|
||||
let syms = &data.syms;
|
||||
let mut out: Vec<SymbolMatch> = data
|
||||
.files
|
||||
.iter()
|
||||
.flatten()
|
||||
.filter(|entry| entry.path.starts_with(root))
|
||||
.flat_map(|entry| {
|
||||
(entry.sym_start..entry.sym_start + entry.sym_len)
|
||||
.filter(|&at| wanted.iter().any(|&(mask, name)| syms.mask(at) == mask && syms.name(at) == name))
|
||||
.map(move |at| SymbolMatch {
|
||||
name: syms.name(at).to_string(),
|
||||
kind: syms.kind(at),
|
||||
container: syms.container(at).map(str::to_owned),
|
||||
path: entry.path.clone().into(),
|
||||
rel_path: entry.rel.to_string(),
|
||||
range: syms.range(at),
|
||||
score: 0,
|
||||
indices: Vec::new(),
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
out.sort_by(|left, right| left.rel_path.cmp(&right.rel_path).then_with(|| left.range.cmp(&right.range)));
|
||||
let mut kept: HashMap<String, usize> = HashMap::new();
|
||||
out.retain(|symbol| {
|
||||
let count = kept.entry(symbol.name.clone()).or_default();
|
||||
*count += 1;
|
||||
*count <= limit
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -549,24 +549,6 @@ fn symbols_named_within_keeps_out_of_root_matches_from_evicting_a_root() {
|
||||
assert!(idx.symbols_named_within("Decoder", None, &[f.root.join("none")], 3).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
|
||||
let fixture = Fixture::new(&[
|
||||
("app/a.rs", "struct Config;\nfn load() {}\nfn load_all() {}\n"),
|
||||
("app/b.rs", "fn load() {}\nfn load() {}\n"),
|
||||
("other/c.rs", "struct Config;\n"),
|
||||
]);
|
||||
let idx = fixture.open();
|
||||
let names = ["Config".to_string(), "load".to_string(), "missing".to_string()];
|
||||
let found: Vec<(String, String)> = idx
|
||||
.symbols_named_any(&names, &fixture.root.join("app"), 2)
|
||||
.into_iter()
|
||||
.map(|symbol| (symbol.name, symbol.rel_path))
|
||||
.collect();
|
||||
let expected = [("Config", "app/a.rs"), ("load", "app/a.rs"), ("load", "app/b.rs")];
|
||||
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn content_roots_and_excludes_change_without_reopening() {
|
||||
let fx = Fixture::new(&[("src/main.rs", "fn alpha() {}\n"), ("src/gen/out.rs", "fn generated() {}\n")]);
|
||||
@@ -797,13 +779,8 @@ fn incremental_changes_refresh_the_warm_start_snapshot() {
|
||||
let changed = f.write("src/a.rs", "fn renamed() {}\n");
|
||||
idx.update(&[changed], &[]);
|
||||
assert!(idx.wait_idle(WAIT));
|
||||
// The snapshot is written after a short delay, on the worker's next round.
|
||||
let snapshot = f.cache.join("index.snapshot");
|
||||
let deadline = std::time::Instant::now() + WAIT;
|
||||
while !snapshot.exists() && std::time::Instant::now() < deadline {
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
assert!(snapshot.exists(), "a watcher update must regenerate the snapshot");
|
||||
std::thread::sleep(Duration::from_millis(150));
|
||||
assert!(f.cache.join("index.snapshot").exists(), "a watcher update must regenerate the snapshot");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -985,85 +962,3 @@ fn warm_start_sees_edits_deletions_and_renames_made_while_closed() {
|
||||
assert_eq!(idx.status().files, 3);
|
||||
assert_eq!(symbols(&idx, "zzzz", SymbolFilter::All), ["zzzz"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn queries_during_streaming_scan_do_not_deadlock() {
|
||||
// More than `2 * SCAN_BATCH` (4,096) files so a scan both flushes mid-pass
|
||||
// (`publish` -> `data.write()`) and fills the bounded parse channel while
|
||||
// concurrent queries hold `data.read()` and dispatch onto Rayon.
|
||||
const FILES: usize = 4_600;
|
||||
let f = Fixture::new(&[]);
|
||||
for m in 0..32 {
|
||||
std::fs::create_dir_all(f.root.join(format!("mod{m}"))).unwrap();
|
||||
}
|
||||
for i in 0..FILES {
|
||||
std::fs::write(
|
||||
f.root.join(format!("mod{}/File{i}.rs", i % 32)),
|
||||
format!("pub struct Type{i};\npub fn sym{i}() {{}}\n"),
|
||||
)
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
let (done_tx, done_rx) = std::sync::mpsc::channel();
|
||||
std::thread::spawn(move || {
|
||||
let languages = Arc::new(LanguageRegistry::load(None).unwrap());
|
||||
let syntax = Arc::new(Syntax::new());
|
||||
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
|
||||
let idx =
|
||||
ProjectIndex::open(&f.root, &f.cache, Vec::new(), vec![], languages, syntax, Arc::new(NullSink)).unwrap();
|
||||
|
||||
let readers: Vec<_> = (0..4usize)
|
||||
.map(|r| {
|
||||
let idx = idx.clone();
|
||||
let stop = stop.clone();
|
||||
std::thread::spawn(move || {
|
||||
let mut n = r;
|
||||
while !stop.load(Ordering::Relaxed) {
|
||||
match n % 3 {
|
||||
0 => {
|
||||
let _ = idx.find_files("File1", 20);
|
||||
}
|
||||
1 => {
|
||||
let _ = idx.find_dirs("mod", 20);
|
||||
}
|
||||
_ => {
|
||||
let _ = idx.find_symbols("sym1", SymbolFilter::All, 20);
|
||||
}
|
||||
}
|
||||
n = n.wrapping_add(1);
|
||||
}
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
|
||||
assert!(idx.wait_idle(WAIT), "initial streaming scan did not finish");
|
||||
let parsed_before = idx.shared.parsed.load(Ordering::SeqCst);
|
||||
assert_eq!(parsed_before, FILES);
|
||||
|
||||
// Touch every file without changing its contents so `parse_found` takes
|
||||
// the `Extracted::Unchanged` path across multiple `SCAN_BATCH` flushes.
|
||||
let bumped = std::fs::FileTimes::new().set_modified(std::time::SystemTime::now() + Duration::from_secs(10));
|
||||
for i in 0..FILES {
|
||||
let path = f.root.join(format!("mod{}/File{i}.rs", i % 32));
|
||||
std::fs::File::options().write(true).open(path).unwrap().set_times(bumped).unwrap();
|
||||
}
|
||||
idx.shared.enqueue(Job::Rescan);
|
||||
assert!(idx.wait_idle(WAIT), "rescan of unchanged-content files did not finish");
|
||||
assert_eq!(idx.shared.parsed.load(Ordering::SeqCst), parsed_before, "unchanged content is not re-parsed");
|
||||
assert_eq!(symbols(&idx, "sym4599", SymbolFilter::All), ["sym4599"]);
|
||||
|
||||
stop.store(true, Ordering::Relaxed);
|
||||
for h in readers {
|
||||
h.join().unwrap();
|
||||
}
|
||||
assert_eq!(idx.status().files, FILES as u32);
|
||||
drop(idx);
|
||||
|
||||
let reopened = f.open();
|
||||
assert_eq!(reopened.shared.parsed.load(Ordering::SeqCst), 0);
|
||||
assert_eq!(symbols(&reopened, "sym4599", SymbolFilter::All), ["sym4599"]);
|
||||
let _ = done_tx.send(());
|
||||
});
|
||||
|
||||
done_rx.recv_timeout(Duration::from_secs(60)).expect("concurrent index queries deadlocked with streaming scan");
|
||||
}
|
||||
@@ -11,21 +11,9 @@ use rayon::prelude::*;
|
||||
use std::collections::{HashMap, HashSet, VecDeque};
|
||||
use std::io::Read;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::sync::LazyLock;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::time::{Duration, Instant, SystemTime};
|
||||
|
||||
/// Dedicated pool for background indexing and snapshot hydration: queries hold
|
||||
/// `IndexData::read` while scanning on the global Rayon pool, so indexing work
|
||||
/// (which may block on channel backpressure while the index thread waits for
|
||||
/// `IndexData::write`) must never compete for the same workers.
|
||||
static INDEX_POOL: LazyLock<rayon::ThreadPool> = LazyLock::new(|| {
|
||||
rayon::ThreadPoolBuilder::new()
|
||||
.thread_name(|i| format!("openidea-index-{i}"))
|
||||
.build()
|
||||
.expect("cannot build index thread pool")
|
||||
});
|
||||
|
||||
/// Files larger than this are listed but not parsed for symbols.
|
||||
pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
|
||||
const CHUNK: usize = 512;
|
||||
@@ -266,19 +254,17 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
let build_started = Instant::now();
|
||||
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = INDEX_POOL.install(|| {
|
||||
(0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.map(|i| {
|
||||
let path = root.join(snapshot.rel(i));
|
||||
let meta = std::fs::symlink_metadata(&path).ok()?;
|
||||
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
|
||||
return None;
|
||||
}
|
||||
Some(snapshot.entry(i, root))
|
||||
})
|
||||
.collect()
|
||||
});
|
||||
let entries: Vec<Option<(FileEntry, Vec<StoredSymbol>)>> = (0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.map(|i| {
|
||||
let path = root.join(snapshot.rel(i));
|
||||
let meta = std::fs::symlink_metadata(&path).ok()?;
|
||||
if !meta.is_file() || mtime_of(&meta) != snapshot.mtime(i) || meta.len() != snapshot.size(i) {
|
||||
return None;
|
||||
}
|
||||
Some(snapshot.entry(i, root))
|
||||
})
|
||||
.collect();
|
||||
let built = build_started.elapsed();
|
||||
if entries.iter().any(Option::is_none) {
|
||||
return false;
|
||||
@@ -347,19 +333,17 @@ impl Shared {
|
||||
let started = Instant::now();
|
||||
match store.load_snapshot() {
|
||||
Some(snapshot) => {
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
|
||||
(0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.filter_map(|i| {
|
||||
let rel = snapshot.rel(i);
|
||||
if !safe_rel(rel) {
|
||||
return None;
|
||||
}
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
|
||||
})
|
||||
.collect()
|
||||
});
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = (0..snapshot.len())
|
||||
.into_par_iter()
|
||||
.filter_map(|i| {
|
||||
let rel = snapshot.rel(i);
|
||||
if !safe_rel(rel) {
|
||||
return None;
|
||||
}
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path()).then(|| snapshot.entry(i, &root))
|
||||
})
|
||||
.collect();
|
||||
let mut d = self.data.write();
|
||||
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
|
||||
d.reserve(entries.len(), symbols, 0);
|
||||
@@ -379,18 +363,16 @@ impl Shared {
|
||||
Ok(records) => {
|
||||
// Fallback for an index that changed since the snapshot: redb
|
||||
// records are decoded one file at a time and filtered by the walk.
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = INDEX_POOL.install(|| {
|
||||
records
|
||||
.into_par_iter()
|
||||
.filter(|(rel, _)| {
|
||||
safe_rel(rel) && {
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path())
|
||||
}
|
||||
})
|
||||
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
|
||||
.collect()
|
||||
});
|
||||
let entries: Vec<(FileEntry, Vec<StoredSymbol>)> = records
|
||||
.into_par_iter()
|
||||
.filter(|(rel, _)| {
|
||||
safe_rel(rel) && {
|
||||
let path = root.join(rel);
|
||||
seen.contains(path.as_path())
|
||||
}
|
||||
})
|
||||
.map(|(rel, rec)| FileEntry::new(root.join(&rel), rel, rec))
|
||||
.collect();
|
||||
let mut d = self.data.write();
|
||||
let symbols = entries.iter().map(|(_, symbols)| symbols.len()).sum();
|
||||
d.reserve(entries.len(), symbols, 0);
|
||||
@@ -464,11 +446,10 @@ impl Shared {
|
||||
}
|
||||
let classify_started = Instant::now();
|
||||
let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
|
||||
let (todo, stale) = {
|
||||
let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
|
||||
let d = self.data.read();
|
||||
let todo: Vec<(&Found, Option<ContentHash>)> =
|
||||
found.iter().filter_map(|f| prev_hash_if_stale(&d, f).map(|h| (f, h))).collect();
|
||||
let stale: Vec<PathBuf> = d
|
||||
let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
|
||||
let stale = d
|
||||
.paths()
|
||||
.filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
|
||||
.filter(|p| !seen.contains(p.as_path()))
|
||||
@@ -489,7 +470,7 @@ impl Shared {
|
||||
let total = todo.len();
|
||||
let mut laps = ChunkLaps::default();
|
||||
{
|
||||
// One streaming parallel pass: parse on `INDEX_POOL` without
|
||||
// One streaming parallel pass: parse on the rayon pool without
|
||||
// per-chunk joins (a straggler file at a join's tail idles every
|
||||
// other core), while parsed files flow to this thread to be
|
||||
// inserted and persisted in batches. `filter` moves into the
|
||||
@@ -504,14 +485,12 @@ impl Shared {
|
||||
let pass_started = Instant::now();
|
||||
std::thread::scope(|scope| -> () {
|
||||
scope.spawn(move || {
|
||||
INDEX_POOL.install(|| {
|
||||
todo.par_iter().for_each(|&(f, prev_hash)| {
|
||||
if cancelled.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let Some(out) = self.parse_found(f, prev_hash, &filter) else { return };
|
||||
let _ = tx.send(out);
|
||||
});
|
||||
todo.par_iter().for_each(|f| {
|
||||
if cancelled.load(Ordering::Relaxed) {
|
||||
return;
|
||||
}
|
||||
let Some(out) = self.parse_found(f, &filter, false) else { return };
|
||||
let _ = tx.send(out);
|
||||
});
|
||||
// `tx` drops here: the consumer's loop ends with the channel.
|
||||
});
|
||||
@@ -591,13 +570,13 @@ impl Shared {
|
||||
}
|
||||
|
||||
/// Extracts records in parallel, then publishes them to memory and disk.
|
||||
fn index_files(&self, files: &[(Found, Option<ContentHash>)]) -> ChunkLaps {
|
||||
/// `force` re-parses files whose content is unchanged (their language changed).
|
||||
fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
|
||||
let mut laps = ChunkLaps::default();
|
||||
let files: Vec<&Found> = files.collect();
|
||||
let filter = self.filter();
|
||||
let started = Instant::now();
|
||||
let extracted: Vec<ParsedFile> = INDEX_POOL.install(|| {
|
||||
files.par_iter().filter_map(|(f, prev_hash)| self.parse_found(f, *prev_hash, &filter)).collect()
|
||||
});
|
||||
let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
|
||||
laps.extract = started.elapsed();
|
||||
if extracted.is_empty() {
|
||||
return laps;
|
||||
@@ -606,69 +585,49 @@ impl Shared {
|
||||
laps
|
||||
}
|
||||
|
||||
/// Reads and parses one file on `INDEX_POOL` without locking `self.data`,
|
||||
/// serializing new records for the cache alongside the parse. `None` when
|
||||
/// the file is outside the scope or the scan was cancelled.
|
||||
fn parse_found(
|
||||
&self,
|
||||
f: &Found,
|
||||
prev_hash: Option<ContentHash>,
|
||||
filter: &std::sync::Arc<PathFilter>,
|
||||
) -> Option<ParsedFile> {
|
||||
/// Reads and parses one file (parallel-safe), serializing its record for
|
||||
/// the cache alongside the parse. `None` when the file is outside the
|
||||
/// scope or the scan was cancelled.
|
||||
fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
|
||||
if self.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
let rel = filter.rel(&f.path)?;
|
||||
let key = filter.store_key(&f.path);
|
||||
let outcome = match self.extract(f, prev_hash) {
|
||||
Extracted::Unchanged => ParsedOutcome::Unchanged { mtime: f.mtime, size: f.size, ignored: f.ignored },
|
||||
Extracted::New(rec) => {
|
||||
let bytes = key.as_ref().and_then(|_| postcard::to_allocvec(&rec).ok());
|
||||
ParsedOutcome::New { rec, bytes }
|
||||
let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
|
||||
let rec = match self.extract(f, prev_hash) {
|
||||
Extracted::Unchanged => {
|
||||
// Same content, new mtime: keep the symbols, refresh metadata.
|
||||
let mut rec = self.data.read().record_of(&f.path)?;
|
||||
rec.mtime = f.mtime;
|
||||
rec.size = f.size;
|
||||
rec.ignored = f.ignored;
|
||||
rec
|
||||
}
|
||||
Extracted::New(rec) => rec,
|
||||
};
|
||||
Some(ParsedFile { rel, key, outcome, path: f.path.clone() })
|
||||
let key = filter.store_key(&f.path);
|
||||
let bytes = postcard::to_allocvec(&rec).ok();
|
||||
Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
|
||||
}
|
||||
|
||||
/// Inserts a parsed batch into the in-memory index and persists the records.
|
||||
fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
|
||||
let mut laps = ChunkLaps::default();
|
||||
let started = Instant::now();
|
||||
let mut inserts: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
|
||||
let mut refreshes: Vec<MetadataRefresh> = Vec::new();
|
||||
let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
|
||||
let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
|
||||
for out in batch {
|
||||
let ParsedFile { rel, key, outcome, path } = out;
|
||||
match outcome {
|
||||
ParsedOutcome::New { rec, bytes } => {
|
||||
if let (Some(key), Some(bytes)) = (key, bytes) {
|
||||
puts.push((key, bytes));
|
||||
}
|
||||
inserts.push(FileEntry::new(path, rel, rec));
|
||||
}
|
||||
ParsedOutcome::Unchanged { mtime, size, ignored } => {
|
||||
refreshes.push(MetadataRefresh { path, key, mtime, size, ignored });
|
||||
}
|
||||
let ParsedFile { rel, rec, key, bytes, path } = out;
|
||||
if let (Some(key), Some(bytes)) = (key, bytes) {
|
||||
puts.push((key, bytes));
|
||||
}
|
||||
entries.push(FileEntry::new(path, rel, rec));
|
||||
}
|
||||
let mut refreshed_records: Vec<(String, FileRecord)> = Vec::new();
|
||||
{
|
||||
let mut d = self.data.write();
|
||||
for (e, symbols) in inserts {
|
||||
for (e, symbols) in entries {
|
||||
d.insert(e, symbols);
|
||||
}
|
||||
for r in refreshes {
|
||||
if let Some(rec) = d.refresh_metadata(&r.path, r.mtime, r.size, r.ignored)
|
||||
&& let Some(key) = r.key
|
||||
{
|
||||
refreshed_records.push((key, rec));
|
||||
}
|
||||
}
|
||||
}
|
||||
for (key, rec) in refreshed_records {
|
||||
if let Ok(bytes) = postcard::to_allocvec(&rec) {
|
||||
puts.push((key, bytes));
|
||||
}
|
||||
}
|
||||
laps.insert = started.elapsed();
|
||||
let started = Instant::now();
|
||||
@@ -859,9 +818,9 @@ impl Shared {
|
||||
for (dir, wanted) in by_dir {
|
||||
files.extend(filter.list_dir(&dir).into_iter().filter(|f| wanted.contains(&f.path)));
|
||||
}
|
||||
let files: Vec<(Found, Option<ContentHash>)> = {
|
||||
let files: Vec<Found> = {
|
||||
let d = self.data.read();
|
||||
files.into_iter().filter_map(|f| prev_hash_if_stale(&d, &f).map(|h| (f, h))).collect()
|
||||
files.into_iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect()
|
||||
};
|
||||
if !files.is_empty() {
|
||||
touched = true;
|
||||
@@ -869,17 +828,17 @@ impl Shared {
|
||||
if self.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
self.index_files(chunk);
|
||||
self.index_files(chunk.iter(), false);
|
||||
}
|
||||
}
|
||||
for before in reparse {
|
||||
let affected: Vec<(Found, Option<ContentHash>)> = {
|
||||
let affected: Vec<Found> = {
|
||||
let d = self.data.read();
|
||||
d.paths()
|
||||
.filter(|p| before.detect(p, None) != self.languages.detect(p, None))
|
||||
.filter_map(|p| {
|
||||
let e = d.get(p)?;
|
||||
Some((Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored }, None))
|
||||
Some(Found { path: p.clone(), mtime: e.mtime, size: e.size, ignored: e.ignored })
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
@@ -889,7 +848,7 @@ impl Shared {
|
||||
if self.is_cancelled() {
|
||||
return;
|
||||
}
|
||||
self.index_files(chunk);
|
||||
self.index_files(chunk.iter(), true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -907,18 +866,6 @@ impl Shared {
|
||||
}
|
||||
}
|
||||
|
||||
type ContentHash = [u8; 32];
|
||||
|
||||
/// `Some(prev_hash)` when `f` is missing or stale in `d` (`None` inner hash when
|
||||
/// the file must be parsed fresh); `None` when `d` is already current for `f`.
|
||||
fn prev_hash_if_stale(d: &IndexData, f: &Found) -> Option<Option<ContentHash>> {
|
||||
match d.get(&f.path) {
|
||||
None => Some(None),
|
||||
Some(e) if e.stale_for(f) => Some((!e.ignored).then_some(e.hash)),
|
||||
Some(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The first line, capped at 256 bytes (for shebang / `<?xml` detection).
|
||||
fn first_line(text: &str) -> &str {
|
||||
let line = text.lines().next().unwrap_or_default();
|
||||
@@ -951,26 +898,14 @@ impl ChunkLaps {
|
||||
}
|
||||
}
|
||||
|
||||
struct MetadataRefresh {
|
||||
path: PathBuf,
|
||||
key: Option<String>,
|
||||
mtime: u64,
|
||||
size: u64,
|
||||
ignored: bool,
|
||||
}
|
||||
|
||||
enum ParsedOutcome {
|
||||
Unchanged { mtime: u64, size: u64, ignored: bool },
|
||||
New { rec: FileRecord, bytes: Option<Vec<u8>> },
|
||||
}
|
||||
|
||||
/// One file parsed off the index thread: its outcome ready to publish, with new
|
||||
/// records already serialized for the cache in parallel with the parse.
|
||||
/// One file parsed off the index thread: its record ready to publish, already
|
||||
/// serialized for the cache (in parallel with the parse).
|
||||
struct ParsedFile {
|
||||
rel: String,
|
||||
/// Cache key; `None` when outside the persisted root.
|
||||
rec: FileRecord,
|
||||
/// Cache key and postcard bytes; `None` when outside the persisted root.
|
||||
key: Option<String>,
|
||||
outcome: ParsedOutcome,
|
||||
bytes: Option<Vec<u8>>,
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
|
||||
@@ -194,9 +194,6 @@ pub mod codes {
|
||||
pub const METHOD_NOT_FOUND: i64 = -32601;
|
||||
pub const INVALID_PARAMS: i64 = -32602;
|
||||
pub const INTERNAL_ERROR: i64 = -32603;
|
||||
/// LSP `RequestFailed`: the request was understood and could not be carried out; the
|
||||
/// message says why.
|
||||
pub const REQUEST_FAILED: i64 = -32803;
|
||||
/// LSP `ServerCancelled`.
|
||||
pub const SERVER_CANCELLED: i64 = -32802;
|
||||
/// LSP `ContentModified`.
|
||||
@@ -218,18 +215,12 @@ pub trait Handler: Send + Sync + 'static {
|
||||
/// Respond to a server→client request (e.g. `workspace/configuration`).
|
||||
fn on_request(&self, method: &str, params: Value) -> Result<Value, (i64, String)>;
|
||||
|
||||
/// [`on_request`](Self::on_request) for handlers whose errors carry `data`.
|
||||
/// [`on_request`](Self::on_request) for handlers whose errors carry `data`. This is the
|
||||
/// one the connection calls.
|
||||
fn on_request_with_data(&self, method: &str, params: Value) -> Result<Value, (i64, String, Option<Value>)> {
|
||||
self.on_request(method, params).map_err(|(code, message)| (code, message, None))
|
||||
}
|
||||
|
||||
/// [`on_request_with_data`](Self::on_request_with_data) with the request as received, for
|
||||
/// handlers that need what `Value` drops, such as the order of an object's keys. This is the
|
||||
/// one the connection calls.
|
||||
fn on_request_raw(&self, method: &str, params: Value, _raw: &[u8]) -> Result<Value, (i64, String, Option<Value>)> {
|
||||
self.on_request_with_data(method, params)
|
||||
}
|
||||
|
||||
/// Called once the response to a `method` request is queued: what it sends follows the response.
|
||||
fn after_response(&self, _method: &str) {}
|
||||
|
||||
@@ -586,8 +577,8 @@ impl Peer {
|
||||
tracing::error!("jsonrpc notification handler panicked on {method}");
|
||||
}
|
||||
}
|
||||
Incoming::Request(id, method, params, raw) => {
|
||||
runtime.spawn(handle_request(inner.clone(), handler.clone(), id, method, params, raw));
|
||||
Incoming::Request(id, method, params) => {
|
||||
runtime.spawn(handle_request(inner.clone(), handler.clone(), id, method, params));
|
||||
}
|
||||
Incoming::Response(tx, result) => {
|
||||
let _ = tx.send(result);
|
||||
@@ -770,21 +761,14 @@ fn parse_id(id: &Value) -> Option<i64> {
|
||||
|
||||
enum Incoming {
|
||||
Notification(String, Value),
|
||||
Request(Value, String, Value, Arc<[u8]>),
|
||||
Request(Value, String, Value),
|
||||
Response(oneshot::Sender<Result<Value, RpcError>>, Result<Value, RpcError>),
|
||||
}
|
||||
|
||||
async fn handle_request(
|
||||
inner: Arc<Inner>,
|
||||
handler: Arc<dyn Handler>,
|
||||
id: Value,
|
||||
method: String,
|
||||
params: Value,
|
||||
raw: Arc<[u8]>,
|
||||
) {
|
||||
async fn handle_request(inner: Arc<Inner>, handler: Arc<dyn Handler>, id: Value, method: String, params: Value) {
|
||||
let m = method.clone();
|
||||
let h = handler.clone();
|
||||
let result = tokio::task::spawn_blocking(move || h.on_request_raw(&m, params, &raw)).await;
|
||||
let result = tokio::task::spawn_blocking(move || h.on_request_with_data(&m, params)).await;
|
||||
let reply = match result {
|
||||
Ok(Ok(result)) => json!({ "jsonrpc": "2.0", "id": id, "result": result }),
|
||||
Ok(Err((code, message, data))) => {
|
||||
@@ -824,7 +808,7 @@ fn dispatch(inner: &Arc<Inner>, handler: &dyn Handler, notif_tx: &std::sync::mps
|
||||
let params = obj.remove("params").unwrap_or(Value::Null);
|
||||
match id {
|
||||
Some(id) if !id.is_null() => {
|
||||
let _ = notif_tx.send(Incoming::Request(id, method, params, Arc::from(body)));
|
||||
let _ = notif_tx.send(Incoming::Request(id, method, params));
|
||||
}
|
||||
_ => {
|
||||
let _ = notif_tx.send(Incoming::Notification(method, params));
|
||||
|
||||
@@ -170,11 +170,6 @@ pub struct LanguageServerConfig {
|
||||
/// basedpyright): only used while none of those is installed.
|
||||
#[serde(default)]
|
||||
pub fallback: bool,
|
||||
/// Names of servers listed after this one that it makes redundant (a PHP server
|
||||
/// with its own Laravel support replaces `laravel-lsp`): they aren't used while
|
||||
/// this one serves the file.
|
||||
#[serde(default)]
|
||||
pub replaces: Vec<String>,
|
||||
/// What the server is used for (`completion`, `code-action`, `diagnostics`,
|
||||
/// … `FEATURES` in `ide-lsp/src/caps.rs`); empty means everything. The other
|
||||
/// capabilities it announces are ignored, so a refactoring-only server next
|
||||
|
||||
@@ -33,7 +33,6 @@ const BUILTIN: &[(&str, &str)] = &[
|
||||
("gdscript", include_str!("../../../languages/gdscript.toml")),
|
||||
("gdshader", include_str!("../../../languages/gdshader.toml")),
|
||||
("go", include_str!("../../../languages/go.toml")),
|
||||
("gherkin", include_str!("../../../languages/gherkin.toml")),
|
||||
("gomod", include_str!("../../../languages/gomod.toml")),
|
||||
("gowork", include_str!("../../../languages/gowork.toml")),
|
||||
("godot-resource", include_str!("../../../languages/godot-resource.toml")),
|
||||
@@ -679,7 +678,7 @@ mod tests {
|
||||
let got: Vec<(&str, bool)> = cfg
|
||||
.language_servers
|
||||
.iter()
|
||||
.filter(|s| !s.require_root_marker && s.features.is_empty())
|
||||
.filter(|s| !s.require_root_marker)
|
||||
.map(|s| (s.name.as_str(), s.fallback))
|
||||
.collect();
|
||||
let expected: Vec<(&str, bool)> = servers.iter().enumerate().map(|(i, name)| (*name, i > 0)).collect();
|
||||
@@ -759,10 +758,7 @@ mod tests {
|
||||
let cfg = reg.get(&LanguageId::new("php")).unwrap();
|
||||
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
|
||||
// After the fallback: hover, rename and symbols stay with Intelephense.
|
||||
assert_eq!(names, ["intelephense", "phpactor", "phoxite", "laravel-lsp"]);
|
||||
// Phoxite answers the Laravel strings itself.
|
||||
let phoxite = cfg.language_servers.iter().find(|s| s.name == "phoxite").unwrap();
|
||||
assert!(phoxite.fallback && phoxite.replaces == ["laravel-lsp"]);
|
||||
assert_eq!(names, ["intelephense", "phpactor", "laravel-lsp"]);
|
||||
let lsp = cfg.language_servers.iter().find(|s| s.name == "laravel-lsp").unwrap();
|
||||
assert_eq!(lsp.command.as_str(), "laravel-lsp");
|
||||
// Its `lsp` command takes no options and speaks over stdio; `--stdio` stops it at startup.
|
||||
@@ -779,26 +775,13 @@ mod tests {
|
||||
assert_eq!(served("lib/src/Parser.php"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pylsp_adds_only_rope_refactorings_to_python() {
|
||||
let reg = reg();
|
||||
let cfg = reg.get(&LanguageId::new("python")).unwrap();
|
||||
let pylsp = cfg.language_servers.iter().find(|s| s.name == "pylsp").unwrap();
|
||||
assert!(!pylsp.fallback && !pylsp.require_root_marker);
|
||||
assert_eq!(pylsp.features, ["code-action"]);
|
||||
assert_eq!(pylsp.code_action_kinds, ["refactor"]);
|
||||
let plugins = pylsp.initialization_options.as_ref().unwrap()["pylsp"]["plugins"].as_table().unwrap();
|
||||
assert_eq!(plugins["jedi_completion"]["enabled"].as_bool(), Some(false));
|
||||
assert!(plugins.values().all(|p| p["enabled"].as_bool() == Some(false)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ruff_serves_python_files_only_below_its_config() {
|
||||
let reg = reg();
|
||||
let cfg = reg.get(&LanguageId::new("python")).unwrap();
|
||||
let names: Vec<&str> = cfg.language_servers.iter().map(|s| s.name.as_str()).collect();
|
||||
// After the fallbacks: hover, rename and symbols stay with the type checker.
|
||||
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff", "pylsp"]);
|
||||
assert_eq!(names, ["basedpyright", "pyright", "ty", "pyrefly", "ruff"]);
|
||||
let ruff = cfg.language_servers.iter().find(|s| s.name == "ruff").unwrap();
|
||||
assert_eq!((ruff.command.as_str(), ruff.args.as_slice()), ("ruff", ["server".to_string()].as_slice()));
|
||||
assert!(ruff.require_root_marker && !ruff.fallback);
|
||||
@@ -1071,7 +1054,6 @@ mod tests {
|
||||
("CMakeLists.txt", "cmake"),
|
||||
("api.proto", "proto"),
|
||||
("schema.graphql", "graphql"),
|
||||
("checkout.feature", "gherkin"),
|
||||
("schema.prisma", "prisma"),
|
||||
("main.tf", "terraform"),
|
||||
("prod.tfvars", "terraform-vars"),
|
||||
|
||||
@@ -6,15 +6,11 @@
|
||||
|
||||
use crate::LspManager;
|
||||
use crate::server::Server;
|
||||
use ide_core::{CancellationToken, DocId, Pos, Range};
|
||||
use ide_core::{DocId, Pos, Range};
|
||||
use serde::Deserialize;
|
||||
use std::collections::HashMap;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::time::Duration;
|
||||
use tokio::io::AsyncReadExt;
|
||||
|
||||
pub(crate) const CHECK_UPGRADES: &str = "gopls.check_upgrades";
|
||||
/// gopls answers code lenses once it has loaded the module.
|
||||
@@ -22,43 +18,6 @@ const ATTEMPTS: u32 = 10;
|
||||
const RETRY: Duration = Duration::from_secs(2);
|
||||
/// Producer of the deprecation diagnostics (one full set per go.mod).
|
||||
const DEPRECATIONS: &str = "go-mod-deprecations";
|
||||
// This optional background check must not wait indefinitely on a proxy or toolchain download.
|
||||
const QUERY_TIMEOUT: Duration = Duration::from_secs(60);
|
||||
const OUTPUT_LIMIT: u64 = 8 * 1024 * 1024;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct Queries {
|
||||
generation: u64,
|
||||
running: HashMap<DocId, (u64, CancellationToken)>,
|
||||
}
|
||||
|
||||
impl Queries {
|
||||
fn begin(&mut self, doc: DocId) -> (u64, CancellationToken) {
|
||||
self.cancel(doc);
|
||||
self.generation += 1;
|
||||
let cancel = CancellationToken::new();
|
||||
self.running.insert(doc, (self.generation, cancel.clone()));
|
||||
(self.generation, cancel)
|
||||
}
|
||||
|
||||
fn finish(&mut self, doc: DocId, generation: u64) {
|
||||
if self.running.get(&doc).is_some_and(|(current, _)| *current == generation) {
|
||||
self.running.remove(&doc);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn cancel(&mut self, doc: DocId) {
|
||||
if let Some((_, cancel)) = self.running.remove(&doc) {
|
||||
cancel.cancel();
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn cancel_all(&mut self) {
|
||||
for (_, (_, cancel)) in self.running.drain() {
|
||||
cancel.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn is_go_mod(path: &Path) -> bool {
|
||||
path.file_name().is_some_and(|n| n == "go.mod")
|
||||
@@ -107,15 +66,6 @@ impl LspManager {
|
||||
}
|
||||
|
||||
async fn report_deprecated_modules(&self, doc: DocId, server: &Server) {
|
||||
let (generation, cancel) = self.go_mod_queries.lock().begin(doc);
|
||||
self.report_deprecated_modules_query(doc, server, &cancel).await;
|
||||
self.go_mod_queries.lock().finish(doc, generation);
|
||||
}
|
||||
|
||||
async fn report_deprecated_modules_query(&self, doc: DocId, server: &Server, cancel: &CancellationToken) {
|
||||
if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {
|
||||
return;
|
||||
}
|
||||
let Some((path, text)) = self.docs.lock().get(&doc).map(|d| (d.path.clone(), d.text.as_str().to_owned()))
|
||||
else {
|
||||
return;
|
||||
@@ -128,9 +78,10 @@ impl LspManager {
|
||||
let search = crate::launch::server_search_path(&config);
|
||||
let Some(dir) = path.parent().map(Path::to_path_buf) else { return };
|
||||
let modules: Vec<String> = required.iter().map(|r| r.path.clone()).collect();
|
||||
let Some(deprecated) = list_deprecations(&dir, &search, &modules, cancel).await else { return };
|
||||
let listed = tokio::task::spawn_blocking(move || list_deprecations(&dir, &search, &modules)).await;
|
||||
let Ok(Some(deprecated)) = listed else { return };
|
||||
// The document changed meanwhile: its own save runs again.
|
||||
if cancel.is_cancelled() || self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
|
||||
if self.docs.lock().get(&doc).is_none_or(|d| d.text.as_str() != text) {
|
||||
return;
|
||||
}
|
||||
let items = required
|
||||
@@ -206,100 +157,22 @@ struct ListedModule {
|
||||
}
|
||||
|
||||
/// `(module, message)` of each deprecated module in `modules`; `None` when `go` failed.
|
||||
async fn list_deprecations(
|
||||
dir: &Path,
|
||||
search: &std::ffi::OsStr,
|
||||
modules: &[String],
|
||||
cancel: &CancellationToken,
|
||||
) -> Option<Vec<(String, String)>> {
|
||||
let (dir, search, modules) = (dir.to_path_buf(), search.to_owned(), modules.to_vec());
|
||||
let command = tokio::task::spawn_blocking(move || {
|
||||
let go: PathBuf = ide_core::tool_path::find_command("go", &search, &dir)?;
|
||||
let mut command = Command::new(go);
|
||||
command.args(["list", "-m", "-u", "-e", "-json"]).args(modules).current_dir(dir).env("PATH", search);
|
||||
Some(command)
|
||||
})
|
||||
.await
|
||||
.ok()??;
|
||||
let output = run_query(command, cancel, QUERY_TIMEOUT).await?;
|
||||
if output.is_empty() {
|
||||
fn list_deprecations(dir: &Path, search: &std::ffi::OsStr, modules: &[String]) -> Option<Vec<(String, String)>> {
|
||||
let go: PathBuf = ide_core::tool_path::find_command("go", search, dir)?;
|
||||
let output = ide_core::process::prepare(&mut std::process::Command::new(go))
|
||||
.args(["list", "-m", "-u", "-e", "-json"])
|
||||
.args(modules)
|
||||
.current_dir(dir)
|
||||
.env("PATH", search)
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stderr(std::process::Stdio::null())
|
||||
.output()
|
||||
.ok()?;
|
||||
if output.stdout.is_empty() {
|
||||
tracing::debug!("go list -m -u in {}: {}", dir.display(), output.status);
|
||||
return None;
|
||||
}
|
||||
tokio::task::spawn_blocking(move || parse_deprecations(&output)).await.ok()
|
||||
}
|
||||
|
||||
async fn run_query(command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
|
||||
let cancel = cancel.child_token();
|
||||
let _cancel_on_drop = cancel.clone().drop_guard();
|
||||
// The supervisor owns cleanup even if the caller's future is dropped.
|
||||
tokio::spawn(async move { supervise_query(command, &cancel, timeout).await }).await.ok().flatten()
|
||||
}
|
||||
|
||||
async fn supervise_query(mut command: Command, cancel: &CancellationToken, timeout: Duration) -> Option<Vec<u8>> {
|
||||
if cancel.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
ide_core::process::prepare(&mut command);
|
||||
ide_core::process::own_group(&mut command);
|
||||
command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
|
||||
let mut command = tokio::process::Command::from(command);
|
||||
command.kill_on_drop(true);
|
||||
let mut child = command.spawn().ok()?;
|
||||
#[cfg(windows)]
|
||||
let job = child.id().and_then(ide_core::process::Job::for_pid);
|
||||
let stdout = child.stdout.take()?;
|
||||
let mut reader = tokio::spawn(async move {
|
||||
let mut output = Vec::new();
|
||||
stdout.take(OUTPUT_LIMIT + 1).read_to_end(&mut output).await.ok()?;
|
||||
if output.len() as u64 > OUTPUT_LIMIT {
|
||||
tracing::debug!("go module query exceeded stdout budget");
|
||||
return None;
|
||||
}
|
||||
Some(output)
|
||||
});
|
||||
let deadline = tokio::time::sleep(timeout);
|
||||
tokio::pin!(deadline);
|
||||
// Drain before reaping: if a descendant holds stdout open, the root's id
|
||||
// still belongs to this child when cancellation kills its process tree.
|
||||
let output = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => None,
|
||||
() = &mut deadline => {
|
||||
tracing::debug!("go module query timed out");
|
||||
None
|
||||
},
|
||||
result = &mut reader => result.ok().flatten(),
|
||||
};
|
||||
if let Some(bytes) = output {
|
||||
let status = tokio::select! {
|
||||
biased;
|
||||
() = cancel.cancelled() => None,
|
||||
() = &mut deadline => {
|
||||
tracing::debug!("go module query timed out");
|
||||
None
|
||||
},
|
||||
status = child.wait() => Some(status),
|
||||
};
|
||||
if let Some(status) = status {
|
||||
return status.ok().map(|_| bytes);
|
||||
}
|
||||
}
|
||||
// The root is still unreaped here, so its process/group id cannot be reused.
|
||||
if let Some(pid) = child.id() {
|
||||
let _ = tokio::task::spawn_blocking(move || {
|
||||
#[cfg(windows)]
|
||||
if let Some(job) = job {
|
||||
job.terminate();
|
||||
return;
|
||||
}
|
||||
ide_core::process::kill_tree_of(pid);
|
||||
})
|
||||
.await;
|
||||
}
|
||||
let _ = child.start_kill();
|
||||
let _ = child.wait().await;
|
||||
reader.abort();
|
||||
None
|
||||
Some(parse_deprecations(&output.stdout))
|
||||
}
|
||||
|
||||
fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
|
||||
@@ -314,231 +187,6 @@ fn parse_deprecations(json: &[u8]) -> Vec<(String, String)> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn queries_cancel_only_the_superseded_document() {
|
||||
let mut queries = Queries::default();
|
||||
let (first, old) = queries.begin(DocId(1));
|
||||
let (_, other) = queries.begin(DocId(2));
|
||||
let (second, new) = queries.begin(DocId(1));
|
||||
assert!(old.is_cancelled());
|
||||
assert!(!other.is_cancelled());
|
||||
assert!(!new.is_cancelled());
|
||||
queries.finish(DocId(1), first);
|
||||
assert_eq!(queries.running.len(), 2);
|
||||
queries.finish(DocId(1), second);
|
||||
assert_eq!(queries.running.len(), 1);
|
||||
queries.cancel_all();
|
||||
assert!(other.is_cancelled());
|
||||
assert!(queries.running.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn closing_one_document_does_not_cancel_another() {
|
||||
let mut queries = Queries::default();
|
||||
let (_, closed) = queries.begin(DocId(1));
|
||||
let (_, other) = queries.begin(DocId(2));
|
||||
queries.cancel(DocId(1));
|
||||
assert!(closed.is_cancelled());
|
||||
assert!(!other.is_cancelled());
|
||||
assert_eq!(queries.running.len(), 1);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn shell(script: &str) -> Command {
|
||||
let mut command = Command::new("sh");
|
||||
command.args(["-c", script]);
|
||||
command
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
async fn assert_stopped(pid: u32) {
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while let Ok(stat) = std::fs::read_to_string(format!("/proc/{pid}/stat")) {
|
||||
if stat.rsplit_once(") ").unwrap().1.split_whitespace().next() == Some("Z") {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn cancelled_query_never_spawns() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let cancel = CancellationToken::new();
|
||||
cancel.cancel();
|
||||
let mut command = shell("touch started");
|
||||
command.current_dir(dir.path());
|
||||
assert!(run_query(command, &cancel, Duration::from_secs(5)).await.is_none());
|
||||
assert!(!dir.path().join("started").exists());
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn queries_keep_working_directories_and_environments_separate() {
|
||||
let a = tempfile::tempdir().unwrap();
|
||||
let b = tempfile::tempdir().unwrap();
|
||||
std::fs::write(a.path().join("value"), "directory-a").unwrap();
|
||||
std::fs::write(b.path().join("value"), "directory-b").unwrap();
|
||||
let mut ca = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
|
||||
ca.current_dir(a.path()).env("QUERY_VALUE", "env-a");
|
||||
let mut cb = shell("printf '%s:' \"$QUERY_VALUE\"; cat value");
|
||||
cb.current_dir(b.path()).env("QUERY_VALUE", "env-b");
|
||||
let cancel = CancellationToken::new();
|
||||
let (a, b) = tokio::join!(
|
||||
run_query(ca, &cancel, Duration::from_secs(5)),
|
||||
run_query(cb, &cancel, Duration::from_secs(5)),
|
||||
);
|
||||
assert_eq!(a.unwrap(), b"env-a:directory-a");
|
||||
assert_eq!(b.unwrap(), b"env-b:directory-b");
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn timeout_kills_and_reaps_the_query() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("echo $$ > pid; exec sleep 2");
|
||||
command.current_dir(dir.path());
|
||||
let output = run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await;
|
||||
assert!(output.is_none());
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
|
||||
assert!(!ide_core::process::process_alive(pid));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn cancellation_kills_the_running_query_and_its_child() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("sleep 30 & echo $$ $! > pids; wait");
|
||||
command.current_dir(dir.path());
|
||||
let cancel = CancellationToken::new();
|
||||
let token = cancel.clone();
|
||||
let task = tokio::spawn(async move { run_query(command, &token, Duration::from_secs(10)).await });
|
||||
let pids = dir.path().join("pids");
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !std::fs::read_to_string(&pids).is_ok_and(|s| s.split_whitespace().count() == 2) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let text = std::fs::read_to_string(pids).unwrap();
|
||||
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
|
||||
cancel.cancel();
|
||||
assert!(task.await.unwrap().is_none());
|
||||
assert!(!ide_core::process::process_alive(pids[0]));
|
||||
// An orphaned child may remain a zombie until the host's init reaps it.
|
||||
#[cfg(target_os = "linux")]
|
||||
assert_stopped(pids[1]).await;
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while ide_core::process::process_alive(pids[1]) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn dropping_the_caller_still_reaps_its_query() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("sleep 30 & echo $$ $! > pid; wait");
|
||||
command.current_dir(dir.path());
|
||||
let task =
|
||||
tokio::spawn(async move { run_query(command, &CancellationToken::new(), Duration::from_secs(10)).await });
|
||||
let file = dir.path().join("pid");
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while !std::fs::read_to_string(&file).is_ok_and(|s| s.split_whitespace().count() == 2) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let text = std::fs::read_to_string(file).unwrap();
|
||||
let pids: Vec<u32> = text.split_whitespace().map(|p| p.parse().unwrap()).collect();
|
||||
let pid = pids[0];
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while ide_core::process::process_alive(pid) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
#[cfg(target_os = "linux")]
|
||||
assert_stopped(pids[1]).await;
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while ide_core::process::process_alive(pids[1]) {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
#[tokio::test]
|
||||
async fn timeout_cleans_up_a_child_holding_stdout_after_root_exit() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("sleep 30 & echo $! > pid; exit 0");
|
||||
command.current_dir(dir.path());
|
||||
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(1)).await.is_none());
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap();
|
||||
assert_stopped(pid.trim().parse().unwrap()).await;
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn output_at_the_limit_is_not_truncated() {
|
||||
let output = run_query(shell("head -c 8388608 /dev/zero"), &CancellationToken::new(), Duration::from_secs(5))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(output.len() as u64, OUTPUT_LIMIT);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn oversized_output_kills_the_query() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut command = shell("echo $$ > pid; head -c 8388609 /dev/zero; exec sleep 30");
|
||||
command.current_dir(dir.path());
|
||||
assert!(run_query(command, &CancellationToken::new(), Duration::from_secs(5)).await.is_none());
|
||||
let pid = std::fs::read_to_string(dir.path().join("pid")).unwrap().trim().parse().unwrap();
|
||||
assert!(!ide_core::process::process_alive(pid));
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn preserves_output_from_a_nonzero_exit() {
|
||||
assert_eq!(
|
||||
run_query(shell("printf partial; exit 1"), &CancellationToken::new(), Duration::from_secs(5))
|
||||
.await
|
||||
.unwrap(),
|
||||
b"partial"
|
||||
);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn failed_spawn_does_not_poison_a_following_query() {
|
||||
assert!(
|
||||
run_query(Command::new("/no/such/go-query"), &CancellationToken::new(), Duration::from_secs(5))
|
||||
.await
|
||||
.is_none()
|
||||
);
|
||||
assert_eq!(
|
||||
run_query(shell("printf ok"), &CancellationToken::new(), Duration::from_secs(5)).await.unwrap(),
|
||||
b"ok"
|
||||
);
|
||||
}
|
||||
|
||||
fn at(line: u32, from: u32, to: u32) -> Range {
|
||||
Range { start: Pos { line, col: from }, end: Pos { line, col: to } }
|
||||
}
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
//! Pull Members Up / Push Members Down through the app-owned JDT extension
|
||||
//! (`java/java-usages`), or through Phoxite's own requests when the document's
|
||||
//! server advertises them (`crate::phoxite`). The server checks the move and computes the edit; the UI
|
||||
//! (`java/java-usages`). The server checks the move and computes the edit; the UI
|
||||
//! shows its problems and applies the edit itself.
|
||||
use super::COMMAND_TIMEOUT;
|
||||
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
|
||||
@@ -76,9 +75,6 @@ impl LspManager {
|
||||
kind: HierarchyRefactoring,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<HierarchyMembers> {
|
||||
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
|
||||
return self.phoxite_hierarchy_members(&phoxite, pos, kind, &cancel).await;
|
||||
}
|
||||
let (members, _, _) = self.hierarchy_command(doc, pos, kind, MEMBERS, &[], &cancel).await?;
|
||||
Ok(members)
|
||||
}
|
||||
@@ -93,9 +89,6 @@ impl LspManager {
|
||||
choices: Vec<HierarchyChoice>,
|
||||
cancel: CancellationToken,
|
||||
) -> IdeResult<HierarchyRefactored> {
|
||||
if let Some(phoxite) = self.phoxite_refactor_target(doc).await {
|
||||
return self.phoxite_hierarchy_refactor(&phoxite, pos, kind, target, &choices, &cancel).await;
|
||||
}
|
||||
let choices: Vec<Value> = choices.iter().map(|c| json!({ "id": c.id, "abstract": c.make_abstract })).collect();
|
||||
let (refactored, _, t): (Refactored, _, _) =
|
||||
self.hierarchy_command(doc, pos, kind, REFACTOR, &[json!(target), json!(choices)], &cancel).await?;
|
||||
|
||||
@@ -26,8 +26,6 @@ mod launch;
|
||||
mod library_source;
|
||||
mod loading;
|
||||
mod notebook;
|
||||
mod phoxite;
|
||||
mod plugin_requests;
|
||||
mod pull;
|
||||
mod scope;
|
||||
mod server;
|
||||
@@ -47,7 +45,6 @@ pub use jdtls::jvm_inspect::JdtJvmInspector;
|
||||
pub use kotlin_lsp::{KotlinDebugServer, KotlinDebugUnavailable};
|
||||
pub use launch::{LaunchError, Launcher, ProcessLauncher};
|
||||
pub use notebook::{NotebookCell, NotebookCellDoc, cell_uri};
|
||||
pub use plugin_requests::plugin_method_allowed;
|
||||
pub use scope::{CandidateFiles, CandidateFn, CandidateQuery, MAX_CANDIDATES};
|
||||
pub use uri::{is_virtual_uri, path_to_uri_string, uri_target, uri_to_path};
|
||||
|
||||
@@ -240,7 +237,6 @@ pub struct LspManager {
|
||||
shown_messages: Mutex<HashSet<(String, String)>>,
|
||||
/// go.mod files whose upgrades gopls has been asked to check this session.
|
||||
go_mod_checked: Mutex<HashSet<PathBuf>>,
|
||||
go_mod_queries: Mutex<go_mod::Queries>,
|
||||
/// Virtual (non-`file:`) URIs a server returned, by the server that owns them.
|
||||
virtual_origins: Mutex<HashMap<String, ide_core::ServerId>>,
|
||||
/// Contents fetched for virtual URIs.
|
||||
@@ -517,7 +513,6 @@ impl LspManager {
|
||||
configuration_cache: Arc::new(Mutex::new(Default::default())),
|
||||
shown_messages: Mutex::new(HashSet::new()),
|
||||
go_mod_checked: Mutex::new(HashSet::new()),
|
||||
go_mod_queries: Mutex::new(go_mod::Queries::default()),
|
||||
virtual_origins: Mutex::new(HashMap::new()),
|
||||
virtual_docs: Mutex::new(HashMap::new()),
|
||||
virtual_stamps: Mutex::new(HashMap::new()),
|
||||
@@ -665,17 +660,15 @@ impl LspManager {
|
||||
/// The servers serving `path`: every regular one, and each `fallback` one
|
||||
/// only while all servers listed before it have given up (missing, not
|
||||
/// launchable, or crashed for good). One that requires a root marker serves
|
||||
/// only files below one, and stands in for no other. One that a server before
|
||||
/// it `replaces` is left out while that server serves the file.
|
||||
/// only files below one, and stands in for no other.
|
||||
fn servers_for(&self, language: &LanguageId, path: &Path) -> Vec<Arc<Server>> {
|
||||
if let Some(servers) = self.arduino_servers(language, path) {
|
||||
return servers;
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
let mut available_before = false;
|
||||
let mut replaced: Vec<String> = Vec::new();
|
||||
for sc in &self.language_servers(language) {
|
||||
if (sc.fallback && available_before) || replaced.contains(&sc.name) {
|
||||
if sc.fallback && available_before {
|
||||
continue;
|
||||
}
|
||||
if sc.require_root_marker
|
||||
@@ -685,9 +678,6 @@ impl LspManager {
|
||||
}
|
||||
let server = self.server_for(sc, language, path);
|
||||
available_before |= !sc.require_root_marker && !server.gave_up();
|
||||
if !server.gave_up() {
|
||||
replaced.extend(sc.replaces.iter().cloned());
|
||||
}
|
||||
out.push(server);
|
||||
}
|
||||
out
|
||||
@@ -875,7 +865,7 @@ impl LspManager {
|
||||
ide_core::event::ServerStatus::Missing,
|
||||
Some(message),
|
||||
) {
|
||||
self.fallbacks_take_over().await;
|
||||
self.attach_fallbacks();
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -888,7 +878,7 @@ impl LspManager {
|
||||
ide_core::event::ServerStatus::Misconfigured,
|
||||
Some(message),
|
||||
) {
|
||||
self.fallbacks_take_over().await;
|
||||
self.attach_fallbacks();
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -901,7 +891,7 @@ impl LspManager {
|
||||
ide_core::event::ServerStatus::Crashed,
|
||||
Some(message),
|
||||
) {
|
||||
self.fallbacks_take_over().await;
|
||||
self.attach_fallbacks();
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -1049,7 +1039,7 @@ impl LspManager {
|
||||
}
|
||||
}
|
||||
// Gave up (crashed repeatedly, or its build expired): the fallbacks it hid take over.
|
||||
None => self.fallbacks_take_over().await,
|
||||
None => self.attach_fallbacks(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1395,7 +1385,6 @@ impl LspManager {
|
||||
}
|
||||
|
||||
fn close_document(&self, doc: DocId) {
|
||||
self.go_mod_queries.lock().cancel(doc);
|
||||
let (d, compose_removed) = {
|
||||
let mut docs = self.docs.lock();
|
||||
let Some(d) = docs.remove(&doc) else { return };
|
||||
@@ -3475,10 +3464,7 @@ impl LspManager {
|
||||
virtual_doc::is_decompiled(&text)
|
||||
};
|
||||
let title = title.unwrap_or_else(|| virtual_doc::title(uri, decompiled));
|
||||
let mut detected = self.languages.detect(Path::new(&title), None);
|
||||
if let Some(stem) = title.strip_suffix(".class").filter(|_| virtual_doc::is_java_class_stub(&text)) {
|
||||
detected = self.languages.detect(Path::new(&format!("{stem}.java")), None);
|
||||
}
|
||||
let detected = self.languages.detect(Path::new(&title), None);
|
||||
let language_id = if detected == LanguageId::plain_text() {
|
||||
languages.first().cloned().unwrap_or(detected)
|
||||
} else {
|
||||
@@ -3716,7 +3702,6 @@ impl LspManager {
|
||||
pub fn set_execution_allowed(&self, allowed: bool) {
|
||||
let previous = self.execution_allowed.swap(allowed, Ordering::AcqRel);
|
||||
if !allowed {
|
||||
self.go_mod_queries.lock().cancel_all();
|
||||
for server in self.servers.lock().iter() {
|
||||
server.start_token().cancel();
|
||||
}
|
||||
@@ -3843,16 +3828,8 @@ impl LspManager {
|
||||
}
|
||||
}
|
||||
|
||||
/// A server gave up: its fallbacks take over the open documents, and the servers
|
||||
/// they replace leave.
|
||||
async fn fallbacks_take_over(&self) {
|
||||
self.attach_fallbacks();
|
||||
self.detach_shadowed_fallbacks().await;
|
||||
}
|
||||
|
||||
/// A server enabled again shadows the fallbacks attached in its place, and a
|
||||
/// fallback that took over may replace a server attached earlier: they leave the
|
||||
/// open documents, and stop once no document uses them.
|
||||
/// A server enabled again shadows the fallbacks attached in its place: they
|
||||
/// leave the open documents, and stop once no document uses them.
|
||||
async fn detach_shadowed_fallbacks(&self) {
|
||||
let open: Vec<(DocId, LanguageId, PathBuf)> =
|
||||
self.docs.lock().iter().map(|(id, d)| (*id, d.language.clone(), d.path.clone())).collect();
|
||||
@@ -3868,7 +3845,6 @@ impl LspManager {
|
||||
.filter(|a| {
|
||||
!wanted.iter().any(|w| w.id == a.server.id)
|
||||
&& (configs.iter().any(|c| c.fallback && c.name == a.server.name)
|
||||
|| configs.iter().any(|c| c.replaces.contains(&a.server.name))
|
||||
|| (a.server.name == "clangd" && wanted.iter().any(|s| s.name == arduino::SERVER)))
|
||||
})
|
||||
.map(|a| a.server.id)
|
||||
@@ -4061,7 +4037,6 @@ impl LspManager {
|
||||
|
||||
pub async fn shutdown_all(&self) {
|
||||
self.shutting_down.store(true, Ordering::Release);
|
||||
self.go_mod_queries.lock().cancel_all();
|
||||
let _reconfigure = self.reconfigure_lock.lock().await;
|
||||
let servers: Vec<Arc<Server>> = self.servers.lock().clone();
|
||||
join_all(servers.iter().map(|s| self.stop_instance(s, true))).await;
|
||||
|
||||
@@ -1,97 +0,0 @@
|
||||
//! Pull Members Up / Push Members Down through Phoxite's own requests
|
||||
//! (`phoxite/refactor/hierarchyMembers` and `phoxite/refactor/hierarchy`). A server says it
|
||||
//! answers them with `experimental.phoxite.refactor` in its capabilities, so the server is
|
||||
//! found by what it advertises, not by its name. As with the JDT extension, the server
|
||||
//! checks the move and computes the edit; the UI shows its problems and applies the edit.
|
||||
use crate::caps::ServerCaps;
|
||||
use crate::types::{HierarchyChoice, HierarchyMembers, HierarchyRefactored, HierarchyRefactoring, RefactoringProblem};
|
||||
use crate::{DocSnap, LspManager, Target, convert, rpc_err};
|
||||
use ide_core::{CancellationToken, DocId, IdeError, IdeResult, Pos};
|
||||
use ide_jsonrpc::RpcError;
|
||||
use serde::Deserialize;
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde_json::{Value, json};
|
||||
use std::time::Duration;
|
||||
|
||||
const MEMBERS: &str = "phoxite/refactor/hierarchyMembers";
|
||||
const REFACTOR: &str = "phoxite/refactor/hierarchy";
|
||||
/// The move is computed over the whole project.
|
||||
const TIMEOUT: Duration = Duration::from_secs(120);
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Refactored {
|
||||
problems: Vec<RefactoringProblem>,
|
||||
edit: Option<lsp_types::WorkspaceEdit>,
|
||||
}
|
||||
|
||||
/// Whether the server answers the `phoxite/refactor/*` requests.
|
||||
fn refactors(caps: &ServerCaps) -> bool {
|
||||
caps.raw.pointer("/experimental/phoxite/refactor").and_then(Value::as_bool) == Some(true)
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// The server of `doc` that answers `phoxite/refactor/*`, when one is attached.
|
||||
pub(crate) async fn phoxite_refactor_target(&self, doc: DocId) -> Option<(DocSnap, Target)> {
|
||||
let (snap, mut targets) = self.doc_targets(doc, "refactorings", refactors).await.ok()?;
|
||||
Some((snap, targets.swap_remove(0)))
|
||||
}
|
||||
|
||||
/// Sends one of the hierarchy requests. The server refuses a position it can't
|
||||
/// refactor with LSP's `RequestFailed` and a message for the user: that is invalid
|
||||
/// input, as the JDT extension's `refused` is. Any other error is the server failing.
|
||||
async fn phoxite_hierarchy<R: DeserializeOwned>(
|
||||
&self,
|
||||
(snap, t): &(DocSnap, Target),
|
||||
method: &str,
|
||||
pos: Pos,
|
||||
kind: HierarchyRefactoring,
|
||||
extra: Value,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<R> {
|
||||
let mut params = json!({ "uri": snap.uri, "position": snap.position(t, pos), "kind": kind });
|
||||
if let (Some(params), Value::Object(extra)) = (params.as_object_mut(), extra) {
|
||||
params.extend(extra);
|
||||
}
|
||||
let request = t.run.peer.request::<Value, Value>(method, params, Some(cancel.clone()));
|
||||
let answer = match tokio::time::timeout(TIMEOUT, request).await {
|
||||
Ok(Ok(value)) => value,
|
||||
Ok(Err(RpcError::Server { code, message, .. })) if code == ide_jsonrpc::codes::REQUEST_FAILED => {
|
||||
return Err(IdeError::invalid(message));
|
||||
}
|
||||
Ok(Err(e)) => return Err(rpc_err(&t.server.name, method, e)),
|
||||
Err(_) => return Err(rpc_err(&t.server.name, method, RpcError::Timeout)),
|
||||
};
|
||||
if cancel.is_cancelled() {
|
||||
return Err(IdeError::cancelled());
|
||||
}
|
||||
serde_json::from_value(answer).map_err(|e| rpc_err(&t.server.name, method, RpcError::Protocol(e.to_string())))
|
||||
}
|
||||
|
||||
pub(crate) async fn phoxite_hierarchy_members(
|
||||
&self,
|
||||
target: &(DocSnap, Target),
|
||||
pos: Pos,
|
||||
kind: HierarchyRefactoring,
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HierarchyMembers> {
|
||||
self.phoxite_hierarchy(target, MEMBERS, pos, kind, Value::Null, cancel).await
|
||||
}
|
||||
|
||||
pub(crate) async fn phoxite_hierarchy_refactor(
|
||||
&self,
|
||||
target: &(DocSnap, Target),
|
||||
pos: Pos,
|
||||
kind: HierarchyRefactoring,
|
||||
destination: Option<String>,
|
||||
choices: &[HierarchyChoice],
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<HierarchyRefactored> {
|
||||
let extra = json!({ "target": destination, "choices": choices });
|
||||
let refactored: Refactored = self.phoxite_hierarchy(target, REFACTOR, pos, kind, extra, cancel).await?;
|
||||
let conv = self.conv(target.1.enc());
|
||||
Ok(HierarchyRefactored {
|
||||
problems: refactored.problems,
|
||||
edit: refactored.edit.map(|e| convert::workspace_edit(&conv, e)),
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -1,129 +0,0 @@
|
||||
//! Requests a plugin sends to a running server (`language-servers` in the plugin API):
|
||||
//! the server's own methods only, and only to a server that already runs.
|
||||
|
||||
use crate::{LspManager, Target, rpc_err};
|
||||
use ide_core::{CancellationToken, IdeError, IdeResult};
|
||||
use serde_json::Value;
|
||||
use std::path::Path;
|
||||
use std::time::Duration;
|
||||
|
||||
/// The first segment of the methods LSP itself defines.
|
||||
const LSP_NAMESPACES: [&str; 14] = [
|
||||
"textDocument",
|
||||
"workspace",
|
||||
"window",
|
||||
"notebookDocument",
|
||||
"callHierarchy",
|
||||
"typeHierarchy",
|
||||
"completionItem",
|
||||
"codeAction",
|
||||
"codeLens",
|
||||
"documentLink",
|
||||
"inlayHint",
|
||||
"workspaceSymbol",
|
||||
"client",
|
||||
"telemetry",
|
||||
];
|
||||
const LIFECYCLE: [&str; 4] = ["initialize", "initialized", "shutdown", "exit"];
|
||||
|
||||
/// Whether a plugin may send `method`: only a server's own namespace passes
|
||||
/// (`phoxite/laravel/routes`), so a plugin can't interfere with document sync, the
|
||||
/// features the IDE asks for itself, or the server's lifecycle.
|
||||
pub fn plugin_method_allowed(method: &str) -> bool {
|
||||
let namespace = method.split('/').next().unwrap_or_default();
|
||||
!(method.is_empty()
|
||||
|| method.starts_with("$/")
|
||||
|| LIFECYCLE.contains(&method)
|
||||
|| LSP_NAMESPACES.contains(&namespace))
|
||||
}
|
||||
|
||||
impl LspManager {
|
||||
/// The running server named `server`, the one rooted at `root` first. Never starts one.
|
||||
fn plugin_target(&self, root: &Path, server: &str, method: &str) -> IdeResult<Target> {
|
||||
if !plugin_method_allowed(method) {
|
||||
return Err(IdeError::invalid(format!("`{method}` is not one of the server's own methods")));
|
||||
}
|
||||
let mut running: Vec<Target> = self
|
||||
.servers
|
||||
.lock()
|
||||
.iter()
|
||||
.filter(|s| s.name == server)
|
||||
.filter_map(|s| s.running().map(|run| Target { server: s.clone(), run }))
|
||||
.collect();
|
||||
let at = running.iter().position(|t| t.server.root == root).unwrap_or(0);
|
||||
if running.is_empty() {
|
||||
return Err(IdeError::not_found(format!("no language server `{server}` is running for this project")));
|
||||
}
|
||||
Ok(running.swap_remove(at))
|
||||
}
|
||||
|
||||
/// Names (in the language definition) of the servers attached to `doc`, or of every
|
||||
/// server of the project when the document is not open; only `server`'s when given.
|
||||
pub fn server_names(&self, doc: ide_core::DocId, server: Option<ide_core::ServerId>) -> Vec<String> {
|
||||
let servers = match self.snapshot(doc) {
|
||||
Ok(snap) => snap.servers,
|
||||
Err(_) => self.servers.lock().clone(),
|
||||
};
|
||||
servers.iter().filter(|s| server.is_none_or(|id| s.id == id)).map(|s| s.name.clone()).collect()
|
||||
}
|
||||
|
||||
/// Sends a plugin's request to the running server named `server` (its name in the
|
||||
/// language definition) and returns the result. `not_found` when it is not running,
|
||||
/// `invalid` for a method that is not the server's own.
|
||||
pub async fn server_request(
|
||||
&self,
|
||||
root: &Path,
|
||||
server: &str,
|
||||
method: &str,
|
||||
params: Option<Value>,
|
||||
cancel: &CancellationToken,
|
||||
timeout: Duration,
|
||||
) -> IdeResult<Value> {
|
||||
let t = self.plugin_target(root, server, method)?;
|
||||
self.call(&t, method, params.unwrap_or(Value::Null), Some(cancel), timeout).await
|
||||
}
|
||||
|
||||
/// The same for a notification.
|
||||
pub fn server_notify(&self, root: &Path, server: &str, method: &str, params: Option<Value>) -> IdeResult<()> {
|
||||
let t = self.plugin_target(root, server, method)?;
|
||||
t.run.peer.notify(method, params.unwrap_or(Value::Null)).map_err(|e| rpc_err(server, method, e))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::plugin_method_allowed;
|
||||
|
||||
#[test]
|
||||
fn only_a_servers_own_methods_pass() {
|
||||
for method in ["phoxite/laravel/routes", "phoxite/refactor/hierarchy", "rust-analyzer/expandMacro", "custom"] {
|
||||
assert!(plugin_method_allowed(method), "{method}");
|
||||
}
|
||||
for method in [
|
||||
"",
|
||||
"initialize",
|
||||
"initialized",
|
||||
"shutdown",
|
||||
"exit",
|
||||
"$/cancelRequest",
|
||||
"$/progress",
|
||||
"textDocument/hover",
|
||||
"textDocument/didChange",
|
||||
"workspace/executeCommand",
|
||||
"window/showMessage",
|
||||
"notebookDocument/didOpen",
|
||||
"callHierarchy/incomingCalls",
|
||||
"typeHierarchy/supertypes",
|
||||
"completionItem/resolve",
|
||||
"codeAction/resolve",
|
||||
"codeLens/resolve",
|
||||
"documentLink/resolve",
|
||||
"inlayHint/resolve",
|
||||
"workspaceSymbol/resolve",
|
||||
"client/registerCapability",
|
||||
"telemetry/event",
|
||||
] {
|
||||
assert!(!plugin_method_allowed(method), "{method}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -110,17 +110,6 @@ pub fn is_decompiled(text: &str) -> bool {
|
||||
})
|
||||
}
|
||||
|
||||
/// Whether a `.class` stub is written in Java: its first `package` or `import` line ends with `;`.
|
||||
/// The Kotlin language server shows Java classes from jars as Java and Kotlin ones as Kotlin, under
|
||||
/// the same `.class` name.
|
||||
pub fn is_java_class_stub(text: &str) -> bool {
|
||||
text.lines()
|
||||
.take(200)
|
||||
.map(str::trim)
|
||||
.find(|line| line.starts_with("package ") || line.starts_with("import "))
|
||||
.is_some_and(|line| line.ends_with(';'))
|
||||
}
|
||||
|
||||
/// `scheme` of a URI (`jdt` for `jdt://…`).
|
||||
pub fn scheme(uri: &str) -> &str {
|
||||
uri.split_once(':').map(|(s, _)| s).unwrap_or("")
|
||||
@@ -216,17 +205,6 @@ mod tests {
|
||||
|
||||
const JDT: &str = "jdt://contents/spring-boot-4.1.1.jar/org.springframework.boot/SpringApplication.class?=spring-demo/%5C/Users%5C/me%5C/.m2%5C/repository%5C/spring-boot-4.1.1.jar%3Corg.springframework.boot%28SpringApplication.class";
|
||||
|
||||
#[test]
|
||||
fn class_stubs_in_java_or_kotlin() {
|
||||
let java = "// IntelliJ API Decompiler stub source generated from a class file\n\npackage com.boydti.fawe.util;\n\npublic class EditSessionBuilder {\n}\n";
|
||||
let kotlin = "// IntelliJ API Decompiler stub source generated from a class file\n// Implementation of methods is not available\n\npackage kotlin.collections\n\npublic fun <T> listOf(): List<T> { /* compiled code */ }\n";
|
||||
let imports_only = "import java.util.List;\n\npublic class A {}\n";
|
||||
assert!(is_java_class_stub(java));
|
||||
assert!(is_java_class_stub(imports_only));
|
||||
assert!(!is_java_class_stub(kotlin));
|
||||
assert!(!is_java_class_stub("public class A {}"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn csharp_metadata_titles_and_kinds() {
|
||||
for (uri, expected) in [
|
||||
|
||||
@@ -264,7 +264,6 @@ fn server_cfg(name: &str) -> LanguageServerConfig {
|
||||
install_hint: Some(format!("install {name}")),
|
||||
connect: None,
|
||||
fallback: false,
|
||||
replaces: Vec::new(),
|
||||
features: Vec::new(),
|
||||
code_action_kinds: Vec::new(),
|
||||
max_java: None,
|
||||
@@ -2969,8 +2968,7 @@ async fn library_classes_without_sources_open_decompiled_by_a_running_jdtls() {
|
||||
zip.write_all(b"\0").unwrap();
|
||||
zip.finish().unwrap();
|
||||
let class = format!("jar://{}!/acme/Thing.class", uri_of(&jar).trim_start_matches("file://"));
|
||||
// jdtls writes the portable path (forward slashes on Windows too), each `/` escaped.
|
||||
let escaped = jar.to_string_lossy().replace('\\', "/").replace('/', "%5C/");
|
||||
let escaped = jar.to_string_lossy().replace('/', "%5C/");
|
||||
let jdt = format!("jdt://contents/lib-1.0.jar/acme/Thing.class?=app/{escaped}%3Cacme%28Thing.class");
|
||||
let decompiled =
|
||||
"package acme;\n\npublic class Thing {\n public void run() {\n System.out.println();\n }\n}\n";
|
||||
@@ -3288,67 +3286,6 @@ async fn a_server_requiring_a_root_marker_serves_only_files_below_one() {
|
||||
h.wait_status("alt", ServerStatus::Ready).await;
|
||||
}
|
||||
|
||||
/// A server that `replaces` another (a PHP server with its own Laravel support and
|
||||
/// `laravel-lsp`) keeps it away while it serves, and only then.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_replaced_server_stays_away_while_its_replacement_serves() {
|
||||
let servers = [("main", incremental_caps()), ("alt", incremental_caps()), ("framework", incremental_caps())];
|
||||
let configure = |cfg: &mut LanguageServerConfig| match cfg.name.as_str() {
|
||||
"alt" => {
|
||||
cfg.fallback = true;
|
||||
cfg.replaces = vec!["framework".into()];
|
||||
}
|
||||
"framework" => cfg.require_root_marker = true,
|
||||
_ => {}
|
||||
};
|
||||
let h = harness_configured("mock", "mk", &servers, configure);
|
||||
let disabled: Arc<Mutex<Vec<String>>> = Default::default();
|
||||
{
|
||||
let disabled = disabled.clone();
|
||||
h.mgr.set_servers_hook(Box::new(move |_, defined| {
|
||||
defined.iter().filter(|c| !disabled.lock().contains(&c.name)).cloned().collect()
|
||||
}));
|
||||
}
|
||||
std::fs::write(h.root.join("mock.toml"), "").unwrap();
|
||||
let (_, path) = h.open("a.mk", "x");
|
||||
let uri = uri_of(&path);
|
||||
|
||||
// The preferred server serves: the framework's server joins it, the alternative stays away.
|
||||
h.wait_status("main", ServerStatus::Ready).await;
|
||||
h.wait_status("framework", ServerStatus::Ready).await;
|
||||
eventually(|| h.launcher.state("framework").docs.lock().contains_key(&uri)).await;
|
||||
assert!(h.statuses("alt").is_empty());
|
||||
|
||||
// The alternative takes over: the server it replaces closes the document and stops.
|
||||
disabled.lock().push("main".into());
|
||||
h.mgr.reconfigure().await;
|
||||
h.wait_status("alt", ServerStatus::Ready).await;
|
||||
eventually(|| h.launcher.state("alt").docs.lock().contains_key(&uri)).await;
|
||||
assert!(!h.launcher.state("framework").notified("textDocument/didClose").is_empty());
|
||||
assert_eq!(h.statuses("framework").last(), Some(&ServerStatus::Stopped));
|
||||
assert_eq!(h.mgr.servers().iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), ["alt"]);
|
||||
|
||||
// The preferred server again: the framework's server comes back with it.
|
||||
disabled.lock().clear();
|
||||
h.mgr.reconfigure().await;
|
||||
h.wait_status("main", ServerStatus::Ready).await;
|
||||
eventually(|| h.statuses("framework").last() == Some(&ServerStatus::Ready)).await;
|
||||
assert_eq!(h.statuses("alt").last(), Some(&ServerStatus::Stopped));
|
||||
|
||||
// A preferred server that is not installed: the alternative replaces the framework's
|
||||
// server although that one attached first.
|
||||
let servers = [("ghost", json!({})), ("alt", incremental_caps()), ("framework", incremental_caps())];
|
||||
let h = harness_configured("mock", "mk", &servers, configure);
|
||||
h.launcher.state("ghost").missing.store(true, Ordering::SeqCst);
|
||||
std::fs::write(h.root.join("mock.toml"), "").unwrap();
|
||||
let (_, path) = h.open("a.mk", "x");
|
||||
let uri = uri_of(&path);
|
||||
h.wait_status("ghost", ServerStatus::Missing).await;
|
||||
h.wait_status("alt", ServerStatus::Ready).await;
|
||||
eventually(|| h.launcher.state("alt").docs.lock().contains_key(&uri)).await;
|
||||
eventually(|| !h.mgr.servers().iter().any(|s| s.name == "framework")).await;
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_fallback_leaves_when_the_preferred_server_is_enabled_again() {
|
||||
let h = harness_with_fallbacks(&[("main", incremental_caps()), ("alt", incremental_caps())], &["alt"]);
|
||||
@@ -7373,147 +7310,3 @@ async fn notebook_edits_change_cell_text_and_reorders_reopen_it() {
|
||||
.await;
|
||||
h.mgr.shutdown_all().await;
|
||||
}
|
||||
|
||||
/// A plugin's request (`language-servers` in the plugin API) reaches the running server
|
||||
/// named in the language definition: only the server's own methods, and never a start.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn a_plugin_request_reaches_only_a_running_servers_own_methods() {
|
||||
let servers = [("main", incremental_caps()), ("alt", incremental_caps())];
|
||||
let h = harness_for("mock", "mk", &servers, &["alt"]);
|
||||
let _ = h.open("a.mk", "x");
|
||||
h.wait_status("main", ServerStatus::Ready).await;
|
||||
let s = h.launcher.state("main");
|
||||
s.respond("mock/routes", json!([{ "uri": "/users", "name": "users.index" }]));
|
||||
let cancel = CancellationToken::new();
|
||||
let timeout = Duration::from_secs(5);
|
||||
|
||||
// A request: the params arrive, the result comes back.
|
||||
let routes = h
|
||||
.mgr
|
||||
.server_request(&h.root, "main", "mock/routes", Some(json!({ "method": "GET" })), &cancel, timeout)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(routes, json!([{ "uri": "/users", "name": "users.index" }]));
|
||||
assert_eq!(s.requested("mock/routes"), [json!({ "method": "GET" })]);
|
||||
|
||||
// A notification.
|
||||
h.mgr.server_notify(&h.root, "main", "mock/changed", Some(json!({ "what": "routes" }))).unwrap();
|
||||
eventually(|| s.notified("mock/changed") == [json!({ "what": "routes" })]).await;
|
||||
|
||||
// LSP's own methods are refused before anything is sent.
|
||||
for method in ["textDocument/hover", "workspace/executeCommand", "$/cancelRequest", "shutdown", "initialize"] {
|
||||
let before = (s.requested(method).len(), s.notified(method).len());
|
||||
let e = h.mgr.server_request(&h.root, "main", method, None, &cancel, timeout).await.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::InvalidInput, "{method}");
|
||||
assert_eq!(
|
||||
h.mgr.server_notify(&h.root, "main", method, None).unwrap_err().kind,
|
||||
ide_core::error::ErrorKind::InvalidInput
|
||||
);
|
||||
assert_eq!((s.requested(method).len(), s.notified(method).len()), before, "{method}");
|
||||
}
|
||||
|
||||
// A server that is defined but not running is not started; an unknown name is the same.
|
||||
for server in ["alt", "nobody"] {
|
||||
let e = h.mgr.server_request(&h.root, server, "mock/routes", None, &cancel, timeout).await.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::NotFound, "{server}");
|
||||
assert_eq!(
|
||||
h.mgr.server_notify(&h.root, server, "mock/changed", None).unwrap_err().kind,
|
||||
ide_core::error::ErrorKind::NotFound
|
||||
);
|
||||
}
|
||||
assert_eq!(h.launcher.state("alt").launches.load(Ordering::SeqCst), 0);
|
||||
assert!(h.statuses("alt").is_empty());
|
||||
|
||||
// A cancelled invocation ends the request.
|
||||
cancel.cancel();
|
||||
let e = h.mgr.server_request(&h.root, "main", "mock/routes", None, &cancel, timeout).await.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::Cancelled);
|
||||
}
|
||||
|
||||
/// A server that advertises `experimental.phoxite.refactor` gets Pull Members Up / Push
|
||||
/// Members Down as its own `phoxite/refactor/*` requests, whatever its name.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn hierarchy_refactorings_use_phoxites_requests_when_the_server_advertises_them() {
|
||||
let mut caps = incremental_caps();
|
||||
caps["experimental"] = json!({ "phoxite": { "laravel": true, "refactor": true } });
|
||||
let h = harness_for("php", "php", &[("any-name", caps)], &[]);
|
||||
let s = h.launcher.state("any-name");
|
||||
*s.responder.lock() = Some(Arc::new(|_, method, params| {
|
||||
let uri = params["uri"].clone();
|
||||
match (method, params["position"]["line"].as_u64()) {
|
||||
("phoxite/refactor/hierarchyMembers", Some(0)) => Some(json!({
|
||||
"className": "Dog",
|
||||
"targets": [{ "id": "App\\Animal", "name": "Animal", "qualifiedName": "App\\Animal", "interface": false }],
|
||||
"members": [
|
||||
{ "id": "method:bark", "label": "bark(): string", "kind": "method", "selected": true, "abstractable": true },
|
||||
{ "id": "constant:LEGS", "label": "LEGS", "kind": "field", "selected": false, "abstractable": false },
|
||||
],
|
||||
})),
|
||||
("phoxite/refactor/hierarchy", _) => Some(json!({
|
||||
"problems": [{ "severity": "warning", "message": "bark() uses $tail, which stays in Dog" }],
|
||||
"edit": { "changes": { uri.as_str().unwrap(): [
|
||||
{ "range": { "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 5 } }, "newText": "<?php" }
|
||||
] } },
|
||||
})),
|
||||
_ => None,
|
||||
}
|
||||
}));
|
||||
let text =
|
||||
format!("<?php class Dog extends Animal {{ function bark(): string {{ return ''; }} }}{}", "\n".repeat(9));
|
||||
let (doc, path) = h.open("Dog.php", &text);
|
||||
h.wait_status("any-name", ServerStatus::Ready).await;
|
||||
eventually(|| s.docs.lock().len() == 1).await;
|
||||
|
||||
let info =
|
||||
h.mgr.hierarchy_members(doc, Pos::new(0, 40), HierarchyRefactoring::PullUp, Default::default()).await.unwrap();
|
||||
assert_eq!((info.class_name.as_str(), info.targets[0].qualified_name.as_str()), ("Dog", "App\\Animal"));
|
||||
assert!(info.members[0].selected && info.members[0].abstractable);
|
||||
assert_eq!(
|
||||
info.members.iter().map(|m| m.kind).collect::<Vec<_>>(),
|
||||
[HierarchyMemberKind::Method, HierarchyMemberKind::Field]
|
||||
);
|
||||
assert_eq!(
|
||||
s.requested("phoxite/refactor/hierarchyMembers"),
|
||||
[json!({ "uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp" })]
|
||||
);
|
||||
|
||||
let choices = vec![HierarchyChoice { id: "method:bark".into(), make_abstract: true }];
|
||||
let done = h
|
||||
.mgr
|
||||
.hierarchy_refactor(
|
||||
doc,
|
||||
Pos::new(0, 40),
|
||||
HierarchyRefactoring::PullUp,
|
||||
Some("App\\Animal".into()),
|
||||
choices,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(done.problems[0].severity, ProblemSeverity::Warning);
|
||||
let edit = done.edit.unwrap();
|
||||
assert!(matches!(&edit.files[..], [FileEdit::Edit { path: p, edits, .. }] if p == &path && edits.len() == 1));
|
||||
assert_eq!(
|
||||
s.requested("phoxite/refactor/hierarchy"),
|
||||
[json!({
|
||||
"uri": uri_of(&path), "position": { "line": 0, "character": 40 }, "kind": "pullUp",
|
||||
"target": "App\\Animal", "choices": [{ "id": "method:bark", "makeAbstract": true }],
|
||||
})]
|
||||
);
|
||||
assert!(s.requested("workspace/executeCommand").is_empty(), "not the JDT extension's commands");
|
||||
|
||||
// The server refuses a position with `RequestFailed` and a message for the user.
|
||||
let refusal = (-32803, "'Dog' has no parent class or interface in the project".to_owned());
|
||||
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), refusal);
|
||||
let refused = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
|
||||
let e = refused.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::InvalidInput);
|
||||
assert_eq!(e.message, "'Dog' has no parent class or interface in the project");
|
||||
|
||||
// Any other error is the server failing, not a reason to show as the user's mistake.
|
||||
s.errors.lock().insert("phoxite/refactor/hierarchyMembers".into(), (-32603, "index out of bounds".to_owned()));
|
||||
let failed = h.mgr.hierarchy_members(doc, Pos::new(9, 0), HierarchyRefactoring::PullUp, Default::default()).await;
|
||||
let e = failed.unwrap_err();
|
||||
assert_eq!(e.kind, ide_core::error::ErrorKind::Protocol);
|
||||
assert_eq!(e.message, "any-name: index out of bounds");
|
||||
}
|
||||
@@ -419,7 +419,6 @@ async fn missing_binary_is_reported_with_install_hint() {
|
||||
install_hint: Some("npm i -g nope-ls".into()),
|
||||
connect: None,
|
||||
fallback: false,
|
||||
replaces: Vec::new(),
|
||||
features: Vec::new(),
|
||||
code_action_kinds: Vec::new(),
|
||||
max_java: None,
|
||||
@@ -693,7 +692,6 @@ async fn typescript_language_server_end_to_end() {
|
||||
install_hint: None,
|
||||
connect: None,
|
||||
fallback: false,
|
||||
replaces: Vec::new(),
|
||||
features: Vec::new(),
|
||||
code_action_kinds: Vec::new(),
|
||||
max_java: None,
|
||||
@@ -747,7 +745,6 @@ fn npm_server(tools: &Path, name: &str, bin: &str, init: Option<serde_json::Valu
|
||||
install_hint: None,
|
||||
connect: None,
|
||||
fallback: false,
|
||||
replaces: Vec::new(),
|
||||
features: Vec::new(),
|
||||
code_action_kinds: Vec::new(),
|
||||
max_java: None,
|
||||
@@ -1022,82 +1019,3 @@ async fn basedpyright_and_ruff_serve_notebook_cells() {
|
||||
mgr.close_notebook(&path);
|
||||
tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();
|
||||
}
|
||||
|
||||
/// Pull Members Up through Phoxite's own requests: the real server moves a method to
|
||||
/// the parent class in another file.
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
#[ignore = "requires phoxite-lsp on PATH (or OPENIDEA_TEST_PHOXITE_LSP)"]
|
||||
async fn phoxite_pulls_a_member_up_end_to_end() {
|
||||
use ide_core::FileEdit;
|
||||
use ide_lsp::types::{HierarchyChoice, HierarchyRefactoring};
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let root = dir.path().canonicalize().unwrap();
|
||||
std::fs::create_dir(root.join("src")).unwrap();
|
||||
std::fs::write(root.join("composer.json"), r#"{"autoload":{"psr-4":{"App\\":"src/"}}}"#).unwrap();
|
||||
let animal = root.join("src").join("Animal.php");
|
||||
std::fs::write(&animal, "<?php\n\nnamespace App;\n\nclass Animal\n{\n}\n").unwrap();
|
||||
let path = root.join("src").join("Dog.php");
|
||||
let source = "<?php\n\nnamespace App;\n\nclass Dog extends Animal\n{\n public function bark(): string\n {\n return 'woof';\n }\n}\n";
|
||||
std::fs::write(&path, source).unwrap();
|
||||
let mut php = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("php")).unwrap();
|
||||
php.language_servers.retain(|s| s.name == "phoxite");
|
||||
assert_eq!(php.language_servers.len(), 1);
|
||||
php.language_servers[0].fallback = false;
|
||||
if let Ok(bin) = std::env::var("OPENIDEA_TEST_PHOXITE_LSP") {
|
||||
php.language_servers[0].command = bin;
|
||||
}
|
||||
let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![php]));
|
||||
let doc = DocId::next();
|
||||
mgr.did_open(doc, &path, &LanguageId::new("php"), 1, source);
|
||||
retry("phoxite ready", Duration::from_secs(30), || {
|
||||
let status = last_status(&events, "phoxite");
|
||||
if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, msg)) = &status {
|
||||
panic!("phoxite failed: {msg:?}");
|
||||
}
|
||||
async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }
|
||||
})
|
||||
.await;
|
||||
// On `bark`; the parent is known once the project is indexed.
|
||||
let at = Pos::new(6, 22);
|
||||
let info = retry("the movable members", Duration::from_secs(60), || {
|
||||
let mgr = mgr.clone();
|
||||
async move { mgr.hierarchy_members(doc, at, HierarchyRefactoring::PullUp, Default::default()).await.ok() }
|
||||
})
|
||||
.await;
|
||||
assert_eq!(info.class_name, "Dog");
|
||||
assert_eq!(
|
||||
info.targets.iter().map(|t| t.qualified_name.trim_start_matches('\\')).collect::<Vec<_>>(),
|
||||
["App\\Animal"]
|
||||
);
|
||||
let bark = info.members.iter().find(|m| m.label.starts_with("bark")).expect("bark is movable");
|
||||
assert!(bark.selected, "{bark:?}");
|
||||
let choices = vec![HierarchyChoice { id: bark.id.clone(), make_abstract: false }];
|
||||
let done = mgr
|
||||
.hierarchy_refactor(
|
||||
doc,
|
||||
at,
|
||||
HierarchyRefactoring::PullUp,
|
||||
Some(info.targets[0].id.clone()),
|
||||
choices,
|
||||
Default::default(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let edit = done.edit.expect("an edit");
|
||||
let mut edited: Vec<_> = edit
|
||||
.files
|
||||
.iter()
|
||||
.filter_map(|f| match f {
|
||||
FileEdit::Edit { path, edits, .. } if !edits.is_empty() => path.0.file_name()?.to_str().map(str::to_owned),
|
||||
_ => None,
|
||||
})
|
||||
.collect();
|
||||
edited.sort();
|
||||
assert_eq!(edited, ["Animal.php", "Dog.php"], "the method leaves Dog and arrives in Animal");
|
||||
// Outside any class the server refuses with `RequestFailed`: the reason reaches the user.
|
||||
let refused = mgr.hierarchy_members(doc, Pos::new(0, 0), HierarchyRefactoring::PullUp, Default::default()).await;
|
||||
let refused = refused.unwrap_err();
|
||||
assert_eq!(refused.kind, ide_core::error::ErrorKind::InvalidInput, "{refused:?}");
|
||||
assert!(!refused.message.is_empty() && !refused.message.starts_with("phoxite:"), "{refused:?}");
|
||||
mgr.shutdown_all().await;
|
||||
}
|
||||
@@ -100,23 +100,6 @@ pub trait HostApi: Send + Sync {
|
||||
let _ = (root, client, id, cancel, timeout);
|
||||
Err(HostError::Invalid("Database subsystem is unavailable on this host".into()))
|
||||
}
|
||||
/// Sends `method` to the running language server named `server` of the project at
|
||||
/// `root`: a request (the result as JSON), or with `notify` a notification (`null`).
|
||||
/// `params` is JSON. Never starts a server.
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn lsp_request(
|
||||
&self,
|
||||
root: &Path,
|
||||
server: &str,
|
||||
method: &str,
|
||||
params: Option<String>,
|
||||
notify: bool,
|
||||
cancel: &CancellationToken,
|
||||
timeout: Duration,
|
||||
) -> Result<String, HostError> {
|
||||
let _ = (root, method, params, notify, cancel, timeout);
|
||||
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
|
||||
}
|
||||
/// Stdio argv only; no URL or bearer token.
|
||||
fn mcp_stdio_command(&self, client: &str) -> Option<Vec<String>> {
|
||||
let _ = client;
|
||||
|
||||
@@ -59,7 +59,6 @@ pub(crate) mod syntax_bindings {
|
||||
"openidea:plugin/output": super::bindings::openidea::plugin::output,
|
||||
"openidea:plugin/auth": super::bindings::openidea::plugin::auth,
|
||||
"openidea:plugin/command-runner": super::bindings::openidea::plugin::command_runner,
|
||||
"openidea:plugin/language-servers": super::bindings::openidea::plugin::language_servers,
|
||||
"openidea:plugin/ipc": super::bindings::openidea::plugin::ipc,
|
||||
"openidea:plugin/fs": super::bindings::openidea::plugin::fs,
|
||||
"openidea:plugin/views": super::bindings::openidea::plugin::views,
|
||||
@@ -98,7 +97,6 @@ pub(crate) mod providers_bindings {
|
||||
"openidea:plugin/output": super::bindings::openidea::plugin::output,
|
||||
"openidea:plugin/auth": super::bindings::openidea::plugin::auth,
|
||||
"openidea:plugin/command-runner": super::bindings::openidea::plugin::command_runner,
|
||||
"openidea:plugin/language-servers": super::bindings::openidea::plugin::language_servers,
|
||||
"openidea:plugin/ipc": super::bindings::openidea::plugin::ipc,
|
||||
"openidea:plugin/fs": super::bindings::openidea::plugin::fs,
|
||||
"openidea:plugin/views": super::bindings::openidea::plugin::views,
|
||||
@@ -137,7 +135,6 @@ pub(crate) mod views_bindings {
|
||||
"openidea:plugin/output": super::bindings::openidea::plugin::output,
|
||||
"openidea:plugin/auth": super::bindings::openidea::plugin::auth,
|
||||
"openidea:plugin/command-runner": super::bindings::openidea::plugin::command_runner,
|
||||
"openidea:plugin/language-servers": super::bindings::openidea::plugin::language_servers,
|
||||
"openidea:plugin/ipc": super::bindings::openidea::plugin::ipc,
|
||||
"openidea:plugin/fs": super::bindings::openidea::plugin::fs,
|
||||
"openidea:plugin/views": super::bindings::openidea::plugin::views,
|
||||
@@ -2651,57 +2648,6 @@ impl bindings::openidea::plugin::database::Host for StoreData {
|
||||
Ok(result.map_err(to_wit))
|
||||
}
|
||||
}
|
||||
/// The longest method name and params a plugin may send a language server.
|
||||
const MAX_LSP_METHOD: usize = 256;
|
||||
const MAX_LSP_PARAMS: usize = 1 << 20;
|
||||
|
||||
impl StoreData {
|
||||
fn lsp_call(
|
||||
&mut self,
|
||||
project: Resource<ProjectRes>,
|
||||
server: String,
|
||||
method: String,
|
||||
params: Option<String>,
|
||||
notify: bool,
|
||||
) -> Fallible<String> {
|
||||
if let Err(e) = self.require(Capability::Lsp(server.clone())) {
|
||||
return Ok(Err(e));
|
||||
}
|
||||
if method.len() > MAX_LSP_METHOD || params.as_ref().is_some_and(|p| p.len() > MAX_LSP_PARAMS) {
|
||||
return Ok(Err(wit::Error::Invalid("method exceeds 256 bytes or params exceed 1 MiB".into())));
|
||||
}
|
||||
let root = self.table.get(&project)?.root.clone();
|
||||
let token = self.cancel.token();
|
||||
let timeout = self.io_timeout();
|
||||
let outcome = self.host.lsp_request(&root, &server, &method, params, notify, &token, timeout);
|
||||
if outcome.is_err() {
|
||||
self.grant_io_error_grace();
|
||||
}
|
||||
Ok(outcome.map_err(to_wit))
|
||||
}
|
||||
}
|
||||
|
||||
impl bindings::openidea::plugin::language_servers::Host for StoreData {
|
||||
fn request(
|
||||
&mut self,
|
||||
project: Resource<ProjectRes>,
|
||||
server: String,
|
||||
method: String,
|
||||
params: Option<String>,
|
||||
) -> Fallible<String> {
|
||||
self.lsp_call(project, server, method, params, false)
|
||||
}
|
||||
fn notify(
|
||||
&mut self,
|
||||
project: Resource<ProjectRes>,
|
||||
server: String,
|
||||
method: String,
|
||||
params: Option<String>,
|
||||
) -> Fallible<()> {
|
||||
Ok(self.lsp_call(project, server, method, params, true)?.map(|_| ()))
|
||||
}
|
||||
}
|
||||
|
||||
impl bindings::openidea::plugin::extensions::Host for StoreData {
|
||||
fn contributions(&mut self, point: String) -> Fallible<Vec<bindings::openidea::plugin::extensions::Contribution>> {
|
||||
Ok(self
|
||||
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
75123cf60f87ec9bdd36e0b7f75efb69d000136d74c3e9da893ecd1534bdf534
|
||||
a3d2511f30277245a8cb9673c4d8a948a8a025b8b9149d5015bed5137a98ccdd
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
60d66ec578e3adc7adaebbcd01aa92a74a8a7e4cfd4d1aa778f9b033c75234a6
|
||||
dad3edad99ad85234aa612bbc1f3a66e50361189e54038b91674703815f049cc
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
df55973ed77e734e48fe1d2b7bb5d1e4eb68153b17452e4385599145427292b6
|
||||
918af7d4d8bc302621b9b68070a56930813b1fc2ba235d89de4e56c53eaba5bd
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
94f1c4a8192e15961bd136cf9dc3416fca7b295bce0d563608a3ee9fdf81c28e
|
||||
7a140c2255a3d251a5ab9079bec953cccc4408727b067b49da47cf8fb27d8cb8
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
db140480eaf4352fa8db8d87aab95cb07944e19c28d2cc08e299b37c5deb4230
|
||||
ef41934bd0b67f76a17ef321b44c172496314c9fea6b46b4cd2f1d0f4b96907d
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
5fd76f6168d3a7b3259281171f375cf01da6ceabdf4ffd382c5fe7034b2e94f2
|
||||
c6dc1ae00d9f3d936f4bf5ff110915050cb503ac06982bdc48e967deac84a913
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
5d9049fa006194e92e06de47ab933d249118706a8ba92100493318a1582f2b65
|
||||
25a782556dd6bbf8ed1ad7b50b9b55685f074d80220af08f3bd9cb12cf07f74e
|
||||
Бінарний файл не відображається.
@@ -1 +1 @@
|
||||
c723d915b69292740a863b3a94db6f6f8c218ecda46c527229d621084f2df3b1
|
||||
f58b5f68d56611c3d15f69ff8e73e6e65d84e55d14c9bae00ed50b346460adfa
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
2dbab98cfc473650675b2691c7d0f2d5b088ffd6208e31ef30aaa54dd3b1b4b0
|
||||
749bff2d051984edf65590494ef803225dfccd03d032de140974d8e984683ac1
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
1fa1515aae810e588f2c1d25728755c25fd51c78d35d96d823583052372c34dd
|
||||
50c609ebf387b400a01ea28e6ccf0f3de2ff7a5eedbb47c0a4bc40d05e3aaade
|
||||
Бінарний файл не відображається.
+1
-1
@@ -1 +1 @@
|
||||
69eaf24b0ed3260a6b3656563b1d0b8b268de81899f05bc984c668b0765e361f
|
||||
c2350d0277636285b182d1484d01d706c3116ef5e28917ddeb24ca78bac251ba
|
||||
Бінарний файл не відображається.
Loaded 100 of 699 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Заблокувати користувача